Curve DAO 백서

Curve DAO

원문

bitpro가 원문에서 글자만 모은 내용이에요. 표·그림·수식은 빠지거나 깨질 수 있어요. 전체 75쪽 중 3쪽

_fee 20000000000, # _offpeg_fee_multiplier 865, # _ma_exp_time 0, # _implementation_idx [0, 0], # _asset_types [b"", b""], # _method_ids ["0x0000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000"] # _oracles ) 'returns address of the deployed plain pool' ``` <a id="deploy_metapool"></a> ### `deploy_metapool` *Parameter limitations when deploying a meta pool:* - Cannot pair against a token that is included in the base pool. - `_fee` ≤ 100000000 (1%). - `_offpeg_fee_multiplier` \* `_fee` ≤ `MAX_FEE` \* `FEE_DENOMINATOR`. - Valid implementation index. - Maximum of 18 decimals for a coin. `Factory.deploy_metapool(_base_pool: address, _name: String[32], _symbol: String[10], _coin: address, _A: uint256, _fee: uint256, _offpeg_fee_multiplier: uint256, _ma_exp_time: uint256, _implementation_idx: uint256, _asset_type: uint8, _method_id: bytes4, _oracle: address) -> address:` Function to deploy a stableswap-ng metapool. Returns: Deployed metapool (`address`). Emits: `MetaPoolDeployed` | Input | Type | Description | | --- | --- | --- | | `_base_pool` | `address` | Address of the base pool to pair the token with | | `_name` | `String[32]` | Name of the new metapool | | `_symbol` | `String[10]` | Symbol for the new metapool’s LP token - will be concatenated with the base pool symbol | | `_coin` | `address` | Address of the coin being used in the metapool | | `_A` | `uint256` | Amplification coefficient | | `_fee` | `uint256` | Trade fee, given as an integer with `1e10` precision | | `_offpeg_fee_multiplier` | `uint256` | Off-peg multiplier | | `_ma_exp_time` | `uint256` | MA time; set as time\_in\_seconds / ln(2) | | `_implementation_idx` | `uint256` | Index of the implementation to use | | `_asset_type` | `uint8` | Asset type of the pool as an integer; more [here](https://docs.curve.finance/developer/amm/stableswap-ng/overview.md#supported-assets) | | `_method_id` | `bytes4` | First four bytes of the Keccak-256 hash of the function signatures of the oracle addresses that give rate oracles | | `_oracle` | `address` | Rate oracle address | Implementation ID There might be multiple metapool implementations. To query all available ones, see [here](https://docs.curve.finance/developer/amm/factory/stableswap-ng/overview.md#query-implementations). As of the current date (31.10.2023), there is only one metapool implementation available. Since the \*\*`_implementation_idx`\*\*starts at 0, users need to input "0" when deploying a pool. **<>Source code▼** ```vyper event MetaPoolDeployed: coin: address base_pool: address A: uint256 fee: uint256 deployer: address MAX_COINS: constant(uint256) = 8 MAX_FEE: constant(uint256) = 5 * 10 **9 FEE_DENOMINATOR: constant(uint256) = 10 **10 @external def deploy_metapool( _base_pool: address, _name: String[32], _symbol: String[10], _coin: address, _A: uint256, _fee: uint256, _offpeg_fee_multiplier: uint256, _ma_exp_time: uint256, _implementation_idx: uint256, _asset_type: uint8, _method_id: bytes4, _oracle: address, ) -> address: """ @notice Deploy a new metapool @param _base_pool Address of the base pool to use within the metapool @param _name Name of the new metapool @param _symbol Symbol for the new metapool - will be concatenated with the base pool symbol @param _coin Address of the coin being used in the metapool @param _A Amplification co-efficient - a higher value here means less tolerance for imbalance within the pool's assets. Suggested values include: * Uncollateralized algorithmic stablecoins: 5-10 * Non-redeemable, collateralized assets: 100 * Redeemable assets: 200-400 @param _fee Trade fee, given as an integer with 1e10 precision. The the maximum is 1% (100000000). 50% of the fee is distributed to veCRV holders. @param _ma_exp_time Averaging window of oracle. Set as time_in_seconds / ln(2) Example: for 10 minute EMA, _ma_exp_time is 600 / ln(2) ~= 866 @param _implementation_idx Index of the implementation to use @param _asset_type Asset type for token, as an integer @param _method_id First four bytes of the Keccak-256 hash of the function signatures of the oracle addresses that gives rate oracles. Calculated as: keccak(text=event_signature.replace(" ", ""))[:4] @param _oracle Rate oracle address. @return Address of the deployed pool """ assert not self.base_pool_assets[_coin], "Invalid asset: Cannot pair base pool asset with base pool's LP token" assert _fee <= 100000000, "Invalid fee" assert _offpeg_fee_multiplier * _fee <= MAX_FEE * FEE_DENOMINATOR base_pool_n_coins: uint256 = len(self.base_pool_data[_base_pool].coins) assert base_pool_n_coins != 0, "Base pool is not added" implementation: address = self.metapool_implementations[_implementation_idx] assert implementation != empty(address), "Invalid implementation index" # things break if a token has >18 decimals decimals: uint256 = ERC20(_coin).decimals() assert decimals < 19, "Max 18 decimals for coins" # combine _coins's _asset_type and basepool coins _asset_types: base_pool_asset_types: DynArray[uint8, MAX_COINS] = self.base_pool_data[_base_pool].asset_types asset_types: DynArray[uint8, MAX_COINS] = [_asset_type, 0] for i in range(0, MAX_COINS): if i == base_pool_n_coins: break asset_types.append(base_pool_asset_types[i]) _coins: DynArray[address, MAX_COINS] = [_coin, self.base_pool_data[_base_pool].lp_token] _rate_multipliers: DynArray[uint256, MAX_COINS] = [10 **(36 - decimals), 10 **18] _method_ids: DynArray[bytes4, MAX_COINS] = [_method_id, empty(bytes4)] _oracles: DynArray[address, MAX_COINS] = [_oracle, empty(address)] pool: address = create_from_blueprint( implementation, _name, # _name: String[32] _symbol, # _symbol: String[10] _A, # _A: uint256 _fee, # _fee: uint256 _offpeg_fee_multiplier, # _offpeg_fee_multiplier: uint256 _ma_exp_time, # _ma_exp_time: uint256 self.math_implementation, # _math_implementation: address _base_pool, # _base_pool: address _coins, # _coins: DynArray[address, MAX_COINS] self.base_pool_data[_base_pool].coins, # base_coins: DynArray[address, MAX_COINS] _rate_multipliers, # _rate_multipliers: DynArray[uint256, MAX_COINS] asset_types, # asset_types: DynArray[uint8, MAX_COINS] _method_ids, # _method_ids: DynArray[bytes4, MAX_COINS] _oracles, # _oracles: DynArray[address, MAX_COINS] code_offset=3 ) # add pool to pool_list length: uint256 = self.pool_count self.pool_list[length] = pool self.pool_count = length + 1 base_lp_token: address = self.base_pool_data[_base_pool].lp_token self.pool_data[pool].decimals = [decimals, 18, 0, 0, 0, 0, 0, 0] self.pool_data[pool].n_coins = 2 self.pool_data[pool].base_pool = _base_pool self.pool_data[pool].coins = [_coin, self.base_pool_data[_base_pool].lp_token] self.pool_data[pool].implementation = implementation is_finished: bool = False swappable_coin: address = empty(address) for i in range(MAX_COINS): if i < len(self.base_pool_data[_base_pool].coins): swappable_coin = self.base_pool_data[_base_pool].coins[i] else: is_finished = True swappable_coin = base_lp_token key: uint256 = (convert(_coin, uint256) ^ convert(swappable_coin, uint256)) length = self.market_counts[key] self.markets[key][length] = pool self.market_counts[key] = length + 1 if is_finished: break log MetaPoolDeployed(_coin, _base_pool, _A, _fee, msg.sender) return pool ``` **▶Example▼** ```shell >>> Factory.deploy_metapool( "0xbebc44782c7db0a1a60cb6fe97d0b483032ff1c7", # _base_pool "crvusd/3CRV", # _name "crvusd-3crv" # _symbol "0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E", # _coin 1500 # _A 1000000, # _fee 20000000000, # _offpeg_fee_multiplier 865, # _ma_exp_time 0, # _implementation_idx 0, # _asset_type "b""", # _method_id "0x0000000000000000000000000000000000000000" # _oracle ) 'returns address of the deployed metapool' ``` * * * <a id="deploying-liquidity-gauges"></a> ## Deploying Liquidity Gauges Liquidity gauges for pools can also be deployed from this contract, but deploying gauges through a factory contract is only possible using the same factory contract that was used for deploying the pool. This feature is only available on the Ethereum mainnet, as liquidity gauges on sidechains need to be deployed through the [RootChainGaugeFactory](https://docs.curve.finance/developer/gauges/xchain-gauges/root-gauge-factory.md). <a id="deploy_gauge"></a> ### `deploy_gauge` `Factory.deploy_gauge(_pool: address) -> address:` Function to deploy a gauge. The Factory utilizes the `gauge_implementation` to create the contract from a blueprint. Returns: deployed gauge (`address`). Emits: `LiquidityGaugeDeployed` | Input | Type | Description | | --- | --- | --- | | `_pool` | `address` | Pool address to deploy the gauge for | **<>Source code▼** ```vyper event LiquidityGaugeDeployed: pool: address gauge: address @external def deploy_gauge(_pool: address) -> address: """ @notice Deploy a liquidity gauge for a factory pool @param _pool Factory pool address to deploy a gauge for @return Address of the deployed gauge """ assert self.pool_data[_pool].coins[0] != empty(address), "Unknown pool" assert self.pool_data[_pool].liquidity_gauge == empty(address), "Gauge already deployed" implementation: address = self.gauge_implementation assert implementation != empty(address), "Gauge implementation not set" gauge: address = create_from_blueprint(self.gauge_implementation, _pool, code_offset=3) self.pool_data[_pool].liquidity_gauge = gauge log LiquidityGaugeDeployed(_pool, gauge) return gauge ``` **▶Example▼** ```shell >>> Factory.deploy_gauge("0x36DfE783603522566C046Ba1Fa403C8c6F569220") 'returns address of the deployed gauge' ``` --- # Stableswap-NG Factory: Overview Source: [https://docs.curve.finance/developer/amm/factory/stableswap-ng/overview](https://docs.curve.finance/developer/amm/factory/stableswap-ng/overview) The `CurveStableswapFactoryNG.vy` allows the permissionless deployment of up to eight-coin plain- and metapools, as well as gauges. \*\*Liquidity pool and LP token share the same contract.\*\*For more details, see here: [Stableswap-NG Documentation](https://docs.curve.finance/developer/amm/stableswap-ng/overview.md). GitHub The source code of the `CurveStableSwapFactoryNG.vy` can be found on [GitHub](https://github.com/curvefi/stableswap-ng/blob/main/contracts/main/CurveStableSwapFactoryNG.vy) . A list of all deployments can be found [here](https://docs.curve.finance/developer/deployments.md). * * * <a id="asset-types"></a> ## Asset Types Stableswap-NG pools supports various tokens with different [asset types](https://docs.curve.finance/developer/amm/stableswap-ng/overview.md#supported-assets). New asset types can be added by the `admin` of the contract via the `add_asset_type` method. For a list of all supported assets, please see [below](https://docs.curve.finance/developer/amm/factory/stableswap-ng/overview.md#assets-types). <a id="asset_types"></a> ### `asset_types` `CurveStableswapFactoryNG.asset_types(arg0: uint8) -> String[20]` Getter for name of the different asset types. | Input | Type | Description | | --- | --- | --- | | `arg0` | `uint8` | Index value of the asset type | Returns: asset type (`String[20]`) **<>Source code▼** ```vyper asset_types: public(HashMap[uint8, String[20]]) ``` **▶Example▼** ```shell >>> CurveStableswapFactoryNG.asset_types(0) 'Standard' >>> CurveStableswapFactoryNG.asset_types(1) 'Oracle' ``` <a id="add_asset_type"></a> ### `add_asset_type` `CurveStableSwapFactoryNG.add_asset_type(_id: uint8, _name: String[10])` Guarded Method This function is only callable by the `admin` of the contract. Function to add a new asset type. | Input | Type | Description | | --- | --- | --- | | `_id` | `uint8` | Asset type ID | | `_name` | `String[10]` | Name of the new asset type | **<>Source code▼** ```vyper asset_types: public(HashMap[uint8, String[20]]) @external def add_asset_type(_id: uint8, _name: String[10]): """ @notice Admin only method that adds a new asset type. @param _id asset type id. @param _name Name of the asset type. """ assert msg.sender == self.admin # dev: admin only self.asset_types[_id] = _name ``` * * * <a id="base-pools"></a> ## Base Pools Stableswap pools also allow the deployment of metapools (an asset paired against a base pool). When deploying a new Factory, the existing base pools must be manually added to the contract for them to be used for metapools. *Limitations when adding new base pools:* - Rebasing tokens are not allowed in a base pool. - Can not add a base pool that contains native tokens (e.g., ETH). - As much as possible: Use standard `ERC20` tokens. <a id="add_base_pool"></a> ### `add_base_pool` `CurveStableSwapFactoryNG.add_base_pool(_base_pool: address, _base_lp_token: address, _asset_types: DynArray[uint8, MAX_COINS], _n_coins: uint256):` Guarded Method This function is only callable by the `admin` of the contract. Function to add a new base pool. | Input | Type | Description | | --- | --- | --- | | `_base_pool` | `address` | Pool address to add as a base pool | | `_base_lp_token` | `address` | LP token address of the pool | | `_asset_types` | `DynArray[uint8, MAX_COINS]` | Array of asset types of the pool | | `_n_coins` | `uint256` | Number of coins in the base pool | Emits: `BasePoolAdded` **<>Source code▼** ```vyper event BasePoolAdded: base_pool: address @external def add_base_pool( _base_pool: address, _base_lp_token: address, _asset_types: DynArray[uint8, MAX_COINS], _n_coins: uint256, ): """ @notice Add a base pool to the registry, which may be used in factory metapools @dev 1. Only callable by admin 1. Rebasing tokens are not allowed in the base pool. 2. Do not add base pool which contains native tokens (e.g. ETH). 3. As much as possible: use standard ERC20 tokens. Should you choose to deviate from these recommendations, audits are advised. @param _base_pool Pool address to add @param _asset_types Asset type for pool, as an integer """ assert msg.sender == self.admin # dev: admin-only function assert 2 not in _asset_types # dev: rebasing tokens cannot be in base pool assert len(self.base_pool_data[_base_pool].coins) == 0 # dev: pool exists assert _n_coins < MAX_COINS # dev: base pool can only have (MAX_COINS - 1) coins. # add pool to pool_list length: uint256 = self.base_pool_count self.base_pool_list[length] = _base_pool self.base_pool_count = length + 1 self.base_pool_data[_base_pool].lp_token = _base_lp_token self.base_pool_data[_base_pool].n_coins = _n_coins self.base_pool_data[_base_pool].asset_types = _asset_types decimals: uint256 = 0 coins: DynArray[address, MAX_COINS] = empty(DynArray[address, MAX_COINS]) coin: address = empty(address) for i in range(MAX_COINS): if i == _n_coins: break coin = CurvePool(_base_pool).coins(i) assert coin != 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE # dev: native token is not supported self.base_pool_data[_base_pool].coins.append(coin) self.base_pool_assets[coin] = True decimals += (ERC20(coin).decimals() << i*8) self.base_pool_data[_base_pool].decimals = decimals log BasePoolAdded(_base_pool) ``` <a id="base_pool_list"></a> ### `base_pool_list` `CurveStableSwapFactoryNG.base_pool_list(arg0: uint256) -> address: view` Getter for the base pool at index `arg0`. | Input | Type | Description | | --- | --- | --- | | `arg0` | `uint256` | Index of the base pool | **<>Source code▼** ```vyper base_pool_list: public(address[4294967296]) # list of base pools ``` **▶Example▼** ```shell >>> CurveStableSwapFactoryNG.base_pool_list(0) '0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7' ``` * * * <a id="implementations"></a> ## Implementations The Stableswap-NG Factory makes use of **blueprint contracts**to deploy its contracts from the implementations. warning \*\*Implementation contracts are upgradable.\*\*They can either be replaced, or additional implementation contracts can be added. Therefore, please always make sure to check the most recent ones. *It utilizes five different implementations:* - **`pool_implementations`**, containing multiple blueprint contracts that are used to deploy plain pools. - **`metapool_implementations`**, containing multiple blueprint contracts that are used to deploy metapools. - **`math_implementation`**, containing math functions used in the AMM. - **`gauge_implementation`**, containing a blueprint contract that is used when deploying gauges for pools.[1](https://docs.curve.finance/developer/amm/factory/stableswap-ng/overview.md#user-content-fn-1) - **`views_implementation`**, containing a view methods contract relevant for integrators and users looking to interact with the AMMs. *More on the [**Math Implementation**](https://docs.curve.finance/developer/amm/stableswap-ng/utility-contracts/math.md) and [**Views Implementation**](https://docs.curve.finance/developer/amm/stableswap-ng/utility-contracts/views.md).* <a id="query-implementations"></a> ## Query Implementations <a id="pool_implementations"></a> ### `pool_implementations` `CurveStableSwapFactoryNG.pool_implementations(arg0: uint256) -> address: view` Getter for the pool implementations. There might be multiple pool implementations base on various circumstances. | Input | Type | Description | | --- | --- | --- | | `arg0` | `uint256` | index value of the implementation | Returns: implementation (`address`). **<>Source code▼** ```vyper # index -> implementation address pool_implementations: public(HashMap[uint256, address]) ``` **▶Example▼** ```shell >>> CurveStableSwapFactoryNG.pool_implementation(0) '0x3E3B5F27bbf5CC967E074b70E9f4046e31663181' ``` <a id="metapool_implementations"></a> ### `metapool_implementations` `CurveStableSwapFactoryNG.metapool_implementations(arg0: uint256) -> address: view` Getter for the pool implementations at index `arg0`. This variable can hold multiple implementations which may be tailored for specific setups. | Input | Type | Description | | --- | --- | --- | | `arg0` | `uint256` | Index of the pool implementation | Returns: pool implementation (`address`). **<>Source code▼** ```vyper # index -> implementation address metapool_implementations: public(HashMap[uint256, address]) ``` **▶Example▼** ```shell >>> CurveStableSwapFactoryNG.metapool_implementation(0) '0x19bd1AB34d6ABB584b9C1D5519093bfAA7f6c7d2' ``` <a id="math_implementations"></a> ### `math_implementations` `CurveStableSwapFactoryNG.math_implementations() -> address: view` Getter for the math implementation. Returns: math implementation (`address`). **<>Source code▼** ```vyper # index -> implementation address math_implementation: public(address) ``` **▶Example▼** ```shell >>> CurveStableSwapFactoryNG.math_implementation() '0x20D1c021525C85D9617Ccc64D8f547d5f730118A' ``` <a id="gauge_implementations"></a> ### `gauge_implementations` `CurveStableSwapFactoryNG.gauge_implementations() -> address: view` Getter for the gauge implementation. Returns: gauge implementation (`address`). **<>Source code▼** ```vyper # index -> implementation address gauge_implementation: public(address) ``` **▶Example▼** ```shell >>> CurveStableSwapFactoryNG.gauge_implementation() '0xF5617D4f7514bE35fce829a1C19AE7f6c9106979' ``` <a id="views_implementation"></a> ### `views_implementation` `CurveStableSwapFactoryNG.views_implementations() -> address: view` Getter for the views implementation. Returns: views implementation (`address`). **<>Source code▼** ```vyper # index -> implementation address views_implementation: public(address) ``` **▶Example▼** ```shell >>> CurveStableSwapFactoryNG.views_implementation() '0x87DD13Dd25a1DBde0E1EdcF5B8Fa6cfff7eABCaD' ``` <a id="setting-new-implementations"></a> ## Setting New Implementations New implementation can be by the `admin` of the contract using the following functions: <a id="set_pool_implementations"></a> ### `set_pool_implementations`
프로젝트로 돌아가기