Market Reserve Automation

.github/workflows/base-integration.yml

@@ -34,6 +34,30 @@ jobs:
            max_attempts: 3
            command: time forge test --match-contract LiveSystem -vvv --ffi
 
+  reserve-automation-integration-tests:
+    name: Reserve Automation Integration Tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v2
+        with:
+          submodules: recursive
+
+      - name: Setup Environment
+        uses: ./.github/actions
+
+      - name: Give write permissions
+        run: chmod -R +x proposals/mips/
+
+      - name: Reserve Automation Integration Tests
+        uses: nick-fields/retry@v3
+        with:
+           polling_interval_seconds: 30
+           retry_wait_seconds: 60
+           timeout_minutes: 50
+           max_attempts: 3
+           command: time forge test --match-contract 'ReserveAutomationLiveIntegrationTest|ERC20HoldingDepositLiveIntegrationTest' -vvv --fork-url base
+
   fee-splitter-xwell-integration-tests:
     name: Fee Splitter/xWell Integration Test
     runs-on: ubuntu-latest

proposals/mips/mip-reserve-automation/8453.json

@@ -0,0 +1,14 @@
+[
+    "MOONWELL_USDC",
+    "MOONWELL_USDBC",
+    "MOONWELL_DAI",
+    "MOONWELL_WETH",
+    "MOONWELL_cbETH",
+    "MOONWELL_wstETH",
+    "MOONWELL_rETH",
+    "MOONWELL_AERO",
+    "MOONWELL_weETH",
+    "MOONWELL_cbBTC",
+    "MOONWELL_EURC",
+    "MOONWELL_wrsETH"
+]

proposals/mips/mip-reserve-automation/reserveAutomationDeploy.sol

