implementations

The Stableswap Factory utilizes the create_forwarder_to function 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 three different implementations:

• metapool_implementations, containing multiple contracts that are used to deploy metapools.
• plain_implementations, containing multiple contracts that are used to deploy plain pools.
• gauge_implementation, containing a contract which is used when deploying liquidity gauges for pools.

Query Implementations

metapool_implementations

Factory.metapool_implementations(_base_pool: address) -> address[10]:

Getter for a list of implementation contracts for metapools targetting _base_pool.

Returns: metapool implementation contracts (address[10]).

Input	Type	Description
_base_pool	address	Base pool

<>Source code▼

base_pool_data: HashMap[address, BasePoolArray]

@view
@external
def metapool_implementations(_base_pool: address) -> address[10]:
    """
    @notice Get a list of implementation contracts for metapools targetting the given base pool
    @dev A base pool is the pool for the LP token contained within the metapool
    @param _base_pool Address of the base pool
    @return List of implementation contract addresses
    """
    return self.base_pool_data[_base_pool].implementations

▶Example▼

>>> Factory.metapool_implementation('0xbebc44782c7db0a1a60cb6fe97d0b483032ff1c7')
'[[0x213be373FDff327658139C7df330817DAD2d5bBE]
[0x55Aa9BF126bCABF0bDC17Fa9E39Ec9239e1ce7A9]
[0x0000000000000000000000000000000000000000]
[0x0000000000000000000000000000000000000000]
[0x0000000000000000000000000000000000000000]
[0x0000000000000000000000000000000000000000]
[0x0000000000000000000000000000000000000000]
[0x0000000000000000000000000000000000000000]
[0x0000000000000000000000000000000000000000]
[0x0000000000000000000000000000000000000000]]'

plain_implementations

Factory.plain_implementations(arg0: uint256, arg1: uint256) -> address: view

Getter for the plain implementations index arg1 for a plain pool with a number of arg0 coins.

Returns: Plain implementation (address).

Input	Type	Description
arg0	uint256	Number of coins in pool
arg1	uint256	Index of implementation

<>Source code▼

# number of coins -> implementation addresses


# for "plain pools" (as opposed to metapools), implementation contracts
# are organized according to the number of coins in the pool
plain_implementations: public(HashMap[uint256, address[10]])

▶Example▼

>>> Factory.plain_implementations(2, 0)
'0x6523Ac15EC152Cb70a334230F6c5d62C5Bd963f1'

gauge_implementation

Factory.gauge_implementations() -> address: view

Getter for the gauge implementation of the Factory.

Returns: gauge implementation (address).

<>Source code▼

gauge_implementation: public(address)

▶Example▼

>>> Factory.gauge_implementation()
'0x5aE854b098727a9f1603A1E21c50D52DC834D846'

get_implementation_address

Factory.get_implementation_address(_pool: address) -> address:

Getter for the address of the implementation contract used for a factory pool.

Returns: Implementation (address).

Input	Type	Description
_pool	address	Factory pool address

<>Source code▼

@view
@external
def get_implementation_address(_pool: address) -> address:
    """
    @notice Get the address of the implementation contract used for a factory pool
    @param _pool Pool address
    @return Implementation contract address
    """
    return self.pool_data[_pool].implementation

▶Example▼

>>> Factory.gauge_implementation()
'0x5aE854b098727a9f1603A1E21c50D52DC834D846'

Set New ImplementationNew implementations can be set via these admin-only functions:

set_metapool_implementation

Factory.set_metapool_implementations(_base_pool: address, _implementations: address[10]):

Guarded Method

This function is only callable by the admin of the contract.

Function to set new metapool implementations.

Input	Type	Description
_base_pool	address	Base pool to add implementations for
_implementations	address[10]	New metapool implementations

<>Source code▼

base_pool_data: HashMap[address, BasePoolArray]

@external
def set_metapool_implementations(
    _base_pool: address,
    _implementations: address[10],
):
    """
    @notice Set implementation contracts for a metapool
    @dev Only callable by admin
    @param _base_pool Pool address to add
    @param _implementations Implementation address to use when deploying metapools
    """
    assert msg.sender == self.admin  # dev: admin-only function
    assert self.base_pool_data[_base_pool].coins[0] != ZERO_ADDRESS  # dev: base pool does not exist

    for i in range(10):
        new_imp: address = _implementations[i]
        current_imp: address = self.base_pool_data[_base_pool].implementations[i]
        if new_imp == current_imp:
            if new_imp == ZERO_ADDRESS:
                break
        else:
            self.base_pool_data[_base_pool].implementations[i] = new_imp

▶Example▼

>>> Factory.set_metapool_implementation("todo")
'todo'

set_plain_implementation

Factory.set_plain_implementations(_n_coins: uint256, _implementations: address[10]):

Guarded Method

This function is only callable by the admin of the contract.

Function to set new plain pool implementations.

Input	Type	Description
_n_coins	uint256	Number of coins in pool to set implementations for
_pool_implementation	address	New plain pool implementations

<>Source code▼

# number of coins -> implementation addresses
# for "plain pools" (as opposed to metapools), implementation contracts
# are organized according to the number of coins in the pool
plain_implementations: public(HashMap[uint256, address[10]])

@external
def set_plain_implementations(
    _n_coins: uint256,
    _implementations: address[10],
):
    assert msg.sender == self.admin  # dev: admin-only function

    for i in range(10):
        new_imp: address = _implementations[i]
        current_imp: address = self.plain_implementations[_n_coins][i]
        if new_imp == current_imp:
            if new_imp == ZERO_ADDRESS:
                break
        else:
            self.plain_implementations[_n_coins][i] = new_imp

▶Example▼

>>> Factory.set_plain_implementation("todo")
'todo'

set_gauge_implementation

Factory.set_gauge_implementation(_gauge_implementation: address):

Guarded Method

This function is only callable by the admin of the contract.

Function to set a new gauge implementation contract.

Input	Type	Description
_gauge_implementation	address	New gauge implementation

<>Source code▼

gauge_implementation: public(address)

@external
def set_gauge_implementation(_gauge_implementation: address):
    assert msg.sender == self.admin  # dev: admin-only function

    self.gauge_implementation = _gauge_implementation

▶Example▼

>>> Factory.set_gauge_implementation("todo")
'todo'