Registry

Registry is the main registry contract. It is used to locate pools and query information about them.

Source code for this contract is available on Github.

Deployment Address

Use the get_registry method to get the address of the main registry from the address provider:

>>> provider = Contract('0x0000000022D53366457F9d5E68Ec105046FC4383')
>>> provider.get_registry()
'0x90E00ACe148ca3b23Ac1bC8C240C2a7Dd9c2d7f5'

View Functions

Because Vyper does not support dynamic-length arrays, all arrays have a fixed length. Excess fields contain zero values.

Finding Pools

Registry.pool_count() → uint256: view

The number of pools currently registered within the contract.

>>> registry.pool_count()
18

Registry.pool_list(i: uint256) → address: view

Master list of registered pool addresses.

Note that the ordering of this list is not fixed. Index values of addresses may change as pools are added or removed.

Querying values greater than Registry.pool_count returns 0x00.

>>> registry.pool_list(7)
'0x8474DdbE98F5aA3179B3B3F5942D724aFcdec9f6'

Registry.get_pool_from_lp_token(lp_token: address) → address: view

Get the pool address for a given Curve LP token.

>>> registry.get_pool_from_lp_token('0x1AEf73d49Dedc4b1778d0706583995958Dc862e6')
'0x8474DdbE98F5aA3179B3B3F5942D724aFcdec9f6'

Registry.get_lp_token(pool: address) → address: view

Get the LP token address for a given Curve pool.

>>> registry.get_lp_token('0x8474DdbE98F5aA3179B3B3F5942D724aFcdec9f6')
'0x1AEf73d49Dedc4b1778d0706583995958Dc862e6'

Registry.find_pool_for_coins(_from: address, _to: address, i: uint256 = 0) → address: view

Finds a pool that allows for swaps between _from and _to. You can optionally include i to get the n-th pool, when multiple pools exist for the given pairing.

The order of _from and _to does not affect the result.

Returns 0x00 when swaps are not possible for the pair or i exceeds the number of available pools.

>>> registry.find_pool_for_coins('0x6b175474e89094c44da98b954eedeac495271d0f', '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48')
'0xbEbc44782C7dB0a1A60Cb6fe97d0b483032FF1C7'

>>> registry.find_pool_for_coins('0x6b175474e89094c44da98b954eedeac495271d0f', '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48', 1)
'0x79a8C46DeA5aDa233ABaFFD40F3A0A2B1e5A4F27'

Getting Info About a Pool

Coins and Coin Info

Registry.get_n_coins(pool: address) → uint256[2]: view

Get the number of coins and underlying coins within a pool.

>>> registry.get_n_coins('0x8474DdbE98F5aA3179B3B3F5942D724aFcdec9f6')
(2, 4)

Registry.get_coins(pool: address) → address[8]: view

Get a list of the swappable coins within a pool.

>>> registry.get_coins('0x8474DdbE98F5aA3179B3B3F5942D724aFcdec9f6')
("0xe2f2a5C287993345a840Db3B0845fbC70f5935a5", "0x6c3F90f043a72FA612cbac8115EE7e52BDe6E490", "0x0000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000")

Registry.get_underlying_coins(pool: address) → address[8]: view

Get a list of the swappable underlying coins within a pool.

For pools that do not involve lending, the return value is identical to Registry.get_coins.

>>> registry.get_underlying_coins('0x8474DdbE98F5aA3179B3B3F5942D724aFcdec9f6')
("0xe2f2a5C287993345a840Db3B0845fbC70f5935a5", "0x6B175474E89094C44Da98b954EedeAC495271d0F", "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", "0xdAC17F958D2ee523a2206206994597C13D831ec7", "0x0000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000", "0x0000000000000000000000000000000000000000")

Registry.get_decimals(pool: address) → uint256[8]: view

Get a list of decimal places for each coin within a pool.

>>> registry.get_decimals('0x8474DdbE98F5aA3179B3B3F5942D724aFcdec9f6')
(18, 18, 0, 0, 0, 0, 0, 0)

Registry.get_underlying_decimals(pool: address) → uint256[8]: view

