Skip to content

Overview

The crvUSD Factory enables the creation of new markets and adjustments, including setting a new fee receiver, modifying the debt ceiling of an existing market, or updating blueprint implementations.

Other than the pool factory, this factory does not allow permissionless deployment of new markets. Only its admin, the CurveOwnershipAgent, can call to add a market. Therefore, adding a new market requires a successfully passed DAO vote.

Contract Source & Deployment

crvUSD Market Factory contract is deployed to the Ethereum mainnet at: 0xC9332fdCB1C491Dcc683bAe86Fe3cb70360738BC.
Source code available on Github.

Debt Ceilings

debt_ceiling

ControllerFactory.debt_ceiling(agr0: address) -> uint256: view

Getter for the current debt ceiling of a market.

Returns: debt ceiling (uint256).

Input Type Description
arg0 address Address of the controller
Source code 
debt_ceiling: public(HashMap[address, uint256])

>>> ControllerFactory.debt_ceiling("0x8472A9A7632b173c8Cf3a86D3afec50c35548e76")
10000000000000000000000000

debt_ceiling_residual

ControllerFactory.debt_ceiling_residual(arg0: address) -> uint256: view

Getter for the residual debt ceiling for a market.

Returns: debt ceiling residual (uint256).

Input Type Description
arg0 address Address of the controller
Source code 
debt_ceiling: public(HashMap[address, uint256])

>>> ControllerFactory.debt_ceiling("0x8472A9A7632b173c8Cf3a86D3afec50c35548e76")
10000000000000000000000000

rug_debt_ceiling

ControllerFactory.rug_debt_ceiling(_to: address):

Function to remove stablecoins above the debt seiling from a controller and burn them. This function is used to burn residual crvUSD when the debt ceiling was lowered.

Input Type Description
_to address Address of the controller to remove stablecoins from
Source code 
@external
@nonreentrant('lock')
def rug_debt_ceiling(_to: address):
    """
    @notice Remove stablecoins above the debt ceiling from the address and burn them
    @param _to Address to remove stablecoins from
    """
    self._set_debt_ceiling(_to, self.debt_ceiling[_to], False)

@internal
def _set_debt_ceiling(addr: address, debt_ceiling: uint256, update: bool):
    """
    @notice Set debt ceiling for a market
    @param addr Controller address
    @param debt_ceiling Value for stablecoin debt ceiling
    @param update Whether to actually update the debt ceiling (False is used for burning the residuals)
    """
    old_debt_residual: uint256 = self.debt_ceiling_residual[addr]

    if debt_ceiling > old_debt_residual:
        to_mint: uint256 = debt_ceiling - old_debt_residual
        STABLECOIN.mint(addr, to_mint)
        self.debt_ceiling_residual[addr] = debt_ceiling
        log MintForMarket(addr, to_mint)

    if debt_ceiling < old_debt_residual:
        diff: uint256 = min(old_debt_residual - debt_ceiling, STABLECOIN.balanceOf(addr))
        STABLECOIN.burnFrom(addr, diff)
        self.debt_ceiling_residual[addr] = old_debt_residual - diff
        log RemoveFromMarket(addr, diff)

    if update:
        self.debt_ceiling[addr] = debt_ceiling
        log SetDebtCeiling(addr, debt_ceiling)

>>> ControllerFactory.rug_debt_ceiling("controller address")

Fee Receiver

The fee receiver is the address that receives the claimed fees when calling collect_fees() on the Controller. A new receiver can be set by the admin of the contract, which is the CurveOwnershipAgent.

fee_receiver

ControllerFactory.fee_receiver() -> address: view

Getter for the fee receiver address.

Returns: address of fee receiver.

Source code 
fee_receiver: public(address)

@external
def __init__(stablecoin: ERC20,
            admin: address,
            fee_receiver: address,
            weth: address):
    """
    @notice Factory which creates both controllers and AMMs from blueprints
    @param stablecoin Stablecoin address
    @param admin Admin of the factory (ideally DAO)
    @param fee_receiver Receiver of interest and admin fees
    @param weth Address of WETH contract address
    """
    STABLECOIN = stablecoin
    self.admin = admin
    self.fee_receiver = fee_receiver
    WETH = weth

>>> ControllerFactory.fee_receiver()
'0xeCb456EA5365865EbAb8a2661B0c503410e9B347'

Implementations

Implementations are blueprint contracts used to deploy new markets. When calling add_market, Controller and AMM are created from the current implementations.

controller_implementation

ControllerFactory.controller_implementation() -> address: view

Getter for controller implementation address.

Returns: implementation (address).

Source code 
collaterals: public(address[MAX_CONTROLLERS])

>>> ControllerFactory.controller_implementation()
'0x6340678b2bab22a37d781Cd8da958a3cD1d97cdD'

amm_implementation

ControllerFactory.amm_implementation() -> address: view

Getter for amm implementation address.

Returns: implementation (address).

Source code 
amm_implementation: public(address)

>>> ControllerFactory.amm_implementation()
'0x3da7fF6C15C0c97D9C2dF4AF82a9910384b372FD'

Contract Info Methods

stablecoin

ControllerFactory.stablecoin() -> address: view

Getter for the stablecoin address.

Returns: stablecoin (address).

Source code 
STABLECOIN: immutable(ERC20)

