Share Dialog

Share Dialog

<100 subscribers

<100 subscribers

How Frax beats the Rest

How Frax beats the Rest

1. Minting using the said collateral is not paused.

require(mintPaused[col_idx] == false, "Minting is paused");

1. Current FRAX price is above the mint price threshold. The initial threshold is set to be $1.01. Given how the protocol wants to stabilize FRAX at around $1, it does not make sense to allow inflate token supply when the price is above $1.

require(getFRAXPrice() >= mint_price_threshold, "Frax price too low");

FRAX’s price in USD is retrieved from Chainlink. Most Chainlink price feeds return a number in 8 decimals. The function then trims it to 6 decimal places by multiplying it by PRICE_PRECISION (1e6) and then dividing it by 10 ** 8 (It is common to see decimals conversion in Solidity due to the absence of native decimals type. Also, always multiply first before division to avoid a loss in precision!).

function getFRAXPrice() public view returns (uint256) {
    (uint80 roundID, int price, , uint256 updatedAt, uint80 answeredInRound) = priceFeedFRAXUSD.latestRoundData();
    require(price >= 0 && updatedAt!= 0 && answeredInRound >= roundID, "Invalid chainlink price");

    return uint256(price).mul(PRICE_PRECISION).div(10 ** chainlink_frax_usd_decimals);
}

The amount of collateral (USDC) required to back 1 FRAX depends on FRAX’s global collateral ratio. Before going straight to the collateral calculation, let’s take a detour and inspect how this global collateral ratio is adjusted.

The variable global_collateral_ratio lives in the Frax contract. It has the initial value of 1e7, meaning that each FRAX is fully backed by 1 USDC. This ratio can be adjusted every refresh_cooldown seconds (currently 1 hour) by calling the function refreshCollateralRatio. This function retrieves the price of FRAX in USD (this time not getting FRAX/USD price directly, but calculating FRAX/USD through FRAX/ETH and ETH/USD). The collateral ratio can only be adjusted if FRAX is trading outside of the price_band, which is currently set to 5000 (< $0.995 and > $1.005). If FRAX is trading within the price band, there is no reason for the protocol to destabilize the protocol by making adjustments.

It is perceived as acceptable to decrease the collateral ratio when FRAX is trading above the price band because the price reflects the confidence in the currency and vice versa. In order to not create price volatility by drastically changing the collateral ratio, the collateral ratio can only go up/down by frax_step(0.25%) in each refresh period. The code also makes sure the collateral ratio is between 0% and 100%.

uint256 public last_call_time; // Last time the refreshCollateralRatio function was called
function refreshCollateralRatio() public {
    require(collateral_ratio_paused == false, "Collateral Ratio has been paused");
    uint256 frax_price_cur = frax_price();
    require(block.timestamp - last_call_time >= refresh_cooldown, "Must wait for the refresh cooldown since last refresh");

    // Step increments are 0.25% (upon genesis, changable by setFraxStep()) 
    
    if (frax_price_cur > price_target.add(price_band)) { //decrease collateral ratio
        if(global_collateral_ratio <= frax_step){ //if within a step of 0, go to 0
            global_collateral_ratio = 0;
        } else {
            global_collateral_ratio = global_collateral_ratio.sub(frax_step);
        }
    } else if (frax_price_cur < price_target.sub(price_band)) { //increase collateral ratio
        if(global_collateral_ratio.add(frax_step) >= 1000000){
            global_collateral_ratio = 1000000; // cap collateral ratio at 1.000000
        } else {
            global_collateral_ratio = global_collateral_ratio.add(frax_step);
        }
    }

    last_call_time = block.timestamp; // Set the time of the last expansion

    emit CollateralRatioRefreshed(global_collateral_ratio);
}

Now going back to collateral calculation.

The collateral ratio, between 0-100%, determines the amount of USDC backing required to mint one FRAX. The remaining value is backed by the FXS token. For example, if the collateral ratio was 90%, 90c of USDC would be required to mint one FRAX and the remainder would be covered by 10c of FXS tokens. It also uses a Chainlink oracle to get FXS price.

if (one_to_one_override || global_collateral_ratio >= PRICE_PRECISION) { 
    // 1-to-1, overcollateralized, or user selects override
    collat_needed = getFRAXInCollateral(col_idx, frax_amt);
    fxs_needed = 0;
} else if (global_collateral_ratio == 0) { 
    // Algorithmic
    collat_needed = 0;
    fxs_needed = frax_amt.mul(PRICE_PRECISION).div(getFXSPrice());
} else { 
    // Fractional
    uint256 frax_for_collat = frax_amt.mul(global_collateral_ratio).div(PRICE_PRECISION);
    uint256 frax_for_fxs = frax_amt.sub(frax_for_collat);
    collat_needed = getFRAXInCollateral(col_idx, frax_for_collat);
    fxs_needed = frax_for_fxs.mul(PRICE_PRECISION).div(getFXSPrice());
}

Interestingly, the function getFRAXInCollateral relies on a manually set collateral price to calculate collateral required (most likely because it is only USDC as of now). collateral_prices[col_idx] is set by privileged accounts via the function setCollateralPrice. This could potentially be an issue down the road and an oracle should eventually replace this manual setting.

function getFRAXInCollateral(uint256 col_idx, uint256 frax_amount) public view returns (uint256) {
    return frax_amount.mul(PRICE_PRECISION).div(10 ** missing_decimals[col_idx]).div(collateral_prices[col_idx]);
}

Finally, the function mints FRAX to the user. It charges a small minting fee. The FXS backing the FRAX minted is burned. One last thing to note is that each collateral type has a ceiling and only privileged accounts have the ability to lift it.

total_frax_mint = (frax_amt.mul(PRICE_PRECISION.sub(minting_fee[col_idx]))).div(PRICE_PRECISION);

require(freeCollatBalance(col_idx).add(collat_needed) <= pool_ceilings[col_idx], "Pool ceiling");

FXS.pool_burn_from(msg.sender, fxs_needed);

TransferHelper.safeTransferFrom(collateral_addresses[col_idx], msg.sender, address(this), collat_needed);

FRAX.pool_mint(msg.sender, total_frax_mint);

Anyone can deposit FRAX to redeem USDC/FXS by calling FraxPoolV3#redeemFrax. The mechanism (including the condition checks) is similar to minting FRAX in which the final outputted USDC/FXS amounts are also dependent on the global collateral ratio.

// Prevent unnecessary redemptions that could adversely affect the FXS price
require(getFRAXPrice() <= redeem_price_threshold, "Frax price too high");

// There is a redemption fee, like the minting fee.
uint256 frax_after_fee = (frax_amount.mul(PRICE_PRECISION.sub(redemption_fee[col_idx]))).div(PRICE_PRECISION);

// Assumes $1 FRAX in all cases
if(global_collateral_ratio >= PRICE_PRECISION) { 
    // 1-to-1 or overcollateralized
    collat_out = getFRAXInCollateral(col_idx, frax_after_fee);
    fxs_out = 0;
} else if (global_collateral_ratio == 0) { 
    // Algorithmic
    fxs_out = frax_after_fee
                    .mul(PRICE_PRECISION)
                    .div(getFXSPrice());
    collat_out = 0;
} else { 
    // Fractional
    collat_out = getFRAXInCollateral(col_idx, frax_after_fee)
                    .mul(global_collateral_ratio)
                    .div(PRICE_PRECISION);
    fxs_out = frax_after_fee
                    .mul(PRICE_PRECISION.sub(global_collateral_ratio))
                    .div(getFXSPrice()); // PRICE_PRECISIONS CANCEL OUT
}

The pool needs to have sufficient collateral to be withdrawn.

require(collat_out <= (ERC20(collateral_addresses[col_idx])).balanceOf(address(this)).sub(unclaimedPoolCollateral[col_idx]), "Insufficient pool collateral");

