Class default

Hierarchy

default

Constructors

constructor

new default(provider, programId): default
Parameters
- provider: AnchorProvider
- programId: string
Returns default
- Defined in lib/program.ts:24

Properties

`Readonly` program

program: Program<BalancerAmm>

Methods

addLiquidity

addLiquidity(opts): Promise<{
tx: Transaction;
txId: string;
}>
Add liquidity to the pool. It supports full and sided liquidity deposit.
Parameters
- opts: {
      amounts: BN[];
      poolAddress: Address;
      sendAndConfirm?: boolean;
  }
  Input:
  - amounts: BN[]
    Amounts to deposit
  - poolAddress: Address
    Pool address
  - Optional sendAndConfirm?: boolean
    (true) Send and confirm the transaction.
Returns Promise<{
tx: Transaction;
txId: string;
}>
- Defined in lib/program.ts:265

closePool

closePool(opts): Promise<{
tx: Transaction;
txId: string;
}>
Cancel a pool in case it's not started yet.
Parameters
- opts: {
  poolAddress: Address;
  sendAndConfirm?: boolean;
  }
  Input:
  - poolAddress: Address
    Pool address
  - Optional sendAndConfirm?: boolean
    (true) Send and confirm the transaction.
Returns Promise<{
tx: Transaction;
txId: string;
}>
- Defined in lib/program.ts:820

deriveTreasurerAddress

deriveTreasurerAddress(poolAddress): string
Derive treasurer address of a pool by pool address.
Parameters
- poolAddress: Address
  Pool address.
Returns string
Treasurer address that holds the token treasuries of the pool.
- Defined in lib/program.ts:63

finalizePool

finalizePool(opts): Promise<{
tx: Transaction;
txId: string;
}>
Finalize a pool.
Parameters
- opts: {
  poolAddress: Address;
  sendAndConfirm?: boolean;
  }
  Input:
  - poolAddress: Address
    Pool address
  - Optional sendAndConfirm?: boolean
    (true) Send and confirm the transaction.
Returns Promise<{
tx: Transaction;
txId: string;
}>
- Defined in lib/program.ts:703

freezePool

freezePool(opts): Promise<{
tx: Transaction;
txId: string;
}>
Freeze a pool.
Parameters
- opts: {
  poolAddress: Address;
  sendAndConfirm?: boolean;
  }
  Input:
  - poolAddress: Address
    Pool address
  - Optional sendAndConfirm?: boolean
    (true) Send and confirm the transaction.
Returns Promise<{
tx: Transaction;
txId: string;
}>
- Defined in lib/program.ts:731

getAllPoolData

getAllPoolData(): Promise<ProgramAccount<DecodeStruct<{
    fields: [{
        name: "authority";
        type: "publicKey";
    }, {
        name: "fee";
        type: "u64";
    }, {
        name: "tax";
        type: "u64";
    }, {
        name: "state";
        type: {
            defined: "PoolState";
        };
    }, {
        name: "mintLpt";
        type: "publicKey";
    }, {
        name: "taxman";
        type: "publicKey";
    }, {
        name: "mints";
        type: {
            vec: "publicKey";
        };
    }, {
        name: "actions";
        type: {
            vec: {
                defined: "MintActionState";
            };
        };
    }];
    kind: "struct";
}, DecodedHelper<[{
    docs: ["", "Pool state", ""];
    name: "PoolState";
    type: {
        kind: "enum";
        variants: [{
            name: "Uninitialized";
        }, {
            name: "Initialized";
        }, {
            name: "Frozen";
        }, {
            name: "Deleted";
        }, {
            name: "Initializing";
        }];
    };
}, {
    docs: ["", "Mint state", ""];
    name: "MintActionState";
    type: {
        kind: "enum";
        variants: [{
            name: "Active";
        }, {
            name: "BidOnly";
        }, {
            name: "AskOnly";
        }, {
            name: "Paused";
        }];
    };
}], EmptyDefined>>>[]>
Get all pool data.

