Dual Stability Mechanism: Minting and Redeeming USC

How is Stability Maintained? How Can Users Mint and Redeem USC?

Introduction to the Dual Stability Mechanism

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

Arbitrage Data

Arbitrage data includes 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, and 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 \space reserves$, $y = USC \space reserves$ , $\Delta y = amount \space In \space USC = delta$ , $0.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 \space reserves$, $y = USC \space reserves$ , $\Delta x = amount \space In \space ETH = delta$, $0.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

discount is 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 approximately 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 Name	USC Price vs Target	USC 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 performs buybacks on 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 or when the price of USC is below 1 USD and the reserves are equivalent to the outstanding stablecoin debt . 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 RewardController contract as uscAmountToReward and distributed to USC stakers .

When deltaUSD > reserveDiff, the ethAmountToRedeem from the reserveHolderis capped to deltaInETH.Once is USC bought back, reservesDiff in USC is preserved in the system as reward and deltaUSD - reserveDiff is burnt. This is done to ensure the solvency of the protocol following the arbitrage.

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 the protocol's reserves. Finally, ethAmountFromChi + ethAmountToRedeem is exchanged for USC anddeltaUSD is burnt.

Price at 1 USD

The arbitrage contract can profit from situations in which the price of USC is at 1 USD 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 mints the reserveDiff in USC.

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, the reserveDiff in USC is burnt from the arbitrage contract. Assuming the the totalMintedUSC stored in the arbitrage contract is not sufficient to cover the deficit, ethToGetInUsd is set to reserveDiffInUsc - totalMintedUsc. Following this, the calculation 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 function 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 and Redeeming USC

Any user can mint USC by depositing ETH, stETH or WETH and calling the mint function . Similarly, any user can burn USC and receive the equivalent dollar value in WETH from the protocol's reserves.

Note that when minting (redeeming) USC, a protocol fee of 0.3% is deducted from the minted (redeemed) amount.

 function mint() external payable whenMintNotPaused nonReentrant onlyWhenMintableOrBurnable returns (uint256);
 function burn(uint256 amount) external whenBurnNotPaused nonReentrant onlyWhenMintableOrBurnable returns (uint256);

It is important to note that USC can only be minted and burnt when the price of USC and the collateral ratio are within a predefined range (≈ $1 price for USC, ≈ CR 100%) . When USC is minted with ETH (WETH), the ethAmount - fee ( wethAmount - fee) is sent to the reserveHolder and then staked into Lido via a rebalancing function.

When USC is burnt, the ethAmountToRedeem is set to the USC value less any fee, which is then deducted from the protocol's reserves and given to the redeemer in the form of WETH.