The redeem mechanism is not a straightforward “deposit FRAX and get USDC/FXS immediately” because Frax Finance wants to prevent flash loan attacks (take out FRAX/collateral from the system, use an AMM to trade the new price, and then mint back into the system). There is a 2 blocks delay between the redemption and when the redeemer can actually collect the collaterals.

// Update the protocol's debt to the redeemer in USDC and FXS
redeemCollateralBalances[msg.sender][col_idx] = redeemCollateralBalances[msg.sender][col_idx].add(collat_out);
unclaimedPoolCollateral[col_idx] = unclaimedPoolCollateral[col_idx].add(collat_out);

redeemFXSBalances[msg.sender] = redeemFXSBalances[msg.sender].add(fxs_out);
unclaimedPoolFXS = unclaimedPoolFXS.add(fxs_out);

// The redemption delay starts from the mined block
lastRedeemed[msg.sender] = block.number;

Finally, FRAX is burned and FXS is minted to the pool (address(this) and not msg.sender! remember the block delay!)

FRAX.pool_burn_from(msg.sender, frax_amount);
FXS.pool_mint(address(this), fxs_out);

After 2 blocks have elapsed, redeemers who are owed collaterals can collect them by calling FraxPoolV3#collectRedemption.

// 2 blocks must have elapsed
require((lastRedeemed[msg.sender].add(redemption_delay)) <= block.number, "Too soon");

The function checks that there are really tokens to be collected and does not make safeTransfer calls if there aren’t any to be sent (probably gas optimization).

bool sendFXS = false;
bool sendCollateral = false;

// Use Checks-Effects-Interactions pattern
if(redeemFXSBalances[msg.sender] > 0){
    fxs_amount = redeemFXSBalances[msg.sender];
    redeemFXSBalances[msg.sender] = 0;
    unclaimedPoolFXS = unclaimedPoolFXS.sub(fxs_amount);
    sendFXS = true;
}

if(redeemCollateralBalances[msg.sender][col_idx] > 0){
    collateral_amount = redeemCollateralBalances[msg.sender][col_idx];
    redeemCollateralBalances[msg.sender][col_idx] = 0;
    unclaimedPoolCollateral[col_idx] = unclaimedPoolCollateral[col_idx].sub(collateral_amount);
    sendCollateral = true;
}

// Send out the tokens
if(sendFXS){
    TransferHelper.safeTransfer(address(FXS), msg.sender, fxs_amount);
}
if(sendCollateral){
    TransferHelper.safeTransfer(collateral_addresses[col_idx], msg.sender, collateral_amount);
}

When the protocol is holding more collateral than is required, FXS holders can call FraxPoolV3#buybackFxs to pump everyone’s bags.

The protocol needs to first calculate the excess collateral value in the system. The theoretical amount of excess collateral available for buybacks is simply the difference between the current collateral value in the protocol and the collateral value required by the current collateral ratio. But realistically it is not a good idea to take out all the excess collaterals due to volatility, especially as Frax plans to introduce non-stable collateral types in the future. By getting to right at the collateral line, Frax can immediately become undercollateralized. For this reason, Frax implements an hourly limit on how much collateral can leave the protocol (bbkMaxColE18OutPerHour - buyback max collateal 1e18 out per hour).

The function comboCalcBbkRct calculates the actual available FXS amount for buybacks given the utilized hourly limit, max hourly limit, and the theoretical hourly limit.

function buybackAvailableCollat() public view returns (uint256) {
    uint256 total_supply = FRAX.totalSupply();
    uint256 global_collateral_ratio = FRAX.global_collateral_ratio();
    uint256 global_collat_value = FRAX.globalCollateralValue();

    if (global_collateral_ratio > PRICE_PRECISION) global_collateral_ratio = PRICE_PRECISION; // Handles an overcollateralized contract with CR > 1
    uint256 required_collat_dollar_value_d18 = (total_supply.mul(global_collateral_ratio)).div(PRICE_PRECISION); // Calculates collateral needed to back each 1 FRAX with $1 of collateral at current collat ratio
    
    if (global_collat_value > required_collat_dollar_value_d18) {
        // Get the theoretical buyback amount
        uint256 theoretical_bbk_amt = global_collat_value.sub(required_collat_dollar_value_d18);

        // See how much has collateral has been issued this hour
        uint256 current_hr_bbk = bbkHourlyCum[curEpochHr()];

        // Account for the throttling
        return comboCalcBbkRct(current_hr_bbk, bbkMaxColE18OutPerHour, theoretical_bbk_amt);
    }
    else return 0;
}

It then makes sure the dollar value of the FXS to burn is not greater than the excess collateral value so that the collateral ratio is not breached.

uint256 fxs_dollar_value_d18 = fxs_amount.mul(fxs_price).div(PRICE_PRECISION);
require(fxs_dollar_value_d18 <= available_excess_collat_dv, "Insuf Collat Avail For BBK");

The collateral value to be removed is calculated based on the FXS’s dollar value. A buyback fee is charged by the protocol. missing_decimals is an array to account for the difference in decimals between FRAX (18) and its collaterals (USDC - 6). It is set during contract construction.

// In the constructor...
missing_decimals.push(uint256(18).sub(ERC20(_collateral_addresses[i]).decimals()));

// Get the equivalent amount of collateral based on the market value of FXS provided 
uint256 collateral_equivalent_d18 = fxs_dollar_value_d18.mul(PRICE_PRECISION).div(collateral_prices[col_idx]);
col_out = collateral_equivalent_d18.div(10 ** missing_decimals[col_idx]); // In its natural decimals()

// Subtract the buyback fee
col_out = (col_out.mul(PRICE_PRECISION.sub(buyback_fee[col_idx]))).div(PRICE_PRECISION);

FXS is burned, collateral transferred to the burner and the hourly buyback counter value is updated.

// Take in and burn the FXS, then send out the collateral
FXS.pool_burn_from(msg.sender, fxs_amount);
TransferHelper.safeTransfer(collateral_addresses[col_idx], msg.sender, col_out);

// Increment the outbound collateral, in E18, for that hour
// Used for buyback throttling
bbkHourlyCum[curEpochHr()] += collateral_equivalent_d18;

When FRAX’s collateral backed value is below the collateral ratio, the vault needs to be topped up for the protocol to stay healthy. In order to incentivize people to help re-collateralize, the protocol gives a bonus in FXS, defined by the bonus_rate.

Similar to buybacks, there is an hourly limit on the available amount for re-collateralization so the actual value will be smaller than the theoretical available value.

function recollatAvailableFxs() public view returns (uint256) {
    uint256 fxs_price = getFXSPrice();

    // Get the amount of collateral theoretically available
    uint256 recollat_theo_available_e18 = recollatTheoColAvailableE18();

    // Get the amount of FXS theoretically outputtable
    uint256 fxs_theo_out = recollat_theo_available_e18.mul(PRICE_PRECISION).div(fxs_price);

    // See how much FXS has been issued this hour
    uint256 current_hr_rct = rctHourlyCum[curEpochHr()];

    // Account for the throttling
    return comboCalcBbkRct(current_hr_rct, rctMaxFxsOutPerHour, fxs_theo_out);
}

The theoretical available amount is the difference between the minimum collateral value (collateral ratio x FRAX total supply) and the effective collateral value (actual collateral ratio based on collateral value x FRAX total supply).

function recollatTheoColAvailableE18() public view returns (uint256) {
    uint256 frax_total_supply = FRAX.totalSupply();
    uint256 effective_collateral_ratio = FRAX.globalCollateralValue().mul(PRICE_PRECISION).div(frax_total_supply); // Returns it in 1e6
    
    uint256 desired_collat_e24 = (FRAX.global_collateral_ratio()).mul(frax_total_supply);
    uint256 effective_collat_e24 = effective_collateral_ratio.mul(frax_total_supply);

    // Return 0 if already overcollateralized
    // Otherwise, return the deficiency
    if (effective_collat_e24 >= desired_collat_e24) return 0;
    else {
        return (desired_collat_e24.sub(effective_collat_e24)).div(PRICE_PRECISION);
    }
}

