Add permissioned rebase (#2889)

* Add permissioned rebase

* Remove public rebase

Author: shahthepro

brownie/addresses.py

@@ -213,7 +213,7 @@
 
 ## Safe Modules
 ETHEREUM_BRIDGE_HELPER_MODULE = "0x630C1763D38AbE76301F58909fa174E7B84A7ECD"
-BASE_BRIDGE_HELPER_MODULE = "0x362DBD4Ff662b2E2b05b9cEDC91da2Dd2c655b26"
+BASE_BRIDGE_HELPER_MODULE = "0xe3B3b4Fc77505EcfAACf6dD21619a8Cc12fcc501"
 PLUME_BRIDGE_HELPER_MODULE = "0xAc58C88349e00509FEc216E1B61d13b43315E18D"
 
 ## Morpho V2 (Base) Crosschain strategy

contracts/contracts/interfaces/IVault.sol

@@ -18,7 +18,6 @@ interface IVault {
     event RebaseUnpaused();
     event VaultBufferUpdated(uint256 _vaultBuffer);
     event AllocateThresholdUpdated(uint256 _threshold);
-    event RebaseThresholdUpdated(uint256 _threshold);
     event StrategistUpdated(address _address);
     event MaxSupplyDiffChanged(uint256 maxSupplyDiff);
     event YieldDistribution(address _to, uint256 _yield, uint256 _fee);
@@ -58,14 +57,14 @@ interface IVault {
 
     function autoAllocateThreshold() external view returns (uint256);
 
-    function setRebaseThreshold(uint256 _threshold) external;
-
-    function rebaseThreshold() external view returns (uint256);
-
     function setStrategistAddr(address _address) external;
 
     function strategistAddr() external view returns (address);
 
+    function setOperatorAddr(address _operator) external;
+
+    function operatorAddr() external view returns (address);
+
     function setMaxSupplyDiff(uint256 _maxSupplyDiff) external;
 
     function maxSupplyDiff() external view returns (uint256);

contracts/contracts/vault/VaultAdmin.sol

@@ -63,16 +63,6 @@ abstract contract VaultAdmin is VaultCore {
         emit AllocateThresholdUpdated(_threshold);
     }
 
-    /**
-     * @notice Set a minimum amount of OTokens in a mint or redeem that triggers a
-     * rebase
-     * @param _threshold OToken amount with 18 fixed decimals.
-     */
-    function setRebaseThreshold(uint256 _threshold) external onlyGovernor {
-        rebaseThreshold = _threshold;
-        emit RebaseThresholdUpdated(_threshold);
-    }
-
     /**
      * @notice Set address of Strategist
      * @param _address Address of Strategist
@@ -82,6 +72,16 @@ abstract contract VaultAdmin is VaultCore {
         emit StrategistUpdated(_address);
     }
 
+    /**
+     * @notice Set the address authorized to call `rebase()`.
+     * @param _operator New operator address. May be set to the zero address
+     *                  to disable operator-initiated rebases.
+     */
+    function setOperatorAddr(address _operator) external onlyGovernor {
+        operatorAddr = _operator;
+        emit OperatorUpdated(_operator);
+    }
+
     /**
      * @notice Set the default Strategy for asset, i.e. the one which
      * the asset will be automatically allocated to and withdrawn from

contracts/contracts/vault/VaultCore.sol

@@ -79,11 +79,6 @@ abstract contract VaultCore is VaultInitializer {
 
         emit Mint(msg.sender, scaledAmount);
 
-        // Rebase must happen before any transfers occur.
-        if (!rebasePaused && scaledAmount >= rebaseThreshold) {
-            _rebase();
-        }
-
         // Mint oTokens
         oToken.mint(msg.sender, scaledAmount);
 
@@ -218,7 +213,7 @@ abstract contract VaultCore is VaultInitializer {
         oToken.burn(msg.sender, _amount);
 
         // Prevent withdrawal if the vault is solvent by more than the allowed percentage
-        _postRedeem(_amount);
+        _postRedeem();
 
         emit WithdrawalRequested(msg.sender, requestId, _amount, queued);
     }
@@ -262,7 +257,7 @@ abstract contract VaultCore is VaultInitializer {
         IERC20(asset).safeTransfer(msg.sender, amount);
 
         // Prevent insolvency
-        _postRedeem(amount.scaleBy(18, assetDecimals));
+        _postRedeem();
     }
 
     // slither-disable-end reentrancy-no-eth
@@ -303,7 +298,7 @@ abstract contract VaultCore is VaultInitializer {
         IERC20(asset).safeTransfer(msg.sender, totalAmount);
 
         // Prevent insolvency
-        _postRedeem(totalAmount.scaleBy(18, assetDecimals));
+        _postRedeem();
 
         return (amounts, totalAmount);
     }
@@ -341,17 +336,12 @@ abstract contract VaultCore is VaultInitializer {
         return StableMath.scaleBy(request.amount, assetDecimals, 18);
     }
 
-    function _postRedeem(uint256 _amount) internal {
+    function _postRedeem() internal view {
         // Until we can prove that we won't affect the prices of our asset
         // by withdrawing them, this should be here.
         // It's possible that a strategy was off on its asset total, perhaps
         // a reward token sold for more or for less than anticipated.
-        uint256 totalUnits = 0;
-        if (_amount >= rebaseThreshold && !rebasePaused) {
-            totalUnits = _rebase();
-        } else {
-            totalUnits = _totalValue();
-        }
+        uint256 totalUnits = _totalValue();
 
         // Check that the OTokens are backed by enough asset
         if (maxSupplyDiff > 0) {
@@ -420,8 +410,15 @@ abstract contract VaultCore is VaultInitializer {
     /**
      * @notice Calculate the total value of asset held by the Vault and all
      *      strategies and update the supply of OTokens.
+     * @dev Restricted to the Operator, Strategist or Governor.
      */
     function rebase() external virtual nonReentrant {
+        require(
+            msg.sender == operatorAddr ||
+                msg.sender == strategistAddr ||
+                isGovernor(),
+            "Caller not authorized"
+        );
         _rebase();
     }
 

contracts/contracts/vault/VaultInitializer.sol

@@ -24,8 +24,6 @@ abstract contract VaultInitializer is VaultStorage {
         vaultBuffer = 0;
         // Initial allocate threshold of 25,000 OUSD
         autoAllocateThreshold = 25000e18;
-        // Threshold for rebasing
-        rebaseThreshold = 1000e18;
         // Initialize all strategies
         allStrategies = new address[](0);
         // Start with drip duration: 7 days

contracts/contracts/vault/VaultStorage.sol

@@ -33,7 +33,6 @@ abstract contract VaultStorage is Initializable, Governable {
     event RebaseUnpaused();
     event VaultBufferUpdated(uint256 _vaultBuffer);
     event AllocateThresholdUpdated(uint256 _threshold);
-    event RebaseThresholdUpdated(uint256 _threshold);
     event StrategistUpdated(address _address);
     event MaxSupplyDiffChanged(uint256 maxSupplyDiff);
     event YieldDistribution(address _to, uint256 _yield, uint256 _fee);
@@ -43,6 +42,7 @@ abstract contract VaultStorage is Initializable, Governable {
     event StrategyRemovedFromMintWhitelist(address indexed strategy);
     event RebasePerSecondMaxChanged(uint256 rebaseRatePerSecond);
     event DripDurationChanged(uint256 dripDuration);
+    event OperatorUpdated(address newOperator);
     event WithdrawalRequested(
         address indexed _withdrawer,
         uint256 indexed _requestId,
@@ -91,8 +91,9 @@ abstract contract VaultStorage is Initializable, Governable {
     uint256 public vaultBuffer;
     /// @notice OToken mints over this amount automatically allocate funds. 18 decimals.
     uint256 public autoAllocateThreshold;
-    /// @notice OToken mints over this amount automatically rebase. 18 decimals.
-    uint256 public rebaseThreshold;
+    /// @dev Deprecated. Was the auto-rebase trigger threshold for mint/redeem.
+    ///      Storage slot retained for proxy compatibility; no longer read or written.
+    uint256 internal __deprecatedRebaseThreshold;
 
     /// @dev Address of the OToken token. eg OUSD or OETH.
     OUSD public oToken;
@@ -202,8 +203,12 @@ abstract contract VaultStorage is Initializable, Governable {
     /// @notice Default strategy for asset
     address public defaultStrategy;
 
+    /// @notice Address authorized to call `rebase()` directly. The Governor
+    ///         and Strategist are always allowed in addition to this address.
+    address public operatorAddr;
+
     // For future use
-    uint256[42] private __gap;
+    uint256[41] private __gap;
 
     /// @notice Index of WETH asset in allAssets array
     /// Legacy OETHVaultCore code, relocated here for vault consistency.

contracts/deploy/base/049_vault_permissioned_rebase.js

@@ -0,0 +1,40 @@
+const { deployOnBase } = require("../../utils/deploy-l2");
+const { deployWithConfirmation } = require("../../utils/deploy");
+const addresses = require("../../utils/addresses");
+
+module.exports = deployOnBase(
+  {
+    deployName: "049_vault_permissioned_rebase",
+  },
+  async ({ ethers }) => {
+    // 1. Deploy new OETHBaseVault implementation
+    const dOETHbVault = await deployWithConfirmation(
+      "OETHBaseVault",
+      [addresses.base.WETH],
+      "OETHBaseVault",
+      true
+    );
+
+    const cOETHbVaultProxy = await ethers.getContract("OETHBaseVaultProxy");
+    const cOETHbVault = await ethers.getContractAt(
+      "IVault",
+      cOETHbVaultProxy.address
+    );
+
+    return {
+      name: "Upgrade OETHBaseVault: permissioned rebase, drop auto-rebase triggers",
+      actions: [
+        {
+          contract: cOETHbVaultProxy,
+          signature: "upgradeTo(address)",
+          args: [dOETHbVault.address],
+        },
+        {
+          contract: cOETHbVault,
+          signature: "setOperatorAddr(address)",
+          args: [addresses.multichainStrategist],
+        },
+      ],
+    };
+  }
+);

contracts/deploy/mainnet/193_vault_permissioned_rebase.js

@@ -0,0 +1,61 @@
+const addresses = require("../../utils/addresses");
+const { deploymentWithGovernanceProposal } = require("../../utils/deploy");
+
+module.exports = deploymentWithGovernanceProposal(
+  {
+    deployName: "193_vault_permissioned_rebase",
+    forceDeploy: false,
+    reduceQueueTime: true,
+    deployerIsProposer: false,
+    proposalId: "",
+  },
+  async ({ deployWithConfirmation }) => {
+    // 1. Deploy new OUSD Vault implementation
+    const dOUSDVault = await deployWithConfirmation("OUSDVault", [
+      addresses.mainnet.USDC,
+    ]);
+
+    // 2. Deploy new OETH Vault implementation
+    const dOETHVault = await deployWithConfirmation("OETHVault", [
+      addresses.mainnet.WETH,
+    ]);
+
+    const cVaultProxy = await ethers.getContract("VaultProxy");
+    const cOUSDVault = await ethers.getContractAt(
+      "IVault",
+      cVaultProxy.address
+    );
+
+    const cOETHVaultProxy = await ethers.getContract("OETHVaultProxy");
+    const cOETHVault = await ethers.getContractAt(
+      "IVault",
+      cOETHVaultProxy.address
+    );
+
+    return {
+      name: "Upgrade OUSD and OETH vaults: permissioned rebase, drop auto-rebase triggers",
+      actions: [
+        {
+          contract: cVaultProxy,
+          signature: "upgradeTo(address)",
+          args: [dOUSDVault.address],
+        },
+        {
+          contract: cOUSDVault,
+          signature: "setOperatorAddr(address)",
+          args: [addresses.multichainStrategist],
+        },
+        {
+          contract: cOETHVaultProxy,
+          signature: "upgradeTo(address)",
+          args: [dOETHVault.address],
+        },
+        {
+          contract: cOETHVault,
+          signature: "setOperatorAddr(address)",
+          args: [addresses.multichainStrategist],
+        },
+      ],
+    };
+  }
+);

contracts/deploy/plume/002_core.js

@@ -178,13 +178,10 @@ module.exports = deployOnPlume(
           signature: "setWithdrawalClaimDelay(uint256)",
           args: [24 * 60 * 60],
         },
-        {
-          // Set rebase threshold
-          contract: cOETHpVault,
-          signature: "setRebaseThreshold(uint256)",
-          // TODO: Change this after Vault is fixed
-          args: [parseUnits("10000", 18)], // 10000 OETHp
-        },
+        // setRebaseThreshold removed: rebaseThreshold is deprecated and the
+        // setter no longer exists on the vault. This script has already run
+        // on Plume mainnet so the action is preserved here as a comment for
+        // historical context only.
         {
           // Set strategist
           contract: cOETHpVault,

contracts/deploy/plume/005_vault_config.js

@@ -1,5 +1,4 @@
 const { deployOnPlume } = require("../../utils/deploy-l2");
-const { parseUnits } = require("ethers/lib/utils.js");
 
 module.exports = deployOnPlume(
   {
@@ -28,12 +27,8 @@ module.exports = deployOnPlume(
           signature: "setTrusteeFeeBps(uint256)",
           args: [2000], // 20%
         },
-        {
-          // Set rebase threshold
-          contract: cOETHpVault,
-          signature: "setRebaseThreshold(uint256)",
-          args: [parseUnits("1", 18)], // 1 OETHp
-        },
+        // setRebaseThreshold removed: rebaseThreshold deprecated and the
+        // setter no longer exists on the vault. OETP is winding down.
       ],
     };
   }