Returns Promise<ProgramAccount<DecodeStruct<{
    fields: [{
        name: "authority";
        type: "publicKey";
    }, {
        name: "fee";
        type: "u64";
    }, {
        name: "tax";
        type: "u64";
    }, {
        name: "state";
        type: {
            defined: "PoolState";
        };
    }, {
        name: "mintLpt";
        type: "publicKey";
    }, {
        name: "taxman";
        type: "publicKey";
    }, {
        name: "mints";
        type: {
            vec: "publicKey";
        };
    }, {
        name: "actions";
        type: {
            vec: {
                defined: "MintActionState";
            };
        };
    }];
    kind: "struct";
}, DecodedHelper<[{
    docs: ["", "Pool state", ""];
    name: "PoolState";
    type: {
        kind: "enum";
        variants: [{
            name: "Uninitialized";
        }, {
            name: "Initialized";
        }, {
            name: "Frozen";
        }, {
            name: "Deleted";
        }, {
            name: "Initializing";
        }];
    };
}, {
    docs: ["", "Mint state", ""];
    name: "MintActionState";
    type: {
        kind: "enum";
        variants: [{
            name: "Active";
        }, {
            name: "BidOnly";
        }, {
            name: "AskOnly";
        }, {
            name: "Paused";
        }];
    };
}], EmptyDefined>>>[]>
All pool readable data.
- Defined in lib/program.ts:54

getPoolData

getPoolData(poolAddress): Promise<DecodeStruct<{
    fields: [{
        name: "authority";
        type: "publicKey";
    }, {
        name: "fee";
        type: "u64";
    }, {
        name: "tax";
        type: "u64";
    }, {
        name: "state";
        type: {
            defined: "PoolState";
        };
    }, {
        name: "mintLpt";
        type: "publicKey";
    }, {
        name: "taxman";
        type: "publicKey";
    }, {
        name: "mints";
        type: {
            vec: "publicKey";
        };
    }, {
        name: "actions";
        type: {
            vec: {
                defined: "MintActionState";
            };
        };
    }];
    kind: "struct";
}, DecodedHelper<[{
    docs: ["", "Pool state", ""];
    name: "PoolState";
    type: {
        kind: "enum";
        variants: [{
            name: "Uninitialized";
        }, {
            name: "Initialized";
        }, {
            name: "Frozen";
        }, {
            name: "Deleted";
        }, {
            name: "Initializing";
        }];
    };
}, {
    docs: ["", "Mint state", ""];
    name: "MintActionState";
    type: {
        kind: "enum";
        variants: [{
            name: "Active";
        }, {
            name: "BidOnly";
        }, {
            name: "AskOnly";
        }, {
            name: "Paused";
        }];
    };
}], EmptyDefined>>>
Get pool data.
Parameters
- poolAddress: Address
  Pool address.
Returns Promise<DecodeStruct<{
    fields: [{
        name: "authority";
        type: "publicKey";
    }, {
        name: "fee";
        type: "u64";
    }, {
        name: "tax";
        type: "u64";
    }, {
        name: "state";
        type: {
            defined: "PoolState";
        };
    }, {
        name: "mintLpt";
        type: "publicKey";
    }, {
        name: "taxman";
        type: "publicKey";
    }, {
        name: "mints";
        type: {
            vec: "publicKey";
        };
    }, {
        name: "actions";
        type: {
            vec: {
                defined: "MintActionState";
            };
        };
    }];
    kind: "struct";
}, DecodedHelper<[{
    docs: ["", "Pool state", ""];
    name: "PoolState";
    type: {
        kind: "enum";
        variants: [{
            name: "Uninitialized";
        }, {
            name: "Initialized";
        }, {
            name: "Frozen";
        }, {
            name: "Deleted";
        }, {
            name: "Initializing";
        }];
    };
}, {
    docs: ["", "Mint state", ""];
    name: "MintActionState";
    type: {
        kind: "enum";
        variants: [{
            name: "Active";
        }, {
            name: "BidOnly";
        }, {
            name: "AskOnly";
        }, {
            name: "Paused";
        }];
    };
}], EmptyDefined>>>
Pool readable data.
- Defined in lib/program.ts:46

initializeJoin

initializeJoin(opts): Promise<{
tx: Transaction;
txId: string;
}>
Initialize joins to add liquidity for each mint to the pool. After joinning all tokens, the pool will change its state from Uninitialized to Initialized.
Parameters
- opts: {
      amount: BN;
      mint: Address;
      poolAddress: Address;
      sendAndConfirm?: boolean;
  }
  Input:
  - amount: BN
    Amount of tokens.
  - mint: Address
    Token address will be add liquidity.
  - poolAddress: Address
    The pool address will be add liquidity.
  - Optional sendAndConfirm?: boolean
    (true) Send and confirm the transaction.
Returns Promise<{
tx: Transaction;
txId: string;
}>
- Defined in lib/program.ts:203

initializePool