@external
def __init__(stablecoin: ERC20,
            admin: address,
            fee_receiver: address,
            weth: address):
    """
    @notice Factory which creates both controllers and AMMs from blueprints
    @param stablecoin Stablecoin address
    @param admin Admin of the factory (ideally DAO)
    @param fee_receiver Receiver of interest and admin fees
    @param weth Address of WETH contract address
    """
    STABLECOIN = stablecoin
    self.admin = admin
    self.fee_receiver = fee_receiver
    WETH = weth

>>> ControllerFactory.stablecoin()
'0xf939E0A03FB07F59A73314E73794Be0E57ac1b4E'

total_debt

ControllerFactory.total_debt() -> uint256: view

Getter for the sum of all debts across the controllers.

Returns: total amount of debt (uint256).

Source code 
@external
@view
def total_debt() -> uint256:
    """
    @notice Sum of all debts across controllers
    """
    total: uint256 = 0
    n_collaterals: uint256 = self.n_collaterals
    for i in range(MAX_CONTROLLERS):
        if i == n_collaterals:
            break
        total += Controller(self.controllers[i]).total_debt()
    return total

>>> ControllerFactory.total_debt()
37565735180665889485176526

get_controller

ControllerFactory.get_controller(collateral: address, i: uint256 = 0) -> address:

Getter for the controller address for collateral.

Returns: controller address.

Input Type Description
collateral address Address of collateral token
i uint256 Index to iterate over several controller for the same collateral if needed
Source code 
@external
@view
def get_controller(collateral: address, i: uint256 = 0) -> address:
    """
    @notice Get controller address for collateral
    @param collateral Address of collateral token
    @param i Iterate over several controllers for collateral if needed
    """
    return self.controllers[self.collaterals_index[collateral][i] - 2**128]

>>> ControllerFactory.get_controller("0xac3E018457B222d93114458476f3E3416Abbe38F", 0)
'0x8472A9A7632b173c8Cf3a86D3afec50c35548e76'

get_amm

ControllerFactory.get_amm(collateral: address, i: uint256 = 0) -> address:

Getter for the amm address for collateral.

Returns: amm address.

Input Type Description
collateral address Address of collateral token
i uint256 Index to iterate over several amms for the same collateral if needed
Source code 
@external
@view
def get_amm(collateral: address, i: uint256 = 0) -> address:
    """
    @notice Get AMM address for collateral
    @param collateral Address of collateral token
    @param i Iterate over several AMMs for collateral if needed
    """
    return self.amms[self.collaterals_index[collateral][i] - 2**128]

>>> ControllerFactory.get_amm("0xac3E018457B222d93114458476f3E3416Abbe38F", 0)
'0x136e783846ef68C8Bd00a3369F787dF8d683a696'

controllers

ControllerFactory.controllers(arg0: uint256) -> address:

Getter for the controller address at index arg0.

Returns: controller address at specific index.

Input Type Description
arg0 uint256 Index
Source code 
MAX_CONTROLLERS: constant(uint256) = 50000
controllers: public(address[MAX_CONTROLLERS])

>>> ControllerFactory.controllers(0)
'0x8472A9A7632b173c8Cf3a86D3afec50c35548e76'

amms

ControllerFactory.amms(arg0: uint256) -> address:

Getter for the amm address at index arg0.

Returns: AMM address at specific index.

Input Type Description
arg0 uint256 Index
Source code 
amms: public(address[MAX_CONTROLLERS])

>>> ControllerFactory.amms(0)
'0x136e783846ef68C8Bd00a3369F787dF8d683a696'

n_collaterals

ControllerFactory.n_collaterals() -> uint256: view

Getter for the number of collaterals.

Returns: number of collaterals (uint256).

Source code 
n_collaterals: public(uint256)

>>> ControllerFactory.n_collaterals()
2

collaterals

ControllerFactory.collaterals(arg0: uint256) -> address: view

Getter for the collateral addresses at index arg0.

Returns: address of collateral.

Input Type Description
arg0 uint256 Index
Source code 
collaterals: public(address[MAX_CONTROLLERS])

>>> ControllerFactory.collaterals(0)
'0xac3E018457B222d93114458476f3E3416Abbe38F'

collaterals_index

ControllerFactory.collaterals(arg0: address, arg1: uint256) -> uint256: view

Getter for the index of a controller for arg0.

Returns: index (uint256).

Note

The returned value is \(2^{128}\) + index.

Input Type Description
arg0 address Address of collateral
arg0 uint256 Index
Source code 
collaterals_index: public(HashMap[address, uint256[1000]])

>>> ControllerFactory.collaterals(0xac3E018457B222d93114458476f3E3416Abbe38F, 0)
340282366920938463463374607431768211456

WETH

ControllerFactory.WETH() -> address: view

Getter for WETH address.

Returns: address of WETH.

Source code 
WETH: public(immutable(address))

@external
def __init__(stablecoin: ERC20,
            admin: address,
            fee_receiver: address,
            weth: address):
    """
    @notice Factory which creates both controllers and AMMs from blueprints
    @param stablecoin Stablecoin address
    @param admin Admin of the factory (ideally DAO)
    @param fee_receiver Receiver of interest and admin fees
    @param weth Address of WETH contract address
    """
    STABLECOIN = stablecoin
    self.admin = admin
    self.fee_receiver = fee_receiver
    WETH = weth

>>> ControllerFactory.WETH()
'0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2'