Ebisu ~ weETH/sUSDai Oracles Integration

Both weETH and sUSDai represent shares of staked tokens, having the native deployments of the assets serving as ERC-4626-like vaults.

This inherently means that typically:

• Both of the assets have an on-chain exchange rate with the underlying staked token which is retrievable from the weETH/sUSDai contracts respectively.
• Both assets can be instantly redeemed for the underlying asset at any time.

While Liquity (and by extension Ebisu) operate based on Chainlink-provided prices, the protocol wishes to guard against scenarios where the off-chain price information on instantly redeemable assets lags behind the current on-chain exchange rate. In such scenarios, parties could treat the protocol as a seller of the instantly redeemable asset and:

• “Buy” the asset at a cheaper price (because the Chainlink price is lagging) using Liquity/Ebisu’s redemption mechanism
• Redeem the asset to the native vault-like contract at a higher price

Typically the protocol guards against this scenario by comparing the on-chain exchange rate against the price obtained by Chainlink:

...
// If it's a redemption and canonical is within 2% of market, use the max to mitigate unwanted redemption oracle arb
if (
    _isRedemption
        && _withinDeviationThreshold(rEthUsdMarketPrice, rEthUsdCanonicalPrice, RETH_ETH_DEVIATION_THRESHOLD)
) {
    rEthUsdPrice = LiquityMath._max(rEthUsdMarketPrice, rEthUsdCanonicalPrice);
...

If the on-chain exchange rate deviates from the off-chain price by a small amount, this is considered to occur due to oracle lagging; therefore, the price oracle yields the worst of the two prices for redemption.

Because weETH, sUSDe, and sUSDai are all bridged to Plasma using LayerZero’s OFT standard, there is no way to obtain the current on-chain exchange rate of those redeemable assets from their corresponding contracts. Instead, these exchange rates can only be supplied externally via Chainlink oracles:

...
        // Get USDe/USD price (returns in 18 decimals from _getOracleAnswer)
        (uint256 usdeUsdPrice, bool usdeUsdOracleDown) = _getOracleAnswer(ethUsdOracle);
...

        // Get sUSDe/USD price (returns in 18 decimals from _getOracleAnswer)
        (uint256 sUsdeUsdPrice, bool sUsdeUsdOracleDown) = _getOracleAnswer(sUSDeUsdOracle);
...

        // Get sUSDe/USDe rate from oracle (returns in 18 decimals from _getOracleAnswer)
        (uint256 sUsdeUsdeRate, bool sUsdeUsdeRateOracleDown) = _getOracleAnswer(sUSDeUsdeRateOracle);
...

In the event that Chainlink prices fall behind the true on-chain exchange rate, deviation checks can consequently lag behind the on-chain state. This is a fundamental limitation of the cross-chain deployment of these assets and lies outside the protocol’s control. However, it could give rise to small arbitrage opportunities—especially when arbitrageurs can use LayerZero’s bridging primitives to transfer assets to the host chain within seconds and complete the arbitrage cycle.

Under normal Chainlink oracle operation, this is not expected to be a likely scenario. Even if such deviations occur, they should exist only momentarily without posing any significant risk to the protocol’s ability to operate healthily.

In the following snippet:

...
// Get weETH/eETH rate from oracle (returns in 18 decimals from _getOracleAnswer)
// Since eETH ≈ ETH (1:1), this effectively gives us weETH/ETH rate
(uint256 weEthEthRate, bool weEthEthRateOracleDown) = _getOracleAnswer(weETHEthRateOracle);
if (weEthEthRateOracleDown) {
    return (_shutDownAndSwitchToLastGoodPrice(address(weETHEthRateOracle.aggregator)), true);
}
...

There exists the implicit assumption that eETH and ETH are priced at a 1:1 ratio. While this is approximately correct, it can be the case that the market prices of those assets (even within Chainlink oracles) experience slight deviations:

Under normal circumstances, this is not expected to pose significant security risks to the protocol. When such deviations occur, micro-arbitrage opportunities like the ones described in P1 can momentarily arise.

When a branch shuts down because of an oracle failure, the fallback price that is used for instantly redeemable assets like eUSDe, weETH and sUSDai is providing the last good price:

...
if (usdeUsdOracleDown) {
    return (_shutDownAndSwitchToLastGoodPrice(address(ethUsdOracle.aggregator)), true);
}
...
if (sUsdeUsdOracleDown) {
    return (_shutDownAndSwitchToLastGoodPrice(address(sUSDeUsdOracle.aggregator)), true);
}
...
if (sUsdeUsdeRateOracleDown) {
   return (_shutDownAndSwitchToLastGoodPrice(address(sUSDeUsdeRateOracle.aggregator)), true);
}
...

The fallback price after a shut down can no longer be updated, and given the fact that the above-mentioned assets have a potentially constantly-changing on-chain exchange rate there could exist scenarios when shutdown branches create arbitrage incentives during Liquidations and urgent Redemptions.

That being said, even if profitable opportunities for arbitrage arise because of a deviation of the stored price compared to the on-chain exchange rate, it’s expected that a lot of users would be urged to burn debt because of the incentives during shutdown. In the end, such opportunities are both highly unlikely (a Chainlink oracle failure would mean systemic risk) and short-lived.

Stemming from P1 , the following immutable field is unused:

contract sUSDaiPriceFeed is MainnetPriceFeedBase {
    uint256 public constant SUSDAI_USD_DEVIATION_THRESHOLD = 2e16; // 2%
...

Stemming from P1 and the lack of a sUSDai/USD Chainlink price feed on Plasma, the following internal function is unused:

function _withinDeviationThreshold(uint256 _priceToCheck, uint256 _referencePrice, uint256 _deviationThreshold)
    internal
    pure
    returns (bool)
{
    uint256 max = _referencePrice * (DECIMAL_PRECISION + _deviationThreshold) / DECIMAL_PRECISION;
    uint256 min = _referencePrice * (DECIMAL_PRECISION - _deviationThreshold) / DECIMAL_PRECISION;
    return _priceToCheck >= min && _priceToCheck <= max;
}

During the construction of sUSDaiPriceFeed:

constructor(
    address _usdaiUsdOracleAddress, // USDai/USD oracle
    address _sUsdaiUsdaiRateOracleAddress, // sUSDai/USDai rate oracle
    uint256 _usdaiUsdStalenessThreshold,
    uint256 _sUsdaiUsdaiRateStalenessThreshold,
    address _borrowerOperationsAddress
) MainnetPriceFeedBase(_usdaiUsdOracleAddress, _usdaiUsdStalenessThreshold, _borrowerOperationsAddress) {
    usdaiUsdOracle.aggregator = AggregatorV3Interface(_usdaiUsdOracleAddress);
...
    usdaiUsdOracle.decimals = usdaiUsdOracle.aggregator.decimals();
...
    require(usdaiUsdOracle.decimals == 8, "USDai/USD oracle must have 8 decimals");
...

The decimals of the USDai/USD oracle are first asserted to be 8 inside the constructor of MainnetPriceFeedBase:

constructor(address _ethUsdOracleAddress, uint256 _ethUsdStalenessThreshold, address _borrowOperationsAddress) {
    ethUsdOracle.aggregator = AggregatorV3Interface(_ethUsdOracleAddress);
...
    ethUsdOracle.decimals = ethUsdOracle.aggregator.decimals();
...
    assert(ethUsdOracle.decimals == 8);
}

The code is compiled with Solidity 0.8.24. Version 0.8.24 has no known bugs.