initializePool(opts): Promise<{
    poolAddress: string;
    tx: Transaction;
    txId: string;
}>
Initialize a Pool. This pool will generate with mintsConfigs. Maximum number of tokens in pool = 8 After the init, the authority needs to call initializeJoin to add liquidity and activate the pool.
Parameters
- opts: {
      fee: BN;
      mintLpt?: Keypair;
      mintsConfigs: MintConfigs[];
      pool?: Keypair;
      sendAndConfirm?: boolean;
      tax: BN;
      taxman: Address;
  }
  Input:
  - fee: BN
    The fee of swap.
  - Optional mintLpt?: Keypair
    The LP token keypair.
  - mintsConfigs: MintConfigs[]
    List mint config of pool (pk, treasury, weight, action status).
  - Optional pool?: Keypair
    The pool keypair.
  - Optional sendAndConfirm?: boolean
    (true) Send and confirm the transaction.
  - tax: BN
    The tax (platform fee) of swap.
  - taxman: Address
    The taxman address.
Returns Promise<{
    poolAddress: string;
    tx: Transaction;
    txId: string;
}>
- Defined in lib/program.ts:139

parsePoolData

parsePoolData(data): DecodeStruct<{
    fields: [{
        name: "authority";
        type: "publicKey";
    }, {
        name: "fee";
        type: "u64";
    }, {
        name: "tax";
        type: "u64";
    }, {
        name: "state";
        type: {
            defined: "PoolState";
        };
    }, {
        name: "mintLpt";
        type: "publicKey";
    }, {
        name: "taxman";
        type: "publicKey";
    }, {
        name: "mints";
        type: {
            vec: "publicKey";
        };
    }, {
        name: "actions";
        type: {
            vec: {
                defined: "MintActionState";
            };
        };
    }];
    kind: "struct";
}, DecodedHelper<[{
    docs: ["", "Pool state", ""];
    name: "PoolState";
    type: {
        kind: "enum";
        variants: [{
            name: "Uninitialized";
        }, {
            name: "Initialized";
        }, {
            name: "Frozen";
        }, {
            name: "Deleted";
        }, {
            name: "Initializing";
        }];
    };
}, {
    docs: ["", "Mint state", ""];
    name: "MintActionState";
    type: {
        kind: "enum";
        variants: [{
            name: "Active";
        }, {
            name: "BidOnly";
        }, {
            name: "AskOnly";
        }, {
            name: "Paused";
        }];
    };
}], EmptyDefined>>
Parse pool buffer data.
Parameters
- data: Buffer
  Pool buffer data.
Returns DecodeStruct<{
    fields: [{
        name: "authority";
        type: "publicKey";
    }, {
        name: "fee";
        type: "u64";
    }, {
        name: "tax";
        type: "u64";
    }, {
        name: "state";
        type: {
            defined: "PoolState";
        };
    }, {
        name: "mintLpt";
        type: "publicKey";
    }, {
        name: "taxman";
        type: "publicKey";
    }, {
        name: "mints";
        type: {
            vec: "publicKey";
        };
    }, {
        name: "actions";
        type: {
            vec: {
                defined: "MintActionState";
            };
        };
    }];
    kind: "struct";
}, DecodedHelper<[{
    docs: ["", "Pool state", ""];
    name: "PoolState";
    type: {
        kind: "enum";
        variants: [{
            name: "Uninitialized";
        }, {
            name: "Initialized";
        }, {
            name: "Frozen";
        }, {
            name: "Deleted";
        }, {
            name: "Initializing";
        }];
    };
}, {
    docs: ["", "Mint state", ""];
    name: "MintActionState";
    type: {
        kind: "enum";
        variants: [{
            name: "Active";
        }, {
            name: "BidOnly";
        }, {
            name: "AskOnly";
        }, {
            name: "Paused";
        }];
    };
}], EmptyDefined>>
Pool readable data.
- Defined in lib/program.ts:37

removeLiquidity

removeLiquidity(opts): Promise<{
tx: Transaction;
txId: string;
}>
Remove liquidity.
Parameters
- opts: {
      amount: BN;
      poolAddress: Address;
      sendAndConfirm?: boolean;
  }
  Input:
  - amount: BN
    Amount of LP tokens
  - poolAddress: Address
    Pool address
  - Optional sendAndConfirm?: boolean
    (true) Send and confirm the transaction.
Returns Promise<{
tx: Transaction;
txId: string;
}>
- Defined in lib/program.ts:338

route

