Dual Stability Mechanism and Minting USC

How is stability maintained? How can users mint USC?

Introduction to the Dual Stability Mechanism

The dual stability mechanism is designed to maintain the price of USC stable at 1 USD. Any user can interact with the dual stability mechanism through the Arbitrage Contract. To understand the mechanism behind this contract, users must be familiar with some essential calculations on arbitrage data.

Arbitrage Data

Arbitrage data include all the necessary information needed in the arbitrage functions to identify the current arbitrage opportunity and execute transactions accordingly. Five data variables exist: isPriceAboveTarget, isExcessOfReserves, reserveDiff, delta, discount.

Boolean

PriceAboveTarget identifies if the price of USC is above or below 1 USD:

isPriceAboveTarget = (uscPrice >= USC_TARGET_PRICE)

isExcessOfReserves verifies the solvency state of the protocol by checking if the LSTs and ETH reserves to back USC are in excess or in deficit

if (reserveValue > uscTotalSupplyValue) {
isExcessOfReserves = true;
}
else {isExcessOfReserves = false;
}

uint256

reserveDiff is a measure of the excess or deficit gap between reserves and circulating USC supply. reserveDiff defines the discount when the price of USC is at 1 USD and the reserves are in deficit or excess.

if (isExcessOfReserves) { 
reserveDiff = (reserveValue - uscTotalSupplyValue) / BASE_PRICE; 
} else 
reserveDiff = (uscTotalSupplyValue - reserveValue) / BASE_PRICE; 
}

delta is a number that indicates the amount of ETH or USC that must be added to the USC/ETH Uniswap pool to keep it balanced (in USD terms) and re-peg the price at 1 USD

function _calculateDelta(uint256 reserveIn, uint256 priceIn,uint256 reserveOut, uint256 priceOut) public pure returns (uint256)

Depending on the price of USC with respect to the target price, the function _calculateDelta is called with different inputs. In all cases, it returns the root solution to a quadratic equation (i.e., delta).

When the price of USC is above peg ( _arbitrageAbovePegExcessOfReserves, _arbitrageAbovePegDeficitOfReserves), the arbitrage function calls _calculateDeltaUSC, which returns the delta in USC that must be added in the pool to return its price at 1 USD.

 function _calculateDeltaUSC(uint256 ethPrice) public view returns (uint256)
(uint256 reserveUSC, uint256 reserveWETH) = UniswapV2Library.getReserves(
      address(poolFactory),
      address(USC),
      address(WETH)
    );
    return _calculateDelta(reserveUSC, USC_TARGET_PRICE, reserveWETH, ethPrice);
  }

In this case, the quadratic equation is of the following form:

Note: x=ETH reservesx = ETH \space reserves, y=USC reservesy = USC \space reserves , Δy=amount In USC=delta\Delta y = amount \space In \space USC = delta , 0.997=1pool fee0.997 = 1-pool \space fee

Similarly, when the price of USC is below peg ( _arbitrageBelowPegExcessOfReserves, _arbitrageBelowPegDeficitOfReserves), the arbitrage function calls _calculateDeltaETH, which returns the delta in ETH that must be added to increase the price at 1 USD.

function _calculateDeltaETH(uint256 ethPrice) public view returns (uint256) {
    (uint256 reserveUSC, uint256 reserveWETH) = UniswapV2Library.getReserves(
      address(poolFactory),
      address(USC),
      address(WETH)
    );
    return _calculateDelta(reserveWETH, ethPrice, reserveUSC, USC_TARGET_PRICE);
  }

In this scenario, the quadratic equation is as follows:

Note: x=ETH reservesx = ETH \space reserves, y=USC reservesy = USC \space reserves , Δx=amount In ETH=delta\Delta x = amount \space In \space ETH = delta, 0.997=1pool fee0.997 = 1-pool \space fee

In the background, the function calculateDelta performs all the necessary steps to get a real (positive) root for delta .

  1. f = (1 - pool_fee) = 0.997 on 18 decimals, in square root formula a = f

  2. parameter b in square root formula, b = rIn * (1+f) , on 18 decimals

  3. parameter c in square root formula, c = rIn^2 - (rIn * rOut * priceOut) / priceIn.

if rIn^2 > (rIn * rOut * priceOut) / priceIn: 
  c= rIn^2 - (rIn * rOut * priceOut) / priceIn 
  delta = sqrt(b^2 - 4ac)/2a - b

else if rIn^2 < (rIn * rOut * priceOut) / priceIn 
c= (rIn * rOut * priceOut) / priceIn - rIn^2  
  delta = sqrt(b^2 + 4ac)/2a - b 