The protocol gives a bonus, but at the same time also charges a re-collateralization fee. The final FXS amount leaving the protocol has to be ≤ the available FXS for re-collateralization.

fxs_out = collateral_amount_d18.mul(PRICE_PRECISION.add(bonus_rate).sub(recollat_fee[col_idx])).div(fxs_price);

// Make sure there is FXS available
require(fxs_out <= fxs_actually_available, "Insuf FXS Avail For RCT");

It also makes sure the pool ceiling is not breached after the collateral deposit.

require(freeCollatBalance(col_idx).add(collateral_amount) <= pool_ceilings[col_idx], "Pool ceiling");

Finally it takes the collateral, sends the msg.sender FXS and updates the hourly re-collateralization counter.

// Take in the collateral and pay out the FXS
TransferHelper.safeTransferFrom(collateral_addresses[col_idx], msg.sender, address(this), collateral_amount);
FXS.pool_mint(msg.sender, fxs_out);

// Increment the outbound FXS, in E18
// Used for recollat throttling
rctHourlyCum[curEpochHr()] += fxs_out;

Algorithmic Market Operations Controller, or AMO minters, can borrow collaterals to deploy excess collateral to Algorithmic Market Operations (AMOs).

function amoMinterBorrow(uint256 collateral_amount) external onlyAMOMinters {
        // Checks the col_idx of the minter as an additional safety check
        uint256 minter_col_idx = IFraxAMOMinter(msg.sender).col_idx();

        // Checks to see if borrowing is paused
        require(borrowingPaused[minter_col_idx] == false, "Borrowing is paused");

        // Ensure collateral is enabled
        require(enabled_collaterals[collateral_addresses[minter_col_idx]], "Collateral disabled");

        // Transfer
        TransferHelper.safeTransfer(collateral_addresses[minter_col_idx], msg.sender, collateral_amount);
    }

An AMO minter is a privileged role that can only be added by the contract owner or governance through the function addAMOMinter. An AMO minter must have the function collatDollarBalance defined.

uint256 collat_val_e18 = IFraxAMOMinter(amo_minter_addr).collatDollarBalance();
require(collat_val_e18 >= 0, "Invalid AMO");

The contract FraxAMOMinter is the implementation of AMO minter. It holds an array of destination AMOs under its control and it runs its internal accounting to keep track on how much has been borrowed. When a destination AMO wants to borrow, it can call giveCollatToAMO. The function checks that the collateral borrow cap is not reached, adds the borrow amount to the destination AMO’s balance, asks the pool to provide the collateral, transfers the collateral to the destination AMO and sync all AMOs’ total FRAX and collateral balances through syncDollarBalances.

function giveCollatToAMO(
    address destination_amo,
    uint256 collat_amount
) external onlyByOwnGov validAMO(destination_amo) {
    int256 collat_amount_i256 = int256(collat_amount);

    require((collat_borrowed_sum + collat_amount_i256) <= collat_borrow_cap, "Borrow cap");
    collat_borrowed_balances[destination_amo] += collat_amount_i256;
    collat_borrowed_sum += collat_amount_i256;

    // Borrow the collateral
    pool.amoMinterBorrow(collat_amount);

    // Give the collateral to the AMO
    TransferHelper.safeTransfer(collateral_address, destination_amo, collat_amount);

    // Sync
    syncDollarBalances();
}

syncDollarBalances loops through every AMO to get its FRAX and collateral balances. Each AMO must have a function called dollarBalances that returns a tuple of FRAX and collateral balances. The mapping correction_offsets_amos is used to fix incorrect balance accounting and can be set by contract owner or governance through setAMOCorrectionOffsets.

function syncDollarBalances() public {
    uint256 total_frax_value_d18 = 0;
    uint256 total_collateral_value_d18 = 0; 
    for (uint i = 0; i < amos_array.length; i++){ 
        // Exclude null addresses
        address amo_address = amos_array[i];
        if (amo_address != address(0)){
            (uint256 frax_val_e18, uint256 collat_val_e18) = IAMO(amo_address).dollarBalances();
            total_frax_value_d18 += uint256(int256(frax_val_e18) + correction_offsets_amos[amo_address][0]);
            total_collateral_value_d18 += uint256(int256(collat_val_e18) + correction_offsets_amos[amo_address][1]);
        }
    }
    fraxDollarBalanceStored = total_frax_value_d18;
    collatDollarBalanceStored = total_collateral_value_d18;
}

There are many different AMOs being developed in Frax Finance, but let’s look at one of them to see how it actually works. The contract InvestorAMO_V3 deposits USDC into Yearn, Aave and Compound to earn interest as well as to farm their tokens. To execute an excess collateral deployment, the contract owner or the time-locked governance has to execute the transaction through execute, which is just a generic proxy to pass arbitrary bytes to the _to address (it should be the AMO minter).

function execute(
    address _to,
    uint256 _value,
    bytes calldata _data
) external onlyByOwnGov returns (bool, bytes memory) {
    (bool success, bytes memory result) = _to.call{value:_value}(_data);
    return (success, result);
}

Once the AMO acquires USDC in its contract, privileged accounts can deploy USDC to the protocols.

function yDepositUSDC(uint256 USDC_amount) public onlyByOwnGovCust {
    require(allow_yearn, 'yearn strategy is currently off');
    collateral_token.approve(address(yUSDC_V2), USDC_amount);
    yUSDC_V2.deposit(USDC_amount);
}

function aaveDepositUSDC(uint256 USDC_amount) public onlyByOwnGovCust {
    require(allow_aave, 'AAVE strategy is currently off');
    collateral_token.approve(address(aaveUSDC_Pool), USDC_amount);
    aaveUSDC_Pool.deposit(collateral_address, USDC_amount, address(this), 0);
}

function compoundMint_cUSDC(uint256 USDC_amount) public onlyByOwnGovCust {
    require(allow_compound, 'Compound strategy is currently off');
    collateral_token.approve(address(cUSDC), USDC_amount);
    cUSDC.mint(USDC_amount);
}

The AMO’s dollar balances is the sum of its unallocated USDC plus the USDC deployed to the 3 protocols. This is the required function by AMO minter’s syncDollarBalances mentioned earlier.

function dollarBalances() public view returns (uint256 frax_val_e18, uint256 collat_val_e18) {
    frax_val_e18 = (showAllocations()[4]).mul(10 ** missing_decimals);
    collat_val_e18 = frax_val_e18;
}

function showAllocations() public view returns (uint256[5] memory allocations) {
    // All numbers given are assuming xyzUSDC, etc. is converted back to actual USDC
    allocations[0] = collateral_token.balanceOf(address(this)); // Unallocated
    allocations[1] = (yUSDC_V2.balanceOf(address(this))).mul(yUSDC_V2.pricePerShare()).div(1e6); // yearn
    allocations[2] = aaveUSDC_Token.balanceOf(address(this)); // AAVE
    allocations[3] = (cUSDC.balanceOf(address(this)).mul(cUSDC.exchangeRateStored()).div(1e18)); // Compound. Note that cUSDC is E8

    uint256 sum_tally = 0;
    for (uint i = 0; i < 4; i++){ 
        if (allocations[i] > 0){
            sum_tally = sum_tally.add(allocations[i]);
        }
    }

    allocations[4] = sum_tally; // Total USDC Value
}

Meanwhile, not only is the AMO earning yield on USDC. It is also earning COMP and AAVE! You can call showRewards to see how much the AMO has made and collect its rewards by calling various claim reward functions.