route(opts): Promise<{
tx: Transaction;
txId: string;
}>
Swap multiple hops in once.
Parameters
- opts: {
      bidAmount: BN;
      limit: BN;
      routes: {
          askMint: Address;
          bidMint: Address;
          pool: Address;
      }[];
      sendAndConfirm?: boolean;
  }
  Input:
  - bidAmount: BN
    Bid amount
  - limit: BN
    The bottom limit is to prevent slippage rate.
  - routes: {
        askMint: Address;
        bidMint: Address;
        pool: Address;
    }[]
    The route specification
  - Optional sendAndConfirm?: boolean
    (true) Send and confirm the transaction.
Returns Promise<{
tx: Transaction;
txId: string;
}>
- Defined in lib/program.ts:515

swap

swap(opts): Promise<{
tx: Transaction;
txId: string;
}>
Swap tokens. This function is to swap on a signle hop. If you intent to swap multiple hops, you route instead.
Parameters
- opts: {
      askMint: Address;
      bidAmount: BN;
      bidMint: Address;
      limit: BN;
      poolAddress: Address;
      referralAddresses?: Address[];
      sendAndConfirm?: boolean;
  }
  Input:
  - askMint: Address
    Ask token address
  - bidAmount: BN
    Bid Amount
  - bidMint: Address
    Bid token address
  - limit: BN
    The bottom limit. It prevents large slippage rate.
  - poolAddress: Address
    Pool address
  - Optional referralAddresses?: Address[]
    The list of referral addresses.
  - Optional sendAndConfirm?: boolean
    (true) Send and confirm the transaction.
Returns Promise<{
tx: Transaction;
txId: string;
}>
- Defined in lib/program.ts:424

thawPool

thawPool(opts): Promise<{
tx: Transaction;
txId: string;
}>
Thaw a pool.
Parameters
- opts: {
  poolAddress: Address;
  sendAndConfirm?: boolean;
  }
  Input:
  - poolAddress: Address
    Pool address
  - Optional sendAndConfirm?: boolean
    (true) Send and confirm the transaction.
Returns Promise<{
tx: Transaction;
txId: string;
}>
- Defined in lib/program.ts:759

transferOwnership

transferOwnership(opts): Promise<{
tx: Transaction;
txId: string;
}>
Transfer pool ownership.
Parameters
- opts: {
      newOwner: Address;
      poolAddress: Address;
      sendAndConfirm?: boolean;
  }
  Input:
  - newOwner: Address
    New owner address
  - poolAddress: Address
    Pool address
  - Optional sendAndConfirm?: boolean
    (true) Send and confirm the transaction.
Returns Promise<{
tx: Transaction;
txId: string;
}>
- Defined in lib/program.ts:788

unwatch

unwatch(watchId): Promise<void>
Unwatch a watcher by the watch id
Parameters
- watchId: number
Returns Promise<void>
- Defined in lib/program.ts:118

updateActions

updateActions(opts): Promise<{
tx: Transaction;
txId: string;
}>
Update token actions in a pool.
Parameters
- opts: {
      actions: DecodeEnum<{
          kind: "enum";
          variants: [{
              name: "Active";
          }, {
              name: "BidOnly";
          }, {
              name: "AskOnly";
          }, {
              name: "Paused";
          }];
      }, EmptyDefined>[];
      poolAddress: Address;
      sendAndConfirm?: boolean;
  }
  Input:
  - actions: DecodeEnum<{
        kind: "enum";
        variants: [{
            name: "Active";
        }, {
            name: "BidOnly";
        }, {
            name: "AskOnly";
        }, {
            name: "Paused";
        }];
    }, EmptyDefined>[]
    Token actions
  - poolAddress: Address
    Pool address
  - Optional sendAndConfirm?: boolean
    (true) Send and confirm the transaction.
Returns Promise<{
tx: Transaction;
txId: string;
}>
- Defined in lib/program.ts:642

updateFee

updateFee(opts): Promise<{
tx: Transaction;
txId: string;
}>
Update pool fee & tax
Parameters
- opts: {
      fee: BN;
      poolAddress: Address;
      sendAndConfirm?: boolean;
      tax: BN;
  }
  Input:
  - fee: BN
    New fee
  - poolAddress: Address
    Pool address
  - Optional sendAndConfirm?: boolean
    (true) Send and confirm the transaction.
  - tax: BN
    New tax
Returns Promise<{
tx: Transaction;
txId: string;
}>
- Defined in lib/program.ts:882