To learn more about delta calculation: https://hackmd.io/@6jzKo0C7QCGkNGHQ9oU28g/ryQdB_5M6 discountis a number between zero and one which measures the difference between reserves and USC supply. This used to define an additional arbitrage opportunity when the price of USC is at 1 USD.

if (isExcessOfReserves) { 
discount = (reserveDiff * 1 ether) / uscTotalSupplyValue; 
} else 
discount = (reserveDiff * 1 ether) / reserveValue;
}

Arbitrage Functions

Users can call arbitrage functions to make profits and stabilise the price of USC at 1 USD. Different arbitrage opportunities can arise depending on the price of USC and the solvency state. There exist six arbitrage opportunities:

Arbitrage NameUSC Price vs TargetUSC Supply Value vs Reserves Value

_arbitrageAbovePegExcessOfReserves

uscPrice > USC_TARGET_PRICE

reservesValue > UscTotalSupplyValue

_arbitrageAbovePegDeficitOfReserves

uscPrice > USC_TARGET_PRICE

reservesValue ≤ UscTotalSupplyValue

_arbitrageBelowPegExcessOfReserves

uscPrice < USC_TARGET_PRICE

reservesValue > UscTotalSupplyValue

_arbitrageBelowPegDeficitOfReserves

uscPrice < USC_TARGET_PRICE

reservesValue ≤ UscTotalSupplyValue

arbitrageAtPegExcessOfReserves

discount != 0

reservesValue > UscTotalSupplyValue

_arbitrageAtPegDeficitOfReserves

discount != 0

reservesValue ≤ UscTotalSupplyValue

All arbitrage functions return the rewardValue in USD.

Price above 1 USD

The arbitrage contract caps the mint amount of USC at delta and users can call the respective functions when its price is above 1 USD. USC is minted through _arbitrageAbovePegExcessOfReserves and _arbitrageAbovePegDeficitOfReserves. These functions get executed only if the arbitrage is profitable. In other words, if the deltaInETH > ethAmountReceived from the swap of newly minted USC, the transaction gets reverted.

Excess Reserves

This function executes arbitrage that occurs when the price of USC is above 1 USD, and the reserves are in excess.

function _arbitrageAbovePegExcessOfReserves(uint256 reserveDiff, uint256 ethPrice) private returns (uint256)

Following the swap of the newly minted deltaUSC for ETH, the function verifies if the reserveDiff is sufficient to back the delta. Assuming deltaUSD ≤ reserveDiff, the ethAmountToSwap is set to deltaInETH, exchanged for CHI and the chiAmountReceived is burnt.

When deltaUSD > reserveDiff, the ethAmountToSwap in CHI is capped to reserveDiff. This is done to ensure the full backing of USC after the delta has been added to the circulating supply. The remaining difference (deltaInETH - ethAmountToSwap), known as ethAmountForReserves, is added to the reserveHolder.

Deficit Reserves

This function executes arbitrage which occurs when the price of USC is above 1 USD, and the reserves are in deficit.

  function_arbitrageAbovePegDeficitOfReserves(uint256 reserveDiff, uint256 ethPrice) private returns (uint256)

Following the swap of the newly minted delta USC for ETH, the deltaInETHis added to the reserveHolder.

Price below 1 USD

The arbitrage contract enables redemptions of USC for ETH when the protocol has excess reserves and the price of USC is below 1 USD. Moreover USC can be burnt when there is a deficit of reserves and the price is below 1 USD. Redeem and burn functions are called through _arbitrageBelowPegExcessOfReserves and _arbitrageBelowPegDeficitOfReserves .

Excess Reserves

_arbitrageBelowPegExcessOfReserves can be called when the price of USC is below 1 USD, and the reserves are in excess.

function _arbitrageBelowPegExcessOfReserves (uint256 reserveDiff, uint256 ethPrice) private returns (uint256)

Assuming delta ≤ reserveDiff, the ethAmountToRedeem is set to deltaInETH and it's removed from the reserveHolder to buy USC on Uniswap. Finally, the uscAmountReceived from the swap in USC is sent to the USCStaking contract as uscAmountToReward and distributed proportionally among all USC stakers.

When deltaUSD > reserveDiff, the ethAmountToRedeem from the reserveHolderis capped to reserveDiffInETH. This is done to ensure the solvency of the protocol following the redemption. Then the function computes the chiAmountToMint to cover the remaining difference deltaETH - ethAmountToRedeem, which is swapped for ETH and set to ethAmountFromChi Finally, ethAmountToRedeem + ethAmountFromChiis exchanged for USC: reserveDiff is sent to the USCStaking contract and deltaUSD - reserveDiff is burnt .

