Merge pull request #1031 from reserve-protocol/3.2.0

3.2.0

Author: tbrent

.github/workflows/tests.yml

@@ -83,7 +83,7 @@ jobs:
           restore-keys: |
             hardhat-network-fork-${{ runner.os }}-
             hardhat-network-fork-
-      - run: npx hardhat test ./test/plugins/individual-collateral/{cbeth,aave-v3,compoundv3,stargate}/*.test.ts
+      - run: npx hardhat test ./test/plugins/individual-collateral/{cbeth,aave-v3,compoundv3,stargate,lido}/*.test.ts
         env:
           NODE_OPTIONS: '--max-old-space-size=8192'
           TS_NODE_SKIP_IGNORE: true

CHANGELOG.md

@@ -1,8 +1,68 @@
 # Changelog
 
+# 3.2.0
+
+This release makes bidding in dutch auctions easier for MEV searchers and gives new RTokens being deployed the option to enable a variable target basket, or to be "reweightable". An RToken that is not reweightable cannot have its target basket changed in terms of quantities of target units.
+
+## Upgrade Steps
+
+Upgrade BasketHandler, BackingManager, and Distributor.
+
+Call `broker.setDutchTradeImplementation(newGnosisTrade)` with the new `DutchTrade` contract address.
+
+If this is the first upgrade to a >= 3.0.0 token, call `*.cacheComponents()` on all components.
+
+For plugins, upgrade all plugins that contain an appreciating asset (not FiatCollateral. AppreciatingFiatCollateral etc) OR contain multiple oracle feeds.
+
+## Core Protocol Contracts
+
+New governance param added: `reweightable`
+
+- `BackingManager`
+  - Track basket nonce last collateralized at end of `settleTrade()`
+- `BasketHandler` [+1 slot]
+  - Restrict `redeemCustom()` to nonces after `lastCollateralized`
+  - New `LastCollateralizedChanged()` event -- track to determine earliest basket nonce to use for `redeemCustom()`
+  - Add concept of a reweightable basket: a basket that can have its target amounts (once grouped by target unit) changed
+  - Add `reweightable()` view
+  - Add `forceSetPrimeBasket()` to allow setting a new prime basket without normalizing by USD value
+  - Alter `setPrimeBasket()` to enforce basket normalization for reweightable RTokens
+- `BackingManager`
+  - Minor gas optimization
+- `Deployer`
+  - New boolean field `reweightable` added to `IDeployer.DeploymentParams`
+- `Distributor`
+  - Minor gas optimization
+
+## Plugins
+
+### Assets
+
+- frax-eth: Add new `sFrxETH` plugin that leverages a curve EMA
+- stargate: Continue transfers of wrapper tokens if stargate rewards break
+- All plugins with variable refPerTok(): do not revert refresh() when underlying protocol reverts
+- All plugins with multiple chainlink feeds will now timeout over the maximum of the feeds' timeouts
+- Add ORACLE_TIMEOUT_BUFFER to all usages of chainlink feeds
+
+### Facades
+
+- `FacadeRead`
+  - Use avg prices instead of low prices in `backingOverview()` and `basketBreakdown()`
+
+### Trading
+
+- `DutchTrade`
+
+  - Add new `bidTradeCallback()` function to allow payment of tokens at the _end_ of the tx, removing need for flash loans. Example of how-to-use in `contracts/plugins/mocks/DutchTradeRouter.sol`
+
+  ### Facades
+
+  - `FacadeRead`
+    - Add `maxIssuableByAmounts()` function to provide an estimation independent of account balances
+
 # 3.1.0
 
-### Upgrade Steps -- Required
+## Upgrade Steps
 
 Upgrade all core contracts and _all_ assets. Most ERC20s do not need to be upgraded. Use `Deployer.deployRTokenAsset()` to create a new `RTokenAsset` instance. This asset should be swapped too.
 
@@ -16,7 +76,7 @@ Then, call `Broker.cacheComponents()`.
 
 Finally, call `Broker.setBatchTradeImplementation(newGnosisTrade)`.
 
-### Core Protocol Contracts
+## Core Protocol Contracts
 
 - `BackingManager` [+2 slots]
   - Replace use of `lotPrice()` with `price()` everywhere
@@ -48,7 +108,7 @@ Finally, call `Broker.setBatchTradeImplementation(newGnosisTrade)`.
   - Use correct era in `UnstakingStarted` event
   - Expose `draftEra` via `getDraftEra()` view
 
-### Facades
+## Facades
 
 - `FacadeMonitor`
   - Add `batchAuctionsDisabled()` view

… Audit Report 3_1_0 - Trust Security.pdf …ecurity - Reserve Audit Report 3_1_0.pdfaudits/Reserve Audit Report 3_1_0 - Trust Security.pdf renamed to audits/Trust Security - Reserve Audit Report 3_1_0.pdf audits/Reserve Audit Report 3_1_0 - Trust Security.pdf renamed to audits/Trust Security - Reserve Audit Report 3_1_0.pdf

@@ -88,6 +88,8 @@ export interface IFeeds {
   stETHUSD?: string
   wstETHstETHexr?: string
   cbETHETHexr?: string
+  ETHUSD?: string
+  wstETHstETH?: string
 }
 
 export interface IPools {
@@ -124,6 +126,7 @@ interface INetworkConfig {
   AAVE_V3_INCENTIVES_CONTROLLER?: string
   AAVE_V3_POOL?: string
   STARGATE_STAKING_CONTRACT?: string
+  CURVE_POOL_WETH_FRXETH?: string
 }
 
 export const networkConfig: { [key: string]: INetworkConfig } = {
@@ -220,6 +223,7 @@ export const networkConfig: { [key: string]: INetworkConfig } = {
       stETHUSD: '0xCfE54B5cD566aB89272946F602D76Ea879CAb4a8', // stETH/USD
       rETH: '0x536218f9E9Eb48863970252233c8F271f554C2d0', // rETH/ETH
       cbETH: '0xf017fcb346a1885194689ba23eff2fe6fa5c483b', // cbETH/ETH
+      frxETH: '0xc58f3385fbc1c8ad2c0c9a061d7c13b141d7a5df', // frxETH/ETH
     },
     AAVE_LENDING_POOL: '0x7d2768dE32b0b80b7a3454c06BdAc94A69DDc7A9',
     AAVE_INCENTIVES: '0xd784927Ff2f95ba542BfC824c8a8a98F3495f6b5',
@@ -240,6 +244,7 @@ export const networkConfig: { [key: string]: INetworkConfig } = {
     AAVE_V3_POOL: '0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2',
     AAVE_V3_INCENTIVES_CONTROLLER: '0x8164Cc65827dcFe994AB23944CBC90e0aa80bFcb',
     STARGATE_STAKING_CONTRACT: '0xB0D502E938ed5f4df2E681fE6E419ff29631d62b',
+    CURVE_POOL_WETH_FRXETH: '0x9c3b46c0ceb5b9e304fcd6d88fc50f7dd24b31bc',
   },
   '1': {
     name: 'mainnet',
@@ -345,6 +350,7 @@ export const networkConfig: { [key: string]: INetworkConfig } = {
     AAVE_V3_POOL: '0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2',
     AAVE_V3_INCENTIVES_CONTROLLER: '0x8164Cc65827dcFe994AB23944CBC90e0aa80bFcb',
     STARGATE_STAKING_CONTRACT: '0xB0D502E938ed5f4df2E681fE6E419ff29631d62b',
+    CURVE_POOL_WETH_FRXETH: '0x9c3b46c0ceb5b9e304fcd6d88fc50f7dd24b31bc',
   },
   '3': {
     name: 'tenderly',
@@ -445,6 +451,7 @@ export const networkConfig: { [key: string]: INetworkConfig } = {
     AAVE_V3_POOL: '0x87870Bca3F3fD6335C3F4ce8392D69350B4fA4E2',
     AAVE_V3_INCENTIVES_CONTROLLER: '0x8164Cc65827dcFe994AB23944CBC90e0aa80bFcb',
     STARGATE_STAKING_CONTRACT: '0xB0D502E938ed5f4df2E681fE6E419ff29631d62b',
+    CURVE_POOL_WETH_FRXETH: '0xa1F8A6807c402E4A15ef4EBa36528A3FED24E577',
   },
   '5': {
     name: 'goerli',
@@ -548,6 +555,7 @@ export const networkConfig: { [key: string]: INetworkConfig } = {
       aWETHv3: '0xD4a0e0b9149BCee3C920d2E00b5dE09138fd8bb7',
       acbETHv3: '0xcf3D55c10DB69f28fD1A75Bd73f3D8A2d9c595ad',
       sUSDbC: '0x4c80e24119cfb836cdf0a6b53dc23f04f7e652ca',
+      wstETH: '0xc1CBa3fCea344f92D9239c08C0568f6F2F0ee452',
       STG: '0xE3B53AF74a4BF62Ae5511055290838050bf764Df',
     },
     chainlinkFeeds: {
@@ -562,6 +570,9 @@ export const networkConfig: { [key: string]: INetworkConfig } = {
       wstETHstETHexr: '0xB88BAc61a4Ca37C43a3725912B1f472c9A5bc061', // 0.5%, 24hr
       cbETHETHexr: '0x868a501e68F3D1E89CfC0D22F6b22E8dabce5F04', // 0.5%, 24hr
       STG: '0x63Af8341b62E683B87bB540896bF283D96B4D385',
+      stETHETH: '0xf586d0728a47229e747d824a939000Cf21dEF5A0', // 0.5%, 24h
+      ETHUSD: '0x71041dddad3595F9CEd3DcCFBe3D1F4b0a16Bb70', // 0.15%, 20min
+      wstETHstETH: '0xB88BAc61a4Ca37C43a3725912B1f472c9A5bc061', // 0.5%, 24h
     },
     GNOSIS_EASY_AUCTION: '0xb1875Feaeea32Bbb02DE83D81772e07E37A40f02', // mock
     COMET_REWARDS: '0x123964802e6ABabBE1Bc9547D72Ef1B69B00A6b1',
@@ -596,6 +607,7 @@ export interface IConfig {
   unstakingDelay: BigNumber
   withdrawalLeak: BigNumber
   warmupPeriod: BigNumber
+  reweightable: boolean
   tradingDelay: BigNumber
   batchAuctionLength: BigNumber
   dutchAuctionLength: BigNumber

audits/Trust Security - Reserve Audit Report 3_2_0.pdf

@@ -56,6 +56,12 @@ export enum TradeKind {
   BATCH_AUCTION,
 }
 
+export enum BidType {
+  NONE,
+  CALLBACK,
+  TRANSFER,
+}
+
 export const FURNACE_DEST = '0x0000000000000000000000000000000000000001'
 export const STRSR_DEST = '0x0000000000000000000000000000000000000002'
 

common/configuration.ts

@@ -28,26 +28,46 @@ contract FacadeRead is IFacadeRead {
     /// @return {qRTok} How many RToken `account` can issue given current holdings
     /// @custom:static-call
     function maxIssuable(IRToken rToken, address account) external returns (uint256) {
+        (address[] memory erc20s, ) = rToken.main().basketHandler().quote(FIX_ONE, FLOOR);
+        uint256[] memory balances = new uint256[](erc20s.length);
+        for (uint256 i = 0; i < erc20s.length; ++i) {
+            balances[i] = IERC20(erc20s[i]).balanceOf(account);
+        }
+        return maxIssuableByAmounts(rToken, balances);
+    }
+
+    /// @param amounts {qTok} Amounts per basket ERC20
+    ///                       Assumes same order as current basket ERC20s given by bh.quote()
+    /// @return {qRTok} How many RToken `account` can issue given current holdings
+    /// @custom:static-call
+    function maxIssuableByAmounts(IRToken rToken, uint256[] memory amounts)
+        public
+        returns (uint256)
+    {
         IMain main = rToken.main();
 
         require(!main.frozen(), "frozen");
 
         // Poke Main
         main.assetRegistry().refresh();
 
-        // {BU}
-        BasketRange memory basketsHeld = main.basketHandler().basketsHeldBy(account);
-        uint192 needed = rToken.basketsNeeded();
-
-        int8 decimals = int8(rToken.decimals());
-
-        // return {qRTok} = {BU} * {(1 RToken) qRTok/BU)}
-        if (needed.eq(FIX_ZERO)) return basketsHeld.bottom.shiftl_toUint(decimals);
+        // Get basket ERC20s
+        IBasketHandler bh = main.basketHandler();
+        (address[] memory erc20s, uint256[] memory quantities) = bh.quote(FIX_ONE, CEIL);
 
-        uint192 totalSupply = shiftl_toFix(rToken.totalSupply(), -decimals); // {rTok}
+        // Compute how many baskets we can mint with the collateral amounts
+        uint192 baskets = type(uint192).max;
+        for (uint256 i = 0; i < erc20s.length; ++i) {
+            // {BU} = {tok} / {tok/BU}
+            uint192 inBUs = divuu(amounts[i], quantities[i]); // FLOOR
+            baskets = fixMin(baskets, inBUs);
+        }
 
-        // {qRTok} = {BU} * {rTok} / {BU} * {qRTok/rTok}
-        return basketsHeld.bottom.mulDiv(totalSupply, needed).shiftl_toUint(decimals);
+        // Convert baskets to RToken
+        // {qRTok} = {qRTok/BU} * {qRTok} / {BU}
+        uint256 totalSupply = rToken.totalSupply();
+        if (totalSupply == 0) return baskets;
+        return baskets.muluDivu(rToken.basketsNeeded(), rToken.totalSupply(), FLOOR);
     }
 
     /// Do no use inifite approvals.  Instead, use BasketHandler.quote() to determine the amount
@@ -210,13 +230,17 @@ contract FacadeRead is IFacadeRead {
         targets = new bytes32[](erc20s.length);
         for (uint256 i = 0; i < erc20s.length; ++i) {
             ICollateral coll = assetRegistry.toColl(IERC20(erc20s[i]));
+            targets[i] = coll.targetName();
+
             int8 decimals = int8(IERC20Metadata(erc20s[i]).decimals());
-            (uint192 lowPrice, ) = coll.price();
+            (uint192 low, uint192 high) = coll.price();
+            if (low == 0 || high == FIX_MAX) continue;
+
+            uint192 avg = (low + high) / 2; // {UoA/tok}
 
             // {UoA} = {qTok} * {tok/qTok} * {UoA/tok}
-            uoaAmts[i] = shiftl_toFix(deposits[i], -decimals).mul(lowPrice);
+            uoaAmts[i] = shiftl_toFix(deposits[i], -decimals).mul(avg);
             uoaSum += uoaAmts[i];
-            targets[i] = coll.targetName();
         }
 
         uoaShares = new uint192[](erc20s.length);
@@ -268,8 +292,7 @@ contract FacadeRead is IFacadeRead {
 
     /// @param draftEra {draftEra} The draft era to query unstakings for
     /// @param account The account for the query
-    /// @dev Use stRSR.draftRate() to convert {qDrafts} to {qRSR}
-    /// @return unstakings {qDrafts} All the pending StRSR unstakings for an account, in drafts
+    /// @return unstakings {qRSR} All the pending StRSR unstakings for an account, in RSR
     function pendingUnstakings(
         RTokenP1 rToken,
         uint256 draftEra,
@@ -278,6 +301,7 @@ contract FacadeRead is IFacadeRead {
         StRSRP1 stRSR = StRSRP1(address(rToken.main().stRSR()));
         uint256 left = stRSR.firstRemainingDraft(draftEra, account);
         uint256 right = stRSR.draftQueueLen(draftEra, account);
+        uint192 draftRate = stRSR.draftRate();
 
         unstakings = new Pending[](right - left);
         for (uint256 i = 0; i < right - left; i++) {
@@ -289,7 +313,8 @@ contract FacadeRead is IFacadeRead {
                 diff = drafts - prevDrafts;
             }
 
-            unstakings[i] = Pending(i + left, availableAt, diff);
+            // {qRSR} = {qDrafts} / {qDrafts/qRSR}
+            unstakings[i] = Pending(i + left, availableAt, diff.div(draftRate));
         }
     }
 
@@ -358,17 +383,19 @@ contract FacadeRead is IFacadeRead {
             for (uint256 i = 0; i < basketERC20s.length; i++) {
                 IAsset asset = reg.toAsset(IERC20(basketERC20s[i]));
 
-                // {UoA/tok}
-                (uint192 low, ) = asset.price();
-
                 // {tok}
                 uint192 needed = shiftl_toFix(quantities[i], -int8(asset.erc20Decimals()));
 
+                // {UoA/tok}
+                (uint192 low, uint192 high) = asset.price();
+                if (low == 0 || high == FIX_MAX) continue;
+                uint192 avg = (low + high) / 2;
+
                 // {UoA} = {UoA} + {tok}
-                uoaNeeded += needed.mul(low);
+                uoaNeeded += needed.mul(avg);
 
                 // {UoA} = {UoA} + {tok} * {UoA/tok}
-                uoaHeldInBaskets += fixMin(needed, asset.bal(address(bm))).mul(low);
+                uoaHeldInBaskets += fixMin(needed, asset.bal(address(bm))).mul(avg);
             }
 
             backing = uoaHeldInBaskets.div(uoaNeeded);
@@ -382,13 +409,14 @@ contract FacadeRead is IFacadeRead {
             rsrAsset.bal(address(rToken.main().stRSR()))
         );
 
-        (uint192 lowPrice, ) = rsrAsset.price();
+        (uint192 lowPrice, uint192 highPrice) = rsrAsset.price();
+        if (lowPrice > 0 && highPrice < FIX_MAX) {
+            // {UoA} = {tok} * {UoA/tok}
+            uint192 rsrUoA = rsrBal.mul((lowPrice + highPrice) / 2);
 
-        // {UoA} = {tok} * {UoA/tok}
-        uint192 rsrUoA = rsrBal.mul(lowPrice);
-
-        // {1} = {UoA} / {UoA}
-        overCollateralization = rsrUoA.div(uoaNeeded);
+            // {1} = {UoA} / {UoA}
+            overCollateralization = rsrUoA.div(uoaNeeded);
+        }
     }
 
     /// @return low {UoA/tok} The low price of the RToken as given by the relevant RTokenAsset

common/constants.ts

@@ -77,7 +77,7 @@ contract FacadeWrite is IFacadeWrite {
             }
 
             // Set basket
-            basketHandler.setPrimeBasket(basketERC20s, setup.weights);
+            basketHandler.forceSetPrimeBasket(basketERC20s, setup.weights);
             basketHandler.refreshBasket();
         }
 

contracts/facade/FacadeRead.sol

@@ -69,6 +69,9 @@ interface TestIAsset is IAsset {
     /// @return {s} Seconds that an oracle value is considered valid
     function oracleTimeout() external view returns (uint48);
 
+    /// @return {s} The maximum of all oracle timeouts on the plugin
+    function maxOracleTimeout() external view returns (uint48);
+
     /// @return {s} Seconds that the price() should decay over, after stale price
     function priceTimeout() external view returns (uint48);
 
@@ -136,4 +139,7 @@ interface TestICollateral is TestIAsset, ICollateral {
 
     /// @return The amount of time a collateral must be in IFFY status until being DISABLED
     function delayUntilDefault() external view returns (uint48);
+
+    /// @return The underlying refPerTok, likely not included in all collaterals however.
+    function underlyingRefPerTok() external view returns (uint192);
 }