updateWeights

updateWeights(opts): Promise<{
tx: Transaction;
txId: string;
}>
Update token weights in a pool.
Parameters
- opts: {
      poolAddress: Address;
      sendAndConfirm?: boolean;
      weights: BN[];
  }
  Input:
  - poolAddress: Address
    Pool address
  - Optional sendAndConfirm?: boolean
    (true) Send and confirm the transaction.
  - weights: BN[]
    Token weights
Returns Promise<{
tx: Transaction;
txId: string;
}>
- Defined in lib/program.ts:673

watch

watch(callback, filters?): number
Watch account changes
Parameters
- callback: ((error, data) => void)
  Callback function
  - - (error, data): void
    - Parameters
      error: null | string
      data: null | Omit<BalancerAccountChangeInfo, "data"> & {
          data: DecodeStruct<{
              fields: [{
                  name: "authority";
                  type: "publicKey";
              }, {
                  name: "fee";
                  type: "u64";
              }, {
                  name: "tax";
                  type: "u64";
              }, {
                  name: "state";
                  type: {
                      defined: "PoolState";
                  };
              }, {
                  name: "mintLpt";
                  type: "publicKey";
              }, {
                  name: "taxman";
                  type: "publicKey";
              }, {
                  name: "mints";
                  type: {
                      vec: "publicKey";
                  };
              }, {
                  name: "actions";
                  type: {
                      vec: {
                          defined: "MintActionState";
                      };
                  };
              }];
              kind: "struct";
          }, DecodedHelper<[{
              docs: ["", "Pool state", ""];
              name: "PoolState";
              type: {
                  kind: "enum";
                  variants: [{
                      name: "Uninitialized";
                  }, {
                      name: "Initialized";
                  }, {
                      name: "Frozen";
                  }, {
                      name: "Deleted";
                  }, {
                      name: "Initializing";
                  }];
              };
          }, {
              docs: ["", "Mint state", ""];
              name: "MintActionState";
              type: {
                  kind: "enum";
                  variants: [{
                      name: "Active";
                  }, {
                      name: "BidOnly";
                  }, {
                      name: "AskOnly";
                  }, {
                      name: "Paused";
                  }];
              };
          }], EmptyDefined>>;
      }
      Returns void
- Optional filters: GetProgramAccountsFilter[]
  Event filters
Returns number
Watch id
- Defined in lib/program.ts:80

Class default

Hierarchy

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

provider: AnchorProvider

programId: string

Returns default

Properties

Readonly program

Methods

addLiquidity

Parameters

opts: { amounts: BN[]; poolAddress: Address; sendAndConfirm?: boolean; }

amounts: BN[]

poolAddress: Address

Optional sendAndConfirm?: boolean

Returns Promise<{ tx: Transaction; txId: string; }>

closePool

Parameters

opts: { poolAddress: Address; sendAndConfirm?: boolean; }

poolAddress: Address

Optional sendAndConfirm?: boolean

Returns Promise<{ tx: Transaction; txId: string; }>

deriveTreasurerAddress

Parameters

poolAddress: Address

Returns string

finalizePool

Parameters

opts: { poolAddress: Address; sendAndConfirm?: boolean; }

poolAddress: Address

Optional sendAndConfirm?: boolean

Returns Promise<{ tx: Transaction; txId: string; }>

freezePool

Parameters

opts: { poolAddress: Address; sendAndConfirm?: boolean; }

poolAddress: Address

Optional sendAndConfirm?: boolean

Returns Promise<{ tx: Transaction; txId: string; }>

getAllPoolData

getPoolData

Parameters

poolAddress: Address

initializeJoin

Parameters

opts: { amount: BN; mint: Address; poolAddress: Address; sendAndConfirm?: boolean; }

amount: BN

mint: Address

poolAddress: Address

Optional sendAndConfirm?: boolean

Returns Promise<{ tx: Transaction; txId: string; }>

initializePool

Parameters

opts: { fee: BN; mintLpt?: Keypair; mintsConfigs: MintConfigs[]; pool?: Keypair; sendAndConfirm?: boolean; tax: BN; taxman: Address; }

fee: BN

Optional mintLpt?: Keypair

mintsConfigs: MintConfigs[]

Optional pool?: Keypair

Optional sendAndConfirm?: boolean

tax: BN

taxman: Address

Returns Promise<{ poolAddress: string; tx: Transaction; txId: string; }>

parsePoolData

Parameters

data: Buffer