Deficit Reserves

_arbitrageBelowPegDeficitOfReservescan be called when the price of USC is below 1 USD, and the reserves are in deficit.

 function _arbitrageBelowPegDeficitOfReserves(uint256 reserveDiff, uint256 ethPrice) private returns (uint256)

When deltaUSD ≤ reserveDiff, the function computes the chiAmountToMint from the deltaETH and sets ethAmountFromChi = deltaETH .Once minted, this value in CHI is first swapped for ETH and then exchanged for USC. The deltaUSD in USC is then burnt.

When deltaUSD > reserveDiff, the chiAmountToMint is limited to ethAmountFromChi = reserveDiffInETH. This limits the potential dilution of CHI holders to the reserveDiff value. The remaining difference ethAmountToRedeem = deltaETH - ethAmountFromChi is covered with redemptions. Finally, ethAmountFromChi + ethAmountToRedeem is exchanged for USC: reserveDiff is burnt, and deltaUSD - reserveDiff is sent to USCStaking contract.

Price at 1 USD

The arbitrage contract can profit from situations in which the price of USC is at 1 USD (i.e., with minor symmetrical tolerance from 1) and the reserves are in excess or deficit. This ensures that even if the price of USC trades at 1 USD, there will be an arbitrage opportunity to make the value of the reserves equivalent to the one of USC debt.

Excess Reserves

_arbitrageAtPegExcessOfReserves can be called when the USC price is 1 USD, and the reserves are in excess.

 function _arbitrageAtPegExcessOfReserves(uint256 reserveDiff, uint256 discount, uint256 ethPrice) private returns (uint256) 

Since the protocol has excess reserves to back USC, the discount is measured by reserveDiff / uscTotalSupplyValue.When the function is called the contract redeems the reserveDiff from reserveHolder to buyback CHI and burn it. The function caller is rewarded in CHI with chiArbitrageReward which is a percentage (discount) of the chiReceived from the swap.

Following this, the contract burns CHI net of arbitrage profits: CHI.burn(chiReceived - chiArbitrageReward).

Deficit Reserves

_arbitrageAtPegDeficitOfReservescan be called when the price of USC is 1 USD, and the reserves to back it are in deficit.

  function _arbitrageAtPegDeficitOfReserves(uint256 reserveDiff, uint256 discount, uint256 ethPrice) private returns (uint256)

Since the protocol has a deficit, the discount is measured through reserveDiff / reserveValue.When the function is called, chiToCoverEth is computed in order to obtain the reserveDiffInETH from the CHI to ETH swap . Following this, the calculatiuon of chiArbitrageReward as a percentage (discount) of the chiToCoverEth is performed.

Finally, chiToCoverEth + chiArbitrageReward is minted: chiToCoverEth is swapped for ETH which is then added to the reserveHolder and chiArbitrageReward is sent to the functions caller

Rewards to Function Caller

The function caller is rewarded with the arbitrage profits in all arbitrage functions. The arbitrage profits arise because smart contracts always price USC at 1 USD.

Rewards for _arbitrageAbovePegExcessOfReserves and _arbitrageAbovePegDeficitOfReserves are distributed in ETH:

uint256 rewardAmount = ethAmountReceived - ethAmounToSwap - ethAmountForReserves;
_transferEther(msg.sender, rewardAmount);

Rewards for _arbitrageBelowPegExcessOfReserves and _arbitrageBelowPegDeficitOfReserves are distributed in USC:

uint256 rewardAmount = uscAmountReceived - uscAmountToFreeze - uscAmountToBurn;
USC.safeTransfer(msg.sender, rewardAmount);
USC.safeTransfer(msg.sender, uscAmountReceived - uscAmountToBurn);

Finally, since the ending currency for arbitrage _arbitrageAtPegExcessOfReserves and _arbitrageAtPegDeficitOfReserves is CHI, the arbitrage rewards are given with the governance token.

IERC20(CHI).transfer(msg.sender, chiArbitrageReward);

For _arbitrageAtPegExcessOfReserves, chiArbitrageReward is discount * chiReceived from the ETH - CHI swap. While, in _arbitrageAtPegDeficitOfReserves, chiArbitrageReward is discount * chiToCoverEth.

Minting USC

Any user can mint USC by depositing ETH and calling the mint function

function mint() external payable nonReentrant;

The msg.value is sent to the reserveHolder and then converted into stETH via Lido. When the mint function is called, executeArbitrage() is executed, and the minter receives the arbitrage rewards . This also ensures that the price of USC is 1 USD and the market value of the reserves and debt grows at the same rate when the user deposits. Finally, the msg.value in USC is minted and sent to user.

Last updated