Add L1 & L2 Farm Proxies

.gitignore

@@ -0,0 +1,14 @@
+# Compiler files
+cache/
+out/
+
+# Ignores development broadcast logs
+!/broadcast
+/broadcast/*/31337/
+/broadcast/**/dry-run/
+
+# Docs
+docs/
+
+# Dotenv file
+.env

.gitmodules

@@ -0,0 +1,9 @@
+[submodule "lib/dss-test"]
+	path = lib/dss-test
+	url = https://github.com/makerdao/dss-test
+[submodule "lib/arbitrum-token-bridge"]
+	path = lib/arbitrum-token-bridge
+	url = https://github.com/makerdao/arbitrum-token-bridge
+[submodule "lib/endgame-toolkit"]
+	path = lib/endgame-toolkit
+	url = https://github.com/makerdao/endgame-toolkit

README.md

@@ -0,0 +1 @@
+# Endgame L2 Farms

deploy/FarmProxyDeploy.sol

@@ -0,0 +1,49 @@
+// SPDX-FileCopyrightText: © 2024 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.0;
+
+import { ScriptTools } from "dss-test/ScriptTools.sol";
+
+import { L2FarmProxyInstance } from "./L2FarmProxyInstance.sol";
+import { L2FarmProxySpell } from "./L2FarmProxySpell.sol";
+import { L1FarmProxy } from "src/L1FarmProxy.sol";
+import { L2FarmProxy } from "src/L2FarmProxy.sol";
+
+library FarmProxyDeploy {
+    function deployL1Proxy(
+        address deployer,
+        address owner,
+        address gem,
+        address l2Proxy,
+        address feeRecipient,
+        address inbox,
+        address l1Gateway
+    ) internal returns (address l1Proxy) {
+        l1Proxy = address(new L1FarmProxy(gem, l2Proxy, feeRecipient, inbox, l1Gateway));
+        ScriptTools.switchOwner(l1Proxy, deployer, owner);
+    }
+
+    function deployL2Proxy(
+        address deployer,
+        address owner,
+        address farm
+    ) internal returns (L2FarmProxyInstance memory l2ProxyInstance) {
+        l2ProxyInstance.proxy = address(new L2FarmProxy(farm));
+        l2ProxyInstance.spell = address(new L2FarmProxySpell(l2ProxyInstance.proxy));
+        ScriptTools.switchOwner(l2ProxyInstance.proxy, deployer, owner);
+    }
+}

deploy/FarmProxyInit.sol