// 1. show rewards
// 2. claim rewards
// 3. transfer rewards out of the contract
function showRewards() external view returns (uint256[3] memory rewards) {
    // IMPORTANT
    // Should ONLY be used externally, because it may fail if COMP.balanceOf() fails
    rewards[0] = COMP.balanceOf(address(this)); // COMP
    rewards[1] = stkAAVE.balanceOf(address(this)); // stkAAVE
    rewards[2] = AAVE.balanceOf(address(this)); // AAVE
}

function compoundCollectCOMP() public onlyByOwnGovCust {
    address[] memory cTokens = new addressUnsupported embed;
    cTokens[0] = address(cUSDC);
    CompController.claimComp(address(this), cTokens);
}

function aaveCollect_stkAAVE() public onlyByOwnGovCust {
    address[] memory the_assets = new addressUnsupported embed;
    the_assets[0] = address(aaveUSDC_Token);
    uint256 rewards_balance = AAVEIncentivesController.getRewardsBalance(the_assets, address(this));
    AAVEIncentivesController.claimRewards(the_assets, rewards_balance, address(this));
}

function withdrawRewards() public onlyByOwnGovCust {
    COMP.transfer(msg.sender, COMP.balanceOf(address(this)));
    stkAAVE.transfer(msg.sender, stkAAVE.balanceOf(address(this)));
    AAVE.transfer(msg.sender, AAVE.balanceOf(address(this)));
}

When the yield rate is no longer satisfying, privileged accounts can pull the money out and return the collateral back to the protocol. receiveCollatFromAMO takes the USDC from the AMO, reduces the AMO’s borrowed balance and syncs all pools’ FRAX and collateral balances.

// 1. withdraw USDC from protocols
// 2. send collateral back through the AMO minter
function yWithdrawUSDC(uint256 yUSDC_amount) public onlyByOwnGovCust {
    yUSDC_V2.withdraw(yUSDC_amount);
}

function aaveWithdrawUSDC(uint256 aUSDC_amount) public onlyByOwnGovCust {
    aaveUSDC_Pool.withdraw(collateral_address, aUSDC_amount, address(this));
}

function compoundRedeem_cUSDC(uint256 cUSDC_amount) public onlyByOwnGovCust {
    // NOTE that cUSDC is E8, NOT E6
    cUSDC.redeem(cUSDC_amount);
}

function giveCollatBack(uint256 collat_amount) external onlyByOwnGovCust {
    collateral_token.approve(address(amo_minter), collat_amount);
    amo_minter.receiveCollatFromAMO(collat_amount);
}

// in FraxAMOMinter...
function receiveCollatFromAMO(uint256 usdc_amount) external validAMO(msg.sender) {
    int256 collat_amt_i256 = int256(usdc_amount);

    // Give back first
    TransferHelper.safeTransferFrom(collateral_address, msg.sender, address(pool), usdc_amount);

    // Then update the balances
    collat_borrowed_balances[msg.sender] -= collat_amt_i256;
    collat_borrowed_sum -= collat_amt_i256;

    // Sync
    syncDollarBalances();
}

This function sets the FRAX protocol apart from other algorithmic stablecoins. For example, Frax’s Curve AMO module allows FRAX to directly mint FRAX into Curve’s meta pool in addition to USDC to tighten the peg while knowing exactly how much collateral it has access to if FRAX were to break its peg.

Curve’s AMO can call the AMO minter’s function mintFraxForAMO and then its own function metapoolDeposit to inject liquidity to Curve. The AMO minter is free to mint as long as the destination AMO’s mint cap and the new global collateral ratio are not breached.

function mintFraxForAMO(address destination_amo, uint256 frax_amount) external onlyByOwnGov validAMO(destination_amo) {
    int256 frax_amt_i256 = int256(frax_amount);

    // Make sure you aren't minting more than the mint cap
    require((frax_mint_sum + frax_amt_i256) <= frax_mint_cap, "Mint cap reached");
    frax_mint_balances[destination_amo] += frax_amt_i256;
    frax_mint_sum += frax_amt_i256;

    // Make sure the FRAX minting wouldn't push the CR down too much
    // This is also a sanity check for the int256 math
    uint256 current_collateral_E18 = FRAX.globalCollateralValue();
    uint256 cur_frax_supply = FRAX.totalSupply();
    uint256 new_frax_supply = cur_frax_supply + frax_amount;
    uint256 new_cr = (current_collateral_E18 * PRICE_PRECISION) / new_frax_supply;
    require(new_cr >= min_cr, "CR would be too low");

    // Mint the FRAX to the AMO
    FRAX.pool_mint(destination_amo, frax_amount);

    // Sync
    syncDollarBalances();
}

// 1. Deposit USDC to 3pool
// 2. Deposit 3CRV and FRAX to meta pool
function metapoolDeposit(uint256 _frax_amount, uint256 _collateral_amount) external onlyByOwnGov returns (uint256 metapool_LP_received) {
    uint256 threeCRV_received = 0;
    if (_collateral_amount > 0) {
        // Approve the collateral to be added to 3pool
        collateral_token.approve(address(three_pool), _collateral_amount);

        // Convert collateral into 3pool
        uint256[3] memory three_pool_collaterals;
        three_pool_collaterals[1] = _collateral_amount;
        {
            uint256 min_3pool_out = (_collateral_amount * (10 ** missing_decimals)).mul(liq_slippage_3crv).div(PRICE_PRECISION);
            three_pool.add_liquidity(three_pool_collaterals, min_3pool_out);
        }

        // Approve the 3pool for the metapool
        threeCRV_received = three_pool_erc20.balanceOf(address(this));

        // WEIRD ISSUE: NEED TO DO three_pool_erc20.approve(address(three_pool), 0); first before every time
        // May be related to https://github.com/vyperlang/vyper/blob/3e1ff1eb327e9017c5758e24db4bdf66bbfae371/examples/tokens/ERC20.vy#L85
        three_pool_erc20.approve(frax3crv_metapool_address, 0);
        three_pool_erc20.approve(frax3crv_metapool_address, threeCRV_received);
    }
    
    // Approve the FRAX for the metapool
    FRAX.approve(frax3crv_metapool_address, _frax_amount);

    {
        // Add the FRAX and the collateral to the metapool
        uint256 min_lp_out = (_frax_amount.add(threeCRV_received)).mul(slippage_metapool).div(PRICE_PRECISION);
        metapool_LP_received = frax3crv_metapool.add_liquidity([_frax_amount, threeCRV_received], min_lp_out);
    }

    return metapool_LP_received;
}

Later when governance decides it is time to remove liquidity (FRAX or USDC or both), it can call the functions metapoolWithdrawFrax/metapoolWithdraw3pool/metapoolWithdrawAtCurRatio

to withdraw FRAX from the metapool and USDC from the 3pool. Optionally it can choose to burn the FRAX withdrawn in the same transaction (burnFrax can also be called on its own). The AMO minter burns the FRAX taken from the AMO and decreases the AMO’s FRAX mint balances.

function burnFraxFromAMO(uint256 frax_amount) external validAMO(msg.sender) {
    int256 frax_amt_i256 = int256(frax_amount);

    // Burn first
    FRAX.pool_burn_from(msg.sender, frax_amount);

    // Then update the balances
    frax_mint_balances[msg.sender] -= frax_amt_i256;
    frax_mint_sum -= frax_amt_i256;

    // Sync
    syncDollarBalances();
}

Frax is not the only algorithmic stable in the market. It will not be the only one either.

Ultimately, stablecoins are products that fulfill a specific Job-To-be-done (JTBD). Are you a speculator looking to lever up? Overcollateralization is right for you. Go over there for $DAI and $MIM. Are you a DAO managing $10 million+ of treasuries? Go over there for $FEI and $FRAX. Are you an institutional investor looking for low-risk crypto exposure? Go over there for $UST and $UXD. To each, their own.

Each stablecoin has noticeably different risk profiles and use cases. Even so, we are optimistic that $FRAX will remain a benchmark for future DeFi protocols because it has got the 3 Killer Apps: Curve-like property, peg mechanism and AMOs.

