v1.3 updates

pooleja · pooleja · commit 28fd8d1a820a · 2024-02-02T10:45:59.000-05:00
diff --git a/contracts/Delegation/OperatorDelegator.sol b/contracts/Delegation/OperatorDelegator.sol
@@ -225,6 +225,7 @@ contract OperatorDelegator is
         );
 
         // Send tokens to the specified address
+        // TODO: do not user balance of
         _token.safeTransfer(_sendToAddress, _token.balanceOf(address(this)));
     }
 
@@ -239,6 +240,8 @@ contract OperatorDelegator is
     function getStakedETHBalance() external view returns (uint256) {
         // TODO: Once withdrawals are enabled, allow this to handle pending withdraws and a potential negative share balance in the EigenPodManager ownershares        
         // TODO: Once upgraded to M2, add back in staked verified ETH, e.g. + uint256(strategyManager.stakerStrategyShares(address(this), strategyManager.beaconChainETHStrategy()))
+        // TODO: once M2 is released, there is a possibility someone could call Verify() to try and mess up the TVL calcs (we would double count the stakedButNotVerifiedEth + actual verified ETH in the EigenPod)
+        //       - we should track the validator node's verified status to ensure this doesn't happen
         return stakedButNotVerifiedEth + address(eigenPod).balance;
     }
 
diff --git a/contracts/Errors/Errors.sol b/contracts/Errors/Errors.sol
@@ -71,4 +71,16 @@ error OraclePriceExpired();
 error MismatchedArrayLengths();
 
 /// @dev Error when caller does not have Deposit Withdraw Pauser role
-error NotDepositWithdrawPauser();
+error NotDepositWithdrawPauser();
+
+/// @dev Error when an individual token TVL is over the max
+error MaxTokenTVLReached();
+
+/// @dev Error when Oracle price is invalid
+error InvalidOraclePrice();
+
+/// @dev Error when calling an invalid function
+error NotImplemented();
+
+/// @dev Error when calculating token amounts is invalid
+error InvalidTokenAmount();
diff --git a/contracts/IRestakeManager.sol b/contracts/IRestakeManager.sol
@@ -11,4 +11,9 @@ interface IRestakeManager {
         uint256 _amount
     ) external;
   function depositQueue() external view returns (IDepositQueue);
+
+  function calculateTVLs()
+        external
+        view
+        returns (uint256[][] memory, uint256[] memory, uint256);
 }
