MetaMorpho D3M

.gitmodules

@@ -1,3 +1,6 @@
 [submodule "lib/dss-test"]
 	path = lib/dss-test
 	url = https://github.com/makerdao/dss-test
+[submodule "lib/solmate"]
+	path = lib/solmate
+	url = https://github.com/transmissions11/solmate

script/D3MDeploy.s.sol

@@ -103,6 +103,15 @@ contract D3MDeployScript is Script {
                 hub,
                 config.readAddress(".cdai")
             );
+        } else if (poolType.eq("erc4626")) {
+            d3m.pool = D3MDeploy.deploy4626TypePool(
+                msg.sender,
+                admin,
+                ilk,
+                hub,
+                address(dss.dai),
+                config.readAddress(".vault")
+            );
         } else {
             revert("Unknown pool type");
         }
@@ -135,6 +144,11 @@ contract D3MDeployScript is Script {
             } else {
                 revert("Invalid pool type for liquidity buffer plan type");
             }
+        } else if (planType.eq("operator")) {
+            d3m.plan = D3MDeploy.deployOperatorPlan(
+                msg.sender,
+                admin
+            );
         } else {
             revert("Unknown plan type");
         }

script/D3MInit.s.sol

@@ -35,6 +35,10 @@ import {
     D3MAaveBufferPlanConfig,
     D3MCompoundPoolLike,
     D3MCompoundRateTargetPlanLike,
+    D3M4626PoolLike,
+    D3M4626PoolConfig,
+    D3MOperatorPlanLike,
+    D3MOperatorPlanConfig,
     CDaiLike
 } from "../src/deploy/D3MInit.sol";
 
@@ -119,6 +123,16 @@ contract D3MInitScript is Script {
                 cfg,
                 compoundCfg
             );
+        } else if (poolType.eq("erc4626")) {
+            D3M4626PoolConfig memory erc4626Cfg = D3M4626PoolConfig({
+                vault: D3M4626PoolLike(d3m.pool).vault()
+            });
+            D3MInit.init4626Pool(
+                dss,
+                d3m,
+                cfg,
+                erc4626Cfg
+            );
         } else {
             revert("Unknown pool type");
         }
@@ -165,6 +179,14 @@ contract D3MInitScript is Script {
             } else {
                 revert("Invalid pool type for liquidity buffer plan type");
             }
+        } else if (planType.eq("operator")) {
+            D3MOperatorPlanConfig memory operatorCfg = D3MOperatorPlanConfig({
+                operator: config.readAddress(".operator")
+            });
+            D3MInit.initOperatorPlan(
+                d3m,
+                operatorCfg
+            );
         } else {
             revert("Unknown plan type");
         }

script/input/1/template-morpho.json

@@ -0,0 +1,14 @@
+{
+    "chainlog": "0xdA0Ab1e0017DEbCd72Be8599041a2aa3bA7e740F",
+    "admin": "0x3300f198988e4C9C63F75dF86De36421f06af8c4",
+    "poolType": "erc4626",
+    "planType": "operator",
+    "ilk": "DIRECT-SPARK-MORPHO-DAI",
+    "existingIlk": false,
+    "maxLine": 500000000,
+    "gap": 10000000,
+    "ttl": 21600,
+    "tau": 604800,
+    "vault": "0xB8C7F2a4B3bF76CC04bd55Ebc259b33a67b3b36d",
+    "operator": "0x3300f198988e4C9C63F75dF86De36421f06af8c4"
+}

src/deploy/D3MDeploy.sol

@@ -30,6 +30,8 @@ import { D3MAaveV2TypePool } from "../pools/D3MAaveV2TypePool.sol";
 import { D3MAaveV3NoSupplyCapTypePool } from "../pools/D3MAaveV3NoSupplyCapTypePool.sol";
 import { D3MCompoundV2TypeRateTargetPlan } from "../plans/D3MCompoundV2TypeRateTargetPlan.sol";
 import { D3MCompoundV2TypePool } from "../pools/D3MCompoundV2TypePool.sol";
+import { D3M4626TypePool } from "../pools/D3M4626TypePool.sol";
+import { D3MOperatorPlan } from "../plans/D3MOperatorPlan.sol";
 import { D3MOracle } from "../D3MOracle.sol";
 
 // Deploy a D3M instance
@@ -96,6 +98,19 @@ library D3MDeploy {
         ScriptTools.switchOwner(pool, deployer, owner);
     }
 
+    function deploy4626TypePool(
+        address deployer,
+        address owner,
+        bytes32 ilk,
+        address hub,
+        address dai,
+        address vault
+    ) internal returns (address pool) {
+        pool = address(new D3M4626TypePool(ilk, hub, dai, vault));
+
+        ScriptTools.switchOwner(pool, deployer, owner);
+    }
+
     function deployAaveV2TypeRateTargetPlan(
         address deployer,
         address owner,
@@ -127,4 +142,13 @@ library D3MDeploy {
         ScriptTools.switchOwner(plan, deployer, owner);
     }
 
+    function deployOperatorPlan(
+        address deployer,
+        address owner
+    ) internal returns (address plan) {
+        plan = address(new D3MOperatorPlan());
+
+        ScriptTools.switchOwner(plan, deployer, owner);
+    }
+
 }