1. Minting using the said collateral is not paused.

require(mintPaused[col_idx] == false, "Minting is paused");

1. Current FRAX price is above the mint price threshold. The initial threshold is set to be $1.01. Given how the protocol wants to stabilize FRAX at around $1, it does not make sense to allow inflate token supply when the price is above $1.

require(getFRAXPrice() >= mint_price_threshold, "Frax price too low");

FRAX’s price in USD is retrieved from Chainlink. Most Chainlink price feeds return a number in 8 decimals. The function then trims it to 6 decimal places by multiplying it by PRICE_PRECISION (1e6) and then dividing it by 10 ** 8 (It is common to see decimals conversion in Solidity due to the absence of native decimals type. Also, always multiply first before division to avoid a loss in precision!).

function getFRAXPrice() public view returns (uint256) {
    (uint80 roundID, int price, , uint256 updatedAt, uint80 answeredInRound) = priceFeedFRAXUSD.latestRoundData();
    require(price >= 0 && updatedAt!= 0 && answeredInRound >= roundID, "Invalid chainlink price");

    return uint256(price).mul(PRICE_PRECISION).div(10 ** chainlink_frax_usd_decimals);
}

The amount of collateral (USDC) required to back 1 FRAX depends on FRAX’s global collateral ratio. Before going straight to the collateral calculation, let’s take a detour and inspect how this global collateral ratio is adjusted.

The variable global_collateral_ratio lives in the Frax contract. It has the initial value of 1e7, meaning that each FRAX is fully backed by 1 USDC. This ratio can be adjusted every refresh_cooldown seconds (currently 1 hour) by calling the function refreshCollateralRatio. This function retrieves the price of FRAX in USD (this time not getting FRAX/USD price directly, but calculating FRAX/USD through FRAX/ETH and ETH/USD). The collateral ratio can only be adjusted if FRAX is trading outside of the price_band, which is currently set to 5000 (< $0.995 and > $1.005). If FRAX is trading within the price band, there is no reason for the protocol to destabilize the protocol by making adjustments.

It is perceived as acceptable to decrease the collateral ratio when FRAX is trading above the price band because the price reflects the confidence in the currency and vice versa. In order to not create price volatility by drastically changing the collateral ratio, the collateral ratio can only go up/down by frax_step(0.25%) in each refresh period. The code also makes sure the collateral ratio is between 0% and 100%.

uint256 public last_call_time; // Last time the refreshCollateralRatio function was called
function refreshCollateralRatio() public {
    require(collateral_ratio_paused == false, "Collateral Ratio has been paused");
    uint256 frax_price_cur = frax_price();
    require(block.timestamp - last_call_time >= refresh_cooldown, "Must wait for the refresh cooldown since last refresh");

    // Step increments are 0.25% (upon genesis, changable by setFraxStep()) 
    
    if (frax_price_cur > price_target.add(price_band)) { //decrease collateral ratio
        if(global_collateral_ratio <= frax_step){ //if within a step of 0, go to 0
            global_collateral_ratio = 0;
        } else {
            global_collateral_ratio = global_collateral_ratio.sub(frax_step);
        }
    } else if (frax_price_cur < price_target.sub(price_band)) { //increase collateral ratio
        if(global_collateral_ratio.add(frax_step) >= 1000000){
            global_collateral_ratio = 1000000; // cap collateral ratio at 1.000000
        } else {
            global_collateral_ratio = global_collateral_ratio.add(frax_step);
        }
    }

    last_call_time = block.timestamp; // Set the time of the last expansion

    emit CollateralRatioRefreshed(global_collateral_ratio);
}

Now going back to collateral calculation.

The collateral ratio, between 0-100%, determines the amount of USDC backing required to mint one FRAX. The remaining value is backed by the FXS token. For example, if the collateral ratio was 90%, 90c of USDC would be required to mint one FRAX and the remainder would be covered by 10c of FXS tokens. It also uses a Chainlink oracle to get FXS price.

if (one_to_one_override || global_collateral_ratio >= PRICE_PRECISION) { 
    // 1-to-1, overcollateralized, or user selects override
    collat_needed = getFRAXInCollateral(col_idx, frax_amt);
    fxs_needed = 0;
} else if (global_collateral_ratio == 0) { 
    // Algorithmic
    collat_needed = 0;
    fxs_needed = frax_amt.mul(PRICE_PRECISION).div(getFXSPrice());
} else { 
    // Fractional
    uint256 frax_for_collat = frax_amt.mul(global_collateral_ratio).div(PRICE_PRECISION);
    uint256 frax_for_fxs = frax_amt.sub(frax_for_collat);
    collat_needed = getFRAXInCollateral(col_idx, frax_for_collat);
    fxs_needed = frax_for_fxs.mul(PRICE_PRECISION).div(getFXSPrice());
}

Interestingly, the function getFRAXInCollateral relies on a manually set collateral price to calculate collateral required (most likely because it is only USDC as of now). collateral_prices[col_idx] is set by privileged accounts via the function setCollateralPrice. This could potentially be an issue down the road and an oracle should eventually replace this manual setting.

function getFRAXInCollateral(uint256 col_idx, uint256 frax_amount) public view returns (uint256) {
    return frax_amount.mul(PRICE_PRECISION).div(10 ** missing_decimals[col_idx]).div(collateral_prices[col_idx]);
}

Finally, the function mints FRAX to the user. It charges a small minting fee. The FXS backing the FRAX minted is burned. One last thing to note is that each collateral type has a ceiling and only privileged accounts have the ability to lift it.

total_frax_mint = (frax_amt.mul(PRICE_PRECISION.sub(minting_fee[col_idx]))).div(PRICE_PRECISION);

require(freeCollatBalance(col_idx).add(collat_needed) <= pool_ceilings[col_idx], "Pool ceiling");

FXS.pool_burn_from(msg.sender, fxs_needed);

TransferHelper.safeTransferFrom(collateral_addresses[col_idx], msg.sender, address(this), collat_needed);

FRAX.pool_mint(msg.sender, total_frax_mint);

Anyone can deposit FRAX to redeem USDC/FXS by calling FraxPoolV3#redeemFrax. The mechanism (including the condition checks) is similar to minting FRAX in which the final outputted USDC/FXS amounts are also dependent on the global collateral ratio.

// Prevent unnecessary redemptions that could adversely affect the FXS price
require(getFRAXPrice() <= redeem_price_threshold, "Frax price too high");

// There is a redemption fee, like the minting fee.
uint256 frax_after_fee = (frax_amount.mul(PRICE_PRECISION.sub(redemption_fee[col_idx]))).div(PRICE_PRECISION);

// Assumes $1 FRAX in all cases
if(global_collateral_ratio >= PRICE_PRECISION) { 
    // 1-to-1 or overcollateralized
    collat_out = getFRAXInCollateral(col_idx, frax_after_fee);
    fxs_out = 0;
} else if (global_collateral_ratio == 0) { 
    // Algorithmic
    fxs_out = frax_after_fee
                    .mul(PRICE_PRECISION)
                    .div(getFXSPrice());
    collat_out = 0;
} else { 
    // Fractional
    collat_out = getFRAXInCollateral(col_idx, frax_after_fee)
                    .mul(global_collateral_ratio)
                    .div(PRICE_PRECISION);
    fxs_out = frax_after_fee
                    .mul(PRICE_PRECISION.sub(global_collateral_ratio))
                    .div(getFXSPrice()); // PRICE_PRECISIONS CANCEL OUT
}

The pool needs to have sufficient collateral to be withdrawn.

require(collat_out <= (ERC20(collateral_addresses[col_idx])).balanceOf(address(this)).sub(unclaimedPoolCollateral[col_idx]), "Insufficient pool collateral");