Get a list of decimal places for each underlying coin within a pool.

For pools that do not involve lending, the return value is identical to Registry.get_decimals. Non-lending coins that still involve querying a rate (e.g. renBTC) are marked as having 0 decimals.

>>> registry.get_underlying_decimals('0x8474DdbE98F5aA3179B3B3F5942D724aFcdec9f6')
(18, 18, 6, 6, 0, 0, 0, 0)

Registry.get_coin_indices(pool: address, _from: address, _to: address) → (int128, int128, bool): view

Convert coin addresses into indices for use with pool methods.

Returns the index of _from, index of _to, and a boolean indicating if the coins are considered underlying in the given pool.

>>> registry.get_coin_indices('0x79a8C46DeA5aDa233ABaFFD40F3A0A2B1e5A4F27', '0xdac17f958d2ee523a2206206994597c13d831ec7', '0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48')
(2, 1, True)

Based on the above call, we know:

the index of the coin we are swapping out of is 2

the index of the coin we are swapping into is 1

the coins are considred underlying, so we must call exchange_underlying

From this information we can perform a token swap:

>>> swap = Contract('0x79a8C46DeA5aDa233ABaFFD40F3A0A2B1e5A4F27')
>>> swap.exchange_underlying(2, 1, 1e18, 0, {'from': alice})

Balances and Rates

Registry.get_balances(pool: address) → uint256[8]: view

Get available balances for each coin within a pool.

These values are not necessarily the same as calling Token.balanceOf(pool) as the total balance also includes unclaimed admin fees.

>>> registry.get_balances('0x79a8C46DeA5aDa233ABaFFD40F3A0A2B1e5A4F27')
(11428161394428689823275227, 47831326741306, 45418708932136, 48777578907442492245548483, 0, 0, 0, 0)

Registry.get_underlying_balances(pool: address) → uint256[8]: view

Get balances for each underlying coin within a pool.

For pools that do not involve lending, the return value is identical to Registry.get_balances.

>>> registry.get_underlying_balances('0x79a8C46DeA5aDa233ABaFFD40F3A0A2B1e5A4F27')
(11876658145799734093379928, 48715210997790596223520238, 46553896776332824101242804, 49543896565857325657915396, 0, 0, 0, 0)

Registry.get_admin_balances(pool: address) → uint256[8]: view

Get the current admin balances (uncollected fees) for a pool.

>>> registry.get_admin_balances('0x79a8C46DeA5aDa233ABaFFD40F3A0A2B1e5A4F27')
(10800690926373756722358, 30891687335, 22800662409, 16642955874751891466129, 0, 0, 0, 0)

Registry.get_rates(pool: address) → uint256[8]: view

Get the exchange rates between coins and underlying coins within a pool, normalized to a 1e18 precision.

For non-lending pools or non-lending coins within a lending pool, the rate is 1e18.

>>> registry.get_rates('0x79a8C46DeA5aDa233ABaFFD40F3A0A2B1e5A4F27')
(1039244956550111510, 1018479293504725874, 1024993895758183341, 1015710454247817308, 0, 0, 0, 0)

Registry.get_virtual_price_from_lp_token(lp_token: address) → uint256: view

Get the virtual price of a pool LP token.

>>> registry.get_virtual_price_from_lp_token('0x3B3Ac5386837Dc563660FB6a0937DFAa5924333B')
1060673685385893596

Pool Parameters

Registry.get_A(pool: address) → uint256: view

Get the current amplification coefficient for a pool.

>>> registry.get_A('0x79a8C46DeA5aDa233ABaFFD40F3A0A2B1e5A4F27')
500

Registry.get_fees(pool: address) → uint256[2]: view

Get the fees for a pool.

Fees are expressed as integers with a 1e10 precision. The first value is the total fee, the second is the percentage of the fee taken as an admin fee.

A typical return value here is (4000000, 5000000000) - a 0.04% fee, 50% of which is taken as an admin fee.

>>> registry.get_fees('0x79a8C46DeA5aDa233ABaFFD40F3A0A2B1e5A4F27')
(4000000, 5000000000)

