Address Details
contract
0xdBF27fD2a702Cc02ac7aCF0aea376db780D53247
- Contract Name
- Swap
- Creator
- 0x59a6ab–4883d9 at 0x5eafd4–699b08
- Balance
- 0 CELO ( )
- Locked CELO Balance
- 0.00 CELO
- Voting CELO Balance
- 0.00 CELO
- Pending Unlocked Gold
- 0.00 CELO
- Tokens
-
Fetching tokens...
- Transactions
- 5,743 Transactions
- Transfers
- 9,945 Transfers
- Gas Used
- 1,037,088,379
- Last Balance Update
- 25169324
Transactions
Token Transfers
Tokens
Internal Transactions
Coin Balance History
Logs
Code
Read Contract
Write Contract
This contract has been partially verified via Sourcify.
View contract in Sourcify repository
- Contract name:
- Swap
- Optimization enabled
- true
- Compiler version
- v0.6.12+commit.27d51765
- Optimization runs
- 200
- EVM Version
- istanbul
- Verified at
- 2022-01-09T08:49:05.343286Z
project:/contracts/Swap.sol
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; import './openzeppelin-contracts@3.4.0/contracts/math/SafeMath.sol'; import './openzeppelin-contracts@3.4.0/contracts/token/ERC20/SafeERC20.sol'; import './openzeppelin-contracts@3.4.0/contracts/utils/ReentrancyGuard.sol'; import "./OwnerPausable.sol"; import "./SwapUtils.sol"; import "./MathUtils.sol"; /** * @title Swap - A StableSwap implementation in solidity. * @notice This contract is responsible for custody of closely pegged assets (eg. group of stablecoins) * and automatic market making system. Users become an LP (Liquidity Provider) by depositing their tokens * in desired ratios for an exchange of the pool token that represents their share of the pool. * Users can burn pool tokens and withdraw their share of token(s). * * Each time a swap between the pooled tokens happens, a set fee incurs which effectively gets * distributed to the LPs. * * In case of emergencies, admin can pause additional deposits, swaps, or single-asset withdraws - which * stops the ratio of the tokens in the pool from changing. * Users can always withdraw their tokens via multi-asset withdraws. * * @dev Most of the logic is stored as a library `SwapUtils` for the sake of reducing contract's * deployment size. */ contract Swap is OwnerPausable, ReentrancyGuard { using SafeERC20 for IERC20; using SafeMath for uint256; using MathUtils for uint256; using SwapUtils for SwapUtils.Swap; // Struct storing data responsible for automatic market maker functionalities. In order to // access this data, this contract uses SwapUtils library. For more details, see SwapUtils.sol SwapUtils.Swap public swapStorage; // Maps token address to an index in the pool. Used to prevent duplicate tokens in the pool. // getTokenIndex function also relies on this mapping to retrieve token index. mapping(address => uint8) private tokenIndexes; /*** EVENTS ***/ // events replicated from SwapUtils to make the ABI easier for dumb // clients event TokenSwap( address indexed buyer, uint256 tokensSold, uint256 tokensBought, uint128 soldId, uint128 boughtId ); event AddLiquidity( address indexed provider, uint256[] tokenAmounts, uint256[] fees, uint256 invariant, uint256 lpTokenSupply ); event RemoveLiquidity( address indexed provider, uint256[] tokenAmounts, uint256 lpTokenSupply ); event RemoveLiquidityOne( address indexed provider, uint256 lpTokenAmount, uint256 lpTokenSupply, uint256 boughtId, uint256 tokensBought ); event RemoveLiquidityImbalance( address indexed provider, uint256[] tokenAmounts, uint256[] fees, uint256 invariant, uint256 lpTokenSupply ); event NewAdminFee(uint256 newAdminFee); event NewSwapFee(uint256 newSwapFee); event NewDepositFee(uint256 newDepositFee); event NewWithdrawFee(uint256 newWithdrawFee); event RampA( uint256 oldA, uint256 newA, uint256 initialTime, uint256 futureTime ); event StopRampA(uint256 currentA, uint256 time); /** * @notice Deploys this Swap contract with given parameters as default * values. This will also deploy a LPToken that represents users * LP position. The owner of LPToken will be this contract - which means * only this contract is allowed to mint new tokens. * * @param _pooledTokens an array of ERC20s this pool will accept * @param decimals the decimals to use for each pooled token, * eg 8 for WBTC. Cannot be larger than POOL_PRECISION_DECIMALS * @param lpTokenName the long-form name of the token to be deployed * @param lpTokenSymbol the short symbol for the token to be deployed * @param _a the amplification coefficient * n * (n - 1). See the * StableSwap paper for details * @param _fee default swap fee to be initialized with * @param _adminFee default adminFee to be initialized with * @param _depositFee default depositFee to be initialized with * @param _withdrawFee default withdrawFee to be initialized with * @param _devaddr default _devaddr to be initialized with */ constructor( IERC20[] memory _pooledTokens, uint8[] memory decimals, string memory lpTokenName, string memory lpTokenSymbol, uint256 _a, uint256 _fee, uint256 _adminFee, uint256 _depositFee, uint256 _withdrawFee, address _devaddr ) public OwnerPausable() ReentrancyGuard() { // Check _pooledTokens and precisions parameter require(_pooledTokens.length > 1, "_pooledTokens.length <= 1"); require(_pooledTokens.length <= 32, "_pooledTokens.length > 32"); require( _pooledTokens.length == decimals.length, "_pooledTokens decimals mismatch" ); uint256[] memory precisionMultipliers = new uint256[](decimals.length); for (uint8 i = 0; i < _pooledTokens.length; i++) { if (i > 0) { // Check if index is already used. Check if 0th element is a duplicate. require( tokenIndexes[address(_pooledTokens[i])] == 0 && _pooledTokens[0] != _pooledTokens[i], "Duplicate tokens" ); } require( address(_pooledTokens[i]) != address(0), "The 0 address isn't an ERC-20" ); require( decimals[i] <= SwapUtils.POOL_PRECISION_DECIMALS, "Token decimals exceeds max" ); precisionMultipliers[i] = 10 ** uint256(SwapUtils.POOL_PRECISION_DECIMALS).sub( uint256(decimals[i]) ); tokenIndexes[address(_pooledTokens[i])] = i; } // Check _a, _fee, _adminFee, _depositFee, _withdrawFee require(_a < SwapUtils.MAX_A, "_a exceeds maximum"); require(_fee < SwapUtils.MAX_SWAP_FEE, "_fee exceeds maximum"); require( _adminFee < SwapUtils.MAX_ADMIN_FEE, "_adminFee exceeds maximum" ); require( _withdrawFee < SwapUtils.MAX_WITHDRAW_FEE, "_withdrawFee exceeds maximum" ); require( _depositFee < SwapUtils.MAX_DEPOSIT_FEE, "_depositFee exceeds maximum" ); // Initialize swapStorage struct swapStorage.lpToken = new LPToken( lpTokenName, lpTokenSymbol, SwapUtils.POOL_PRECISION_DECIMALS ); swapStorage.pooledTokens = _pooledTokens; swapStorage.tokenPrecisionMultipliers = precisionMultipliers; swapStorage.balances = new uint256[](_pooledTokens.length); swapStorage.initialA = _a.mul(SwapUtils.A_PRECISION); swapStorage.futureA = _a.mul(SwapUtils.A_PRECISION); swapStorage.initialATime = 0; swapStorage.futureATime = 0; swapStorage.swapFee = _fee; swapStorage.adminFee = _adminFee; swapStorage.defaultDepositFee = _depositFee; swapStorage.defaultWithdrawFee = _withdrawFee; swapStorage.devaddr = _devaddr; } /*** MODIFIERS ***/ /** * @notice Modifier to check deadline against current timestamp * @param deadline latest timestamp to accept this transaction */ modifier deadlineCheck(uint256 deadline) { require(block.timestamp <= deadline, "Deadline not met"); _; } /*** VIEW FUNCTIONS ***/ /** * @notice Return A, the amplification coefficient * n * (n - 1) * @dev See the StableSwap paper for details * @return A parameter */ function getA() external view returns (uint256) { return swapStorage.getA(); } /** * @notice Return A in its raw precision form * @dev See the StableSwap paper for details * @return A parameter in its raw precision form */ function getAPrecise() external view returns (uint256) { return swapStorage.getAPrecise(); } /** * @notice Return address of the pooled token at given index. Reverts if tokenIndex is out of range. * @param index the index of the token * @return address of the token at given index */ function getToken(uint8 index) public view returns (IERC20) { require(index < swapStorage.pooledTokens.length, "Out of range"); return swapStorage.pooledTokens[index]; } /** * @notice Return the index of the given token address. Reverts if no matching * token is found. * @param tokenAddress address of the token * @return the index of the given token address */ function getTokenIndex(address tokenAddress) external view returns (uint8) { uint8 index = tokenIndexes[tokenAddress]; require( address(getToken(index)) == tokenAddress, "Token does not exist" ); return index; } /** * @notice Return timestamp of last deposit of given address * @return timestamp of the last deposit made by the given address */ function getDepositTimestamp(address user) external view returns (uint256) { return swapStorage.getDepositTimestamp(user); } /** * @notice Return current balance of the pooled token at given index * @param index the index of the token * @return current balance of the pooled token at given index with token's native precision */ function getTokenBalance(uint8 index) external view returns (uint256) { require(index < swapStorage.pooledTokens.length, "Index out of range"); return swapStorage.balances[index]; } /** * @notice Return balances of pooled tokens * @return current balances of all tokens in pool */ function getBalances() external view returns (uint256[] memory) { return swapStorage.balances; } /** @notice Returns the swap fee @return current swap fee */ function getSwapFee() external view returns (uint256) { return swapStorage.swapFee; } /** @notice Returns address of lp token @return address of lp token */ function getLpToken() external view returns (address) { return address(swapStorage.lpToken); } /** * @notice Get the virtual price, to help calculate profit * @return the virtual price, scaled to the POOL_PRECISION_DECIMALS */ function getVirtualPrice() external view returns (uint256) { return swapStorage.getVirtualPrice(); } /** * @notice Calculate amount of tokens you receive on swap * @param tokenIndexFrom the token the user wants to sell * @param tokenIndexTo the token the user wants to buy * @param dx the amount of tokens the user wants to sell. If the token charges * a fee on transfers, use the amount that gets transferred after the fee. * @return amount of tokens the user will receive */ function calculateSwap( uint8 tokenIndexFrom, uint8 tokenIndexTo, uint256 dx ) external view returns (uint256) { return swapStorage.calculateSwap(tokenIndexFrom, tokenIndexTo, dx); } /** * @notice A simple method to calculate prices from deposits or * withdrawals, excluding fees but including slippage. This is * helpful as an input into the various "min" parameters on calls * to fight front-running * * @dev This shouldn't be used outside frontends for user estimates. * * @param account address that is depositing or withdrawing tokens * @param amounts an array of token amounts to deposit or withdrawal, * corresponding to pooledTokens. The amount should be in each * pooled token's native precision. If a token charges a fee on transfers, * use the amount that gets transferred after the fee. * @param deposit whether this is a deposit or a withdrawal * @return token amount the user will receive */ function calculateTokenAmount( address account, uint256[] calldata amounts, bool deposit ) external view returns (uint256) { return swapStorage.calculateTokenAmount(account, amounts, deposit); } /** * @notice A simple method to calculate amount of each underlying * tokens that is returned upon burning given amount of LP tokens * @param account the address that is withdrawing tokens * @param amount the amount of LP tokens that would be burned on withdrawal * @return array of token balances that the user will receive */ function calculateRemoveLiquidity(address account, uint256 amount) external view returns (uint256[] memory) { return swapStorage.calculateRemoveLiquidity(account, amount); } /** * @notice Calculate the amount of underlying token available to withdraw * when withdrawing via only single token * @param account the address that is withdrawing tokens * @param tokenAmount the amount of LP token to burn * @param tokenIndex index of which token will be withdrawn * @return availableTokenAmount calculated amount of underlying token * available to withdraw */ function calculateRemoveLiquidityOneToken( address account, uint256 tokenAmount, uint8 tokenIndex ) external view returns (uint256 availableTokenAmount) { (availableTokenAmount, ) = swapStorage.calculateWithdrawOneToken( account, tokenAmount, tokenIndex ); } /** * @notice Calculate the fee that is applied when the given user withdraws. The withdraw fee * decays linearly over period of 4 weeks. For example, depositing and withdrawing right away * will charge you the full amount of withdraw fee. But withdrawing after 4 weeks will charge you * no additional fees. * @dev returned value should be divided by FEE_DENOMINATOR to convert to correct decimals * @param user address you want to calculate withdraw fee of * @return current withdraw fee of the user */ function calculateCurrentWithdrawFee(address user) external view returns (uint256) { return swapStorage.calculateCurrentWithdrawFee(user); } /** * @notice This function reads the accumulated amount of admin fees of the token with given index * @param index Index of the pooled token * @return admin's token balance in the token's precision */ function getAdminBalance(uint256 index) external view returns (uint256) { return swapStorage.getAdminBalance(index); } /*** STATE MODIFYING FUNCTIONS ***/ /** * @notice Swap two tokens using this pool * @param tokenIndexFrom the token the user wants to swap from * @param tokenIndexTo the token the user wants to swap to * @param dx the amount of tokens the user wants to swap from * @param minDy the min amount the user would like to receive, or revert. * @param deadline latest timestamp to accept this transaction */ function swap( uint8 tokenIndexFrom, uint8 tokenIndexTo, uint256 dx, uint256 minDy, uint256 deadline ) external nonReentrant whenNotPaused deadlineCheck(deadline) returns (uint256) { return swapStorage.swap(tokenIndexFrom, tokenIndexTo, dx, minDy); } /** * @notice Add liquidity to the pool with given amounts * @param amounts the amounts of each token to add, in their native precision * @param minToMint the minimum LP tokens adding this amount of liquidity * should mint, otherwise revert. Handy for front-running mitigation * @param deadline latest timestamp to accept this transaction * @return amount of LP token user minted and received */ function addLiquidity( uint256[] calldata amounts, uint256 minToMint, uint256 deadline ) external nonReentrant whenNotPaused deadlineCheck(deadline) returns (uint256) { return swapStorage.addLiquidity(amounts, minToMint); } /** * @notice Burn LP tokens to remove liquidity from the pool. Withdraw fee that decays linearly * over period of 4 weeks since last deposit will apply. * @dev Liquidity can always be removed, even when the pool is paused. * @param amount the amount of LP tokens to burn * @param minAmounts the minimum amounts of each token in the pool * acceptable for this burn. Useful as a front-running mitigation * @param deadline latest timestamp to accept this transaction * @return amounts of tokens user received */ function removeLiquidity( uint256 amount, uint256[] calldata minAmounts, uint256 deadline ) external nonReentrant deadlineCheck(deadline) returns (uint256[] memory) { return swapStorage.removeLiquidity(amount, minAmounts); } /** * @notice Remove liquidity from the pool all in one token. Withdraw fee that decays linearly * over period of 4 weeks since last deposit will apply. * @param tokenAmount the amount of the token you want to receive * @param tokenIndex the index of the token you want to receive * @param minAmount the minimum amount to withdraw, otherwise revert * @param deadline latest timestamp to accept this transaction * @return amount of chosen token user received */ function removeLiquidityOneToken( uint256 tokenAmount, uint8 tokenIndex, uint256 minAmount, uint256 deadline ) external nonReentrant whenNotPaused deadlineCheck(deadline) returns (uint256) { return swapStorage.removeLiquidityOneToken( tokenAmount, tokenIndex, minAmount ); } /** * @notice Remove liquidity from the pool, weighted differently than the * pool's current balances. Withdraw fee that decays linearly * over period of 4 weeks since last deposit will apply. * @param amounts how much of each token to withdraw * @param maxBurnAmount the max LP token provider is willing to pay to * remove liquidity. Useful as a front-running mitigation. * @param deadline latest timestamp to accept this transaction * @return amount of LP tokens burned */ function removeLiquidityImbalance( uint256[] calldata amounts, uint256 maxBurnAmount, uint256 deadline ) external nonReentrant whenNotPaused deadlineCheck(deadline) returns (uint256) { return swapStorage.removeLiquidityImbalance(amounts, maxBurnAmount); } /*** ADMIN FUNCTIONS ***/ /** * @notice Updates the user withdraw fee. This function can only be called by * the pool token. Should be used to update the withdraw fee on transfer of pool tokens. * Transferring your pool token will reset the 4 weeks period. If the recipient is already * holding some pool tokens, the withdraw fee will be discounted in respective amounts. * @param recipient address of the recipient of pool token * @param transferAmount amount of pool token to transfer */ function updateUserWithdrawFee(address recipient, uint256 transferAmount) external { require( msg.sender == address(swapStorage.lpToken), "Only callable by pool token" ); swapStorage.updateUserWithdrawFee(recipient, transferAmount); } /** * @notice Withdraw all admin fees to the contract owner */ function withdrawAdminFees() external onlyOwner { swapStorage.withdrawAdminFees(owner()); } /** * @notice Update the admin fee. Admin fee takes portion of the swap fee. * @param newAdminFee new admin fee to be applied on future transactions */ function setAdminFee(uint256 newAdminFee) external onlyOwner { swapStorage.setAdminFee(newAdminFee); } /** * @notice Update the swap fee to be applied on swaps * @param newSwapFee new swap fee to be applied on future transactions */ function setSwapFee(uint256 newSwapFee) external onlyOwner { swapStorage.setSwapFee(newSwapFee); } /** * @notice Update the deposit fee. * @param newDepositFee new deposit fee to be applied on future deposits */ function setDefaultDepositFee(uint256 newDepositFee) external onlyOwner { swapStorage.setDefaultDepositFee(newDepositFee); } /** * @notice Update the withdraw fee. This fee decays linearly over 4 weeks since * user's last deposit. * @param newWithdrawFee new withdraw fee to be applied on future deposits */ function setDefaultWithdrawFee(uint256 newWithdrawFee) external onlyOwner { swapStorage.setDefaultWithdrawFee(newWithdrawFee); } /** * @notice Start ramping up or down A parameter towards given futureA and futureTime * Checks if the change is too rapid, and commits the new A value only when it falls under * the limit range. * @param futureA the new A to ramp towards * @param futureTime timestamp when the new A should be reached */ function rampA(uint256 futureA, uint256 futureTime) external onlyOwner { swapStorage.rampA(futureA, futureTime); } /** * @notice Stop ramping A immediately. Reverts if ramp A is already stopped. */ function stopRampA() external onlyOwner { swapStorage.stopRampA(); } // Update dev address by the previous dev. function setDevAddress(address _devaddr) external onlyOwner { swapStorage.setDevAddress(_devaddr); } }
/project_/contracts/LPToken.sol
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; import './openzeppelin-contracts@3.4.0/contracts/token/ERC20/ERC20Burnable.sol'; import './openzeppelin-contracts@3.4.0/contracts/access/Ownable.sol'; import './openzeppelin-contracts@3.4.0/contracts/math/SafeMath.sol'; import "../interfaces/ISwap.sol"; /** * @title Liquidity Provider Token * @notice This token is an ERC20 detailed token with added capability to be minted by the owner. * It is used to represent user's shares when providing liquidity to swap contracts. */ contract LPToken is ERC20Burnable, Ownable { using SafeMath for uint256; // Address of the swap contract that owns this LP token. When a user adds liquidity to the swap contract, // they receive a proportionate amount of this LPToken. ISwap public immutable swap; /** * @notice Deploys LPToken contract with given name, symbol, and decimals * @dev the caller of this constructor will become the owner of this contract * @param name_ name of this token * @param symbol_ symbol of this token * @param decimals_ number of decimals this token will be based on */ constructor( string memory name_, string memory symbol_, uint8 decimals_ ) public ERC20(name_, symbol_) { _setupDecimals(decimals_); swap = ISwap(_msgSender()); } /** * @notice Mints the given amount of LPToken to the recipient. * @dev only owner can call this mint function * @param recipient address of account to receive the tokens * @param amount amount of tokens to mint */ function mint( address recipient, uint256 amount ) external onlyOwner { require(amount != 0, "amount == 0"); _mint(recipient, amount); } /** * @dev Overrides ERC20._beforeTokenTransfer() which get called on every transfers including * minting and burning. This ensures that swap.updateUserWithdrawFees are called everytime. */ function _beforeTokenTransfer( address from, address to, uint256 amount ) internal override(ERC20) { super._beforeTokenTransfer(from, to, amount); swap.updateUserWithdrawFee(to, amount); } }
/project_/contracts/MathUtils.sol
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; import './openzeppelin-contracts@3.4.0/contracts/math/SafeMath.sol'; /** * @title MathUtils library * @notice A library to be used in conjunction with SafeMath. Contains functions for calculating * differences between two uint256. */ library MathUtils { /** * @notice Compares a and b and returns true if the difference between a and b * is less than 1 or equal to each other. * @param a uint256 to compare with * @param b uint256 to compare with * @return True if the difference between a and b is less than 1 or equal, * otherwise return false */ function within1(uint256 a, uint256 b) external pure returns (bool) { return (_difference(a, b) <= 1); } /** * @notice Calculates absolute difference between a and b * @param a uint256 to compare with * @param b uint256 to compare with * @return Difference between a and b */ function difference(uint256 a, uint256 b) external pure returns (uint256) { return _difference(a, b); } /** * @notice Calculates absolute difference between a and b * @param a uint256 to compare with * @param b uint256 to compare with * @return Difference between a and b */ function _difference(uint256 a, uint256 b) internal pure returns (uint256) { if (a > b) { return a - b; } return b - a; } }
/project_/contracts/OwnerPausable.sol
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; import './openzeppelin-contracts@3.4.0/contracts/access/Ownable.sol'; import './openzeppelin-contracts@3.4.0/contracts/utils/Pausable.sol'; /** * @title OwnerPausable * @notice An ownable contract allows the owner to pause and unpause the * contract without a delay. * @dev Only methods using the provided modifiers will be paused. */ contract OwnerPausable is Ownable, Pausable { /** * @notice Pause the contract. Revert if already paused. */ function pause() external onlyOwner { Pausable._pause(); } /** * @notice Unpause the contract. Revert if already unpaused. */ function unpause() external onlyOwner { Pausable._unpause(); } }
/project_/contracts/SwapUtils.sol
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; import './openzeppelin-contracts@3.4.0/contracts/math/SafeMath.sol'; import './openzeppelin-contracts@3.4.0/contracts/token/ERC20/SafeERC20.sol'; import "./LPToken.sol"; import "./MathUtils.sol"; /** * @title SwapUtils library * @notice A library to be used within Swap.sol. Contains functions responsible for custody and AMM functionalities. * @dev Contracts relying on this library must initialize SwapUtils.Swap struct then use this library * for SwapUtils.Swap struct. Note that this library contains both functions called by users and admins. * Admin functions should be protected within contracts using this library. */ library SwapUtils { using SafeERC20 for IERC20; using SafeMath for uint256; using MathUtils for uint256; /*** EVENTS ***/ event TokenSwap( address indexed buyer, uint256 tokensSold, uint256 tokensBought, uint128 soldId, uint128 boughtId ); event AddLiquidity( address indexed provider, uint256[] tokenAmounts, uint256[] fees, uint256 invariant, uint256 lpTokenSupply ); event RemoveLiquidity( address indexed provider, uint256[] tokenAmounts, uint256 lpTokenSupply ); event RemoveLiquidityOne( address indexed provider, uint256 lpTokenAmount, uint256 lpTokenSupply, uint256 boughtId, uint256 tokensBought ); event RemoveLiquidityImbalance( address indexed provider, uint256[] tokenAmounts, uint256[] fees, uint256 invariant, uint256 lpTokenSupply ); event NewAdminFee(uint256 newAdminFee); event NewSwapFee(uint256 newSwapFee); event NewWithdrawFee(uint256 newWithdrawFee); event NewDepositFee(uint256 newDepositFee); event RampA( uint256 oldA, uint256 newA, uint256 initialTime, uint256 futureTime ); event StopRampA(uint256 currentA, uint256 time); struct Swap { // variables around the ramp management of A, // the amplification coefficient * n * (n - 1) // see https://www.curve.fi/stableswap-paper.pdf for details uint256 initialA; uint256 futureA; uint256 initialATime; uint256 futureATime; // fee calculation uint256 swapFee; uint256 adminFee; uint256 defaultDepositFee; uint256 defaultWithdrawFee; address devaddr; LPToken lpToken; // contract references for all tokens being pooled IERC20[] pooledTokens; // multipliers for each pooled token's precision to get to POOL_PRECISION_DECIMALS // for example, TBTC has 18 decimals, so the multiplier should be 1. WBTC // has 8, so the multiplier should be 10 ** 18 / 10 ** 8 => 10 ** 10 uint256[] tokenPrecisionMultipliers; // the pool balance of each token, in the token's precision // the contract's actual token balance might differ uint256[] balances; mapping(address => uint256) depositTimestamp; mapping(address => uint256) withdrawFeeMultiplier; } // Struct storing variables used in calculations in the // calculateWithdrawOneTokenDY function to avoid stack too deep errors struct CalculateWithdrawOneTokenDYInfo { uint256 d0; uint256 d1; uint256 newY; uint256 feePerToken; uint256 preciseA; } // Struct storing variables used in calculation in addLiquidity function // to avoid stack too deep error struct AddLiquidityInfo { uint256 d0; uint256 d1; uint256 d2; uint256 preciseA; } // Struct storing variables used in calculation in removeLiquidityImbalance function // to avoid stack too deep error struct RemoveLiquidityImbalanceInfo { uint256 d0; uint256 d1; uint256 d2; uint256 preciseA; } // the precision all pools tokens will be converted to uint8 public constant POOL_PRECISION_DECIMALS = 18; // the denominator used to calculate admin and LP fees. For example, an // LP fee might be something like tradeAmount.mul(fee).div(FEE_DENOMINATOR) uint256 private constant FEE_DENOMINATOR = 10**10; // Max swap fee is 1% or 100bps of each swap uint256 public constant MAX_SWAP_FEE = 10**8; // Max adminFee is 100% of the swapFee // adminFee does not add additional fee on top of swapFee // Instead it takes a certain % of the swapFee. Therefore it has no impact on the // users but only on the earnings of LPs uint256 public constant MAX_ADMIN_FEE = 10**10; // Max withdrawFee is 1% of the value withdrawn // Fee will be redistributed to the LPs in the pool, rewarding // long term providers. uint256 public constant MAX_WITHDRAW_FEE = 10**8; // Max depositFee is 1% of the value deposited uint256 public constant MAX_DEPOSIT_FEE = 10**8; // Constant value used as max loop limit uint256 private constant MAX_LOOP_LIMIT = 256; // Constant values used in ramping A calculations uint256 public constant A_PRECISION = 100; uint256 public constant MAX_A = 10**6; uint256 private constant MAX_A_CHANGE = 2; uint256 private constant MIN_RAMP_TIME = 14 days; /*** VIEW & PURE FUNCTIONS ***/ /** * @notice Return A, the amplification coefficient * n * (n - 1) * @dev See the StableSwap paper for details * @param self Swap struct to read from * @return A parameter */ function getA(Swap storage self) external view returns (uint256) { return _getA(self); } /** * @notice Return A, the amplification coefficient * n * (n - 1) * @dev See the StableSwap paper for details * @param self Swap struct to read from * @return A parameter */ function _getA(Swap storage self) internal view returns (uint256) { return _getAPrecise(self).div(A_PRECISION); } /** * @notice Return A in its raw precision * @dev See the StableSwap paper for details * @param self Swap struct to read from * @return A parameter in its raw precision form */ function getAPrecise(Swap storage self) external view returns (uint256) { return _getAPrecise(self); } /** * @notice Calculates and returns A based on the ramp settings * @dev See the StableSwap paper for details * @param self Swap struct to read from * @return A parameter in its raw precision form */ function _getAPrecise(Swap storage self) internal view returns (uint256) { uint256 t1 = self.futureATime; // time when ramp is finished uint256 a1 = self.futureA; // final A value when ramp is finished if (block.timestamp < t1) { uint256 t0 = self.initialATime; // time when ramp is started uint256 a0 = self.initialA; // initial A value when ramp is started if (a1 > a0) { // a0 + (a1 - a0) * (block.timestamp - t0) / (t1 - t0) return a0.add( a1.sub(a0).mul(block.timestamp.sub(t0)).div(t1.sub(t0)) ); } else { // a0 - (a0 - a1) * (block.timestamp - t0) / (t1 - t0) return a0.sub( a0.sub(a1).mul(block.timestamp.sub(t0)).div(t1.sub(t0)) ); } } else { return a1; } } /** * @notice Retrieves the timestamp of last deposit made by the given address * @param self Swap struct to read from * @return timestamp of last deposit */ function getDepositTimestamp(Swap storage self, address user) external view returns (uint256) { return self.depositTimestamp[user]; } /** * @notice Calculate the dy, the amount of selected token that user receives and * the fee of withdrawing in one token * @param account the address that is withdrawing * @param tokenAmount the amount to withdraw in the pool's precision * @param tokenIndex which token will be withdrawn * @param self Swap struct to read from * @return the amount of token user will receive and the associated swap fee */ function calculateWithdrawOneToken( Swap storage self, address account, uint256 tokenAmount, uint8 tokenIndex ) public view returns (uint256, uint256) { uint256 dy; uint256 newY; (dy, newY) = calculateWithdrawOneTokenDY(self, tokenIndex, tokenAmount); // dy_0 (without fees) // dy, dy_0 - dy uint256 dySwapFee = _xp(self)[tokenIndex] .sub(newY) .div(self.tokenPrecisionMultipliers[tokenIndex]) .sub(dy); dy = dy .mul( FEE_DENOMINATOR.sub(calculateCurrentWithdrawFee(self, account)) ) .div(FEE_DENOMINATOR); return (dy, dySwapFee); } /** * @notice Calculate the dy of withdrawing in one token * @param self Swap struct to read from * @param tokenIndex which token will be withdrawn * @param tokenAmount the amount to withdraw in the pools precision * @return the d and the new y after withdrawing one token */ function calculateWithdrawOneTokenDY( Swap storage self, uint8 tokenIndex, uint256 tokenAmount ) internal view returns (uint256, uint256) { require( tokenIndex < self.pooledTokens.length, "Token index out of range" ); // Get the current D, then solve the stableswap invariant // y_i for D - tokenAmount uint256[] memory xp = _xp(self); CalculateWithdrawOneTokenDYInfo memory v = CalculateWithdrawOneTokenDYInfo(0, 0, 0, 0, 0); v.preciseA = _getAPrecise(self); v.d0 = getD(xp, v.preciseA); v.d1 = v.d0.sub(tokenAmount.mul(v.d0).div(self.lpToken.totalSupply())); require(tokenAmount <= xp[tokenIndex], "Withdraw exceeds available"); v.newY = getYD(v.preciseA, tokenIndex, xp, v.d1); uint256[] memory xpReduced = new uint256[](xp.length); v.feePerToken = _feePerToken(self); for (uint256 i = 0; i < self.pooledTokens.length; i++) { uint256 xpi = xp[i]; // if i == tokenIndex, dxExpected = xp[i] * d1 / d0 - newY // else dxExpected = xp[i] - (xp[i] * d1 / d0) // xpReduced[i] -= dxExpected * fee / FEE_DENOMINATOR xpReduced[i] = xpi.sub( ( (i == tokenIndex) ? xpi.mul(v.d1).div(v.d0).sub(v.newY) : xpi.sub(xpi.mul(v.d1).div(v.d0)) ) .mul(v.feePerToken) .div(FEE_DENOMINATOR) ); } uint256 dy = xpReduced[tokenIndex].sub( getYD(v.preciseA, tokenIndex, xpReduced, v.d1) ); dy = dy.sub(1).div(self.tokenPrecisionMultipliers[tokenIndex]); return (dy, v.newY); } /** * @notice Calculate the price of a token in the pool with given * precision-adjusted balances and a particular D. * * @dev This is accomplished via solving the invariant iteratively. * See the StableSwap paper and Curve.fi implementation for further details. * * x_1**2 + x1 * (sum' - (A*n**n - 1) * D / (A * n**n)) = D ** (n + 1) / (n ** (2 * n) * prod' * A) * x_1**2 + b*x_1 = c * x_1 = (x_1**2 + c) / (2*x_1 + b) * * @param a the amplification coefficient * n * (n - 1). See the StableSwap paper for details. * @param tokenIndex Index of token we are calculating for. * @param xp a precision-adjusted set of pool balances. Array should be * the same cardinality as the pool. * @param d the stableswap invariant * @return the price of the token, in the same precision as in xp */ function getYD( uint256 a, uint8 tokenIndex, uint256[] memory xp, uint256 d ) internal pure returns (uint256) { uint256 numTokens = xp.length; require(tokenIndex < numTokens, "Token not found"); uint256 c = d; uint256 s; uint256 nA = a.mul(numTokens); for (uint256 i = 0; i < numTokens; i++) { if (i != tokenIndex) { s = s.add(xp[i]); c = c.mul(d).div(xp[i].mul(numTokens)); // If we were to protect the division loss we would have to keep the denominator separate // and divide at the end. However this leads to overflow with large numTokens or/and D. // c = c * D * D * D * ... overflow! } } c = c.mul(d).mul(A_PRECISION).div(nA.mul(numTokens)); uint256 b = s.add(d.mul(A_PRECISION).div(nA)); uint256 yPrev; uint256 y = d; for (uint256 i = 0; i < MAX_LOOP_LIMIT; i++) { yPrev = y; y = y.mul(y).add(c).div(y.mul(2).add(b).sub(d)); if (y.within1(yPrev)) { return y; } } revert("Approximation did not converge"); } /** * @notice Get D, the StableSwap invariant, based on a set of balances and a particular A. * @param xp a precision-adjusted set of pool balances. Array should be the same cardinality * as the pool. * @param a the amplification coefficient * n * (n - 1) in A_PRECISION. * See the StableSwap paper for details * @return the invariant, at the precision of the pool */ function getD(uint256[] memory xp, uint256 a) internal pure returns (uint256) { uint256 numTokens = xp.length; uint256 s; for (uint256 i = 0; i < numTokens; i++) { s = s.add(xp[i]); } if (s == 0) { return 0; } uint256 prevD; uint256 d = s; uint256 nA = a.mul(numTokens); for (uint256 i = 0; i < MAX_LOOP_LIMIT; i++) { uint256 dP = d; for (uint256 j = 0; j < numTokens; j++) { dP = dP.mul(d).div(xp[j].mul(numTokens)); // If we were to protect the division loss we would have to keep the denominator separate // and divide at the end. However this leads to overflow with large numTokens or/and D. // dP = dP * D * D * D * ... overflow! } prevD = d; d = nA.mul(s).div(A_PRECISION).add(dP.mul(numTokens)).mul(d).div( nA.sub(A_PRECISION).mul(d).div(A_PRECISION).add( numTokens.add(1).mul(dP) ) ); if (d.within1(prevD)) { return d; } } // Convergence should occur in 4 loops or less. If this is reached, there may be something wrong // with the pool. If this were to occur repeatedly, LPs should withdraw via `removeLiquidity()` // function which does not rely on D. revert("D does not converge"); } /** * @notice Get D, the StableSwap invariant, based on self Swap struct * @param self Swap struct to read from * @return The invariant, at the precision of the pool */ function getD(Swap storage self) internal view returns (uint256) { return getD(_xp(self), _getAPrecise(self)); } /** * @notice Given a set of balances and precision multipliers, return the * precision-adjusted balances. * * @param balances an array of token balances, in their native precisions. * These should generally correspond with pooled tokens. * * @param precisionMultipliers an array of multipliers, corresponding to * the amounts in the balances array. When multiplied together they * should yield amounts at the pool's precision. * * @return an array of amounts "scaled" to the pool's precision */ function _xp( uint256[] memory balances, uint256[] memory precisionMultipliers ) internal pure returns (uint256[] memory) { uint256 numTokens = balances.length; require( numTokens == precisionMultipliers.length, "Balances must match multipliers" ); uint256[] memory xp = new uint256[](numTokens); for (uint256 i = 0; i < numTokens; i++) { xp[i] = balances[i].mul(precisionMultipliers[i]); } return xp; } /** * @notice Return the precision-adjusted balances of all tokens in the pool * @param self Swap struct to read from * @param balances array of balances to scale * @return balances array "scaled" to the pool's precision, allowing * them to be more easily compared. */ function _xp(Swap storage self, uint256[] memory balances) internal view returns (uint256[] memory) { return _xp(balances, self.tokenPrecisionMultipliers); } /** * @notice Return the precision-adjusted balances of all tokens in the pool * @param self Swap struct to read from * @return the pool balances "scaled" to the pool's precision, allowing * them to be more easily compared. */ function _xp(Swap storage self) internal view returns (uint256[] memory) { return _xp(self.balances, self.tokenPrecisionMultipliers); } /** * @notice Get the virtual price, to help calculate profit * @param self Swap struct to read from * @return the virtual price, scaled to precision of POOL_PRECISION_DECIMALS */ function getVirtualPrice(Swap storage self) external view returns (uint256) { uint256 d = getD(_xp(self), _getAPrecise(self)); uint256 supply = self.lpToken.totalSupply(); if (supply > 0) { return d.mul(10**uint256(ERC20(self.lpToken).decimals())).div(supply); } return 0; } /** * @notice Calculate the new balances of the tokens given the indexes of the token * that is swapped from (FROM) and the token that is swapped to (TO). * This function is used as a helper function to calculate how much TO token * the user should receive on swap. * * @param self Swap struct to read from * @param tokenIndexFrom index of FROM token * @param tokenIndexTo index of TO token * @param x the new total amount of FROM token * @param xp balances of the tokens in the pool * @return the amount of TO token that should remain in the pool */ function getY( Swap storage self, uint8 tokenIndexFrom, uint8 tokenIndexTo, uint256 x, uint256[] memory xp ) internal view returns (uint256) { uint256 numTokens = self.pooledTokens.length; require( tokenIndexFrom != tokenIndexTo, "Can't compare token to itself" ); require( tokenIndexFrom < numTokens && tokenIndexTo < numTokens, "Tokens must be in pool" ); uint256 a = _getAPrecise(self); uint256 d = getD(xp, a); uint256 c = d; uint256 s; uint256 nA = numTokens.mul(a); uint256 _x; for (uint256 i = 0; i < numTokens; i++) { if (i == tokenIndexFrom) { _x = x; } else if (i != tokenIndexTo) { _x = xp[i]; } else { continue; } s = s.add(_x); c = c.mul(d).div(_x.mul(numTokens)); // If we were to protect the division loss we would have to keep the denominator separate // and divide at the end. However this leads to overflow with large numTokens or/and D. // c = c * D * D * D * ... overflow! } c = c.mul(d).mul(A_PRECISION).div(nA.mul(numTokens)); uint256 b = s.add(d.mul(A_PRECISION).div(nA)); uint256 yPrev; uint256 y = d; // iterative approximation for (uint256 i = 0; i < MAX_LOOP_LIMIT; i++) { yPrev = y; y = y.mul(y).add(c).div(y.mul(2).add(b).sub(d)); if (y.within1(yPrev)) { return y; } } revert("Approximation did not converge"); } /** * @notice Externally calculates a swap between two tokens. * @param self Swap struct to read from * @param tokenIndexFrom the token to sell * @param tokenIndexTo the token to buy * @param dx the number of tokens to sell. If the token charges a fee on transfers, * use the amount that gets transferred after the fee. * @return dy the number of tokens the user will get */ function calculateSwap( Swap storage self, uint8 tokenIndexFrom, uint8 tokenIndexTo, uint256 dx ) external view returns (uint256 dy) { (dy, ) = _calculateSwap(self, tokenIndexFrom, tokenIndexTo, dx); } /** * @notice Internally calculates a swap between two tokens. * * @dev The caller is expected to transfer the actual amounts (dx and dy) * using the token contracts. * * @param self Swap struct to read from * @param tokenIndexFrom the token to sell * @param tokenIndexTo the token to buy * @param dx the number of tokens to sell. If the token charges a fee on transfers, * use the amount that gets transferred after the fee. * @return dy the number of tokens the user will get * @return dyFee the associated fee */ function _calculateSwap( Swap storage self, uint8 tokenIndexFrom, uint8 tokenIndexTo, uint256 dx ) internal view returns (uint256 dy, uint256 dyFee) { uint256[] memory xp = _xp(self); require( tokenIndexFrom < xp.length && tokenIndexTo < xp.length, "Token index out of range" ); uint256 x = dx.mul(self.tokenPrecisionMultipliers[tokenIndexFrom]).add( xp[tokenIndexFrom] ); uint256 y = getY(self, tokenIndexFrom, tokenIndexTo, x, xp); dy = xp[tokenIndexTo].sub(y).sub(1); dyFee = dy.mul(self.swapFee).div(FEE_DENOMINATOR); dy = dy.sub(dyFee).div(self.tokenPrecisionMultipliers[tokenIndexTo]); } /** * @notice A simple method to calculate amount of each underlying * tokens that is returned upon burning given amount of * LP tokens * * @param account the address that is removing liquidity. required for withdraw fee calculation * @param amount the amount of LP tokens that would to be burned on * withdrawal * @return array of amounts of tokens user will receive */ function calculateRemoveLiquidity( Swap storage self, address account, uint256 amount ) external view returns (uint256[] memory) { return _calculateRemoveLiquidity(self, account, amount); } function _calculateRemoveLiquidity( Swap storage self, address account, uint256 amount ) internal view returns (uint256[] memory) { uint256 totalSupply = self.lpToken.totalSupply(); require(amount <= totalSupply, "Cannot exceed total supply"); uint256 feeAdjustedAmount = amount; // No fees for withdrawals! // amount // .mul( // FEE_DENOMINATOR.sub(calculateCurrentWithdrawFee(self, account)) // ) // .div(FEE_DENOMINATOR); uint256[] memory amounts = new uint256[](self.pooledTokens.length); for (uint256 i = 0; i < self.pooledTokens.length; i++) { amounts[i] = self.balances[i].mul(feeAdjustedAmount).div( totalSupply ); } return amounts; } /** * @notice Calculate the fee that is applied when the given user withdraws. * Withdraw fee decays linearly over 4 weeks. * @param user address you want to calculate withdraw fee of * @return current withdraw fee of the user */ function calculateCurrentWithdrawFee(Swap storage self, address user) public view returns (uint256) { uint256 endTime = self.depositTimestamp[user].add(4 weeks); if (endTime > block.timestamp) { uint256 timeLeftover = endTime.sub(block.timestamp); return self .defaultWithdrawFee .mul(self.withdrawFeeMultiplier[user]) .mul(timeLeftover) .div(4 weeks) .div(FEE_DENOMINATOR); } return 0; } /** * @notice A simple method to calculate prices from deposits or * withdrawals, excluding fees but including slippage. This is * helpful as an input into the various "min" parameters on calls * to fight front-running * * @dev This shouldn't be used outside frontends for user estimates. * * @param self Swap struct to read from * @param account address of the account depositing or withdrawing tokens * @param amounts an array of token amounts to deposit or withdrawal, * corresponding to pooledTokens. The amount should be in each * pooled token's native precision. If a token charges a fee on transfers, * use the amount that gets transferred after the fee. * @param deposit whether this is a deposit or a withdrawal * @return if deposit was true, total amount of lp token that will be minted and if * deposit was false, total amount of lp token that will be burned */ function calculateTokenAmount( Swap storage self, address account, uint256[] calldata amounts, bool deposit ) external view returns (uint256) { uint256 numTokens = self.pooledTokens.length; uint256 a = _getAPrecise(self); uint256 d0 = getD(_xp(self, self.balances), a); uint256[] memory balances1 = self.balances; for (uint256 i = 0; i < numTokens; i++) { if (deposit) { balances1[i] = balances1[i].add(amounts[i]); } else { balances1[i] = balances1[i].sub( amounts[i], "Cannot withdraw more than available" ); } } uint256 d1 = getD(_xp(self, balances1), a); uint256 totalSupply = self.lpToken.totalSupply(); if (deposit) { return d1.sub(d0).mul(totalSupply).div(d0); } else { return d0.sub(d1).mul(totalSupply).div(d0).mul(FEE_DENOMINATOR).div( FEE_DENOMINATOR.sub( calculateCurrentWithdrawFee(self, account) ) ); } } /** * @notice return accumulated amount of admin fees of the token with given index * @param self Swap struct to read from * @param index Index of the pooled token * @return admin balance in the token's precision */ function getAdminBalance(Swap storage self, uint256 index) external view returns (uint256) { require(index < self.pooledTokens.length, "Token index out of range"); return self.pooledTokens[index].balanceOf(address(this)).sub( self.balances[index] ); } /** * @notice internal helper function to calculate fee per token multiplier used in * swap fee calculations * @param self Swap struct to read from */ function _feePerToken(Swap storage self) internal view returns (uint256) { return self.swapFee.mul(self.pooledTokens.length).div( self.pooledTokens.length.sub(1).mul(4) ); } /*** STATE MODIFYING FUNCTIONS ***/ /** * @notice swap two tokens in the pool * @param self Swap struct to read from and write to * @param tokenIndexFrom the token the user wants to sell * @param tokenIndexTo the token the user wants to buy * @param dx the amount of tokens the user wants to sell * @param minDy the min amount the user would like to receive, or revert. * @return amount of token user received on swap */ function swap( Swap storage self, uint8 tokenIndexFrom, uint8 tokenIndexTo, uint256 dx, uint256 minDy ) external returns (uint256) { require( dx <= self.pooledTokens[tokenIndexFrom].balanceOf(msg.sender), "Cannot swap more than you own" ); // Transfer tokens first to see if a fee was charged on transfer uint256 beforeBalance = self.pooledTokens[tokenIndexFrom].balanceOf(address(this)); self.pooledTokens[tokenIndexFrom].safeTransferFrom( msg.sender, address(this), dx ); // Use the actual transferred amount for AMM math uint256 transferredDx = self.pooledTokens[tokenIndexFrom].balanceOf(address(this)).sub( beforeBalance ); (uint256 dy, uint256 dyFee) = _calculateSwap(self, tokenIndexFrom, tokenIndexTo, transferredDx); require(dy >= minDy, "Swap didn't result in min tokens"); uint256 dyAdminFee = dyFee.mul(self.adminFee).div(FEE_DENOMINATOR).div( self.tokenPrecisionMultipliers[tokenIndexTo] ); self.balances[tokenIndexFrom] = self.balances[tokenIndexFrom].add( transferredDx ); self.balances[tokenIndexTo] = self.balances[tokenIndexTo].sub(dy).sub( dyAdminFee ); self.pooledTokens[tokenIndexTo].safeTransfer(msg.sender, dy); emit TokenSwap( msg.sender, transferredDx, dy, tokenIndexFrom, tokenIndexTo ); return dy; } /** * @notice Add liquidity to the pool * @param self Swap struct to read from and write to * @param amounts the amounts of each token to add, in their native precision * @param minToMint the minimum LP tokens adding this amount of liquidity * should mint, otherwise revert. Handy for front-running mitigation * @return amount of LP token user received */ function addLiquidity( Swap storage self, uint256[] memory amounts, uint256 minToMint ) external returns (uint256) { require( amounts.length == self.pooledTokens.length, "Amounts must match pooled tokens" ); uint256[] memory fees = new uint256[](self.pooledTokens.length); uint256 lpTotalSupply = self.lpToken.totalSupply(); // current state AddLiquidityInfo memory v = AddLiquidityInfo(0, 0, 0, 0); if (lpTotalSupply != 0) { v.d0 = getD(self); } uint256[] memory newBalances = self.balances; for (uint256 i = 0; i < self.pooledTokens.length; i++) { require( lpTotalSupply != 0 || amounts[i] > 0, "Must supply all tokens in pool" ); // Transfer tokens first to see if a fee was charged on transfer if (amounts[i] != 0) { uint256 beforeBalance = self.pooledTokens[i].balanceOf(address(this)); self.pooledTokens[i].safeTransferFrom( msg.sender, address(this), amounts[i] ); // Update the amounts[] with actual transfer amount amounts[i] = self.pooledTokens[i].balanceOf(address(this)).sub( beforeBalance ); } newBalances[i] = self.balances[i].add(amounts[i]); } // invariant after change v.preciseA = _getAPrecise(self); v.d1 = getD(_xp(self, newBalances), v.preciseA); require(v.d1 > v.d0, "D should increase"); // updated to reflect fees and calculate the user's LP tokens v.d2 = v.d1; if (lpTotalSupply != 0) { uint256 feePerToken = _feePerToken(self); for (uint256 i = 0; i < self.pooledTokens.length; i++) { uint256 idealBalance = v.d1.mul(self.balances[i]).div(v.d0); fees[i] = feePerToken .mul(idealBalance.difference(newBalances[i])) .div(FEE_DENOMINATOR); self.balances[i] = newBalances[i].sub( fees[i].mul(self.adminFee).div(FEE_DENOMINATOR) ); newBalances[i] = newBalances[i].sub(fees[i]); } v.d2 = getD(_xp(self, newBalances), v.preciseA); } else { // the initial depositor doesn't pay fees self.balances = newBalances; } uint256 toMint; uint256 toMintFee; uint256 toMintUser; if (lpTotalSupply == 0) { toMint = v.d1; } else { toMint = v.d2.sub(v.d0).mul(lpTotalSupply).div(v.d0); } require(toMint >= minToMint, "Couldn't mint min requested"); // if deposit fee is none, mint full amount if (self.defaultDepositFee == 0) { self.lpToken.mint(msg.sender, toMint); } else { // mint the user's LP tokens minus the deposit fee toMintFee = toMint.mul(self.defaultDepositFee).div(FEE_DENOMINATOR); toMintUser = toMint.sub(toMintFee); self.lpToken.mint(self.devaddr, toMintFee); self.lpToken.mint(msg.sender, toMintUser); } emit AddLiquidity( msg.sender, amounts, fees, v.d1, lpTotalSupply + toMint ); return toMint; } /** * @notice Update the withdraw fee for `user`. If the user is currently * not providing liquidity in the pool, sets to default value. If not, recalculate * the starting withdraw fee based on the last deposit's time & amount relative * to the new deposit. * * @param self Swap struct to read from and write to * @param user address of the user depositing tokens * @param toMint amount of pool tokens to be minted */ function updateUserWithdrawFee( Swap storage self, address user, uint256 toMint ) external { _updateUserWithdrawFee(self, user, toMint); } function _updateUserWithdrawFee( Swap storage self, address user, uint256 toMint ) internal { // If token is transferred to address 0 (or burned), don't update the fee. if (user == address(0)) { return; } if (self.defaultWithdrawFee == 0) { // If current fee is set to 0%, set multiplier to FEE_DENOMINATOR self.withdrawFeeMultiplier[user] = FEE_DENOMINATOR; } else { // Otherwise, calculate appropriate discount based on last deposit amount uint256 currentFee = calculateCurrentWithdrawFee(self, user); uint256 currentBalance = self.lpToken.balanceOf(user); // ((currentBalance * currentFee) + (toMint * defaultWithdrawFee)) * FEE_DENOMINATOR / // ((toMint + currentBalance) * defaultWithdrawFee) self.withdrawFeeMultiplier[user] = currentBalance .mul(currentFee) .add(toMint.mul(self.defaultWithdrawFee)) .mul(FEE_DENOMINATOR) .div(toMint.add(currentBalance).mul(self.defaultWithdrawFee)); } self.depositTimestamp[user] = block.timestamp; } /** * @notice Burn LP tokens to remove liquidity from the pool. * @dev Liquidity can always be removed, even when the pool is paused. * @param self Swap struct to read from and write to * @param amount the amount of LP tokens to burn * @param minAmounts the minimum amounts of each token in the pool * acceptable for this burn. Useful as a front-running mitigation * @return amounts of tokens the user received */ function removeLiquidity( Swap storage self, uint256 amount, uint256[] calldata minAmounts ) external returns (uint256[] memory) { require(amount <= self.lpToken.balanceOf(msg.sender), ">LP.balanceOf"); require( minAmounts.length == self.pooledTokens.length, "minAmounts must match poolTokens" ); uint256[] memory amounts = _calculateRemoveLiquidity(self, msg.sender, amount); for (uint256 i = 0; i < amounts.length; i++) { require(amounts[i] >= minAmounts[i], "amounts[i] < minAmounts[i]"); self.balances[i] = self.balances[i].sub(amounts[i]); self.pooledTokens[i].safeTransfer(msg.sender, amounts[i]); } self.lpToken.burnFrom(msg.sender, amount); emit RemoveLiquidity(msg.sender, amounts, self.lpToken.totalSupply()); return amounts; } /** * @notice Remove liquidity from the pool all in one token. * @param self Swap struct to read from and write to * @param tokenAmount the amount of the lp tokens to burn * @param tokenIndex the index of the token you want to receive * @param minAmount the minimum amount to withdraw, otherwise revert * @return amount chosen token that user received */ function removeLiquidityOneToken( Swap storage self, uint256 tokenAmount, uint8 tokenIndex, uint256 minAmount ) external returns (uint256) { uint256 totalSupply = self.lpToken.totalSupply(); uint256 numTokens = self.pooledTokens.length; require( tokenAmount <= self.lpToken.balanceOf(msg.sender), ">LP.balanceOf" ); require(tokenIndex < numTokens, "Token not found"); uint256 dyFee; uint256 dy; (dy, dyFee) = calculateWithdrawOneToken( self, msg.sender, tokenAmount, tokenIndex ); require(dy >= minAmount, "dy < minAmount"); self.balances[tokenIndex] = self.balances[tokenIndex].sub( dy.add(dyFee.mul(self.adminFee).div(FEE_DENOMINATOR)) ); self.lpToken.burnFrom(msg.sender, tokenAmount); self.pooledTokens[tokenIndex].safeTransfer(msg.sender, dy); emit RemoveLiquidityOne( msg.sender, tokenAmount, totalSupply, tokenIndex, dy ); return dy; } /** * @notice Remove liquidity from the pool, weighted differently than the * pool's current balances. * * @param self Swap struct to read from and write to * @param amounts how much of each token to withdraw * @param maxBurnAmount the max LP token provider is willing to pay to * remove liquidity. Useful as a front-running mitigation. * @return actual amount of LP tokens burned in the withdrawal */ function removeLiquidityImbalance( Swap storage self, uint256[] memory amounts, uint256 maxBurnAmount ) public returns (uint256) { require( amounts.length == self.pooledTokens.length, "Amounts should match pool tokens" ); require( maxBurnAmount <= self.lpToken.balanceOf(msg.sender) && maxBurnAmount != 0, ">LP.balanceOf" ); RemoveLiquidityImbalanceInfo memory v = RemoveLiquidityImbalanceInfo(0, 0, 0, 0); uint256 tokenSupply = self.lpToken.totalSupply(); uint256 feePerToken = _feePerToken(self); uint256[] memory balances1 = self.balances; v.preciseA = _getAPrecise(self); v.d0 = getD(_xp(self), v.preciseA); for (uint256 i = 0; i < self.pooledTokens.length; i++) { balances1[i] = balances1[i].sub( amounts[i], "Cannot withdraw more than available" ); } v.d1 = getD(_xp(self, balances1), v.preciseA); uint256[] memory fees = new uint256[](self.pooledTokens.length); for (uint256 i = 0; i < self.pooledTokens.length; i++) { uint256 idealBalance = v.d1.mul(self.balances[i]).div(v.d0); uint256 difference = idealBalance.difference(balances1[i]); fees[i] = feePerToken.mul(difference).div(FEE_DENOMINATOR); self.balances[i] = balances1[i].sub( fees[i].mul(self.adminFee).div(FEE_DENOMINATOR) ); balances1[i] = balances1[i].sub(fees[i]); } v.d2 = getD(_xp(self, balances1), v.preciseA); uint256 tokenAmount = v.d0.sub(v.d2).mul(tokenSupply).div(v.d0); require(tokenAmount != 0, "Burnt amount cannot be zero"); tokenAmount = tokenAmount.add(1).mul(FEE_DENOMINATOR).div( FEE_DENOMINATOR.sub(calculateCurrentWithdrawFee(self, msg.sender)) ); require(tokenAmount <= maxBurnAmount, "tokenAmount > maxBurnAmount"); self.lpToken.burnFrom(msg.sender, tokenAmount); for (uint256 i = 0; i < self.pooledTokens.length; i++) { self.pooledTokens[i].safeTransfer(msg.sender, amounts[i]); } emit RemoveLiquidityImbalance( msg.sender, amounts, fees, v.d1, tokenSupply.sub(tokenAmount) ); return tokenAmount; } /** * @notice withdraw all admin fees to a given address * @param self Swap struct to withdraw fees from * @param to Address to send the fees to */ function withdrawAdminFees(Swap storage self, address to) external { for (uint256 i = 0; i < self.pooledTokens.length; i++) { IERC20 token = self.pooledTokens[i]; uint256 balance = token.balanceOf(address(this)).sub(self.balances[i]); if (balance != 0) { token.safeTransfer(to, balance); } } } /** * @notice Sets the admin fee * @dev adminFee cannot be higher than 100% of the swap fee * @param self Swap struct to update * @param newAdminFee new admin fee to be applied on future transactions */ function setAdminFee(Swap storage self, uint256 newAdminFee) external { require(newAdminFee <= MAX_ADMIN_FEE, "Fee is too high"); self.adminFee = newAdminFee; emit NewAdminFee(newAdminFee); } /** * @notice update the swap fee * @dev fee cannot be higher than 1% of each swap * @param self Swap struct to update * @param newSwapFee new swap fee to be applied on future transactions */ function setSwapFee(Swap storage self, uint256 newSwapFee) external { require(newSwapFee <= MAX_SWAP_FEE, "Fee is too high"); self.swapFee = newSwapFee; emit NewSwapFee(newSwapFee); } /** * @notice update the default withdraw fee. This also affects deposits made in the past as well. * @param self Swap struct to update * @param newWithdrawFee new withdraw fee to be applied */ function setDefaultWithdrawFee(Swap storage self, uint256 newWithdrawFee) external { require(newWithdrawFee <= MAX_WITHDRAW_FEE, "Fee is too high"); self.defaultWithdrawFee = newWithdrawFee; emit NewWithdrawFee(newWithdrawFee); } /** * @notice update the default deposit fee. * @param self Swap struct to update * @param newDepositFee new deposit fee to be applied */ function setDefaultDepositFee(Swap storage self, uint256 newDepositFee) external { require(newDepositFee <= MAX_DEPOSIT_FEE, "Fee is too high"); self.defaultDepositFee = newDepositFee; emit NewDepositFee(newDepositFee); } /** * @notice Start ramping up or down A parameter towards given futureA_ and futureTime_ * Checks if the change is too rapid, and commits the new A value only when it falls under * the limit range. * @param self Swap struct to update * @param futureA_ the new A to ramp towards * @param futureTime_ timestamp when the new A should be reached */ function rampA( Swap storage self, uint256 futureA_, uint256 futureTime_ ) external { require( block.timestamp >= self.initialATime.add(1 days), "Wait 1 day before starting ramp" ); require( futureTime_ >= block.timestamp.add(MIN_RAMP_TIME), "Insufficient ramp time" ); require( futureA_ > 0 && futureA_ < MAX_A, "futureA_ must be > 0 and < MAX_A" ); uint256 initialAPrecise = _getAPrecise(self); uint256 futureAPrecise = futureA_.mul(A_PRECISION); if (futureAPrecise < initialAPrecise) { require( futureAPrecise.mul(MAX_A_CHANGE) >= initialAPrecise, "futureA_ is too small" ); } else { require( futureAPrecise <= initialAPrecise.mul(MAX_A_CHANGE), "futureA_ is too large" ); } self.initialA = initialAPrecise; self.futureA = futureAPrecise; self.initialATime = block.timestamp; self.futureATime = futureTime_; emit RampA( initialAPrecise, futureAPrecise, block.timestamp, futureTime_ ); } /** * @notice Stops ramping A immediately. Once this function is called, rampA() * cannot be called for another 24 hours * @param self Swap struct to update */ function stopRampA(Swap storage self) external { require(self.futureATime > block.timestamp, "Ramp is already stopped"); uint256 currentA = _getAPrecise(self); self.initialA = currentA; self.futureA = currentA; self.initialATime = block.timestamp; self.futureATime = block.timestamp; emit StopRampA(currentA, block.timestamp); } function setDevAddress(Swap storage self, address _devaddr) public { require(msg.sender == self.devaddr, "dev: wut?"); require(msg.sender != address(0), "invalid address"); self.devaddr = _devaddr; } }
/project_/contracts/openzeppelin-contracts_3.4.0/contracts/access/Ownable.sol
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; import "../utils/Context.sol"; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor () internal { address msgSender = _msgSender(); _owner = msgSender; emit OwnershipTransferred(address(0), msgSender); } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { require(owner() == _msgSender(), "Ownable: caller is not the owner"); _; } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { emit OwnershipTransferred(_owner, address(0)); _owner = address(0); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(_owner, newOwner); _owner = newOwner; } }
/project_/contracts/openzeppelin-contracts_3.4.0/contracts/math/SafeMath.sol
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Wrappers over Solidity's arithmetic operations with added overflow * checks. * * Arithmetic operations in Solidity wrap on overflow. This can easily result * in bugs, because programmers usually assume that an overflow raises an * error, which is the standard behavior in high level programming languages. * `SafeMath` restores this intuition by reverting the transaction when an * operation overflows. * * Using this library instead of the unchecked operations eliminates an entire * class of bugs, so it's recommended to use it always. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b > a) return (false, 0); return (true, a - b); } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a / b); } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { if (b == 0) return (false, 0); return (true, a % b); } /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { uint256 c = a + b; require(c >= a, "SafeMath: addition overflow"); return c; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { require(b <= a, "SafeMath: subtraction overflow"); return a - b; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { if (a == 0) return 0; uint256 c = a * b; require(c / a == b, "SafeMath: multiplication overflow"); return c; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: division by zero"); return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { require(b > 0, "SafeMath: modulo by zero"); return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b <= a, errorMessage); return a - b; } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryDiv}. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) { require(b > 0, errorMessage); return a % b; } }
/project_/contracts/openzeppelin-contracts_3.4.0/contracts/token/ERC20/ERC20.sol
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; import "../../utils/Context.sol"; import "./IERC20.sol"; import "../../math/SafeMath.sol"; /** * @dev Implementation of the {IERC20} interface. * * This implementation is agnostic to the way tokens are created. This means * that a supply mechanism has to be added in a derived contract using {_mint}. * For a generic mechanism see {ERC20PresetMinterPauser}. * * TIP: For a detailed writeup see our guide * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How * to implement supply mechanisms]. * * We have followed general OpenZeppelin guidelines: functions revert instead * of returning `false` on failure. This behavior is nonetheless conventional * and does not conflict with the expectations of ERC20 applications. * * Additionally, an {Approval} event is emitted on calls to {transferFrom}. * This allows applications to reconstruct the allowance for all accounts just * by listening to said events. Other implementations of the EIP may not emit * these events, as it isn't required by the specification. * * Finally, the non-standard {decreaseAllowance} and {increaseAllowance} * functions have been added to mitigate the well-known issues around setting * allowances. See {IERC20-approve}. */ contract ERC20 is Context, IERC20 { using SafeMath for uint256; mapping (address => uint256) private _balances; mapping (address => mapping (address => uint256)) private _allowances; uint256 private _totalSupply; string private _name; string private _symbol; uint8 private _decimals; /** * @dev Sets the values for {name} and {symbol}, initializes {decimals} with * a default value of 18. * * To select a different value for {decimals}, use {_setupDecimals}. * * All three of these values are immutable: they can only be set once during * construction. */ constructor (string memory name_, string memory symbol_) public { _name = name_; _symbol = symbol_; _decimals = 18; } /** * @dev Returns the name of the token. */ function name() public view virtual returns (string memory) { return _name; } /** * @dev Returns the symbol of the token, usually a shorter version of the * name. */ function symbol() public view virtual returns (string memory) { return _symbol; } /** * @dev Returns the number of decimals used to get its user representation. * For example, if `decimals` equals `2`, a balance of `505` tokens should * be displayed to a user as `5,05` (`505 / 10 ** 2`). * * Tokens usually opt for a value of 18, imitating the relationship between * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is * called. * * NOTE: This information is only used for _display_ purposes: it in * no way affects any of the arithmetic of the contract, including * {IERC20-balanceOf} and {IERC20-transfer}. */ function decimals() public view virtual returns (uint8) { return _decimals; } /** * @dev See {IERC20-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _totalSupply; } /** * @dev See {IERC20-balanceOf}. */ function balanceOf(address account) public view virtual override returns (uint256) { return _balances[account]; } /** * @dev See {IERC20-transfer}. * * Requirements: * * - `recipient` cannot be the zero address. * - the caller must have a balance of at least `amount`. */ function transfer(address recipient, uint256 amount) public virtual override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; } /** * @dev See {IERC20-allowance}. */ function allowance(address owner, address spender) public view virtual override returns (uint256) { return _allowances[owner][spender]; } /** * @dev See {IERC20-approve}. * * Requirements: * * - `spender` cannot be the zero address. */ function approve(address spender, uint256 amount) public virtual override returns (bool) { _approve(_msgSender(), spender, amount); return true; } /** * @dev See {IERC20-transferFrom}. * * Emits an {Approval} event indicating the updated allowance. This is not * required by the EIP. See the note at the beginning of {ERC20}. * * Requirements: * * - `sender` and `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. * - the caller must have allowance for ``sender``'s tokens of at least * `amount`. */ function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) { _transfer(sender, recipient, amount); _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance")); return true; } /** * @dev Atomically increases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. */ function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue)); return true; } /** * @dev Atomically decreases the allowance granted to `spender` by the caller. * * This is an alternative to {approve} that can be used as a mitigation for * problems described in {IERC20-approve}. * * Emits an {Approval} event indicating the updated allowance. * * Requirements: * * - `spender` cannot be the zero address. * - `spender` must have allowance for the caller of at least * `subtractedValue`. */ function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) { _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero")); return true; } /** * @dev Moves tokens `amount` from `sender` to `recipient`. * * This is internal function is equivalent to {transfer}, and can be used to * e.g. implement automatic token fees, slashing mechanisms, etc. * * Emits a {Transfer} event. * * Requirements: * * - `sender` cannot be the zero address. * - `recipient` cannot be the zero address. * - `sender` must have a balance of at least `amount`. */ function _transfer(address sender, address recipient, uint256 amount) internal virtual { require(sender != address(0), "ERC20: transfer from the zero address"); require(recipient != address(0), "ERC20: transfer to the zero address"); _beforeTokenTransfer(sender, recipient, amount); _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance"); _balances[recipient] = _balances[recipient].add(amount); emit Transfer(sender, recipient, amount); } /** @dev Creates `amount` tokens and assigns them to `account`, increasing * the total supply. * * Emits a {Transfer} event with `from` set to the zero address. * * Requirements: * * - `to` cannot be the zero address. */ function _mint(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: mint to the zero address"); _beforeTokenTransfer(address(0), account, amount); _totalSupply = _totalSupply.add(amount); _balances[account] = _balances[account].add(amount); emit Transfer(address(0), account, amount); } /** * @dev Destroys `amount` tokens from `account`, reducing the * total supply. * * Emits a {Transfer} event with `to` set to the zero address. * * Requirements: * * - `account` cannot be the zero address. * - `account` must have at least `amount` tokens. */ function _burn(address account, uint256 amount) internal virtual { require(account != address(0), "ERC20: burn from the zero address"); _beforeTokenTransfer(account, address(0), amount); _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance"); _totalSupply = _totalSupply.sub(amount); emit Transfer(account, address(0), amount); } /** * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens. * * This internal function is equivalent to `approve`, and can be used to * e.g. set automatic allowances for certain subsystems, etc. * * Emits an {Approval} event. * * Requirements: * * - `owner` cannot be the zero address. * - `spender` cannot be the zero address. */ function _approve(address owner, address spender, uint256 amount) internal virtual { require(owner != address(0), "ERC20: approve from the zero address"); require(spender != address(0), "ERC20: approve to the zero address"); _allowances[owner][spender] = amount; emit Approval(owner, spender, amount); } /** * @dev Sets {decimals} to a value other than the default one of 18. * * WARNING: This function should only be called from the constructor. Most * applications that interact with token contracts will not expect * {decimals} to ever change, and may work incorrectly if it does. */ function _setupDecimals(uint8 decimals_) internal virtual { _decimals = decimals_; } /** * @dev Hook that is called before any transfer of tokens. This includes * minting and burning. * * Calling conditions: * * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens * will be to transferred to `to`. * - when `from` is zero, `amount` tokens will be minted for `to`. * - when `to` is zero, `amount` of ``from``'s tokens will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { } }
/project_/contracts/openzeppelin-contracts_3.4.0/contracts/token/ERC20/ERC20Burnable.sol
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; import "../../utils/Context.sol"; import "./ERC20.sol"; /** * @dev Extension of {ERC20} that allows token holders to destroy both their own * tokens and those that they have an allowance for, in a way that can be * recognized off-chain (via event analysis). */ abstract contract ERC20Burnable is Context, ERC20 { using SafeMath for uint256; /** * @dev Destroys `amount` tokens from the caller. * * See {ERC20-_burn}. */ function burn(uint256 amount) public virtual { _burn(_msgSender(), amount); } /** * @dev Destroys `amount` tokens from `account`, deducting from the caller's * allowance. * * See {ERC20-_burn} and {ERC20-allowance}. * * Requirements: * * - the caller must have allowance for ``accounts``'s tokens of at least * `amount`. */ function burnFrom(address account, uint256 amount) public virtual { uint256 decreasedAllowance = allowance(account, _msgSender()).sub(amount, "ERC20: burn amount exceeds allowance"); _approve(account, _msgSender(), decreasedAllowance); _burn(account, amount); } }
/project_/contracts/openzeppelin-contracts_3.4.0/contracts/token/ERC20/IERC20.sol
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Interface of the ERC20 standard as defined in the EIP. */ interface IERC20 { /** * @dev Returns the amount of tokens in existence. */ function totalSupply() external view returns (uint256); /** * @dev Returns the amount of tokens owned by `account`. */ function balanceOf(address account) external view returns (uint256); /** * @dev Moves `amount` tokens from the caller's account to `recipient`. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transfer(address recipient, uint256 amount) external returns (bool); /** * @dev Returns the remaining number of tokens that `spender` will be * allowed to spend on behalf of `owner` through {transferFrom}. This is * zero by default. * * This value changes when {approve} or {transferFrom} are called. */ function allowance(address owner, address spender) external view returns (uint256); /** * @dev Sets `amount` as the allowance of `spender` over the caller's tokens. * * Returns a boolean value indicating whether the operation succeeded. * * IMPORTANT: Beware that changing an allowance with this method brings the risk * that someone may use both the old and the new allowance by unfortunate * transaction ordering. One possible solution to mitigate this race * condition is to first reduce the spender's allowance to 0 and set the * desired value afterwards: * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729 * * Emits an {Approval} event. */ function approve(address spender, uint256 amount) external returns (bool); /** * @dev Moves `amount` tokens from `sender` to `recipient` using the * allowance mechanism. `amount` is then deducted from the caller's * allowance. * * Returns a boolean value indicating whether the operation succeeded. * * Emits a {Transfer} event. */ function transferFrom(address sender, address recipient, uint256 amount) external returns (bool); /** * @dev Emitted when `value` tokens are moved from one account (`from`) to * another (`to`). * * Note that `value` may be zero. */ event Transfer(address indexed from, address indexed to, uint256 value); /** * @dev Emitted when the allowance of a `spender` for an `owner` is set by * a call to {approve}. `value` is the new allowance. */ event Approval(address indexed owner, address indexed spender, uint256 value); }
/project_/contracts/openzeppelin-contracts_3.4.0/contracts/token/ERC20/SafeERC20.sol
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; import "./IERC20.sol"; import "../../math/SafeMath.sol"; import "../../utils/Address.sol"; /** * @title SafeERC20 * @dev Wrappers around ERC20 operations that throw on failure (when the token * contract returns false). Tokens that return no value (and instead revert or * throw on failure) are also supported, non-reverting calls are assumed to be * successful. * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract, * which allows you to call the safe operations as `token.safeTransfer(...)`, etc. */ library SafeERC20 { using SafeMath for uint256; using Address for address; function safeTransfer(IERC20 token, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value)); } function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal { _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value)); } /** * @dev Deprecated. This function has issues similar to the ones found in * {IERC20-approve}, and its usage is discouraged. * * Whenever possible, use {safeIncreaseAllowance} and * {safeDecreaseAllowance} instead. */ function safeApprove(IERC20 token, address spender, uint256 value) internal { // safeApprove should only be called when setting an initial allowance, // or when resetting it to zero. To increase and decrease it, use // 'safeIncreaseAllowance' and 'safeDecreaseAllowance' // solhint-disable-next-line max-line-length require((value == 0) || (token.allowance(address(this), spender) == 0), "SafeERC20: approve from non-zero to non-zero allowance" ); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value)); } function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).add(value); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal { uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero"); _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance)); } /** * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement * on the return value: the return value is optional (but if data is returned, it must not be false). * @param token The token targeted by the call. * @param data The call data (encoded using abi.encode or one of its variants). */ function _callOptionalReturn(IERC20 token, bytes memory data) private { // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that // the target address contains contract code and also asserts for success in the low-level call. bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed"); if (returndata.length > 0) { // Return data is optional // solhint-disable-next-line max-line-length require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed"); } } }
/project_/contracts/openzeppelin-contracts_3.4.0/contracts/utils/Address.sol
// SPDX-License-Identifier: MIT pragma solidity >=0.6.2 <0.8.0; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; // solhint-disable-next-line no-inline-assembly assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); // solhint-disable-next-line avoid-low-level-calls, avoid-call-value (bool success, ) = recipient.call{ value: amount }(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain`call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.call{ value: value }(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); // solhint-disable-next-line avoid-low-level-calls (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly // solhint-disable-next-line no-inline-assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } }
/project_/contracts/openzeppelin-contracts_3.4.0/contracts/utils/Context.sol
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with GSN meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address payable) { return msg.sender; } function _msgData() internal view virtual returns (bytes memory) { this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691 return msg.data; } }
/project_/contracts/openzeppelin-contracts_3.4.0/contracts/utils/Pausable.sol
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; import "./Context.sol"; /** * @dev Contract module which allows children to implement an emergency stop * mechanism that can be triggered by an authorized account. * * This module is used through inheritance. It will make available the * modifiers `whenNotPaused` and `whenPaused`, which can be applied to * the functions of your contract. Note that they will not be pausable by * simply including this module, only once the modifiers are put in place. */ abstract contract Pausable is Context { /** * @dev Emitted when the pause is triggered by `account`. */ event Paused(address account); /** * @dev Emitted when the pause is lifted by `account`. */ event Unpaused(address account); bool private _paused; /** * @dev Initializes the contract in unpaused state. */ constructor () internal { _paused = false; } /** * @dev Returns true if the contract is paused, and false otherwise. */ function paused() public view virtual returns (bool) { return _paused; } /** * @dev Modifier to make a function callable only when the contract is not paused. * * Requirements: * * - The contract must not be paused. */ modifier whenNotPaused() { require(!paused(), "Pausable: paused"); _; } /** * @dev Modifier to make a function callable only when the contract is paused. * * Requirements: * * - The contract must be paused. */ modifier whenPaused() { require(paused(), "Pausable: not paused"); _; } /** * @dev Triggers stopped state. * * Requirements: * * - The contract must not be paused. */ function _pause() internal virtual whenNotPaused { _paused = true; emit Paused(_msgSender()); } /** * @dev Returns to normal state. * * Requirements: * * - The contract must be paused. */ function _unpause() internal virtual whenPaused { _paused = false; emit Unpaused(_msgSender()); } }
/project_/contracts/openzeppelin-contracts_3.4.0/contracts/utils/ReentrancyGuard.sol
// SPDX-License-Identifier: MIT pragma solidity >=0.6.0 <0.8.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor () internal { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and make it call a * `private` function that does the actual work. */ modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } }
/project_/interfaces/ISwap.sol
// SPDX-License-Identifier: MIT pragma solidity 0.6.12; import '../contracts/openzeppelin-contracts@3.4.0/contracts/token/ERC20/ERC20.sol'; interface ISwap { // pool data view functions function getA() external view returns (uint256); function getToken(uint8 index) external view returns (IERC20); function getTokenIndex(address tokenAddress) external view returns (uint8); function getTokenBalance(uint8 index) external view returns (uint256); function getVirtualPrice() external view returns (uint256); // min return calculation functions function calculateSwap( uint8 tokenIndexFrom, uint8 tokenIndexTo, uint256 dx ) external view returns (uint256); function calculateTokenAmount( address account, uint256[] calldata amounts, bool deposit ) external view returns (uint256); function calculateRemoveLiquidity(address account, uint256 amount) external view returns (uint256[] memory); function calculateRemoveLiquidityOneToken( address account, uint256 tokenAmount, uint8 tokenIndex ) external view returns (uint256 availableTokenAmount); // state modifying functions function initialize( IERC20[] memory pooledTokens, uint8[] memory decimals, string memory lpTokenName, string memory lpTokenSymbol, uint256 a, uint256 fee, uint256 adminFee, uint256 depositFee, uint256 withdrawFee, address devaddr ) external; function swap( uint8 tokenIndexFrom, uint8 tokenIndexTo, uint256 dx, uint256 minDy, uint256 deadline ) external returns (uint256); function addLiquidity( uint256[] calldata amounts, uint256 minToMint, uint256 deadline ) external returns (uint256); function removeLiquidity( uint256 amount, uint256[] calldata minAmounts, uint256 deadline ) external returns (uint256[] memory); function removeLiquidityOneToken( uint256 tokenAmount, uint8 tokenIndex, uint256 minAmount, uint256 deadline ) external returns (uint256); function removeLiquidityImbalance( uint256[] calldata amounts, uint256 maxBurnAmount, uint256 deadline ) external returns (uint256); // withdraw fee update function function updateUserWithdrawFee(address recipient, uint256 transferAmount) external; }
Contract ABI
[{"type":"constructor","stateMutability":"nonpayable","inputs":[{"type":"address[]","name":"_pooledTokens","internalType":"contract IERC20[]"},{"type":"uint8[]","name":"decimals","internalType":"uint8[]"},{"type":"string","name":"lpTokenName","internalType":"string"},{"type":"string","name":"lpTokenSymbol","internalType":"string"},{"type":"uint256","name":"_a","internalType":"uint256"},{"type":"uint256","name":"_fee","internalType":"uint256"},{"type":"uint256","name":"_adminFee","internalType":"uint256"},{"type":"uint256","name":"_depositFee","internalType":"uint256"},{"type":"uint256","name":"_withdrawFee","internalType":"uint256"},{"type":"address","name":"_devaddr","internalType":"address"}]},{"type":"event","name":"AddLiquidity","inputs":[{"type":"address","name":"provider","internalType":"address","indexed":true},{"type":"uint256[]","name":"tokenAmounts","internalType":"uint256[]","indexed":false},{"type":"uint256[]","name":"fees","internalType":"uint256[]","indexed":false},{"type":"uint256","name":"invariant","internalType":"uint256","indexed":false},{"type":"uint256","name":"lpTokenSupply","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"NewAdminFee","inputs":[{"type":"uint256","name":"newAdminFee","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"NewDepositFee","inputs":[{"type":"uint256","name":"newDepositFee","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"NewSwapFee","inputs":[{"type":"uint256","name":"newSwapFee","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"NewWithdrawFee","inputs":[{"type":"uint256","name":"newWithdrawFee","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"OwnershipTransferred","inputs":[{"type":"address","name":"previousOwner","internalType":"address","indexed":true},{"type":"address","name":"newOwner","internalType":"address","indexed":true}],"anonymous":false},{"type":"event","name":"Paused","inputs":[{"type":"address","name":"account","internalType":"address","indexed":false}],"anonymous":false},{"type":"event","name":"RampA","inputs":[{"type":"uint256","name":"oldA","internalType":"uint256","indexed":false},{"type":"uint256","name":"newA","internalType":"uint256","indexed":false},{"type":"uint256","name":"initialTime","internalType":"uint256","indexed":false},{"type":"uint256","name":"futureTime","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"RemoveLiquidity","inputs":[{"type":"address","name":"provider","internalType":"address","indexed":true},{"type":"uint256[]","name":"tokenAmounts","internalType":"uint256[]","indexed":false},{"type":"uint256","name":"lpTokenSupply","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"RemoveLiquidityImbalance","inputs":[{"type":"address","name":"provider","internalType":"address","indexed":true},{"type":"uint256[]","name":"tokenAmounts","internalType":"uint256[]","indexed":false},{"type":"uint256[]","name":"fees","internalType":"uint256[]","indexed":false},{"type":"uint256","name":"invariant","internalType":"uint256","indexed":false},{"type":"uint256","name":"lpTokenSupply","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"RemoveLiquidityOne","inputs":[{"type":"address","name":"provider","internalType":"address","indexed":true},{"type":"uint256","name":"lpTokenAmount","internalType":"uint256","indexed":false},{"type":"uint256","name":"lpTokenSupply","internalType":"uint256","indexed":false},{"type":"uint256","name":"boughtId","internalType":"uint256","indexed":false},{"type":"uint256","name":"tokensBought","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"StopRampA","inputs":[{"type":"uint256","name":"currentA","internalType":"uint256","indexed":false},{"type":"uint256","name":"time","internalType":"uint256","indexed":false}],"anonymous":false},{"type":"event","name":"TokenSwap","inputs":[{"type":"address","name":"buyer","internalType":"address","indexed":true},{"type":"uint256","name":"tokensSold","internalType":"uint256","indexed":false},{"type":"uint256","name":"tokensBought","internalType":"uint256","indexed":false},{"type":"uint128","name":"soldId","internalType":"uint128","indexed":false},{"type":"uint128","name":"boughtId","internalType":"uint128","indexed":false}],"anonymous":false},{"type":"event","name":"Unpaused","inputs":[{"type":"address","name":"account","internalType":"address","indexed":false}],"anonymous":false},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"addLiquidity","inputs":[{"type":"uint256[]","name":"amounts","internalType":"uint256[]"},{"type":"uint256","name":"minToMint","internalType":"uint256"},{"type":"uint256","name":"deadline","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"calculateCurrentWithdrawFee","inputs":[{"type":"address","name":"user","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256[]","name":"","internalType":"uint256[]"}],"name":"calculateRemoveLiquidity","inputs":[{"type":"address","name":"account","internalType":"address"},{"type":"uint256","name":"amount","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"availableTokenAmount","internalType":"uint256"}],"name":"calculateRemoveLiquidityOneToken","inputs":[{"type":"address","name":"account","internalType":"address"},{"type":"uint256","name":"tokenAmount","internalType":"uint256"},{"type":"uint8","name":"tokenIndex","internalType":"uint8"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"calculateSwap","inputs":[{"type":"uint8","name":"tokenIndexFrom","internalType":"uint8"},{"type":"uint8","name":"tokenIndexTo","internalType":"uint8"},{"type":"uint256","name":"dx","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"calculateTokenAmount","inputs":[{"type":"address","name":"account","internalType":"address"},{"type":"uint256[]","name":"amounts","internalType":"uint256[]"},{"type":"bool","name":"deposit","internalType":"bool"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getA","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getAPrecise","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getAdminBalance","inputs":[{"type":"uint256","name":"index","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256[]","name":"","internalType":"uint256[]"}],"name":"getBalances","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getDepositTimestamp","inputs":[{"type":"address","name":"user","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"getLpToken","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getSwapFee","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"contract IERC20"}],"name":"getToken","inputs":[{"type":"uint8","name":"index","internalType":"uint8"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getTokenBalance","inputs":[{"type":"uint8","name":"index","internalType":"uint8"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint8","name":"","internalType":"uint8"}],"name":"getTokenIndex","inputs":[{"type":"address","name":"tokenAddress","internalType":"address"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"getVirtualPrice","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"address","name":"","internalType":"address"}],"name":"owner","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"pause","inputs":[]},{"type":"function","stateMutability":"view","outputs":[{"type":"bool","name":"","internalType":"bool"}],"name":"paused","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"rampA","inputs":[{"type":"uint256","name":"futureA","internalType":"uint256"},{"type":"uint256","name":"futureTime","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"uint256[]","name":"","internalType":"uint256[]"}],"name":"removeLiquidity","inputs":[{"type":"uint256","name":"amount","internalType":"uint256"},{"type":"uint256[]","name":"minAmounts","internalType":"uint256[]"},{"type":"uint256","name":"deadline","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"removeLiquidityImbalance","inputs":[{"type":"uint256[]","name":"amounts","internalType":"uint256[]"},{"type":"uint256","name":"maxBurnAmount","internalType":"uint256"},{"type":"uint256","name":"deadline","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"removeLiquidityOneToken","inputs":[{"type":"uint256","name":"tokenAmount","internalType":"uint256"},{"type":"uint8","name":"tokenIndex","internalType":"uint8"},{"type":"uint256","name":"minAmount","internalType":"uint256"},{"type":"uint256","name":"deadline","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"renounceOwnership","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setAdminFee","inputs":[{"type":"uint256","name":"newAdminFee","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setDefaultDepositFee","inputs":[{"type":"uint256","name":"newDepositFee","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setDefaultWithdrawFee","inputs":[{"type":"uint256","name":"newWithdrawFee","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setDevAddress","inputs":[{"type":"address","name":"_devaddr","internalType":"address"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"setSwapFee","inputs":[{"type":"uint256","name":"newSwapFee","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"stopRampA","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[{"type":"uint256","name":"","internalType":"uint256"}],"name":"swap","inputs":[{"type":"uint8","name":"tokenIndexFrom","internalType":"uint8"},{"type":"uint8","name":"tokenIndexTo","internalType":"uint8"},{"type":"uint256","name":"dx","internalType":"uint256"},{"type":"uint256","name":"minDy","internalType":"uint256"},{"type":"uint256","name":"deadline","internalType":"uint256"}]},{"type":"function","stateMutability":"view","outputs":[{"type":"uint256","name":"initialA","internalType":"uint256"},{"type":"uint256","name":"futureA","internalType":"uint256"},{"type":"uint256","name":"initialATime","internalType":"uint256"},{"type":"uint256","name":"futureATime","internalType":"uint256"},{"type":"uint256","name":"swapFee","internalType":"uint256"},{"type":"uint256","name":"adminFee","internalType":"uint256"},{"type":"uint256","name":"defaultDepositFee","internalType":"uint256"},{"type":"uint256","name":"defaultWithdrawFee","internalType":"uint256"},{"type":"address","name":"devaddr","internalType":"address"},{"type":"address","name":"lpToken","internalType":"contract LPToken"}],"name":"swapStorage","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"transferOwnership","inputs":[{"type":"address","name":"newOwner","internalType":"address"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"unpause","inputs":[]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"updateUserWithdrawFee","inputs":[{"type":"address","name":"recipient","internalType":"address"},{"type":"uint256","name":"transferAmount","internalType":"uint256"}]},{"type":"function","stateMutability":"nonpayable","outputs":[],"name":"withdrawAdminFees","inputs":[]}]
Contract Creation Code
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
Deployed ByteCode
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