The redeem mechanism is not a straightforward “deposit FRAX and get USDC/FXS immediately” because Frax Finance wants to prevent flash loan attacks (take out FRAX/collateral from the system, use an AMM to trade the new price, and then mint back into the system). There is a 2 blocks delay between the redemption and when the redeemer can actually collect the collaterals.

// Update the protocol's debt to the redeemer in USDC and FXS
redeemCollateralBalances[msg.sender][col_idx] = redeemCollateralBalances[msg.sender][col_idx].add(collat_out);
unclaimedPoolCollateral[col_idx] = unclaimedPoolCollateral[col_idx].add(collat_out);

redeemFXSBalances[msg.sender] = redeemFXSBalances[msg.sender].add(fxs_out);
unclaimedPoolFXS = unclaimedPoolFXS.add(fxs_out);

// The redemption delay starts from the mined block
lastRedeemed[msg.sender] = block.number;

Finally, FRAX is burned and FXS is minted to the pool (address(this) and not msg.sender! remember the block delay!)

FRAX.pool_burn_from(msg.sender, frax_amount);
FXS.pool_mint(address(this), fxs_out);

After 2 blocks have elapsed, redeemers who are owed collaterals can collect them by calling FraxPoolV3#collectRedemption.

// 2 blocks must have elapsed
require((lastRedeemed[msg.sender].add(redemption_delay)) <= block.number, "Too soon");

The function checks that there are really tokens to be collected and does not make safeTransfer calls if there aren’t any to be sent (probably gas optimization).

bool sendFXS = false;
bool sendCollateral = false;

// Use Checks-Effects-Interactions pattern
if(redeemFXSBalances[msg.sender] > 0){
    fxs_amount = redeemFXSBalances[msg.sender];
    redeemFXSBalances[msg.sender] = 0;
    unclaimedPoolFXS = unclaimedPoolFXS.sub(fxs_amount);
    sendFXS = true;
}

if(redeemCollateralBalances[msg.sender][col_idx] > 0){
    collateral_amount = redeemCollateralBalances[msg.sender][col_idx];
    redeemCollateralBalances[msg.sender][col_idx] = 0;
    unclaimedPoolCollateral[col_idx] = unclaimedPoolCollateral[col_idx].sub(collateral_amount);
    sendCollateral = true;
}

// Send out the tokens
if(sendFXS){
    TransferHelper.safeTransfer(address(FXS), msg.sender, fxs_amount);
}
if(sendCollateral){
    TransferHelper.safeTransfer(collateral_addresses[col_idx], msg.sender, collateral_amount);
}

When the protocol is holding more collateral than is required, FXS holders can call FraxPoolV3#buybackFxs to pump everyone’s bags.

The protocol needs to first calculate the excess collateral value in the system. The theoretical amount of excess collateral available for buybacks is simply the difference between the current collateral value in the protocol and the collateral value required by the current collateral ratio. But realistically it is not a good idea to take out all the excess collaterals due to volatility, especially as Frax plans to introduce non-stable collateral types in the future. By getting to right at the collateral line, Frax can immediately become undercollateralized. For this reason, Frax implements an hourly limit on how much collateral can leave the protocol (bbkMaxColE18OutPerHour - buyback max collateal 1e18 out per hour).

The function comboCalcBbkRct calculates the actual available FXS amount for buybacks given the utilized hourly limit, max hourly limit, and the theoretical hourly limit.

function buybackAvailableCollat() public view returns (uint256) {
    uint256 total_supply = FRAX.totalSupply();
    uint256 global_collateral_ratio = FRAX.global_collateral_ratio();
    uint256 global_collat_value = FRAX.globalCollateralValue();

    if (global_collateral_ratio > PRICE_PRECISION) global_collateral_ratio = PRICE_PRECISION; // Handles an overcollateralized contract with CR > 1
    uint256 required_collat_dollar_value_d18 = (total_supply.mul(global_collateral_ratio)).div(PRICE_PRECISION); // Calculates collateral needed to back each 1 FRAX with $1 of collateral at current collat ratio
    
    if (global_collat_value > required_collat_dollar_value_d18) {
        // Get the theoretical buyback amount
        uint256 theoretical_bbk_amt = global_collat_value.sub(required_collat_dollar_value_d18);

        // See how much has collateral has been issued this hour
        uint256 current_hr_bbk = bbkHourlyCum[curEpochHr()];

        // Account for the throttling
        return comboCalcBbkRct(current_hr_bbk, bbkMaxColE18OutPerHour, theoretical_bbk_amt);
    }
    else return 0;
}

It then makes sure the dollar value of the FXS to burn is not greater than the excess collateral value so that the collateral ratio is not breached.

uint256 fxs_dollar_value_d18 = fxs_amount.mul(fxs_price).div(PRICE_PRECISION);
require(fxs_dollar_value_d18 <= available_excess_collat_dv, "Insuf Collat Avail For BBK");

The collateral value to be removed is calculated based on the FXS’s dollar value. A buyback fee is charged by the protocol. missing_decimals is an array to account for the difference in decimals between FRAX (18) and its collaterals (USDC - 6). It is set during contract construction.

// In the constructor...
missing_decimals.push(uint256(18).sub(ERC20(_collateral_addresses[i]).decimals()));

// Get the equivalent amount of collateral based on the market value of FXS provided 
uint256 collateral_equivalent_d18 = fxs_dollar_value_d18.mul(PRICE_PRECISION).div(collateral_prices[col_idx]);
col_out = collateral_equivalent_d18.div(10 ** missing_decimals[col_idx]); // In its natural decimals()

// Subtract the buyback fee
col_out = (col_out.mul(PRICE_PRECISION.sub(buyback_fee[col_idx]))).div(PRICE_PRECISION);

FXS is burned, collateral transferred to the burner and the hourly buyback counter value is updated.

// Take in and burn the FXS, then send out the collateral
FXS.pool_burn_from(msg.sender, fxs_amount);
TransferHelper.safeTransfer(collateral_addresses[col_idx], msg.sender, col_out);

// Increment the outbound collateral, in E18, for that hour
// Used for buyback throttling
bbkHourlyCum[curEpochHr()] += collateral_equivalent_d18;

When FRAX’s collateral backed value is below the collateral ratio, the vault needs to be topped up for the protocol to stay healthy. In order to incentivize people to help re-collateralize, the protocol gives a bonus in FXS, defined by the bonus_rate.

Similar to buybacks, there is an hourly limit on the available amount for re-collateralization so the actual value will be smaller than the theoretical available value.

function recollatAvailableFxs() public view returns (uint256) {
    uint256 fxs_price = getFXSPrice();

    // Get the amount of collateral theoretically available
    uint256 recollat_theo_available_e18 = recollatTheoColAvailableE18();

    // Get the amount of FXS theoretically outputtable
    uint256 fxs_theo_out = recollat_theo_available_e18.mul(PRICE_PRECISION).div(fxs_price);

    // See how much FXS has been issued this hour
    uint256 current_hr_rct = rctHourlyCum[curEpochHr()];

    // Account for the throttling
    return comboCalcBbkRct(current_hr_rct, rctMaxFxsOutPerHour, fxs_theo_out);
}

The theoretical available amount is the difference between the minimum collateral value (collateral ratio x FRAX total supply) and the effective collateral value (actual collateral ratio based on collateral value x FRAX total supply).

function recollatTheoColAvailableE18() public view returns (uint256) {
    uint256 frax_total_supply = FRAX.totalSupply();
    uint256 effective_collateral_ratio = FRAX.globalCollateralValue().mul(PRICE_PRECISION).div(frax_total_supply); // Returns it in 1e6
    
    uint256 desired_collat_e24 = (FRAX.global_collateral_ratio()).mul(frax_total_supply);
    uint256 effective_collat_e24 = effective_collateral_ratio.mul(frax_total_supply);

    // Return 0 if already overcollateralized
    // Otherwise, return the deficiency
    if (effective_collat_e24 >= desired_collat_e24) return 0;
    else {
        return (desired_collat_e24.sub(effective_collat_e24)).div(PRICE_PRECISION);
    }
}

