IndexPool.sol

IndexPool
Controls
configure
function configure(address controller, string name, string symbol)
Sets the controller address and the token name & symbol. Note: This saves on storage costs for multi-step pool deployment.
initialize
function initialize(address[] tokens, uint256[] balances, uint96[] denorms, address tokenProvider, address unbindHandler)
Sets up the initial assets for the pool. Note: tokenProvider must have approved the pool to transfer the corresponding balances of tokens.
setMaxPoolTokens
function setMaxPoolTokens(uint256 maxPoolTokens)
Sets the maximum number of pool tokens that can be minted. This value will be used in the alpha to limit the maximum damage that can be caused by a catastrophic error. It can be gradually increased as the pool continues to not be exploited. If it is set to 0, the limit will be removed.
setSwapFee
function setSwapFee(uint256 swapFee)
Set the swap fee. Note: Swap fee must be between 0.0001% and 10%
reweighTokens
function reweighTokens(address[] tokens, uint96[] desiredDenorms)
Sets the desired weights for the pool tokens, which will be adjusted over time as they are swapped. Note: This does not check for duplicate tokens or that the total of the desired weights is equal to the target total weight (25). Those assumptions should be met in the controller. Further, the provided tokens should only include the tokens which are not set for removal.
reindexTokens
function reindexTokens(address[] tokens, uint96[] desiredDenorms, uint256[] minimumBalances)
Update the underlying assets held by the pool and their associated weights. Tokens which are not currently bound will be gradually added as they are swapped in to reach the provided minimum balances, which must be an amount of tokens worth the minimum weight of the total pool value. If a currently bound token is not received in this call, the token's desired weight will be set to 0.
setMinimumBalance
function setMinimumBalance(address token, uint256 minimumBalance)
Updates the minimum balance for an uninitialized token. This becomes useful if a token's external price significantly rises after being bound, since the pool can not send a token out until it reaches the minimum balance.
Liquidity Provider Actions
joinPool
function joinPool(uint256 poolAmountOut, uint256[] maxAmountsIn)
Mint new pool tokens by providing the proportional amount of each underlying token's balance relative to the proportion of pool tokens minted. For any underlying tokens which are not initialized, the caller must provide the proportional share of the minimum balance for the token rather than the actual balance.
joinswapExternAmountIn
function joinswapExternAmountIn(address tokenIn, uint256 tokenAmountIn, uint256 minPoolAmountOut) returns (uint256)
Pay tokenAmountIn of tokenIn to mint at least minPoolAmountOut pool tokens. The pool implicitly swaps (1- weightTokenIn) * tokenAmountIn to the other underlying tokens. Thus a swap fee is charged against the input tokens.
joinswapPoolAmountOut
function joinswapPoolAmountOut(address tokenIn, uint256 poolAmountOut, uint256 maxAmountIn) returns (uint256)
Pay up to maxAmountIn of tokenIn to mint exactly poolAmountOut. The pool implicitly swaps (1- weightTokenIn) * tokenAmountIn to the other underlying tokens. Thus a swap fee is charged against the input tokens.
exitPool
function exitPool(uint256 poolAmountIn, uint256[] minAmountsOut)
Burns poolAmountIn pool tokens in exchange for the amounts of each underlying token's balance proportional to the ratio of tokens burned to total pool supply. The amount of each token transferred to the caller must be greater than or equal to the associated minimum output amount from the minAmountsOut array.
Swaps & Flash Loans
exitswapPoolAmountIn
function exitswapPoolAmountIn(address tokenOut, uint256 poolAmountIn, uint256 minAmountOut) returns (uint256)
Burns poolAmountIn pool tokens in exchange for at least minAmountOut of tokenOut. Returns the number of tokens sent to the caller. The pool implicitly burns the tokens for all underlying tokens and swaps them to the desired output token. A swap fee is charged against the output tokens.
exitswapExternAmountOut
function exitswapExternAmountOut(address tokenOut, uint256 tokenAmountOut, uint256 maxPoolAmountIn) returns (uint256)
Burn up to maxPoolAmountIn for exactly tokenAmountOut of tokenOut. Returns the number of pool tokens burned. The pool implicitly burns the tokens for all underlying tokens and swaps them to the desired output token. A swap fee is charged against the output tokens.
gulp
function gulp(address token)
Absorb any tokens that have been sent to the pool. If the token is not bound, it will be sent to the unbound token handler.
flashBorrow
function flashBorrow(address recipient, address token, uint256 amount, bytes data)
Execute a flash loan, transferring amount of token to recipient. amount must be repaid with swapFee interest by the end of the transaction.
swapExactAmountIn
function swapExactAmountIn(address tokenIn, uint256 tokenAmountIn, address tokenOut, uint256 minAmountOut, uint256 maxPrice) returns (uint256, uint256)
Execute a token swap with a specified amount of input tokens and a minimum amount of output tokens. Note: Will revert if tokenOut is uninitialized.
swapExactAmountOut
function swapExactAmountOut(address tokenIn, uint256 maxAmountIn, address tokenOut, uint256 tokenAmountOut, uint256 maxPrice) returns (uint256, uint256)
Trades at most maxAmountIn of tokenIn for exactly tokenAmountOut of tokenOut. Returns the actual input amount and the new spot price after the swap, which can not exceed maxPrice.
Queries
isPublicSwap
function isPublicSwap() returns (bool)
Check if swapping tokens and joining the pool is allowed.
getSwapFee
function getSwapFee() returns (uint256)
getController
function getController() returns (address)
Returns the controller address.
getMaxPoolTokens
function getMaxPoolTokens() returns (uint256)
Returns the maximum supply. If zero, there is no maximum.
isBound
function isBound(address t) returns (bool)
Check if a token is bound to the pool.
getNumTokens
function getNumTokens() returns (uint256)
Get the number of tokens bound to the pool.
getCurrentTokens
function getCurrentTokens() returns (address[] tokens)
Get all bound tokens.
getCurrentDesiredTokens
function getCurrentDesiredTokens() returns (address[] tokens)
Returns the list of tokens which have a desired weight above 0. Tokens with a desired weight of 0 are set to be phased out of the pool.
getDenormalizedWeight
function getDenormalizedWeight(address token) returns (uint256)
Returns the denormalized weight of a bound token.
getTokenRecord
function getTokenRecord(address token) returns (struct IIndexPool.Record record)
Returns the record for a token bound to the pool.
extrapolatePoolValueFromToken
function extrapolatePoolValueFromToken() returns (address, uint256)
Finds the first token which is both initialized and has a desired weight above 0, then returns the address of that token and the extrapolated value of the pool in terms of that token. The value is extrapolated by multiplying the token's balance by the reciprocal of its normalized weight.
getTotalDenormalizedWeight
function getTotalDenormalizedWeight() returns (uint256)
Get the total denormalized weight of the pool.
getBalance
function getBalance(address token) returns (uint256)
Returns the stored balance of a bound token.
getMinimumBalance
function getMinimumBalance(address token) returns (uint256)
Get the minimum balance of an uninitialized token. Note: Throws if the token is initialized.
getUsedBalance
function getUsedBalance(address token) returns (uint256)
Returns the balance of a token which is used in price calculations. If the token is initialized, this is the stored balance; if not, this is the minimum balance.
getSpotPrice
function getSpotPrice(address tokenIn, address tokenOut) returns (uint256)
Returns the spot price for tokenOut in terms of tokenIn.
Internal Functions
_pullPoolShare
function _pullPoolShare(address from, uint256 amount)
_pushPoolShare
function _pushPoolShare(address to, uint256 amount)
_mintPoolShare
function _mintPoolShare(uint256 amount)
_burnPoolShare
function _burnPoolShare(uint256 amount)
_pullUnderlying
function _pullUnderlying(address erc20, address from, uint256 amount)
_pushUnderlying
function _pushUnderlying(address erc20, address to, uint256 amount)
_bind
function _bind(address token, uint256 minimumBalance, uint96 desiredDenorm)
Bind a token by address without actually depositing a balance. The token will be unable to be swapped out until it reaches the minimum balance. Note: Token must not already be bound. Note: minimumBalance should represent an amount of the token which is worth the portion of the current pool value represented by the minimum weight.
_unbind
function _unbind(address token)
Remove a token from the pool. Replaces the address in the tokens array with the last address, then removes it from the array. Note: This should only be called after the total weight has been adjusted. Note: Must be called in a function with:
lock modifier to prevent reentrance
requirement that the token is bound
_setDesiredDenorm
function _setDesiredDenorm(address token, uint96 desiredDenorm)
_increaseDenorm
function _increaseDenorm(struct IIndexPool.Record record, address token)
_decreaseDenorm
function _decreaseDenorm(struct IIndexPool.Record record, address token)
_updateInputToken
function _updateInputToken(address token, struct IIndexPool.Record record, uint256 realBalance)
Handles weight changes and initialization of an input token. If the token is not initialized and the new balance is still below the minimum, this will not do anything. If the token is not initialized but the new balance will bring the token above the minimum balance, this will mark the token as initialized, remove the minimum balance and set the weight to the minimum weight plus 1%.
_getInputToken
function _getInputToken(address token) returns (struct IIndexPool.Record record, uint256 realBalance)
Get the record for a token which is being swapped in. The token must be bound to the pool. If the token is not initialized (meaning it does not have the minimum balance) this function will return the actual balance of the token which the pool holds, but set the record's balance and weight to the token's minimum balance and the pool's minimum weight. This allows the token swap to be priced correctly even if the pool does not own any of the tokens.
_getOutputToken
function _getOutputToken(address token) returns (struct IIndexPool.Record record)
Index Pool Smart Contracts - Previous
Deployments
Next - Index Pool Smart Contracts
PoolInitializer.sol
Last modified 1yr ago