@@ -0,0 +1,285 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+pragma solidity 0.8.19;
+
+import {ITransparentUpgradeableProxy} from "@openzeppelin-contracts/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+import {ProxyAdmin} from "@openzeppelin-contracts/contracts/proxy/transparent/ProxyAdmin.sol";
+import {Script} from "@forge-std/Script.sol";
+import {Test} from "@forge-std/Test.sol";
+import {console} from "@forge-std/console.sol";
+
+import "@protocol/utils/ChainIds.sol";
+
+import {AutomationDeploy} from "@protocol/market/AutomationDeploy.sol";
+import {ReserveAutomation} from "@protocol/market/ReserveAutomation.sol";
+import {ERC20HoldingDeposit} from "@protocol/market/ERC20HoldingDeposit.sol";
+import {ChainIds, BASE_FORK_ID} from "@utils/ChainIds.sol";
+import {AllChainAddresses as Addresses} from "@proposals/Addresses.sol";
+
+/// how to run locally:
+///       forge script proposals/mips/mip-reserve-automation/reserveAutomationDeploy.sol:ReserveAutomationDeploy --rpc-url base
+contract ReserveAutomationDeploy is Script, Test {
+    using ChainIds for uint256;
+
+    /// @notice the name of the proposal
+    string public constant NAME = "Reserve Automation Deployment";
+
+    AutomationDeploy private _deployer;
+    Addresses internal _addresses;
+
+    function setUp() public virtual {
+        _addresses = new Addresses();
+    }
+
+    /// @notice array of mToken names to deploy automation for
+    function _getMTokens(
+        uint256 chainId
+    ) internal view returns (string[] memory) {
+        string memory file = vm.readFile(
+            string.concat(
+                "./proposals/mips/mip-reserve-automation/",
+                string.concat(vm.toString(chainId), ".json")
+            )
+        );
+        string[] memory mTokens = abi.decode(vm.parseJson(file), (string[]));
+        return mTokens;
+    }
+
+    function run() public {
+        vm.startBroadcast();
+
+        deploy(_addresses);
+
+        vm.stopBroadcast();
+
+        _addresses.printAddresses();
+
+        validate(_addresses);
+    }
+
+    function deploy(Addresses addresses) public {
+        address temporalGov = addresses.getAddress("TEMPORAL_GOVERNOR");
+        address pauseGuardian = addresses.getAddress("PAUSE_GUARDIAN");
+        address xWellProxy = addresses.getAddress("xWELL_PROXY");
+
+        _deployer = new AutomationDeploy();
+
+        /// Deploy ERC20HoldingDeposit for xWELL
+        address holdingDeposit = _deployer.deployERC20HoldingDeposit(
+            xWellProxy,
+            temporalGov
+        );
+
+        addresses.addAddress("RESERVE_WELL_HOLDING_DEPOSIT", holdingDeposit);
+
+        /// Deploy ReserveAutomation for each mToken
+        string[] memory mTokens = _getMTokens(block.chainid);
+        for (uint256 i = 0; i < mTokens.length; i++) {
+            string memory mTokenName = mTokens[i];
+            string memory underlyingName = _getUnderlyingName(mTokenName);
+            string memory oracleName = _getOracleName(underlyingName);
+            string memory reserveAutomationIdentifier = string.concat(
+                "RESERVE_AUTOMATION_",
+                _stripMoonwellPrefix(mTokenName)
+            );
+
+            /// avoid redeploying a contract that already exists
+            if (!addresses.isAddressSet(reserveAutomationIdentifier)) {
+                ReserveAutomation.InitParams memory params = ReserveAutomation
+                    .InitParams({
+                        recipientAddress: holdingDeposit,
+                        wellToken: xWellProxy,
+                        reserveAsset: addresses.getAddress(underlyingName),
+                        wellChainlinkFeed: addresses.getAddress(
+                            "CHAINLINK_WELL_USD"
+                        ),
+                        reserveChainlinkFeed: addresses.getAddress(oracleName),
+                        owner: temporalGov,
+                        mTokenMarket: addresses.getAddress(mTokenName),
+                        guardian: pauseGuardian
+                    });
+
+                address automation = _deployer.deployReserveAutomation(params);
+
+                addresses.addAddress(reserveAutomationIdentifier, automation);
+            }
+        }
+    }
+
+    function validate(Addresses addresses) public view {
+        address temporalGov = addresses.getAddress("TEMPORAL_GOVERNOR");
+        address pauseGuardian = addresses.getAddress("PAUSE_GUARDIAN");
+        address xWellProxy = addresses.getAddress("xWELL_PROXY");
+        address holdingDeposit = addresses.getAddress(
+            "RESERVE_WELL_HOLDING_DEPOSIT"
+        );
+
+        /// Validate ERC20HoldingDeposit
+        assertEq(
+            ERC20HoldingDeposit(holdingDeposit).token(),
+            xWellProxy,
+            "incorrect holding deposit token"
+        );
+        assertEq(
+            ERC20HoldingDeposit(holdingDeposit).owner(),
+            temporalGov,
+            "incorrect holding deposit owner"
+        );
+
+        /// Validate ReserveAutomation for each mToken
+        string[] memory mTokens = _getMTokens(block.chainid);
+        for (uint256 i = 0; i < mTokens.length; i++) {
+            string memory mTokenName = mTokens[i];
+            string memory underlyingName = _getUnderlyingName(mTokenName);
+            string memory oracleName = _getOracleName(underlyingName);
+
+            address automation = addresses.getAddress(
+                string.concat(
+                    "RESERVE_AUTOMATION_",
+                    _stripMoonwellPrefix(mTokenName)
+                )
+            );
+
+            ReserveAutomation reserve = ReserveAutomation(automation);
+
+            assertEq(
+                reserve.owner(),
+                temporalGov,
+                string.concat("incorrect owner for ", mTokenName)
+            );
+            assertEq(
+                reserve.guardian(),
+                pauseGuardian,
+                string.concat("incorrect guardian for ", mTokenName)
+            );
+            assertEq(
+                reserve.recipientAddress(),
+                holdingDeposit,
+                string.concat("incorrect recipient address for ", mTokenName)
+            );
+            assertEq(
+                reserve.wellToken(),
+                xWellProxy,
+                string.concat("incorrect well token for ", mTokenName)
+            );
+            assertEq(
+                reserve.reserveAsset(),
+                addresses.getAddress(underlyingName),
+                string.concat("incorrect reserve asset for ", mTokenName)
+            );
+            assertEq(
+                reserve.wellChainlinkFeed(),
+                addresses.getAddress("CHAINLINK_WELL_USD"),
+                string.concat("incorrect well chainlink feed for ", mTokenName)
+            );
+            assertEq(
+                reserve.reserveChainlinkFeed(),
+                addresses.getAddress(oracleName),
+                string.concat(
+                    "incorrect reserve chainlink feed for ",
+                    mTokenName
+                )
+            );
+            assertEq(
+                reserve.mTokenMarket(),
+                addresses.getAddress(mTokenName),
+                string.concat("incorrect mToken market for ", mTokenName)
+            );
+        }
+    }
+
+    /// @notice Helper function to get the underlying token name from an mToken name
+    /// @param mTokenName The name of the mToken
+    /// @return The name of the underlying token
+    function _getUnderlyingName(
+        string memory mTokenName
+    ) internal pure returns (string memory) {
+        string memory token = _stripMoonwellPrefix(mTokenName);
+        if (keccak256(bytes(token)) == keccak256(bytes("USDBC"))) {
+            return "USDBC";
+        } else if (keccak256(bytes(token)) == keccak256(bytes("USDC"))) {
+            return "USDC";
+        } else if (keccak256(bytes(token)) == keccak256(bytes("DAI"))) {
+            return "DAI";
+        } else if (keccak256(bytes(token)) == keccak256(bytes("WETH"))) {
+            return "WETH";
+        } else if (keccak256(bytes(token)) == keccak256(bytes("cbETH"))) {
+            return "cbETH";
+        } else if (keccak256(bytes(token)) == keccak256(bytes("wstETH"))) {
+            return "wstETH";
+        } else if (keccak256(bytes(token)) == keccak256(bytes("rETH"))) {
+            return "rETH";
+        } else if (keccak256(bytes(token)) == keccak256(bytes("AERO"))) {
+            return "AERO";
+        } else if (keccak256(bytes(token)) == keccak256(bytes("weETH"))) {
+            return "weETH";
+        } else if (keccak256(bytes(token)) == keccak256(bytes("cbBTC"))) {
+            return "cbBTC";
+        } else if (keccak256(bytes(token)) == keccak256(bytes("EURC"))) {
+            return "EURC";
+        } else if (keccak256(bytes(token)) == keccak256(bytes("wrsETH"))) {
+            return "wrsETH";
+        } else if (keccak256(bytes(token)) == keccak256(bytes("WELL"))) {
+            return "xWELL_PROXY";
+        } else {
+            revert("unknown mToken");
+        }
+    }
+
+    /// @notice Helper function to get the oracle name for a token
+    /// @param tokenName The name of the token
+    /// @return The name of the oracle for the token
+    function _getOracleName(
+        string memory tokenName
+    ) internal pure returns (string memory) {
+        if (
+            keccak256(bytes(tokenName)) == keccak256(bytes("USDBC")) ||
+            keccak256(bytes(tokenName)) == keccak256(bytes("USDC"))
+        ) {
+            return "USDC_ORACLE";
+        } else if (keccak256(bytes(tokenName)) == keccak256(bytes("DAI"))) {
+            return "DAI_ORACLE";
+        } else if (keccak256(bytes(tokenName)) == keccak256(bytes("WETH"))) {
+            return "CHAINLINK_ETH_USD";
+        } else if (keccak256(bytes(tokenName)) == keccak256(bytes("cbETH"))) {
+            return "cbETH_ORACLE";
+        } else if (keccak256(bytes(tokenName)) == keccak256(bytes("wstETH"))) {
+            return "CHAINLINK_WSTETH_STETH_COMPOSITE_ORACLE";
+        } else if (keccak256(bytes(tokenName)) == keccak256(bytes("rETH"))) {
+            return "CHAINLINK_RETH_ETH_COMPOSITE_ORACLE";
+        } else if (keccak256(bytes(tokenName)) == keccak256(bytes("AERO"))) {
+            return "CHAINLINK_AERO_ORACLE";
+        } else if (keccak256(bytes(tokenName)) == keccak256(bytes("weETH"))) {
+            return "CHAINLINK_WEETH_ETH_COMPOSITE_ORACLE";
+        } else if (keccak256(bytes(tokenName)) == keccak256(bytes("cbBTC"))) {
+            return "CHAINLINK_BTC_USD";
+        } else if (keccak256(bytes(tokenName)) == keccak256(bytes("EURC"))) {
+            return "CHAINLINK_EURC_USD";
+        } else if (keccak256(bytes(tokenName)) == keccak256(bytes("wrsETH"))) {
+            return "CHAINLINK_wrsETH_COMPOSITE_ORACLE";
+        } else if (
+            keccak256(bytes(tokenName)) == keccak256(bytes("xWELL_PROXY"))
+        ) {
+            return "CHAINLINK_WELL_USD";
+        } else {
+            revert("unknown token");
+        }
+    }
+
+    /// @notice Helper function to strip the MOONWELL_ prefix from a token name
+    /// @param mTokenName The name of the mToken
+    /// @return The token name without the MOONWELL_ prefix
+    function _stripMoonwellPrefix(
+        string memory mTokenName
+    ) internal pure returns (string memory) {
+        bytes memory mTokenBytes = bytes(mTokenName);
+        bytes memory prefix = bytes("MOONWELL_");
+        require(mTokenBytes.length > prefix.length, "invalid mToken name");
+
+        bytes memory result = new bytes(mTokenBytes.length - prefix.length);
+        for (uint256 i = prefix.length; i < mTokenBytes.length; i++) {
+            result[i - prefix.length] = mTokenBytes[i];
+        }
+
+        return string(result);
+    }
+}

