BIP–48: Whitelist BEANwstETH and Migrate Unripe Liquidity

protocol/contracts/C.sol

@@ -69,8 +69,7 @@ library C {
     address internal constant USDC = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
     address internal constant USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
     address internal constant WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
-    address internal constant UNIV3_ETH_USDC_POOL = 0x88e6A0c2dDD26FEEb64F039a2c41296FcB3f5640; // 0.05% pool
-    address internal constant UNIV3_ETH_USDT_POOL = 0x11b815efB8f581194ae79006d24E0d814B7697F6; // 0.05% pool
+    address internal constant WSTETH = 0x7f39C581F595B53c5cb19bD0b3f8dA6c935E2Ca0;
 
     // Use external contract for block.basefee as to avoid upgrading existing contracts to solidity v8
     address private constant BASE_FEE_CONTRACT = 0x84292919cB64b590C0131550483707E43Ef223aC;
@@ -166,10 +165,6 @@ library C {
         return IERC20(THREE_CRV);
     }
 
-    function UniV3EthUsdc() internal pure returns (address){
-        return UNIV3_ETH_USDC_POOL;
-    }
-
     function fertilizer() internal pure returns (IFertilizer) {
         return IFertilizer(FERTILIZER);
     }

protocol/contracts/libraries/Oracle/LibChainlinkOracle.sol

@@ -21,16 +21,23 @@ library LibChainlinkOracle {
     // Uses the same timeout as Liquity's Chainlink timeout.
     uint256 public constant CHAINLINK_TIMEOUT = 14400; // 4 hours: 60 * 60 * 4
 
-    IChainlinkAggregator constant priceAggregator =
-        IChainlinkAggregator(0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419);
     uint256 constant PRECISION = 1e6; // use 6 decimal precision.
 
+    // timeout for Oracles with a 1 hour heartbeat.
+    uint256 constant FOUR_HOUR_TIMEOUT = 14400;
+    // timeout for Oracles with a 1 day heartbeat.
+    uint256 constant FOUR_DAY_TIMEOUT = 345600;
+
     /**
-     * @dev Returns the most recently reported ETH/USD price from the Chainlink Oracle.
+     * @dev Returns the price of a given `priceAggregator`
      * Return value has 6 decimal precision.
      * Returns 0 if Chainlink's price feed is broken or frozen.
      **/
-    function getEthUsdPrice() internal view returns (uint256 price) {
+    function getPrice(
+        address priceAggregatorAddress,
+        uint256 maxTimeout
+    ) internal view returns (uint256 price) {
+        IChainlinkAggregator priceAggregator = IChainlinkAggregator(priceAggregatorAddress);
         // First, try to get current decimal precision:
         uint8 decimals;
         try priceAggregator.decimals() returns (uint8 _decimals) {
@@ -51,7 +58,7 @@ library LibChainlinkOracle {
         ) {
             // Check for an invalid roundId that is 0
             if (roundId == 0) return 0;
-            if (checkForInvalidTimestampOrAnswer(timestamp, answer, block.timestamp)) {
+            if (checkForInvalidTimestampOrAnswer(timestamp, answer, block.timestamp, maxTimeout)) {
                 return 0;
             }
             // Adjust to 6 decimal precision.
@@ -62,12 +69,25 @@ library LibChainlinkOracle {
         }
     }
 
+    struct TwapVariables {
+        uint256 cumulativePrice;
+        uint256 endTimestamp;
+        uint256 lastTimestamp;
+        uint256 timestamp;
+        int256 answer;
+    }
+
     /**
-     * @dev Returns the TWAP ETH/USD price from the Chainlink Oracle over the past `lookback` seconds.
+     * @dev Returns the TWAP price from the Chainlink Oracle over the past `lookback` seconds.
      * Return value has 6 decimal precision.
      * Returns 0 if Chainlink's price feed is broken or frozen.
      **/
-    function getEthUsdTwap(uint256 lookback) internal view returns (uint256 price) {
+    function getTwap(
+        address priceAggregatorAddress,
+        uint256 maxTimeout,
+        uint256 lookback
+    ) internal view returns (uint256 price) {
+        IChainlinkAggregator priceAggregator = IChainlinkAggregator(priceAggregatorAddress);
         // First, try to get current decimal precision:
         uint8 decimals;
         try priceAggregator.decimals() returns (uint8 _decimals) {
@@ -88,62 +108,74 @@ library LibChainlinkOracle {
         ) {
             // Check for an invalid roundId that is 0
             if (roundId == 0) return 0;
-            if (checkForInvalidTimestampOrAnswer(timestamp, answer, block.timestamp)) {
+            if (checkForInvalidTimestampOrAnswer(timestamp, answer, block.timestamp, maxTimeout)) {
                 return 0;
             }
 
-            uint256 endTimestamp = block.timestamp.sub(lookback);
+            TwapVariables memory t;
+
+            t.endTimestamp = block.timestamp.sub(lookback);
             // Check if last round was more than `lookback` ago.
-            if (timestamp <= endTimestamp) {
+            if (timestamp <= t.endTimestamp) {
                 return uint256(answer).mul(PRECISION).div(10 ** decimals);
             } else {
-                uint256 cumulativePrice;
-                uint256 lastTimestamp = block.timestamp;
+                t.lastTimestamp = block.timestamp;
                 // Loop through previous rounds and compute cumulative sum until
                 // a round at least `lookback` seconds ago is reached.
-                while (timestamp > endTimestamp) {
-                    cumulativePrice = cumulativePrice.add(
-                        uint256(answer).mul(lastTimestamp.sub(timestamp))
+                while (timestamp > t.endTimestamp) {
+                    t.cumulativePrice = t.cumulativePrice.add(
+                        uint256(answer).mul(t.lastTimestamp.sub(timestamp))
                     );
                     roundId -= 1;
-                    try priceAggregator.getRoundData(roundId) returns (
-                        uint80 /* roundId */,
-                        int256 _answer,
-                        uint256 /* startedAt */,
-                        uint256 _timestamp,
-                        uint80 /* answeredInRound */
-                    ) {
-                        if (checkForInvalidTimestampOrAnswer(_timestamp, _answer, timestamp)) {
-                            return 0;
-                        }
-                        lastTimestamp = timestamp;
-                        timestamp = _timestamp;
-                        answer = _answer;
-                    } catch {
-                        // If call to Chainlink aggregator reverts, return a price of 0 indicating failure
+                    t.lastTimestamp = timestamp;
+                    (answer, timestamp) = getRoundData(priceAggregator, roundId);
+                    if (checkForInvalidTimestampOrAnswer(
+                            timestamp,
+                            answer,
+                            t.lastTimestamp,
+                            maxTimeout
+                    )) {
                         return 0;
                     }
                 }
-                cumulativePrice = cumulativePrice.add(
-                    uint256(answer).mul(lastTimestamp.sub(endTimestamp))
+                t.cumulativePrice = t.cumulativePrice.add(
+                    uint256(answer).mul(t.lastTimestamp.sub(t.endTimestamp))
                 );
-                return cumulativePrice.mul(PRECISION).div(10 ** decimals).div(lookback);
+                return t.cumulativePrice.mul(PRECISION).div(10 ** decimals).div(lookback);
             }
         } catch {
             // If call to Chainlink aggregator reverts, return a price of 0 indicating failure
             return 0;
         }
     }
 
+    function getRoundData(
+        IChainlinkAggregator priceAggregator,
+        uint80 roundId
+    ) private view returns (int256, uint256) {
+        try priceAggregator.getRoundData(roundId) returns (
+                uint80 /* roundId */,
+                int256 _answer,
+                uint256 /* startedAt */,
+                uint256 _timestamp,
+                uint80 /* answeredInRound */
+        ) {
+            return (_answer, _timestamp);
+        } catch {
+            return (-1, 0);
+        }
+    }
+
     function checkForInvalidTimestampOrAnswer(
         uint256 timestamp,
         int256 answer,
-        uint256 currentTimestamp
-    ) private pure returns (bool) {
+        uint256 currentTimestamp,
+        uint256 maxTimeout
+    ) private view returns (bool) {
         // Check for an invalid timeStamp that is 0, or in the future
         if (timestamp == 0 || timestamp > currentTimestamp) return true;
         // Check if Chainlink's price feed has timed out
-        if (currentTimestamp.sub(timestamp) > CHAINLINK_TIMEOUT) return true;
+        if (currentTimestamp.sub(timestamp) > maxTimeout) return true;
         // Check for non-positive price
         if (answer <= 0) return true;
     }

protocol/contracts/libraries/Oracle/LibEthUsdOracle.sol

@@ -6,49 +6,61 @@ pragma solidity =0.7.6;
 pragma experimental ABIEncoderV2;
 
 import {LibChainlinkOracle} from "./LibChainlinkOracle.sol";
-import {LibUniswapOracle} from "./LibUniswapOracle.sol";
 import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
 import {LibAppStorage, AppStorage} from "contracts/libraries/LibAppStorage.sol";
 import {C} from "contracts/C.sol";
+import {LibOracleHelpers} from "contracts/libraries/Oracle/LibOracleHelpers.sol";
+
 /**
  * @title Eth Usd Oracle Library
  * @notice Contains functionalty to fetch a manipulation resistant ETH/USD price.
  * @dev
  * The Oracle uses a greedy approach to return the average price between the
  * current price returned ETH/USD Chainlink Oracle and either the ETH/USDC
  * Uniswap V3 0.05% fee pool and the ETH/USDT Uniswap V3 0.05% fee pool depending
- * on which is closer. 
- * 
+ * on which is closer.
+ *
  * If the prices in the ETH/USDC Uniswap V3 0.05% fee pool and USD/USDT Uniswap V3 0.05% fee pool are
  * greater than `MAX_DIFFERENCE` apart, then the oracle uses the Chainlink price to maximize liveness.
- * 
+ *
  * The approach is greedy as if the ETH/USDC Uniswap price is sufficiently close
  * to the Chainlink Oracle price (See {MAX_GREEDY_DIFFERENCE}), then the Oracle
  * will not check the ETH/USDT Uniswap Price to save gas.
- * 
+ *
  * The oracle will fail if the Chainlink Oracle is broken or frozen (See: {LibChainlinkOracle}).
  **/
 library LibEthUsdOracle {
-
     using SafeMath for uint256;
 
+    /////////////////// ORACLES ///////////////////
+    address constant ETH_USD_CHAINLINK_PRICE_AGGREGATOR =
+        0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419;
+    ///////////////////////////////////////////////
+
     // The maximum percent different such that it is acceptable to use the greedy approach.
-    uint256 constant MAX_GREEDY_DIFFERENCE = 0.003e18; // 0.3%
+    uint256 constant MAX_GREEDY_DIFFERENCE = 0.003e18; // 0.3%'
 
     // The maximum percent difference such that the oracle assumes no manipulation is occuring.
     uint256 constant MAX_DIFFERENCE = 0.01e18; // 1%
-    uint256 constant ONE = 1e18;
 
-    // The lookback used for Uniswap Oracles when querying the instantaneous USD price.
-    uint32 constant INSTANT_LOOKBACK = 900;
+    function getEthUsdPriceFromStorageIfSaved() internal view returns (uint256) {
+        AppStorage storage s = LibAppStorage.diamondStorage();
+
+        uint256 priceInStorage = s.usdTokenPrice[C.BEAN_ETH_WELL];
+
+        if (priceInStorage == 1) {
+            return getEthUsdPrice();
+        }
+        return priceInStorage;
+    }
 
     /**
      * @dev Returns the instantaneous ETH/USD price
      * Return value has 6 decimal precision.
      * Returns 0 if the Eth Usd Oracle cannot fetch a manipulation resistant price.
      **/
     function getEthUsdPrice() internal view returns (uint256) {
-        return getEthUsdPrice(0);
+        return LibChainlinkOracle.getPrice(ETH_USD_CHAINLINK_PRICE_AGGREGATOR, LibChainlinkOracle.FOUR_HOUR_TIMEOUT);
     }
 
     /**
@@ -59,55 +71,18 @@ library LibEthUsdOracle {
      * A lookback of 900 seconds is used in Uniswap V3 pools for instantaneous price queries.
      * If using a non-zero lookback, it is recommended to use a substantially large
      * `lookback` (> 900 seconds) to protect against manipulation.
-    **/
+     **/
     function getEthUsdPrice(uint256 lookback) internal view returns (uint256) {
-        uint256 chainlinkPrice = lookback > 0 ?
-            LibChainlinkOracle.getEthUsdTwap(lookback) :
-            LibChainlinkOracle.getEthUsdPrice();
-
-        // Check if the chainlink price is broken or frozen.
-        if (chainlinkPrice == 0) return 0;
-
-        // Use a lookback of 900 seconds for an instantaneous price query for manipulation resistance.
-        if (lookback == 0) lookback = INSTANT_LOOKBACK;
-        if (lookback > type(uint32).max) return 0;
-
-        uint256 usdcPrice = LibUniswapOracle.getEthUsdcPrice(uint32(lookback));
-        uint256 usdcChainlinkPercentDiff = getPercentDifference(usdcPrice, chainlinkPrice);
-
-        // Check if the USDC price and the Chainlink Price are sufficiently close enough
-        // to warrant using the greedy approach.
-        if (usdcChainlinkPercentDiff < MAX_GREEDY_DIFFERENCE) {
-            return chainlinkPrice.add(usdcPrice).div(2);
-        }
-
-        uint256 usdtPrice = LibUniswapOracle.getEthUsdtPrice(uint32(lookback));
-        uint256 usdtChainlinkPercentDiff = getPercentDifference(usdtPrice, chainlinkPrice);
-
-        // Check whether the USDT or USDC price is closer to the Chainlink price.
-        if (usdtChainlinkPercentDiff < usdcChainlinkPercentDiff) {
-            // Check whether the USDT price is too far from the Chainlink price.
-            if (usdtChainlinkPercentDiff < MAX_DIFFERENCE) {
-                return chainlinkPrice.add(usdtPrice).div(2);
-            }
-            return chainlinkPrice;
-        } else {
-            // Check whether the USDC price is too far from the Chainlink price.
-            if (usdcChainlinkPercentDiff < MAX_DIFFERENCE) {
-                return chainlinkPrice.add(usdcPrice).div(2);
-            }
-            return chainlinkPrice;
-        }
-    }
-
-    /**
-     * Gets the percent difference between two values with 18 decimal precision.
-     * @dev If x == 0 (Such as in the case of Uniswap Oracle failure), then the percent difference is calculated as 100%.
-     */
-    function getPercentDifference(uint x, uint y) internal pure returns (uint256 percentDifference) {
-        percentDifference = x.mul(ONE).div(y);
-        percentDifference = x > y ?
-            percentDifference - ONE :
-            ONE - percentDifference; // SafeMath unnecessary due to conditional check
+        return
+            lookback > 0
+                ? LibChainlinkOracle.getTwap(
+                    ETH_USD_CHAINLINK_PRICE_AGGREGATOR,
+                    LibChainlinkOracle.FOUR_HOUR_TIMEOUT,
+                    lookback
+                )
+                : LibChainlinkOracle.getPrice(
+                    ETH_USD_CHAINLINK_PRICE_AGGREGATOR,
+                    LibChainlinkOracle.FOUR_HOUR_TIMEOUT
+                );
     }
 }

protocol/contracts/libraries/Oracle/LibOracleHelpers.sol

@@ -0,0 +1,35 @@
+/**
+ * SPDX-License-Identifier: MIT
+ **/
+
+pragma solidity =0.7.6;
+pragma experimental ABIEncoderV2;
+
+import {LibChainlinkOracle} from "./LibChainlinkOracle.sol";
+import {LibUniswapOracle} from "./LibUniswapOracle.sol";
+import {SafeMath} from "@openzeppelin/contracts/math/SafeMath.sol";
+import {LibAppStorage, AppStorage} from "contracts/libraries/LibAppStorage.sol";
+import {C} from "contracts/C.sol";
+/**
+ * @title Oracle Helpers Library
+ * @author brendan
+ * @notice Contains functionalty common to multiple Oracle libraries.
+ **/
+library LibOracleHelpers {
+
+    using SafeMath for uint256;
+
+    uint256 constant ONE = 1e18;
+
+    /**
+     * Gets the percent difference between two values with 18 decimal precision.
+     * @dev If x == 0 (Such as in the case of Uniswap Oracle failure), then the percent difference is calculated as 100%.
+     */
+    function getPercentDifference(
+        uint x,
+        uint y
+    ) internal pure returns (uint256 percentDifference) {
+        percentDifference = x.mul(ONE).div(y);
+        percentDifference = x > y ? percentDifference - ONE : ONE - percentDifference; // SafeMath unnecessary due to conditional check
+    }
+}