removeLiquidity

Parameters

opts: { amount: BN; poolAddress: Address; sendAndConfirm?: boolean; }

amount: BN

poolAddress: Address

Optional sendAndConfirm?: boolean

Returns Promise<{ tx: Transaction; txId: string; }>

route

Parameters

opts: { bidAmount: BN; limit: BN; routes: { askMint: Address; bidMint: Address; pool: Address; }[]; sendAndConfirm?: boolean; }

`Readonly` program

opts: {
amounts: BN[];
poolAddress: Address;
sendAndConfirm?: boolean;
}

`Optional` sendAndConfirm?: boolean

Returns Promise<{
tx: Transaction;
txId: string;
}>

opts: {
poolAddress: Address;
sendAndConfirm?: boolean;
}

`Optional` sendAndConfirm?: boolean

Returns Promise<{
tx: Transaction;
txId: string;
}>

opts: {
poolAddress: Address;
sendAndConfirm?: boolean;
}

`Optional` sendAndConfirm?: boolean

Returns Promise<{
tx: Transaction;
txId: string;
}>

opts: {
poolAddress: Address;
sendAndConfirm?: boolean;
}

`Optional` sendAndConfirm?: boolean

Returns Promise<{
tx: Transaction;
txId: string;
}>

opts: {
amount: BN;
mint: Address;
poolAddress: Address;
sendAndConfirm?: boolean;
}

`Optional` sendAndConfirm?: boolean

Returns Promise<{
tx: Transaction;
txId: string;
}>

opts: {
fee: BN;
mintLpt?: Keypair;
mintsConfigs: MintConfigs[];
pool?: Keypair;
sendAndConfirm?: boolean;
tax: BN;
taxman: Address;
}

`Optional` mintLpt?: Keypair

`Optional` pool?: Keypair

`Optional` sendAndConfirm?: boolean

Returns Promise<{
poolAddress: string;
tx: Transaction;
txId: string;
}>

opts: {
amount: BN;
poolAddress: Address;
sendAndConfirm?: boolean;
}

`Optional` sendAndConfirm?: boolean

Returns Promise<{
tx: Transaction;
txId: string;
}>

opts: {
bidAmount: BN;
limit: BN;
routes: {
askMint: Address;
bidMint: Address;
pool: Address;
}[];
sendAndConfirm?: boolean;
}

routes: {
askMint: Address;
bidMint: Address;
pool: Address;
}[]

`Optional` sendAndConfirm?: boolean

Returns Promise<{
tx: Transaction;
txId: string;
}>

opts: {
askMint: Address;
bidAmount: BN;
bidMint: Address;
limit: BN;
poolAddress: Address;
referralAddresses?: Address[];
sendAndConfirm?: boolean;
}

`Optional` referralAddresses?: Address[]

`Optional` sendAndConfirm?: boolean

Returns Promise<{
tx: Transaction;
txId: string;
}>

opts: {
poolAddress: Address;
sendAndConfirm?: boolean;
}

`Optional` sendAndConfirm?: boolean

Returns Promise<{
tx: Transaction;
txId: string;
}>

opts: {
newOwner: Address;
poolAddress: Address;
sendAndConfirm?: boolean;
}

`Optional` sendAndConfirm?: boolean

Returns Promise<{
tx: Transaction;
txId: string;
}>

opts: {
actions: DecodeEnum<{
kind: "enum";
variants: [{
name: "Active";
}, {
name: "BidOnly";
}, {
name: "AskOnly";
}, {
name: "Paused";
}];
}, EmptyDefined>[];
poolAddress: Address;
sendAndConfirm?: boolean;
}

actions: DecodeEnum<{
kind: "enum";
variants: [{
name: "Active";
}, {
name: "BidOnly";
}, {
name: "AskOnly";
}, {
name: "Paused";
}];
}, EmptyDefined>[]

`Optional` sendAndConfirm?: boolean

Returns Promise<{
tx: Transaction;
txId: string;
}>

opts: {
fee: BN;
poolAddress: Address;
sendAndConfirm?: boolean;
tax: BN;
}

`Optional` sendAndConfirm?: boolean

Returns Promise<{
tx: Transaction;
txId: string;
}>

opts: {
poolAddress: Address;
sendAndConfirm?: boolean;
weights: BN[];
}

`Optional` sendAndConfirm?: boolean

Returns Promise<{
tx: Transaction;
txId: string;
}>

`Optional` filters: GetProgramAccountsFilter[]