def rebind(self, token_address: str, balance_base: int, weight_base: int, from_wallet: web3wallet.Web3Wallet): """ Changes the parameters of an already-bound token. Performs the same validation on the parameters. """ func = self.f.rebind(token_address, balance_base, weight_base) web3wallet.buildAndSendTx(func, from_wallet)
def unbind(self, token_address: str, from_wallet: web3wallet.Web3Wallet): """ Unbinds a token, clearing all of its parameters. Exit fee is charged and the remaining balance is sent to caller. """ func = self.f.unbind(token_address) return web3wallet.buildAndSendTx(func, from_wallet)
def setSwapFee(self, swapFee_base: int, from_wallet: web3wallet.Web3Wallet): """ Caller must be controller. Pool must NOT be finalized. """ func = self.f.setSwapFee(swapFee_base) return web3wallet.buildAndSendTx(func, from_wallet)
def swapExactAmountIn( self, tokenIn_address: str, tokenAmountIn_base: int, tokenOut_address: str, minAmountOut_base: int, maxPrice_base: int, from_wallet: web3wallet.Web3Wallet): """ Trades an exact `tokenAmountIn` of `tokenIn` taken from the caller by the pool, in exchange for at least `minAmountOut` of `tokenOut` given to the caller from the pool, with a maximum marginal price of `maxPrice`. Returns `(tokenAmountOut`, `spotPriceAfter)`, where `tokenAmountOut` is the amount of token that came out of the pool, and `spotPriceAfter` is the new marginal spot price, ie, the result of `getSpotPrice` after the call. (These values are what are limited by the arguments; you are guaranteed `tokenAmountOut >= minAmountOut` and `spotPriceAfter <= maxPrice)`. """ func = self.f.swapExactAmountIn( tokenIn_address, tokenAmountIn_base, tokenOut_address, minAmountOut_base, maxPrice_base) return web3wallet.buildAndSendTx(func, from_wallet)
def swapExactAmountOut(self, tokenIn_address: str, maxAmountIn_base: int, tokenOut_address: str, tokenAmountOut_base: int, maxPrice_base: int, from_wallet: web3wallet.Web3Wallet): func = self.f.swapExactAmountOut(tokenIn_address, maxAmountIn_base, tokenOut_address, tokenAmountOut_base, maxPrice_base) return web3wallet.buildAndSendTx(func, from_wallet)
def setPublicSwap(self, public: bool, from_wallet: web3wallet.Web3Wallet): """ Makes `isPublicSwap` return `_publicSwap`. Requires caller to be controller and pool not to be finalized. Finalized pools always have public swap. """ func = self.f.setPublicSwap(public) return web3wallet.buildAndSendTx(func, from_wallet)
def finalize(self, from_wallet: web3wallet.Web3Wallet): """ This makes the pool **finalized**. This is a one-way transition. `bind`, `rebind`, `unbind`, `setSwapFee` and `setPublicSwap` will all throw `ERR_IS_FINALIZED` after pool is finalized. This also switches `isSwapPublic` to true. """ func = self.f.finalize() return web3wallet.buildAndSendTx(func, from_wallet)
def exitswapPoolAmountIn(self, tokenOut_address: str, poolAmountIn_base: int, minAmountOut_base: int, from_wallet: web3wallet.Web3Wallet): """ Pay `poolAmountIn` pool shares into the pool, getting `tokenAmountOut` of the given token `tokenOut` out of the pool. """ func = self.f.exitswapPoolAmountIn(tokenOut_address, poolAmountIn_base, minAmountOut_base) return web3wallet.buildAndSendTx(func, from_wallet)
def exitPool(self, poolAmountIn_base: int, minAmountsOut_base: typing.List[int], from_wallet: web3wallet.Web3Wallet): """ Exit the pool, paying `poolAmountIn` pool tokens and getting some of each of the currently trading tokens in return. These values are limited by the array of `minAmountsOut` in the order of the pool tokens. """ func = self.f.exitPool(poolAmountIn_base, minAmountsOut_base) return web3wallet.buildAndSendTx(func, from_wallet)
def joinPool(self, poolAmountOut_base: int, maxAmountsIn_base: typing.List[int], from_wallet: web3wallet.Web3Wallet): """ Join the pool, getting `poolAmountOut` pool tokens. This will pull some of each of the currently trading tokens in the pool, meaning you must have called `approve` for each token for this pool. These values are limited by the array of `maxAmountsIn` in the order of the pool tokens. """ func = self.f.joinPool(poolAmountOut_base, maxAmountsIn_base) return web3wallet.buildAndSendTx(func, from_wallet)
def joinswapExternAmountIn(self, tokenIn_address: str, tokenAmountIn_base: int, minPoolAmountOut_base: int, from_wallet: web3wallet.Web3Wallet): """ Pay `tokenAmountIn` of token `tokenIn` to join the pool, getting `poolAmountOut` of the pool shares. """ func = self.f.joinswapExternAmountIn(tokenIn_address, tokenAmountIn_base, minPoolAmountOut_base) return web3wallet.buildAndSendTx(func, from_wallet)
def joinswapPoolAmountOut(self, tokenIn_address: str, poolAmountOut_base: int, maxAmountIn_base: int, from_wallet: web3wallet.Web3Wallet): """ Specify `poolAmountOut` pool shares that you want to get, and a token `tokenIn` to pay with. This costs `maxAmountIn` tokens (these went into the pool). """ func = self.f.joinswapPoolAmountOut(tokenIn_address, poolAmountOut_base, maxAmountIn_base) return web3wallet.buildAndSendTx(func, from_wallet)
def createToken(self, blob: str, name: str, symbol: str, cap_base: int, from_wallet: web3wallet.Web3Wallet) -> str: f = self.contract.functions.createToken(blob, name, symbol, cap_base) (tx_hash, tx_receipt) = web3wallet.buildAndSendTx(f, from_wallet) warnings.filterwarnings("ignore") #ignore unwarranted warning up next rich_logs = getattr(self.contract.events, 'TokenCreated')().processReceipt(tx_receipt) token_address = rich_logs[0]['args']['newTokenAddress'] warnings.resetwarnings() return token_address
def exitswapExternAmountOut(self, tokenOut_address: str, tokenAmountOut_base: int, maxPoolAmountIn_base: int, from_wallet: web3wallet.Web3Wallet): """ Specify `tokenAmountOut` of token `tokenOut` that you want to get out of the pool. This costs `poolAmountIn` pool shares (these went into the pool). """ func = self.f.exitswapExternAmountOut(tokenOut_address, tokenAmountOut_base, maxPoolAmountIn_base) return web3wallet.buildAndSendTx(func, from_wallet)
def newBPool(self, from_wallet: web3wallet.Web3Wallet) -> str: print("BPool.newSPool(). Begin.") f = self.contract.functions.newBPool() (tx_hash, tx_receipt) = web3wallet.buildAndSendTx(f, from_wallet) # grab pool_address warnings.filterwarnings("ignore") #ignore unwarranted warning up next rich_logs = self.contract.events.BPoolCreated().processReceipt( tx_receipt) warnings.resetwarnings() pool_address = rich_logs[0]['args']['newBPoolAddress'] print(f" pool_address = {pool_address}") print("BPool.newSPool(). Done.") return pool_address
def gulp(self, token_address: str, from_wallet: web3wallet.Web3Wallet): """ This syncs the internal `balance` of `token` within a pool with the actual `balance` registered on the ERC20 contract. This is useful to wallet for airdropped tokens or any tokens sent to the pool without using the `join` or `joinSwap` methods. As an example, pools that contain `COMP` tokens can have the `COMP` balance updated with the rewards sent by Compound (https://etherscan.io/tx/0xeccd42bf2b8a180a561c026717707d9024a083059af2f22c197ee511d1010e23). In order for any airdrop balance to be gulped, the token must be bound to the pool. So if a shared pool (which is immutable) does not have a given token, any airdrops in that token will be locked in the pool forever. """ func = self.f.gulp(token_address) return web3wallet.buildAndSendTx(func, from_wallet)
def bind(self, token_address: str, balance_base: int, weight_base: int, from_wallet: web3wallet.Web3Wallet): """ Binds the token with address `token`. Tokens will be pushed/pulled from caller to adjust match new balance. Token must not already be bound. `balance` must be a valid balance and denorm must be a valid denormalized weight. `bind` creates the token record and then calls `rebind` for updating pool weights and token transfers. Possible errors: -`ERR_NOT_CONTROLLER` -- caller is not the controller -`ERR_IS_BOUND` -- T is already bound -`ERR_IS_FINALIZED` -- isFinalized() is true -`ERR_ERC20_FALSE` -- ERC20 token returned false -`ERR_MAX_TOKENS` -- Only 8 tokens are allowed per pool -unspecified error thrown by token """ func = self.f.bind(token_address, balance_base, weight_base) return web3wallet.buildAndSendTx(func, from_wallet)
def approve(self, spender_address: str, amt_base: int, from_wallet: web3wallet.Web3Wallet): f = self.contract.functions.approve(spender_address, amt_base) return web3wallet.buildAndSendTx(f, from_wallet)
def transfer(self, dst_address: str, amt_base: int, from_wallet: web3wallet.Web3Wallet): f = self.contract.functions.transfer(dst_address, amt_base) return web3wallet.buildAndSendTx(f, from_wallet)
def setMinter(self, minter: str, from_wallet: web3wallet.Web3Wallet): f = self.contract.functions.setMinter(minter) return web3wallet.buildAndSendTx(f, from_wallet)
def mint(self, account: str, value_base: int, from_wallet: web3wallet.Web3Wallet): f = self.contract.functions.mint(account, value_base) return web3wallet.buildAndSendTx(f, from_wallet)
def transferFrom(self, src_address: str, dst_address: str, amt_base: int, from_wallet: web3wallet.Web3Wallet): func = self.f.transferFrom(dst_address, src_address, amt_base) return web3wallet.buildAndSendTx(func, from_wallet)
def approve(self, dst_address: str, amt_base: int, from_wallet: web3wallet.Web3Wallet): func = self.f.approve(dst_address, amt_base) return web3wallet.buildAndSendTx(func, from_wallet)
def setController(self, manager_address: str, from_wallet: web3wallet.Web3Wallet): func = self.f.setController(manager_address) return web3wallet.buildAndSendTx(func, from_wallet)