The protocol gives a bonus, but at the same time also charges a re-collateralization fee. The final FXS amount leaving the protocol has to be ≤ the available FXS for re-collateralization.

fxs_out = collateral_amount_d18.mul(PRICE_PRECISION.add(bonus_rate).sub(recollat_fee[col_idx])).div(fxs_price);

// Make sure there is FXS available
require(fxs_out <= fxs_actually_available, "Insuf FXS Avail For RCT");

It also makes sure the pool ceiling is not breached after the collateral deposit.

require(freeCollatBalance(col_idx).add(collateral_amount) <= pool_ceilings[col_idx], "Pool ceiling");

Finally it takes the collateral, sends the msg.sender FXS and updates the hourly re-collateralization counter.

// Take in the collateral and pay out the FXS
TransferHelper.safeTransferFrom(collateral_addresses[col_idx], msg.sender, address(this), collateral_amount);
FXS.pool_mint(msg.sender, fxs_out);

// Increment the outbound FXS, in E18
// Used for recollat throttling
rctHourlyCum[curEpochHr()] += fxs_out;

Algorithmic Market Operations Controller, or AMO minters, can borrow collaterals to deploy excess collateral to Algorithmic Market Operations (AMOs).

function amoMinterBorrow(uint256 collateral_amount) external onlyAMOMinters {
        // Checks the col_idx of the minter as an additional safety check
        uint256 minter_col_idx = IFraxAMOMinter(msg.sender).col_idx();

        // Checks to see if borrowing is paused
        require(borrowingPaused[minter_col_idx] == false, "Borrowing is paused");

        // Ensure collateral is enabled
        require(enabled_collaterals[collateral_addresses[minter_col_idx]], "Collateral disabled");

        // Transfer
        TransferHelper.safeTransfer(collateral_addresses[minter_col_idx], msg.sender, collateral_amount);
    }

An AMO minter is a privileged role that can only be added by the contract owner or governance through the function addAMOMinter. An AMO minter must have the function collatDollarBalance defined.

uint256 collat_val_e18 = IFraxAMOMinter(amo_minter_addr).collatDollarBalance();
require(collat_val_e18 >= 0, "Invalid AMO");

The contract FraxAMOMinter is the implementation of AMO minter. It holds an array of destination AMOs under its control and it runs its internal accounting to keep track on how much has been borrowed. When a destination AMO wants to borrow, it can call giveCollatToAMO. The function checks that the collateral borrow cap is not reached, adds the borrow amount to the destination AMO’s balance, asks the pool to provide the collateral, transfers the collateral to the destination AMO and sync all AMOs’ total FRAX and collateral balances through syncDollarBalances.

function giveCollatToAMO(
    address destination_amo,
    uint256 collat_amount
) external onlyByOwnGov validAMO(destination_amo) {
    int256 collat_amount_i256 = int256(collat_amount);

    require((collat_borrowed_sum + collat_amount_i256) <= collat_borrow_cap, "Borrow cap");
    collat_borrowed_balances[destination_amo] += collat_amount_i256;
    collat_borrowed_sum += collat_amount_i256;

    // Borrow the collateral
    pool.amoMinterBorrow(collat_amount);

    // Give the collateral to the AMO
    TransferHelper.safeTransfer(collateral_address, destination_amo, collat_amount);

    // Sync
    syncDollarBalances();
}

syncDollarBalances loops through every AMO to get its FRAX and collateral balances. Each AMO must have a function called dollarBalances that returns a tuple of FRAX and collateral balances. The mapping correction_offsets_amos is used to fix incorrect balance accounting and can be set by contract owner or governance through setAMOCorrectionOffsets.

function syncDollarBalances() public {
    uint256 total_frax_value_d18 = 0;
    uint256 total_collateral_value_d18 = 0; 
    for (uint i = 0; i < amos_array.length; i++){ 
        // Exclude null addresses
        address amo_address = amos_array[i];
        if (amo_address != address(0)){
            (uint256 frax_val_e18, uint256 collat_val_e18) = IAMO(amo_address).dollarBalances();
            total_frax_value_d18 += uint256(int256(frax_val_e18) + correction_offsets_amos[amo_address][0]);
            total_collateral_value_d18 += uint256(int256(collat_val_e18) + correction_offsets_amos[amo_address][1]);
        }
    }
    fraxDollarBalanceStored = total_frax_value_d18;
    collatDollarBalanceStored = total_collateral_value_d18;
}

There are many different AMOs being developed in Frax Finance, but let’s look at one of them to see how it actually works. The contract InvestorAMO_V3 deposits USDC into Yearn, Aave and Compound to earn interest as well as to farm their tokens. To execute an excess collateral deployment, the contract owner or the time-locked governance has to execute the transaction through execute, which is just a generic proxy to pass arbitrary bytes to the _to address (it should be the AMO minter).

function execute(
    address _to,
    uint256 _value,
    bytes calldata _data
) external onlyByOwnGov returns (bool, bytes memory) {
    (bool success, bytes memory result) = _to.call{value:_value}(_data);
    return (success, result);
}

Once the AMO acquires USDC in its contract, privileged accounts can deploy USDC to the protocols.

function yDepositUSDC(uint256 USDC_amount) public onlyByOwnGovCust {
    require(allow_yearn, 'yearn strategy is currently off');
    collateral_token.approve(address(yUSDC_V2), USDC_amount);
    yUSDC_V2.deposit(USDC_amount);
}

function aaveDepositUSDC(uint256 USDC_amount) public onlyByOwnGovCust {
    require(allow_aave, 'AAVE strategy is currently off');
    collateral_token.approve(address(aaveUSDC_Pool), USDC_amount);
    aaveUSDC_Pool.deposit(collateral_address, USDC_amount, address(this), 0);
}

function compoundMint_cUSDC(uint256 USDC_amount) public onlyByOwnGovCust {
    require(allow_compound, 'Compound strategy is currently off');
    collateral_token.approve(address(cUSDC), USDC_amount);
    cUSDC.mint(USDC_amount);
}

The AMO’s dollar balances is the sum of its unallocated USDC plus the USDC deployed to the 3 protocols. This is the required function by AMO minter’s syncDollarBalances mentioned earlier.

function dollarBalances() public view returns (uint256 frax_val_e18, uint256 collat_val_e18) {
    frax_val_e18 = (showAllocations()[4]).mul(10 ** missing_decimals);
    collat_val_e18 = frax_val_e18;
}

function showAllocations() public view returns (uint256[5] memory allocations) {
    // All numbers given are assuming xyzUSDC, etc. is converted back to actual USDC
    allocations[0] = collateral_token.balanceOf(address(this)); // Unallocated
    allocations[1] = (yUSDC_V2.balanceOf(address(this))).mul(yUSDC_V2.pricePerShare()).div(1e6); // yearn
    allocations[2] = aaveUSDC_Token.balanceOf(address(this)); // AAVE
    allocations[3] = (cUSDC.balanceOf(address(this)).mul(cUSDC.exchangeRateStored()).div(1e18)); // Compound. Note that cUSDC is E8

    uint256 sum_tally = 0;
    for (uint i = 0; i < 4; i++){ 
        if (allocations[i] > 0){
            sum_tally = sum_tally.add(allocations[i]);
        }
    }

    allocations[4] = sum_tally; // Total USDC Value
}

Meanwhile, not only is the AMO earning yield on USDC. It is also earning COMP and AAVE! You can call showRewards to see how much the AMO has made and collect its rewards by calling various claim reward functions.