@@ -0,0 +1,160 @@
+// SPDX-FileCopyrightText: © 2024 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.0;
+
+import { DssInstance } from "dss-test/MCD.sol";
+import { L2FarmProxyInstance } from "./L2FarmProxyInstance.sol";
+import { L2FarmProxySpell } from "./L2FarmProxySpell.sol";
+
+interface AuthLike {
+    function rely(address usr) external;
+}
+
+interface DssVestLike {
+    function gem() external view returns (address);
+    function create(address _usr, uint256 _tot, uint256 _bgn, uint256 _tau, uint256 _eta, address _mgr) external returns (uint256 id);
+    function restrict(uint256 _id) external;
+}
+
+interface VestedRewardsDistributionLike {
+    function dssVest() external view returns (address);
+    function stakingRewards() external view returns (address);
+    function gem() external view returns (address);
+    function file(bytes32 what, uint256 data) external;
+}
+
+interface L1FarmProxyLike {
+    function rewardsToken() external view returns (address);
+    function l2Proxy() external view returns (address);
+    function feeRecipient() external view returns (address);
+    function inbox() external view returns (address);
+    function l1Gateway() external view returns (address);
+    function file(bytes32 what, uint256 data) external;
+}
+
+interface L1RelayLike {
+    function relay(
+        address target,
+        bytes calldata targetData,
+        uint256 l1CallValue,
+        uint256 maxGas,
+        uint256 gasPriceBid,
+        uint256 maxSubmissionCost
+    ) external payable;
+}
+
+struct MessageParams {
+    uint256 maxGas;
+    uint256 gasPriceBid;
+    uint256 maxSubmissionCost;
+}
+
+struct ProxiesConfig {
+    address vest;
+    address vestedRewardDistribution;
+    uint256 vestTot;
+    uint256 vestBgn;
+    uint256 vestTau;
+    address vestMgr;
+    address rewardsToken;
+    address l2Proxy;
+    address feeRecipient;
+    address inbox;
+    address l1Gateway;
+    uint256 maxGas;          // For the L1 proxy
+    uint256 gasPriceBid;     // For the L1 proxy
+    uint256 l1MinReward;     // For the L1 proxy
+    uint256 l2MinReward;     // For the L2 proxy
+    uint256 rewardsDuration; // For the farm on L2
+    MessageParams xchainMsg; // For the xchain message executing the L2 spell
+}
+
+library FarmProxyInit {
+    function initProxies(
+        DssInstance memory         dss,
+        address                    l1Proxy_,
+        L2FarmProxyInstance memory l2ProxyInstance,
+        ProxiesConfig memory       cfg
+    ) internal {
+        L1FarmProxyLike l1Proxy = L1FarmProxyLike(l1Proxy_);
+        DssVestLike vest = DssVestLike(cfg.vest);
+        VestedRewardsDistributionLike distribution = VestedRewardsDistributionLike(cfg.vestedRewardDistribution);
+
+        // sanity checks
+
+        require(vest.gem()                    == cfg.rewardsToken,  "FarmProxyInit/vest-gem-mismatch");
+        require(distribution.gem()            == cfg.rewardsToken,  "FarmProxyInit/distribution-gem-mismatch");
+        require(distribution.stakingRewards() == l1Proxy_,          "FarmProxyInit/distribution-farm-mismatch");
+        require(distribution.dssVest()        == cfg.vest,          "FarmProxyInit/distribution-vest-mismatch");
+        require(l1Proxy.rewardsToken()        == cfg.rewardsToken,  "FarmProxyInit/rewards-token-mismatch");
+        require(l1Proxy.l2Proxy()             == cfg.l2Proxy,       "FarmProxyInit/l2-proxy-mismatch");
+        require(l1Proxy.feeRecipient()        == cfg.feeRecipient,  "FarmProxyInit/fee-recipient-mismatch");
+        require(l1Proxy.inbox()               == cfg.inbox,         "FarmProxyInit/inbox-mismatch");
+        require(l1Proxy.l1Gateway()           == cfg.l1Gateway,     "FarmProxyInit/l1-gateway-mismatch");
+        require(cfg.maxGas                    <= 10_000_000_000,    "FarmProxyInit/max-gas-out-of-bounds");
+        require(cfg.gasPriceBid               <= 10_000 gwei,       "FarmProxyInit/gas-price-bid-out-of-bounds");
+        require(cfg.l1MinReward               <= type(uint128).max, "FarmProxyInit/l1-min-reward-out-of-bounds");
+        require(cfg.l2MinReward               > 0,                  "FarmProxyInit/l2-min-reward-out-of-bounds");
+
+        // setup vest
+
+        if (cfg.rewardsToken == dss.chainlog.getAddress("NST")) {
+            // TODO: NST isn't currently planned as an L2 rewardsToken, so do we want to handle this case at all?
+            AuthLike(dss.chainlog.getAddress("MCD_VAT")).rely(cfg.vest);
+        } else {
+            AuthLike(cfg.rewardsToken).rely(cfg.vest);
+        }
+        uint256 vestId = vest.create({
+            _usr: cfg.vestedRewardDistribution,
+            _tot: cfg.vestTot,
+            _bgn: cfg.vestBgn,
+            _tau: cfg.vestTau,
+            _eta: 0,
+            _mgr: cfg.vestMgr
+        });
+        vest.restrict(vestId);
+        distribution.file("vestId", vestId);
+
+        // setup L1 proxy
+
+        l1Proxy.file("maxGas",      cfg.maxGas);
+        l1Proxy.file("gasPriceBid", cfg.gasPriceBid);
+        l1Proxy.file("minReward",   cfg.l1MinReward);
+
+        // setup L2 proxy
+
+        L1RelayLike l1GovRelay = L1RelayLike(dss.chainlog.getAddress("ARBITRUM_GOV_RELAY"));
+        uint256 l1CallValue = cfg.xchainMsg.maxSubmissionCost + cfg.xchainMsg.maxGas * cfg.xchainMsg.gasPriceBid;
+
+        // not strictly necessary (as the retryable ticket creation would otherwise fail) 
+        // but makes the eth balance requirement more explicit
+        require(address(l1GovRelay).balance >= l1CallValue, "FarmProxyInit/insufficient-relay-balance");
+
+        l1GovRelay.relay({
+            target:            l2ProxyInstance.spell,
+            targetData:        abi.encodeCall(L2FarmProxySpell.init, (cfg.l2MinReward, cfg.rewardsDuration)),
+            l1CallValue:       l1CallValue,
+            maxGas:            cfg.xchainMsg.maxGas,
+            gasPriceBid:       cfg.xchainMsg.gasPriceBid,
+            maxSubmissionCost: cfg.xchainMsg.maxSubmissionCost
+        });
+
+        // update chainlog
+
+        dss.chainlog.setAddress("ARBITRUM_L1_FARM_PROXY", l1Proxy_);
+    }
+}