src/market/AutomationDeploy.sol

@@ -0,0 +1,48 @@
+pragma solidity =0.8.19;
+
+import {MErc20Storage} from "@protocol/MTokenInterfaces.sol";
+import {ReserveAutomation} from "@protocol/market/ReserveAutomation.sol";
+import {ERC20HoldingDeposit} from "@protocol/market/ERC20HoldingDeposit.sol";
+
+contract AutomationDeploy {
+    function deployReserveAutomation(
+        ReserveAutomation.InitParams memory params
+    ) public returns (address) {
+        require(params.wellToken.code.length > 0, "wellToken must be set");
+        require(params.reserveAsset.code.length > 0, "mToken must be set");
+        require(
+            params.wellChainlinkFeed.code.length > 0,
+            "wellChainlinkFeed must be set"
+        );
+        require(
+            params.reserveChainlinkFeed.code.length > 0,
+            "reserveChainlinkFeed must be set"
+        );
+        require(
+            params.recipientAddress.code.length > 0,
+            "recipientAddress must be set"
+        );
+        require(
+            params.mTokenMarket.code.length > 0,
+            "mTokenMarket must be set"
+        );
+        require(
+            MErc20Storage(params.mTokenMarket).underlying() ==
+                params.reserveAsset,
+            "reserveUnderlying must match mToken underlying"
+        );
+        require(params.owner != address(0), "owner must be set");
+        require(params.guardian != address(0), "guardian must be set");
+
+        ReserveAutomation automation = new ReserveAutomation(params);
+        return address(automation);
+    }
+
+    function deployERC20HoldingDeposit(
+        address token,
+        address owner
+    ) public returns (address) {
+        require(token.code.length > 0, "token must be set");
+        return address(new ERC20HoldingDeposit(token, owner));
+    }
+}