Registry.get_parameters(pool: address) → PoolParams: view

Get all parameters for a given pool.

The return value is a struct, organized as follows:

struct PoolParams:
    A: uint256
    future_A: uint256
    fee: uint256
    admin_fee: uint256
    future_fee: uint256
    future_admin_fee: uint256
    future_owner: address
    initial_A: uint256
    initial_A_time: uint256
    future_A_time: uint256

Note that for older pools where initial_A is not public, this value is set to 0.

>>> registry.get_parameters('0x79a8C46DeA5aDa233ABaFFD40F3A0A2B1e5A4F27').dict()
{
    'A': 500,
    'admin_fee': 5000000000,
    'fee': 4000000,
    'future_A': 500,
    'future_A_time': 0,
    'future_admin_fee': 5000000000,
    'future_fee': 4000000,
    'future_owner': "0x56295b752e632f74a6526988eaCE33C25c52c623",
    'initial_A': 0,
    'initial_A_time': 0
}

Gas Estimates

Registry.estimate_gas_used(pool: address, _from: address, _to: address) → uint256: view: Get an estimate on the upper bound for gas used in an exchange.

Pool Metadata

Registry.is_meta(pool: address) → bool: view

Get a boolean identifying whether pool is a metapool.

>>> registry.is_meta('0x4f062658EaAF2C1ccf8C8e36D6824CDf41167956')
True

Registry.get_pool_name(pool: address) → String[64]: view

Get the name given to a pool upon registration.

>>> registry.get_pool_name('0x4f062658EaAF2C1ccf8C8e36D6824CDf41167956')
'gusd'

Registry.get_pool_asset_type(pool: address) → uint256: view

Get the asset type of specific pool as an integer.

Note

The asset type of a pool is subject to modification, and is primarily of use to off-chain integrators.

>>> registry.get_pool_asset_type('0x4f062658EaAF2C1ccf8C8e36D6824CDf41167956')
0

Asset types are as follows:

0: USD

1: BTC

2: ETH

3: Other StableSwap

4: CryptoSwap

Gauges

Registry.gauge_controller() → address: view

Get the address of the Curve DAO GaugeController contract.

>>> registry.gauge_controller()
'0x2F50D538606Fa9EDD2B11E2446BEb18C9D5846bB'

Registry.get_gauges(pool: address) → (address[10], int128[10]): view

Get a list of LiquidityGauge contracts associated with a pool, and their gauge types.

>>> registry.get_gauges('0x79a8C46DeA5aDa233ABaFFD40F3A0A2B1e5A4F27')
(('0x8474DdbE98F5aA3179B3B3F5942D724aFcdec9f6', '0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000', '0x0000000000000000000000000000000000000000'), (0, 0, 0, 0, 0, 0, 0, 0, 0, 0))

Getting Coins and Coin Swap Complements

Registry.coin_count() → uint256: view

Get the total number of unique coins throughout all registered curve pools.

>>> registry.coin_count()
42

Registry.get_coin(i: uint256) → address: view

Get the ith unique coin throughout all registered curve pools.

Returns 0x0000000000000000000000000000000000000000 for values of i greater than the return value of Registry.coin_count.

>>> registry.get_coin(0)
'0x6B175474E89094C44Da98b954EedeAC495271d0F'

Registry.get_coin_swap_count(coin: address) → uint256: view

Get the total number of unique swaps available for coin.

>>> registry.get_coin_swap_count('0x6B175474E89094C44Da98b954EedeAC495271d0F')
12

Registry.get_coin_swap_complement(coin: address, i: uint256) → address: view

Get the ith unique coin available for swapping against coin across all registered curve pools.

>>> registry.get_coin_swap_complement('0x6B175474E89094C44Da98b954EedeAC495271d0F', 0)
'0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48'

Registry Metadata

Registry.last_updated() → uint256:: view

Get the epoch time of the last registry update.

Only successful state modifying functions (add_pool, add_metapool, set_pool_gas_estimates, etc.) will update this return value.

>>> registry.last_updated()
1617850905