deploy/L2FarmProxyInstance.sol

@@ -0,0 +1,22 @@
+// SPDX-FileCopyrightText: © 2024 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.0;
+
+struct L2FarmProxyInstance {
+    address proxy;
+    address spell;
+}

deploy/L2FarmProxySpell.sol

@@ -0,0 +1,46 @@
+// SPDX-FileCopyrightText: © 2024 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.0;
+
+import { L2FarmProxy } from "src/L2FarmProxy.sol";
+
+interface FarmLike {
+    function setRewardsDistribution(address) external;
+    function setRewardsDuration(uint256) external;
+}
+
+// A reusable L2 spell to be used by the L2GovernanceRelay to exert admin control over L2FarmProxy
+contract L2FarmProxySpell {
+    L2FarmProxy public immutable l2Proxy;
+    constructor(address l2Proxy_) {
+        l2Proxy = L2FarmProxy(l2Proxy_);
+    }
+
+    function rely(address usr) external { l2Proxy.rely(usr); }
+    function deny(address usr) external { l2Proxy.deny(usr); }
+    function file(bytes32 what, uint256 data) external { l2Proxy.file(what, data); }
+
+    function init(uint256 minReward, uint256 rewardsDuration) external {
+        // TODO: add L2-side sanity checks
+
+        l2Proxy.file("minReward", minReward);
+
+        FarmLike farm = FarmLike(address(l2Proxy.farm()));
+        farm.setRewardsDistribution(address(l2Proxy));
+        farm.setRewardsDuration(rewardsDuration);
+    }
+}

foundry.toml

@@ -0,0 +1,14 @@
+[profile.default]
+src = "src"
+out = "out"
+libs = ["lib"]
+solc = "0.8.21"
+fs_permissions = [
+    { access = "read", path = "./script/input/"}
+]
+
+[etherscan]
+mainnet = { key = "${ETHERSCAN_KEY}" }
+sepolia = { key = "${ETHERSCAN_KEY}", chain = 11155111 }
+arbitrum_one = { key = "${ARBISCAN_KEY}", chain = 42161, url = "https://api.arbiscan.io/api" }
+arbitrum_one_sepolia = { key = "${ARBISCAN_KEY}", chain = 421614, url = "https://api-sepolia.arbiscan.io/api" }

remappings.txt

@@ -0,0 +1,2 @@
+forge-std/=lib/dss-test/lib/forge-std/src/
+openzeppelin-contracts/=lib/endgame-toolkit/lib/openzeppelin-contracts/contracts/