src/deploy/D3MInit.sol

@@ -80,6 +80,18 @@ interface CDaiLike {
     function implementation() external view returns (address);
 }
 
+interface D3M4626PoolLike {
+    function hub() external view returns (address);
+    function dai() external view returns (address);
+    function ilk() external view returns (bytes32);
+    function vat() external view returns (address);
+    function vault() external view returns (address);
+}
+
+interface D3MOperatorPlanLike {
+    function file(bytes32, address) external;
+}
+
 interface D3MOracleLike {
     function vat() external view returns (address);
     function ilk() external view returns (bytes32);
@@ -148,6 +160,14 @@ struct D3MCompoundRateTargetPlanConfig {
     address delegate;
 }
 
+struct D3M4626PoolConfig {
+    address vault;
+}
+
+struct D3MOperatorPlanConfig {
+    address operator;
+}
+
 // Init a D3M instance
 library D3MInit {
 
@@ -275,6 +295,25 @@ library D3MInit {
         pool.file("king", compoundCfg.king);
     }
 
+    /**
+     * @dev Initialize a 4626 pool.
+     */
+    function init4626Pool(
+        DssInstance memory dss,
+        D3MInstance memory d3m,
+        D3MCommonConfig memory cfg,
+        D3M4626PoolConfig memory erc4626Cfg
+    ) internal {
+        D3M4626PoolLike pool = D3M4626PoolLike(d3m.pool);
+
+        // Sanity checks
+        require(pool.hub() == cfg.hub, "Pool hub mismatch");
+        require(pool.ilk() == cfg.ilk, "Pool ilk mismatch");
+        require(pool.vat() == address(dss.vat), "Pool vat mismatch");
+        require(pool.dai() == address(dss.dai), "Pool dai mismatch");
+        require(pool.vault() == erc4626Cfg.vault, "Pool vault mismatch");
+    }
+
     function initAaveRateTargetPlan(
         D3MInstance memory d3m,
         D3MAaveRateTargetPlanConfig memory aaveCfg
@@ -323,4 +362,13 @@ library D3MInit {
         plan.file("barb", compoundCfg.barb);
     }
 
+    function initOperatorPlan(
+        D3MInstance memory d3m,
+        D3MOperatorPlanConfig memory operatorCfg
+    ) internal {
+        D3MOperatorPlanLike plan = D3MOperatorPlanLike(d3m.plan);
+
+        plan.file("operator", operatorCfg.operator);
+    }
+
 }

src/plans/D3MOperatorPlan.sol

@@ -0,0 +1,96 @@
+// SPDX-FileCopyrightText: © 2022 Dai Foundation <www.daifoundation.org>
+// SPDX-License-Identifier: AGPL-3.0-or-later
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero 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 Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+pragma solidity ^0.8.14;
+
+import "./ID3MPlan.sol";
+
+/**
+ *  @title D3M Operator Plan
+ *  @notice An operator sets the desired target assets.
+ */
+contract D3MOperatorPlan is ID3MPlan {
+
+    mapping (address => uint256) public wards;
+    uint256                      public enabled;
+
+    address public operator;
+    uint256 public targetAssets;
+
+    // --- Events ---
+    event Rely(address indexed usr);
+    event Deny(address indexed usr);
+    event File(bytes32 indexed what, address data);
+    event File(bytes32 indexed what, uint256 data);
+
+    constructor() {
+        enabled = 1;
+
+        wards[msg.sender] = 1;
+        emit Rely(msg.sender);
+    }
+
+    modifier auth {
+        require(wards[msg.sender] == 1, "D3MOperatorPlan/not-authorized");
+        _;
+    }
+
+    // --- Admin ---
+    function rely(address usr) external auth {
+        wards[usr] = 1;
+        emit Rely(usr);
+    }
+    function deny(address usr) external auth {
+        wards[usr] = 0;
+        emit Deny(usr);
+    }
+
+    function file(bytes32 what, address data) external auth {
+        if (what == "operator") {
+            operator = data;
+        } else revert("D3MOperatorPlan/file-unrecognized-param");
+        emit File(what, data);
+    }
+
+    function file(bytes32 what, uint256 data) external auth {
+        if (what == "enabled") {
+            require(data <= 1, "D3MOperatorPlan/invalid-value");
+            enabled = data;
+        } else revert("D3MOperatorPlan/file-unrecognized-param");
+        emit File(what, data);
+    }
+
+    function setTargetAssets(uint256 value) external {
+        require(msg.sender == operator, "D3MOperatorPlan/not-authorized");
+
+        targetAssets = value;
+    }
+
+    function getTargetAssets(uint256) external override view returns (uint256) {
+        if (enabled == 0) return 0;
+
+        return targetAssets;
+    }
+
+    function active() public view override returns (bool) {
+        return enabled == 1;
+    }
+
+    function disable() external override auth {
+        enabled = 0;
+        emit Disable();
+    }
+}