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`
프로젝트로 돌아가기