// 1. show rewards
// 2. claim rewards
// 3. transfer rewards out of the contract
function showRewards() external view returns (uint256[3] memory rewards) {
    // IMPORTANT
    // Should ONLY be used externally, because it may fail if COMP.balanceOf() fails
    rewards[0] = COMP.balanceOf(address(this)); // COMP
    rewards[1] = stkAAVE.balanceOf(address(this)); // stkAAVE
    rewards[2] = AAVE.balanceOf(address(this)); // AAVE
}

function compoundCollectCOMP() public onlyByOwnGovCust {
    address[] memory cTokens = new addressUnsupported embed;
    cTokens[0] = address(cUSDC);
    CompController.claimComp(address(this), cTokens);
}

function aaveCollect_stkAAVE() public onlyByOwnGovCust {
    address[] memory the_assets = new addressUnsupported embed;
    the_assets[0] = address(aaveUSDC_Token);
    uint256 rewards_balance = AAVEIncentivesController.getRewardsBalance(the_assets, address(this));
    AAVEIncentivesController.claimRewards(the_assets, rewards_balance, address(this));
}

function withdrawRewards() public onlyByOwnGovCust {
    COMP.transfer(msg.sender, COMP.balanceOf(address(this)));
    stkAAVE.transfer(msg.sender, stkAAVE.balanceOf(address(this)));
    AAVE.transfer(msg.sender, AAVE.balanceOf(address(this)));
}

When the yield rate is no longer satisfying, privileged accounts can pull the money out and return the collateral back to the protocol. receiveCollatFromAMO takes the USDC from the AMO, reduces the AMO’s borrowed balance and syncs all pools’ FRAX and collateral balances.

// 1. withdraw USDC from protocols
// 2. send collateral back through the AMO minter
function yWithdrawUSDC(uint256 yUSDC_amount) public onlyByOwnGovCust {
    yUSDC_V2.withdraw(yUSDC_amount);
}

function aaveWithdrawUSDC(uint256 aUSDC_amount) public onlyByOwnGovCust {
    aaveUSDC_Pool.withdraw(collateral_address, aUSDC_amount, address(this));
}

function compoundRedeem_cUSDC(uint256 cUSDC_amount) public onlyByOwnGovCust {
    // NOTE that cUSDC is E8, NOT E6
    cUSDC.redeem(cUSDC_amount);
}

function giveCollatBack(uint256 collat_amount) external onlyByOwnGovCust {
    collateral_token.approve(address(amo_minter), collat_amount);
    amo_minter.receiveCollatFromAMO(collat_amount);
}

// in FraxAMOMinter...
function receiveCollatFromAMO(uint256 usdc_amount) external validAMO(msg.sender) {
    int256 collat_amt_i256 = int256(usdc_amount);

    // Give back first
    TransferHelper.safeTransferFrom(collateral_address, msg.sender, address(pool), usdc_amount);

    // Then update the balances
    collat_borrowed_balances[msg.sender] -= collat_amt_i256;
    collat_borrowed_sum -= collat_amt_i256;

    // Sync
    syncDollarBalances();
}

This function sets the FRAX protocol apart from other algorithmic stablecoins. For example, Frax’s Curve AMO module allows FRAX to directly mint FRAX into Curve’s meta pool in addition to USDC to tighten the peg while knowing exactly how much collateral it has access to if FRAX were to break its peg.

Curve’s AMO can call the AMO minter’s function mintFraxForAMO and then its own function metapoolDeposit to inject liquidity to Curve. The AMO minter is free to mint as long as the destination AMO’s mint cap and the new global collateral ratio are not breached.

function mintFraxForAMO(address destination_amo, uint256 frax_amount) external onlyByOwnGov validAMO(destination_amo) {
    int256 frax_amt_i256 = int256(frax_amount);

    // Make sure you aren't minting more than the mint cap
    require((frax_mint_sum + frax_amt_i256) <= frax_mint_cap, "Mint cap reached");
    frax_mint_balances[destination_amo] += frax_amt_i256;
    frax_mint_sum += frax_amt_i256;

    // Make sure the FRAX minting wouldn't push the CR down too much
    // This is also a sanity check for the int256 math
    uint256 current_collateral_E18 = FRAX.globalCollateralValue();
    uint256 cur_frax_supply = FRAX.totalSupply();
    uint256 new_frax_supply = cur_frax_supply + frax_amount;
    uint256 new_cr = (current_collateral_E18 * PRICE_PRECISION) / new_frax_supply;
    require(new_cr >= min_cr, "CR would be too low");

    // Mint the FRAX to the AMO
    FRAX.pool_mint(destination_amo, frax_amount);

    // Sync
    syncDollarBalances();
}

// 1. Deposit USDC to 3pool
// 2. Deposit 3CRV and FRAX to meta pool
function metapoolDeposit(uint256 _frax_amount, uint256 _collateral_amount) external onlyByOwnGov returns (uint256 metapool_LP_received) {
    uint256 threeCRV_received = 0;
    if (_collateral_amount > 0) {
        // Approve the collateral to be added to 3pool
        collateral_token.approve(address(three_pool), _collateral_amount);

        // Convert collateral into 3pool
        uint256[3] memory three_pool_collaterals;
        three_pool_collaterals[1] = _collateral_amount;
        {
            uint256 min_3pool_out = (_collateral_amount * (10 ** missing_decimals)).mul(liq_slippage_3crv).div(PRICE_PRECISION);
            three_pool.add_liquidity(three_pool_collaterals, min_3pool_out);
        }

        // Approve the 3pool for the metapool
        threeCRV_received = three_pool_erc20.balanceOf(address(this));

        // WEIRD ISSUE: NEED TO DO three_pool_erc20.approve(address(three_pool), 0); first before every time
        // May be related to https://github.com/vyperlang/vyper/blob/3e1ff1eb327e9017c5758e24db4bdf66bbfae371/examples/tokens/ERC20.vy#L85
        three_pool_erc20.approve(frax3crv_metapool_address, 0);
        three_pool_erc20.approve(frax3crv_metapool_address, threeCRV_received);
    }
    
    // Approve the FRAX for the metapool
    FRAX.approve(frax3crv_metapool_address, _frax_amount);

    {
        // Add the FRAX and the collateral to the metapool
        uint256 min_lp_out = (_frax_amount.add(threeCRV_received)).mul(slippage_metapool).div(PRICE_PRECISION);
        metapool_LP_received = frax3crv_metapool.add_liquidity([_frax_amount, threeCRV_received], min_lp_out);
    }

    return metapool_LP_received;
}

Later when governance decides it is time to remove liquidity (FRAX or USDC or both), it can call the functions metapoolWithdrawFrax/metapoolWithdraw3pool/metapoolWithdrawAtCurRatio

to withdraw FRAX from the metapool and USDC from the 3pool. Optionally it can choose to burn the FRAX withdrawn in the same transaction (burnFrax can also be called on its own). The AMO minter burns the FRAX taken from the AMO and decreases the AMO’s FRAX mint balances.

function burnFraxFromAMO(uint256 frax_amount) external validAMO(msg.sender) {
    int256 frax_amt_i256 = int256(frax_amount);

    // Burn first
    FRAX.pool_burn_from(msg.sender, frax_amount);

    // Then update the balances
    frax_mint_balances[msg.sender] -= frax_amt_i256;
    frax_mint_sum -= frax_amt_i256;

    // Sync
    syncDollarBalances();
}

Frax is not the only algorithmic stable in the market. It will not be the only one either.

Ultimately, stablecoins are products that fulfill a specific Job-To-be-done (JTBD). Are you a speculator looking to lever up? Overcollateralization is right for you. Go over there for $DAI and $MIM. Are you a DAO managing $10 million+ of treasuries? Go over there for $FEI and $FRAX. Are you an institutional investor looking for low-risk crypto exposure? Go over there for $UST and $UXD. To each, their own.

Each stablecoin has noticeably different risk profiles and use cases. Even so, we are optimistic that $FRAX will remain a benchmark for future DeFi protocols because it has got the 3 Killer Apps: Curve-like property, peg mechanism and AMOs.