diff --git a/contracts/Oracle/Binance/IStakedTokenV2.sol b/contracts/Oracle/Binance/IStakedTokenV2.sol
@@ -0,0 +1,7 @@
+//SPDX-License-Identifier: MIT
+pragma solidity 0.8.19;
+
+/// @dev Interface to get exchange rate on wBETH
+interface IStakedTokenV2 {       
+  function exchangeRate() external view returns (uint256 _exchangeRate);
+}
diff --git a/contracts/Oracle/Binance/WBETHShim.sol b/contracts/Oracle/Binance/WBETHShim.sol
@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.19;
+
+import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "./WBETHShimStorage.sol";
+import "../../Errors/Errors.sol";
+
+/**
+ * @title   WBETHShim
+ * @dev     The contract hard codes the decimals to 18 decimals and returns the conversion rate of 1 mETH to ETH underlying the token in the wBETH protocol
+ * @notice  This contract is a shim that implements the Chainlink AggregatorV3Interface and returns pricing from the wBETH token contract
+ */
+
+contract WBETHShim is
+    Initializable,
+    WBETHShimStorageV1
+{
+    /// @dev Prevents implementation contract from being initialized.
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    /// @dev Initializes the contract with initial vars
+    function initialize(IStakedTokenV2 _wBETHToken) public initializer {
+        if(address(_wBETHToken) == address(0x0)) revert InvalidZeroInput();
+        
+        wBETHToken = _wBETHToken;   
+    }
+
+  function decimals() external pure returns (uint8){
+    return 18;
+  }
+
+  function description() external pure returns (string memory){
+    return "wBETH Chainlink Shim";
+  }
+
+  function version() external pure returns (uint256){
+    return 1;
+  }
+
+  /// @dev Historical data not available
+  function getRoundData(
+    uint80
+  ) external pure returns (uint80, int256, uint256, uint256, uint80){
+    revert NotImplemented();
+  }
+
+  function latestRoundData()
+    external
+    view
+    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound){
+      return _getWBETHData();
+    }
+
+  
+  /**
+   * @notice  This function gets the price of 1 mETH in ETH from the mETH staking contract with 18 decimal precision
+   * @dev     This function does not implement the full Chainlink AggregatorV3Interface 
+   * @return  roundId  0 - never returns valid round ID
+   * @return  answer  The conversion rate of 1 mETH to ETH.
+   * @return  startedAt  0 - never returns valid timestamp
+   * @return  updatedAt  The current timestamp.
+   * @return  answeredInRound  0 - never returns valid round ID
+   */
+  function _getWBETHData() internal view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound){
+    return (
+      0,
+      int256(wBETHToken.exchangeRate()),
+      0,
+      block.timestamp,
+      0
+    );
+  }
+}
diff --git a/contracts/Oracle/Binance/WBETHShimStorage.sol b/contracts/Oracle/Binance/WBETHShimStorage.sol
@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.19;
+
+import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
+import "./IStakedTokenV2.sol";
+
+abstract contract WBETHShimStorageV1 is AggregatorV3Interface{    
+    IStakedTokenV2 public wBETHToken;
+}
diff --git a/contracts/Oracle/Mantle/IMethStaking.sol b/contracts/Oracle/Mantle/IMethStaking.sol
@@ -0,0 +1,8 @@
+//SPDX-License-Identifier: MIT
+pragma solidity 0.8.19;
+
+import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+
+interface IMethStaking {       
+  function mETHToETH(uint256 mETHAmount) external view returns (uint256);
+}
diff --git a/contracts/Oracle/Mantle/METHShim.sol b/contracts/Oracle/Mantle/METHShim.sol
@@ -0,0 +1,77 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.19;
+
+import "@openzeppelin/contracts-upgradeable/security/ReentrancyGuardUpgradeable.sol";
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "./METHShimStorage.sol";
+import "../../Errors/Errors.sol";
+
+/**
+ * @title   METHShim
+ * @dev     The contract hard codes the decimals to 18 decimals and returns the conversion rate of 1 mETH to ETH underlying the token in the mETH protocol
+ * @notice  This contract is a shim that implements the Chainlink AggregatorV3Interface and returns pricing from the mETH staking contract
+ */
+
+contract METHShim is
+    Initializable,
+    METHShimStorageV1
+{
+    /// @dev Prevents implementation contract from being initialized.
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    /// @dev Initializes the contract with initial vars
+    function initialize(IMethStaking _methStaking) public initializer {
+        if(address(_methStaking) == address(0x0)) revert InvalidZeroInput();
+        
+        methStaking = _methStaking;   
+    }
+
+  function decimals() external pure returns (uint8){
+    return 18;
+  }
+
+  function description() external pure returns (string memory){
+    return "METH Chainlink Shim";
+  }
+
+  function version() external pure returns (uint256){
+    return 1;
+  }
+
+  /// @dev Historical data not available
+  function getRoundData(
+    uint80
+  ) external pure returns (uint80, int256, uint256, uint256, uint80){
+    revert NotImplemented();
+  }
+
+  function latestRoundData()
+    external
+    view
+    returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound){
+      return _getMETHData();
+    }
+
+  
+  /**
+   * @notice  This function gets the price of 1 mETH in ETH from the mETH staking contract with 18 decimal precision
+   * @dev     This function does not implement the full Chainlink AggregatorV3Interface 
+   * @return  roundId  0 - never returns valid round ID
+   * @return  answer  The conversion rate of 1 mETH to ETH.
+   * @return  startedAt  0 - never returns valid timestamp
+   * @return  updatedAt  The current timestamp.
+   * @return  answeredInRound  0 - never returns valid round ID
+   */
+  function _getMETHData() internal view returns (uint80 roundId, int256 answer, uint256 startedAt, uint256 updatedAt, uint80 answeredInRound){
+    return (
+      0,
+      int256(methStaking.mETHToETH(1 ether)),
+      0,
+      block.timestamp,
+      0
+    );
+  }
+}
diff --git a/contracts/Oracle/Mantle/METHShimStorage.sol b/contracts/Oracle/Mantle/METHShimStorage.sol
@@ -0,0 +1,9 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.19;
+
+import "@chainlink/contracts/src/v0.8/interfaces/AggregatorV3Interface.sol";
+import "./IMethStaking.sol";
+
+abstract contract METHShimStorageV1 is AggregatorV3Interface{    
+    IMethStaking public methStaking;
+}
diff --git a/contracts/Oracle/RenzoOracle.sol b/contracts/Oracle/RenzoOracle.sol
@@ -70,6 +70,7 @@ contract RenzoOracle is
 
         (, int256 price, , uint256 timestamp, ) = oracle.latestRoundData();
         if(timestamp < block.timestamp - MAX_TIME_WINDOW) revert OraclePriceExpired();
+        if(price <= 0) revert InvalidOraclePrice();
 
         // Price is times 10**18 ensure value amount is scaled
         return uint256(price) * _balance / SCALE_FACTOR;
@@ -83,6 +84,7 @@ contract RenzoOracle is
 
         (, int256 price, , uint256 timestamp, ) = oracle.latestRoundData();
         if(timestamp < block.timestamp - MAX_TIME_WINDOW) revert OraclePriceExpired();
+        if(price <= 0) revert InvalidOraclePrice();
 
         // Price is times 10**18 ensure token amount is scaled
         return _value * SCALE_FACTOR / uint256(price);
@@ -120,12 +122,22 @@ contract RenzoOracle is
         uint256 newEzETHSupply = (_existingEzETHSupply * SCALE_FACTOR) / (SCALE_FACTOR - inflationPercentaage);
 
         // Subtract the old supply from the new supply to get the amount to mint
-        return newEzETHSupply - _existingEzETHSupply;
+        uint256 mintAmount = newEzETHSupply - _existingEzETHSupply;
+
+        // Sanity check
+        if(mintAmount == 0) revert InvalidTokenAmount();
+
+        return mintAmount;
     }
 
     // Given the amount of ezETH to burn, the supply of ezETH, and the total value in the protocol, determine amount of value to return to user    
     function calculateRedeemAmount(uint256 _ezETHBeingBurned, uint256 _existingEzETHSupply, uint256 _currentValueInProtocol) external pure returns (uint256) {
       // This is just returning the percentage of TVL that matches the percentage of ezETH being burned 
-      return (_currentValueInProtocol * _ezETHBeingBurned) / _existingEzETHSupply;
+      uint256 redeemAmount = (_currentValueInProtocol * _ezETHBeingBurned) / _existingEzETHSupply;
+
+      // Sanity check
+      if(redeemAmount == 0) revert InvalidTokenAmount();
+
+      return redeemAmount;
     }
 }
diff --git a/contracts/RateProvider/BalancerRateProvider.sol b/contracts/RateProvider/BalancerRateProvider.sol
@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.19;
+
+import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
+import "./IRateProvider.sol";
+import "../Errors/Errors.sol";
+import "./BalancerRateProviderStorage.sol";
+
+contract BalancerRateProvider is  Initializable, IRateProvider, BalancerRateProviderStorageV1 {
+
+    /// @dev Prevents implementation contract from being initialized.
+    /// @custom:oz-upgrades-unsafe-allow constructor
+    constructor() {
+        _disableInitializers();
+    }
+
+    /// @dev Initializes the contract with initial vars
+    function initialize(IRestakeManager _restakeManager, IERC20Upgradeable _ezETHToken) public initializer {
+        if(address(_restakeManager) == address(0x0)) revert InvalidZeroInput(); 
+        if(address(_ezETHToken) == address(0x0)) revert InvalidZeroInput(); 
+        
+        restakeManager = _restakeManager;   
+        ezETHToken = _ezETHToken;
+    }
+
+    /// @dev Returns the current rate of ezETH in ETH
+    function getRate() external view returns (uint256) {
+        // Get the total TVL priced in ETH from restakeManager
+        ( , , uint256 totalTVL) = restakeManager.calculateTVLs();
+
+        // Get the total supply of the ezETH token
+        uint256 totalSupply = ezETHToken.totalSupply();
+
+        // Sanity check
+        if(totalSupply == 0 || totalTVL == 0) revert InvalidZeroInput();
+
+        // Return the rate
+        return 10**18 * totalTVL / totalSupply;
+    }
+}
diff --git a/contracts/RateProvider/BalancerRateProviderStorage.sol b/contracts/RateProvider/BalancerRateProviderStorage.sol
@@ -0,0 +1,13 @@
+// SPDX-License-Identifier: BUSL-1.1
+pragma solidity 0.8.19;
+
+import "@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol";
+import "../IRestakeManager.sol";
+
+abstract contract BalancerRateProviderStorageV1 {    
+    /// @dev reference to the RestakeManager contract
+    IRestakeManager public restakeManager;
+
+    /// @dev reference to the ezETH token contract
+    IERC20Upgradeable public ezETHToken;
+}
diff --git a/contracts/RateProvider/IRateProvider.sol b/contracts/RateProvider/IRateProvider.sol
@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+pragma solidity 0.8.19;
+
+interface IRateProvider {
+    function getRate() external view returns (uint256);
+}
diff --git a/contracts/RestakeManager.sol b/contracts/RestakeManager.sol
diff --git a/contracts/RestakeManagerStorage.sol b/contracts/RestakeManagerStorage.sol
diff --git a/contracts/Rewards/RewardHandler.sol b/contracts/Rewards/RewardHandler.sol

Original file line number	Diff line number	Diff line change
`@@ -225,6 +225,7 @@ contract OperatorDelegator is`
`225`	`225`	`);`
`226`	`226`
`227`	`227`	`// Send tokens to the specified address`
	`228`	`+ // TODO: do not user balance of`
`228`	`229`	`_token.safeTransfer(_sendToAddress, _token.balanceOf(address(this)));`
`229`	`230`	`}`
`230`	`231`
`@@ -239,6 +240,8 @@ contract OperatorDelegator is`
`239`	`240`	`function getStakedETHBalance() external view returns (uint256) {`
`240`	`241`	`// TODO: Once withdrawals are enabled, allow this to handle pending withdraws and a potential negative share balance in the EigenPodManager ownershares`
`241`	`242`	`// TODO: Once upgraded to M2, add back in staked verified ETH, e.g. + uint256(strategyManager.stakerStrategyShares(address(this), strategyManager.beaconChainETHStrategy()))`
	`243`	`+ // TODO: once M2 is released, there is a possibility someone could call Verify() to try and mess up the TVL calcs (we would double count the stakedButNotVerifiedEth + actual verified ETH in the EigenPod)`
	`244`	`+ // - we should track the validator node's verified status to ensure this doesn't happen`
`242`	`245`	`return stakedButNotVerifiedEth + address(eigenPod).balance;`
`243`	`246`	`}`
`244`	`247`