diff --git a/.env.example b/.env.example new file mode 100644 index 0000000..c376036 --- /dev/null +++ b/.env.example @@ -0,0 +1,12 @@ +export FOUNDRY_SCRIPT_DEPS=deployed +export FOUNDRY_EXPORTS_OVERWRITE_LATEST=true +export L1="sepolia" +export L2="base_sepolia" +export MAINNET_RPC_URL= +export BASE_RPC_URL= +export SEPOLIA_RPC_URL= +export BASE_SEPOLIA_RPC_URL= +export L1_PRIVATE_KEY="0x$(cat /path/to/pkey1)" +export L2_PRIVATE_KEY="0x$(cat /path/to/pkey2)" +export ETHERSCAN_KEY= +export BASESCAN_KEY= diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml new file mode 100644 index 0000000..b7cea14 --- /dev/null +++ b/.github/workflows/test.yml @@ -0,0 +1,37 @@ +name: test + +on: [push, pull_request] + +env: + FOUNDRY_PROFILE: ci + +jobs: + check: + strategy: + fail-fast: true + + name: Foundry project + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v4 + with: + submodules: recursive + + - name: Install Foundry + uses: foundry-rs/foundry-toolchain@v1 + with: + version: nightly + + - name: Run Forge build + run: | + forge --version + forge build --sizes + id: build + + - name: Run Forge tests + run: | + forge test -vvv + id: test + env: + MAINNET_RPC_URL: ${{ secrets.MAINNET_RPC_URL }} + BASE_RPC_URL: ${{ secrets.BASE_RPC_URL }} diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..85198aa --- /dev/null +++ b/.gitignore @@ -0,0 +1,14 @@ +# Compiler files +cache/ +out/ + +# Ignores development broadcast logs +!/broadcast +/broadcast/*/31337/ +/broadcast/**/dry-run/ + +# Docs +docs/ + +# Dotenv file +.env diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..fca70d7 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,10 @@ +[submodule "lib/dss-test"] + path = lib/dss-test + url = https://github.com/makerdao/dss-test +[submodule "lib/endgame-toolkit"] + path = lib/endgame-toolkit + url = https://github.com/makerdao/endgame-toolkit +[submodule "lib/op-token-bridge"] + path = lib/op-token-bridge + url = https://github.com/makerdao/op-token-bridge + branch = dev diff --git a/README.md b/README.md index ba880b3..09e6d10 100644 --- a/README.md +++ b/README.md @@ -1 +1,98 @@ -# op-farms \ No newline at end of file +# Op Farms + +## Overview + +This repository implements a mechanism to distribute rewards vested in a [DssVest](https://github.com/makerdao/dss-vest) contract on L1 to users staking tokens in a [StakingRewards](https://github.com/makerdao/endgame-toolkit/blob/master/src/synthetix/StakingRewards.sol) farm on an OP stack L2. It uses the [Op Token Bridge](https://github.com/makerdao/op-token-bridge) to transfer the rewards from L1 to L2. + +## Contracts + +- `L1FarmProxy.sol` - Proxy to the farm on the L1 side. Receives the token reward (expected to come from a [`VestedRewardDistribution`](https://github.com/makerdao/endgame-toolkit/blob/master/src/VestedRewardsDistribution.sol) contract) and transfers it cross-chain to the `L2FarmProxy`. An instance of `L1FarmProxy` must be deployed for each supported pair of staking and rewards token. +- `L2FarmProxy.sol` - Proxy to the farm on the L2 side. Receives the token reward (expected to be bridged from the `L1FarmProxy`) and forwards it to the [StakingRewards](https://github.com/makerdao/endgame-toolkit/blob/master/src/synthetix/StakingRewards.sol) farm where it gets distributed to stakers. An instance of `L2FarmProxy` must be deployed for each supported pair of staking and rewards token. + +### External dependencies + +- The L2 staking tokens and the L1 and L2 rewards tokens are not provided as part of this repository. It is assumed that only simple, regular ERC20 tokens will be used. In particular, the supported tokens are assumed to revert on failure (instead of returning false) and do not execute any hook on transfer. +- [`DssVest`](https://github.com/makerdao/dss-vest) is used to vest the rewards token on L1. +- [`VestedRewardDistribution`](https://github.com/makerdao/endgame-toolkit/blob/master/src/VestedRewardsDistribution.sol) is used to vest the rewards tokens from `DssVest`, transfer them to the `L1FarmProxy` and trigger the bridging of the tokens. +- The [Op Token Bridge](https://github.com/makerdao/op-token-bridge) is used to bridge the tokens from L1 to L2. +- The [escrow contract](https://github.com/makerdao/op-token-bridge/blob/dev/src/Escrow.sol) is used by the Op Token Bridge to hold the bridged tokens on L1. +- [`StakingRewards`](https://github.com/makerdao/endgame-toolkit/blob/master/src/synthetix/StakingRewards.sol) is used to distribute the bridged rewards to stakers on L2. +- The [`L1GovernanceRelay`](https://github.com/makerdao/op-token-bridge/blob/dev/src/L1GovernanceRelay.sol) & [`L2GovernanceRelay`](https://github.com/makerdao/op-token-bridge/blob/dev/src/L2GovernanceRelay.sol) allow governance to exert admin control over the deployed L2 contracts. + +## Expected flow +- Once the vested amount of rewards tokens exceeds `L1FarmProxy.rewardThreshold`, a keeper calls `VestedRewardDistribution.distribute()` to vest the rewards and have them bridged to L2. +- Once the bridged amount of rewards tokens exceeds `L2FarmProxy.rewardThreshold`, anyone (e.g. a keeper or an L2 staker) can call `L2FarmProxy.forwardReward()` to distribute the rewards to the L2 farm. + +Note that `L1FarmProxy.rewardThreshold` should be sufficiently large to reduce the frequency of cross-chain transfers (thereby saving keepers gas). `L2FarmProxy.rewardThreshold` must also be sufficiently large to limit the reduction of the farm's rate of rewards distribution. Consider also choosing `L2FarmProxy.rewardThreshold <= L1FarmProxy.rewardThreshold` so that the bridged rewards can be promptly distributed to the farm. In the initialization library, these two variables are assigned the same value. + +Note that the L2 Farm's reward rate might not be perfectly constant, even if the `L1FarmProxy` and `L2FarmProxy` reward thresholds are set to the same value. With the cross-chain setup there are several ways that can lead to non-constant reward rates. Therefore the following should be taken into consideration: +* The system configuration (durations and thresholds) should be chosen carefully to align the vesting rate with the farm's reward rate. +* Keepers should monitor and call `VestedRewardsDistribution.distribute` on L1 and `L2FarmProxy.forwardReward` whenever their reward thresholds are reached. +* L2 sequencer downtimes or other bridging delays can lead to delayed L2 distribution. +* Failed reward token bridging transactions should be monitored and retried. + +## Deployment + +### Declare env variables + +Add the required env variables listed in `.env.example` to your `.env` file, and run `source .env`. + +Make sure to set the `L1` and `L2` env variables according to your desired deployment environment. + +Mainnet deployment: + +``` +L1=mainnet +L2=base # in case of using Base as the L2 +``` + +Testnet deployment: + +``` +L1=sepolia +L2=base_sepolia # in case of using Base as the L2 +``` + +### Deploy the farm L1 & L2 proxies + +The deployment assumes that the [op-token-bridge](https://github.com/makerdao/op-token-bridge) has already been deployed and was properly initialized. + +Fill in the addresses of the L2 staking token and L1 and L2 rewards tokens in `script/input/{chainId}/config.json` under the `"stakingToken"` and `"rewardsToken"` keys. + +Fill in the address of the mainnet DssVest contract in `script/input/1/config.json` under the `vest` key. It is assumed that the vesting contract was properly initialized. On testnet, a mock DssVest contract will automatically be deployed. + +Start by deploying the `L2FarmProxySpell` singleton. + +``` +forge script script/DeploySingletons.s.sol:DeploySingletons --slow --multi --broadcast --verify +``` + +Next, run the following command to deploy the L1 vested rewards distribution contract, the L2 farm and the L1 and L2 proxies: + +``` +forge script script/DeployProxy.s.sol:DeployProxy --slow --multi --broadcast --verify +``` + +### Initialize the farm L1 & L2 proxies + +On mainnet, the farm proxies should be initialized via the spell process. +On testnet, the proxies initialization can be performed via the following command: + +``` +forge script script/Init.s.sol:Init --slow --multi --broadcast +``` + +### Run a test distribution + +Run the following command to distribute the vested funds to the L1 proxy. +We add a buffer to the gas estimation per Optimism's [recommendation](https://docs.optimism.io/builders/app-developers/bridging/messaging#for-l1-to-l2-transactions-1) for L1 => L2 transactions. + +``` +forge script script/Distribute.s.sol:Distribute --slow --multi --broadcast --gas-estimate-multiplier 120 +``` + +Wait for the transaction to be relayed to L2, then run the following command to forward the bridged funds from the L2 proxy to the farm: + +``` +forge script script/Forward.s.sol:Forward --slow --multi --broadcast +``` diff --git a/audit/20240909-cantina-report-review-makerdao-op-farms.pdf b/audit/20240909-cantina-report-review-makerdao-op-farms.pdf new file mode 100644 index 0000000..8303e09 Binary files /dev/null and b/audit/20240909-cantina-report-review-makerdao-op-farms.pdf differ diff --git a/audit/20240912-ChainSecurity_MakerDAO_OP_Farms_audit.pdf b/audit/20240912-ChainSecurity_MakerDAO_OP_Farms_audit.pdf new file mode 100644 index 0000000..34aa236 Binary files /dev/null and b/audit/20240912-ChainSecurity_MakerDAO_OP_Farms_audit.pdf differ diff --git a/deploy/FarmProxyDeploy.sol b/deploy/FarmProxyDeploy.sol new file mode 100644 index 0000000..402d0b4 --- /dev/null +++ b/deploy/FarmProxyDeploy.sol @@ -0,0 +1,50 @@ +// SPDX-FileCopyrightText: © 2024 Dai Foundation +// 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 . + +pragma solidity >=0.8.0; + +import { ScriptTools } from "dss-test/ScriptTools.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 rewardsToken, + address remoteToken, + address l2Proxy, + address l1Bridge + ) internal returns (address l1Proxy) { + l1Proxy = address(new L1FarmProxy(rewardsToken, remoteToken, l2Proxy, l1Bridge)); + ScriptTools.switchOwner(l1Proxy, deployer, owner); + } + + function deployL2Proxy( + address deployer, + address owner, + address farm + ) internal returns (address l2Proxy) { + l2Proxy = address(new L2FarmProxy(farm)); + ScriptTools.switchOwner(l2Proxy, deployer, owner); + } + + function deployL2ProxySpell() internal returns (address l2Spell) { + l2Spell = address(new L2FarmProxySpell()); + } +} diff --git a/deploy/FarmProxyInit.sol b/deploy/FarmProxyInit.sol new file mode 100644 index 0000000..f87aae1 --- /dev/null +++ b/deploy/FarmProxyInit.sol @@ -0,0 +1,131 @@ +// SPDX-FileCopyrightText: © 2024 Dai Foundation +// 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 . + +pragma solidity >=0.8.0; + +import { DssInstance } from "dss-test/MCD.sol"; +import { L2FarmProxySpell } from "./L2FarmProxySpell.sol"; + +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 remoteToken() external view returns (address); + function l2Proxy() external view returns (address); + function l1Bridge() external view returns (address); + function file(bytes32 what, uint256 data) external; +} + +interface L1RelayLike { + function l2GovernanceRelay() external view returns (address); + function relay(address target, bytes calldata targetData, uint32 minGasLimit) external; +} + +struct ProxiesConfig { + address vest; // DssVest, assumed to have been fully init'ed for l1RewardsToken + uint256 vestTot; + uint256 vestBgn; + uint256 vestTau; + address vestedRewardsDistribution; + address l1RewardsToken; + address l2RewardsToken; + address l2StakingToken; + address l1Bridge; + uint32 minGasLimit; // For filing in the L1 proxy + uint224 rewardThreshold; // For the L1 and L2 proxies + address farm; // The L2 farm + uint256 rewardsDuration; // For the L2 farm + uint32 initMinGasLimit; // For relaying of `init` L2 spell operation + bytes32 proxyChainlogKey; // Chainlog key for the L1 proxy + bytes32 distrChainlogKey; // Chainlog key for vestedRewardsDistribution +} + +library FarmProxyInit { + function initProxies( + DssInstance memory dss, + address l1GovRelay, + address l1Proxy_, + address l2Proxy, + address l2Spell, + ProxiesConfig memory cfg + ) internal { + L1FarmProxyLike l1Proxy = L1FarmProxyLike(l1Proxy_); + DssVestLike vest = DssVestLike(cfg.vest); + VestedRewardsDistributionLike distribution = VestedRewardsDistributionLike(cfg.vestedRewardsDistribution); + + // sanity checks + + require(vest.gem() == cfg.l1RewardsToken, "FarmProxyInit/vest-gem-mismatch"); + require(distribution.gem() == cfg.l1RewardsToken, "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.l1RewardsToken, "FarmProxyInit/rewardsToken-token-mismatch"); + require(l1Proxy.l2Proxy() == l2Proxy, "FarmProxyInit/l2-proxy-mismatch"); + require(l1Proxy.remoteToken() == cfg.l2RewardsToken, "FarmProxyInit/remote-token-mismatch"); + require(l1Proxy.l1Bridge() == cfg.l1Bridge, "FarmProxyInit/l1-bridge-mismatch"); + require(cfg.minGasLimit <= 500_000_000, "FarmProxyInit/min-gas-limit-out-of-bounds"); + require(cfg.initMinGasLimit <= 500_000_000, "FarmProxyInit/init-min-gas-limit-out-of-bounds"); + + // setup vest + + uint256 vestId = vest.create({ + _usr: cfg.vestedRewardsDistribution, + _tot: cfg.vestTot, + _bgn: cfg.vestBgn, + _tau: cfg.vestTau, + _eta: 0, + _mgr: address(0) + }); + vest.restrict(vestId); + distribution.file("vestId", vestId); + + // setup L1 proxy + + l1Proxy.file("minGasLimit", cfg.minGasLimit); + l1Proxy.file("rewardThreshold", cfg.rewardThreshold); + + // setup L2 proxy + + L1RelayLike(l1GovRelay).relay({ + target: l2Spell, + targetData: abi.encodeCall(L2FarmProxySpell.init, ( + l2Proxy, + cfg.l2RewardsToken, + cfg.l2StakingToken, + cfg.farm, + cfg.rewardThreshold, + cfg.rewardsDuration + )), + minGasLimit: cfg.initMinGasLimit + }); + + // update chainlog + + dss.chainlog.setAddress(cfg.proxyChainlogKey, l1Proxy_); + dss.chainlog.setAddress(cfg.distrChainlogKey, cfg.vestedRewardsDistribution); + } +} diff --git a/deploy/L2FarmProxySpell.sol b/deploy/L2FarmProxySpell.sol new file mode 100644 index 0000000..4069217 --- /dev/null +++ b/deploy/L2FarmProxySpell.sol @@ -0,0 +1,70 @@ +// SPDX-FileCopyrightText: © 2024 Dai Foundation +// 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 . + +pragma solidity >=0.8.0; + +interface L2FarmProxyLike { + function rewardsToken() external view returns (address); + function farm() external view returns (address); + function rely(address) external; + function deny(address) external; + function file(bytes32, uint256) external; + function recover(address, address, uint256) external; +} + +interface FarmLike { + function rewardsToken() external view returns (address); + function stakingToken() external view returns (address); + function nominateNewOwner(address) external; + function setPaused(bool) external; + function recoverERC20(address, uint256) external; + function setRewardsDuration(uint256) external; + function setRewardsDistribution(address) external; +} + +// A reusable L2 spell to be used by the L2GovernanceRelay to exert admin control over L2 farms and their proxies +contract L2FarmProxySpell { + function rely(address l2Proxy, address usr) external { L2FarmProxyLike(l2Proxy).rely(usr); } + function deny(address l2Proxy, address usr) external { L2FarmProxyLike(l2Proxy).deny(usr); } + function file(address l2Proxy, bytes32 what, uint256 data) external { L2FarmProxyLike(l2Proxy).file(what, data); } + function recover(address l2Proxy, address token, address receiver, uint256 amount) external { L2FarmProxyLike(l2Proxy).recover(token, receiver, amount); } + + function nominateNewOwner(address farm, address owner) external { FarmLike(farm).nominateNewOwner(owner); } + function setPaused(address farm, bool paused) external { FarmLike(farm).setPaused(paused); } + function recoverERC20(address farm, address token, uint256 amount) external { FarmLike(farm).recoverERC20(token, amount); } + function setRewardsDuration(address farm, uint256 rewardsDuration) external { FarmLike(farm).setRewardsDuration(rewardsDuration); } + function setRewardsDistribution(address farm, address rewardsDistribution) external { FarmLike(farm).setRewardsDistribution(rewardsDistribution); } + + function init( + address l2Proxy, + address rewardsToken, + address stakingToken, + address farm, + uint256 rewardThreshold, + uint256 rewardsDuration + ) external { + // sanity checks + require(L2FarmProxyLike(l2Proxy).rewardsToken() == rewardsToken, "L2FarmProxySpell/rewards-token-mismatch"); + require(L2FarmProxyLike(l2Proxy).farm() == farm, "L2FarmProxySpell/farm-mismatch"); + require(FarmLike(farm).stakingToken() == stakingToken, "L2FarmProxySpell/farm-staking-token-mismatch"); + require(stakingToken != rewardsToken, "L2FarmProxySpell/rewards-token-same-as-staking-token"); + + L2FarmProxyLike(l2Proxy).file("rewardThreshold", rewardThreshold); + + FarmLike(farm).setRewardsDistribution(l2Proxy); + FarmLike(farm).setRewardsDuration(rewardsDuration); + } +} diff --git a/foundry.toml b/foundry.toml new file mode 100644 index 0000000..c95abb6 --- /dev/null +++ b/foundry.toml @@ -0,0 +1,15 @@ +[profile.default] +src = "src" +out = "out" +libs = ["lib"] +solc = "0.8.21" +fs_permissions = [ + { access = "read", path = "./script/input/"}, + { access = "read-write", path = "./script/output/"} +] + +[etherscan] +mainnet = { key = "${ETHERSCAN_KEY}" } +sepolia = { key = "${ETHERSCAN_KEY}", chain = 11155111 } +base = { key = "${BASESCAN_KEY}", chain = 8453, url = "https://api.basescan.org/api" } +base_sepolia = { key = "${BASESCAN_KEY}", chain = 84532, url = "https://api-sepolia.basescan.org/api" } diff --git a/lib/dss-test b/lib/dss-test new file mode 160000 index 0000000..f2a2b2b --- /dev/null +++ b/lib/dss-test @@ -0,0 +1 @@ +Subproject commit f2a2b2bbea71921103c5b7cf3cb1d241b957bec7 diff --git a/lib/endgame-toolkit b/lib/endgame-toolkit new file mode 160000 index 0000000..87e67bd --- /dev/null +++ b/lib/endgame-toolkit @@ -0,0 +1 @@ +Subproject commit 87e67bdd358a77b34d7b16e188fc1da7d6875999 diff --git a/lib/op-token-bridge b/lib/op-token-bridge new file mode 160000 index 0000000..a01b872 --- /dev/null +++ b/lib/op-token-bridge @@ -0,0 +1 @@ +Subproject commit a01b8725f20896390e63a6f65b109c25f8fb823c diff --git a/remappings.txt b/remappings.txt new file mode 100644 index 0000000..2061cc3 --- /dev/null +++ b/remappings.txt @@ -0,0 +1,2 @@ +forge-std/=lib/dss-test/lib/forge-std/src/ +openzeppelin-contracts/=lib/endgame-toolkit/lib/openzeppelin-contracts/contracts/ \ No newline at end of file diff --git a/script/DeployProxy.s.sol b/script/DeployProxy.s.sol new file mode 100644 index 0000000..7ccb826 --- /dev/null +++ b/script/DeployProxy.s.sol @@ -0,0 +1,151 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later + +// Copyright (C) 2024 Dai Foundation +// +// 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 . + +pragma solidity ^0.8.21; + +import "forge-std/Script.sol"; + +import { ScriptTools } from "dss-test/ScriptTools.sol"; +import { Domain } from "dss-test/domains/Domain.sol"; +import { VestedRewardsDistributionDeploy, VestedRewardsDistributionDeployParams } from "lib/endgame-toolkit/script/dependencies/VestedRewardsDistributionDeploy.sol"; +import { StakingRewardsDeploy, StakingRewardsDeployParams } from "lib/endgame-toolkit/script/dependencies/StakingRewardsDeploy.sol"; +import { DssVestMintableMock } from "test/mocks/DssVestMock.sol"; +import { FarmProxyDeploy } from "deploy/FarmProxyDeploy.sol"; + +interface L1GovernanceRelayLike { + function l2GovernanceRelay() external view returns (address); +} + +interface ChainLogLike { + function getAddress(bytes32) external view returns (address); +} + +interface AuthLike { + function rely(address usr) external; +} + +contract DeployProxy is Script { + using stdJson for string; + + uint256 l1PrivKey = vm.envUint("L1_PRIVATE_KEY"); + uint256 l2PrivKey = vm.envUint("L2_PRIVATE_KEY"); + address l1Deployer = vm.addr(l1PrivKey); + address l2Deployer = vm.addr(l2PrivKey); + + StdChains.Chain l1Chain; + StdChains.Chain l2Chain; + string config; + string deps; + Domain l1Domain; + Domain l2Domain; + ChainLogLike chainlog; + address l1GovRelay; + address l2GovRelay; + address owner; + address l1Bridge; + address vest; + address l2StakingToken; + address l1RewardsToken; + address l2RewardsToken; + address l1Proxy; + address vestedRewardsDistribution; + address farm; + address l2Proxy; + + function run() external { + l1Chain = getChain(string(vm.envOr("L1", string("mainnet")))); + l2Chain = getChain(string(vm.envOr("L2", string("base")))); + vm.setEnv("FOUNDRY_ROOT_CHAINID", vm.toString(l1Chain.chainId)); // used by ScriptTools to determine config path + config = ScriptTools.loadConfig("config"); + deps = ScriptTools.loadDependencies(); + l1Domain = new Domain(config, l1Chain); + l2Domain = new Domain(config, l2Chain); + l1Domain.selectFork(); + + chainlog = ChainLogLike(l1Domain.readConfigAddress("chainlog")); + l1GovRelay = chainlog.getAddress(l2Domain.readConfigBytes32FromString("govRelayCLKey")); + l2GovRelay = L1GovernanceRelayLike(l1GovRelay).l2GovernanceRelay(); + l1Bridge = chainlog.getAddress(l2Domain.readConfigBytes32FromString("l1BridgeCLKey")); + l2StakingToken = l2Domain.readConfigAddress("stakingToken"); + l1RewardsToken = l1Domain.readConfigAddress("rewardsToken"); + l2RewardsToken = l2Domain.readConfigAddress("rewardsToken"); + + if (keccak256(bytes(l1Chain.chainAlias)) == keccak256("mainnet")) { + owner = chainlog.getAddress("MCD_PAUSE_PROXY"); + vest = l1Domain.readConfigAddress("vest"); + } else { + owner = l1Deployer; + vm.startBroadcast(l1PrivKey); + vest = address(new DssVestMintableMock(l1RewardsToken)); + DssVestMintableMock(vest).file("cap", type(uint256).max); + AuthLike(l1RewardsToken).rely(address(vest)); + vm.stopBroadcast(); + } + + // L2 deployment + + StakingRewardsDeployParams memory farmParams = StakingRewardsDeployParams({ + owner: l2GovRelay, + stakingToken: l2StakingToken, + rewardsToken: l2RewardsToken + }); + l2Domain.selectFork(); + vm.startBroadcast(l2PrivKey); + farm = StakingRewardsDeploy.deploy(farmParams); + l2Proxy = FarmProxyDeploy.deployL2Proxy(l2Deployer, l2GovRelay, farm); + vm.stopBroadcast(); + + // L1 deployment + + l1Domain.selectFork(); + vm.startBroadcast(l1PrivKey); + l1Proxy = FarmProxyDeploy.deployL1Proxy( + l1Deployer, + owner, + l1RewardsToken, + l2RewardsToken, + l2Proxy, + l1Bridge + ); + VestedRewardsDistributionDeployParams memory distributionParams = VestedRewardsDistributionDeployParams({ + deployer: l1Deployer, + owner: owner, + vest: vest, + rewards: l1Proxy + }); + vestedRewardsDistribution = (VestedRewardsDistributionDeploy.deploy(distributionParams)); + vm.stopBroadcast(); + + // Export contract addresses + + // TODO: load the existing json so this is not required + ScriptTools.exportContract("deployed", "chainlog", deps.readAddress(".chainlog")); + ScriptTools.exportContract("deployed", "l2ProxySpell", deps.readAddress(".l2ProxySpell")); + ScriptTools.exportContract("deployed", "l1GovRelay", deps.readAddress(".l1GovRelay")); + ScriptTools.exportContract("deployed", "l2GovRelay", deps.readAddress(".l2GovRelay")); + + ScriptTools.exportContract("deployed", "farm", farm); + ScriptTools.exportContract("deployed", "l2Proxy", l2Proxy); + ScriptTools.exportContract("deployed", "l2RewardsToken", l2RewardsToken); + ScriptTools.exportContract("deployed", "l2StakingToken", l2StakingToken); + ScriptTools.exportContract("deployed", "l1Proxy", l1Proxy); + ScriptTools.exportContract("deployed", "vest", vest); + ScriptTools.exportContract("deployed", "vestedRewardsDistribution", vestedRewardsDistribution); + ScriptTools.exportContract("deployed", "l1RewardsToken", l1RewardsToken); + ScriptTools.exportContract("deployed", "l1Bridge", l1Bridge); + } +} diff --git a/script/DeploySingletons.s.sol b/script/DeploySingletons.s.sol new file mode 100644 index 0000000..9146c9a --- /dev/null +++ b/script/DeploySingletons.s.sol @@ -0,0 +1,76 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later + +// Copyright (C) 2024 Dai Foundation +// +// 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 . + +pragma solidity ^0.8.21; + +import "forge-std/Script.sol"; + +import { ScriptTools } from "dss-test/ScriptTools.sol"; +import { Domain } from "dss-test/domains/Domain.sol"; +import { FarmProxyDeploy } from "deploy/FarmProxyDeploy.sol"; + +interface ChainLogLike { + function getAddress(bytes32) external view returns (address); +} + +interface L1GovernanceRelayLike { + function l2GovernanceRelay() external view returns (address); +} + +contract DeploySingletons is Script { + + uint256 l2PrivKey = vm.envUint("L2_PRIVATE_KEY"); + + StdChains.Chain l1Chain; + StdChains.Chain l2Chain; + string config; + Domain l1Domain; + Domain l2Domain; + address deployer; + ChainLogLike chainlog; + address l1GovRelay; + address l2GovRelay; + address l2Spell; + + function run() external { + l1Chain = getChain(string(vm.envOr("L1", string("mainnet")))); + l2Chain = getChain(string(vm.envOr("L2", string("base")))); + vm.setEnv("FOUNDRY_ROOT_CHAINID", vm.toString(l1Chain.chainId)); // used by ScriptTools to determine config path + config = ScriptTools.loadConfig("config"); + l1Domain = new Domain(config, l1Chain); + l2Domain = new Domain(config, l2Chain); + + l1Domain.selectFork(); + + chainlog = ChainLogLike(l1Domain.readConfigAddress("chainlog")); + l1GovRelay = chainlog.getAddress(l2Domain.readConfigBytes32FromString("govRelayCLKey")); + l2GovRelay = L1GovernanceRelayLike(payable(l1GovRelay)).l2GovernanceRelay(); + + l2Domain.selectFork(); + + vm.startBroadcast(l2PrivKey); + l2Spell = FarmProxyDeploy.deployL2ProxySpell(); + vm.stopBroadcast(); + + // Export contract addresses + + ScriptTools.exportContract("deployed", "chainlog", address(chainlog)); + ScriptTools.exportContract("deployed", "l2ProxySpell", l2Spell); + ScriptTools.exportContract("deployed", "l1GovRelay", l1GovRelay); + ScriptTools.exportContract("deployed", "l2GovRelay", l2GovRelay); + } +} diff --git a/script/Distribute.s.sol b/script/Distribute.s.sol new file mode 100644 index 0000000..36bfcf2 --- /dev/null +++ b/script/Distribute.s.sol @@ -0,0 +1,49 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later + +// Copyright (C) 2024 Dai Foundation +// +// 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 . + +pragma solidity ^0.8.21; + +import "forge-std/Script.sol"; + +import { ScriptTools } from "dss-test/ScriptTools.sol"; +import { Domain } from "dss-test/domains/Domain.sol"; + +interface DistributionLike { + function distribute() external returns (uint256); +} + +// Run vestedRewardsDistribution.distribute() to test deployement +contract Distribute is Script { + using stdJson for string; + + uint256 l1PrivKey = vm.envUint("L1_PRIVATE_KEY"); + + function run() external { + StdChains.Chain memory l1Chain = getChain(string(vm.envOr("L1", string("mainnet")))); + vm.setEnv("FOUNDRY_ROOT_CHAINID", vm.toString(l1Chain.chainId)); // used by ScriptTools to determine config path + string memory config = ScriptTools.loadConfig("config"); + string memory deps = ScriptTools.loadDependencies(); + Domain l1Domain = new Domain(config, l1Chain); + l1Domain.selectFork(); + + DistributionLike distribution = DistributionLike(deps.readAddress(".vestedRewardsDistribution")); + + vm.startBroadcast(l1PrivKey); + distribution.distribute(); + vm.stopBroadcast(); + } +} diff --git a/script/Forward.s.sol b/script/Forward.s.sol new file mode 100644 index 0000000..889b47d --- /dev/null +++ b/script/Forward.s.sol @@ -0,0 +1,50 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later + +// Copyright (C) 2024 Dai Foundation +// +// 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 . + +pragma solidity ^0.8.21; + +import "forge-std/Script.sol"; + +import { ScriptTools } from "dss-test/ScriptTools.sol"; +import { Domain } from "dss-test/domains/Domain.sol"; + +interface L2ProxyLike { + function forwardReward() external; +} + +// Run l2Proxy.forwardReward() to test deployement +contract Forward is Script { + using stdJson for string; + + uint256 l2PrivKey = vm.envUint("L2_PRIVATE_KEY"); + + function run() external { + StdChains.Chain memory l1Chain = getChain(string(vm.envOr("L1", string("mainnet")))); + StdChains.Chain memory l2Chain = getChain(string(vm.envOr("L2", string("base")))); + vm.setEnv("FOUNDRY_ROOT_CHAINID", vm.toString(l1Chain.chainId)); // used by ScriptTools to determine config path + string memory config = ScriptTools.loadConfig("config"); + string memory deps = ScriptTools.loadDependencies(); + Domain l2Domain = new Domain(config, l2Chain); + l2Domain.selectFork(); + + address l2Proxy = deps.readAddress(".l2Proxy"); + + vm.startBroadcast(l2PrivKey); + L2ProxyLike(l2Proxy).forwardReward(); + vm.stopBroadcast(); + } +} diff --git a/script/Init.s.sol b/script/Init.s.sol new file mode 100644 index 0000000..7bcd9b8 --- /dev/null +++ b/script/Init.s.sol @@ -0,0 +1,87 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later + +// Copyright (C) 2024 Dai Foundation +// +// 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 . + +pragma solidity ^0.8.21; + +import "forge-std/Script.sol"; + +import { ScriptTools } from "dss-test/ScriptTools.sol"; +import { Domain } from "dss-test/domains/Domain.sol"; +import { MCD, DssInstance } from "dss-test/MCD.sol"; +import { FarmProxyInit, ProxiesConfig } from "deploy/FarmProxyInit.sol"; +import { L2FarmProxySpell } from "deploy/L2FarmProxySpell.sol"; + +interface L2GovernanceRelayLike { + function relay(address, bytes calldata) external; +} + +contract Init is Script { + using stdJson for string; + + uint256 l1PrivKey = vm.envUint("L1_PRIVATE_KEY"); + + StdChains.Chain l1Chain; + StdChains.Chain l2Chain; + string config; + string deps; + Domain l1Domain; + Domain l2Domain; + DssInstance dss; + + function run() external { + l1Chain = getChain(string(vm.envOr("L1", string("mainnet")))); + l2Chain = getChain(string(vm.envOr("L2", string("base")))); + vm.setEnv("FOUNDRY_ROOT_CHAINID", vm.toString(l1Chain.chainId)); // used by ScriptTools to determine config path + config = ScriptTools.loadConfig("config"); + deps = ScriptTools.loadDependencies(); + l1Domain = new Domain(config, l1Chain); + l2Domain = new Domain(config, l2Chain); + l1Domain.selectFork(); + + dss = MCD.loadFromChainlog(deps.readAddress(".chainlog")); + + ProxiesConfig memory cfg = ProxiesConfig({ + vest: deps.readAddress(".vest"), + vestTot: 100 ether, + vestBgn: block.timestamp, + vestTau: 100 days, + vestedRewardsDistribution: deps.readAddress(".vestedRewardsDistribution"), + l1RewardsToken: deps.readAddress(".l1RewardsToken"), + l2RewardsToken: deps.readAddress(".l2RewardsToken"), + l2StakingToken: deps.readAddress(".l2StakingToken"), + l1Bridge: deps.readAddress(".l1Bridge"), + minGasLimit: 1_000_000, // Note that this is just a random value for testing, in production a tight value is recommended to avoid excess gas waste. + rewardThreshold: 0, + farm: deps.readAddress(".farm"), + rewardsDuration: 1 days, + initMinGasLimit: 1_000_000, // Note that also here, a tighter value in production is recommended. + proxyChainlogKey: "FARM_PROXY_TKA_TKB_BASE", // Note: need to change this when non Base (relevant for testing only as in production this is run in the spell) + distrChainlogKey: "REWARDS_DIST_TKA_TKB_BASE" // Note: need to change this when non Base (relevant for testing only as in production this is run in the spell) + }); + + vm.startBroadcast(l1PrivKey); + FarmProxyInit.initProxies( + dss, + deps.readAddress(".l1GovRelay"), + deps.readAddress(".l1Proxy"), + deps.readAddress(".l2Proxy"), + deps.readAddress(".l2ProxySpell"), + cfg + ); + vm.stopBroadcast(); + } +} diff --git a/script/input/1/config.json b/script/input/1/config.json new file mode 100644 index 0000000..e1cc752 --- /dev/null +++ b/script/input/1/config.json @@ -0,0 +1,17 @@ +{ + "domains": { + "mainnet": { + "chainlog": "0xdA0Ab1e0017DEbCd72Be8599041a2aa3bA7e740F", + "rewardsToken": "0x0000000000000000000000000000000000000000", + "vest": "0x0000000000000000000000000000000000000000" + }, + "base": { + "l1Messenger": "0x866E82a600A1414e583f7F13623F1aC5d58b0Afa", + "l2Messenger": "0x4200000000000000000000000000000000000007", + "rewardsToken": "0x0000000000000000000000000000000000000000", + "stakingToken": "0x0000000000000000000000000000000000000000", + "govRelayCLKey": "BASE_GOV_RELAY", + "l1BridgeCLKey": "BASE_TOKEN_BRIDGE" + } + } +} diff --git a/script/input/11155111/config.json b/script/input/11155111/config.json new file mode 100644 index 0000000..2032665 --- /dev/null +++ b/script/input/11155111/config.json @@ -0,0 +1,16 @@ +{ + "domains": { + "sepolia": { + "chainlog": "0x667a1BF9B7271EC89A9c1bDd4F751303c3306289", + "rewardsToken": "0x914af303be48320e8403f91E516946739AD76886" + }, + "base_sepolia": { + "l1Messenger": "0xC34855F4De64F1840e5686e64278da901e261f20", + "l2Messenger": "0x4200000000000000000000000000000000000007", + "rewardsToken": "0x667a1BF9B7271EC89A9c1bDd4F751303c3306289", + "stakingToken": "0x4699614928639b94cc291dEB9c69617D60d49F3b", + "govRelayCLKey": "BASE_GOV_RELAY", + "l1BridgeCLKey": "BASE_TOKEN_BRIDGE" + } + } +} diff --git a/script/output/11155111/deployed-latest.json b/script/output/11155111/deployed-latest.json new file mode 100644 index 0000000..563780d --- /dev/null +++ b/script/output/11155111/deployed-latest.json @@ -0,0 +1,15 @@ +{ + "chainlog": "0x667a1BF9B7271EC89A9c1bDd4F751303c3306289", + "farm": "0x600ae38014470Ea54b74b8bd3c6E4CfF0e87d4e5", + "l1Bridge": "0x4699614928639b94cc291dEB9c69617D60d49F3b", + "l1GovRelay": "0xBB676bc88EEfCFf84e52FbfFE657A3B4A70E9195", + "l1Proxy": "0x310BCC6231a1996ffAc68f7631D729836826f2f4", + "l1RewardsToken": "0x914af303be48320e8403f91E516946739AD76886", + "l2GovRelay": "0xeDa7f76c8Eab9Fc9B5824a97cE975511327e03d4", + "l2Proxy": "0x3Fa4d396C35dAC916001BE45cDb6Ee1647C73E7f", + "l2ProxySpell": "0xCA89139Ad5dc0A6EBBd6Ff4C46f7fd38e3E1F4a2", + "l2RewardsToken": "0x667a1BF9B7271EC89A9c1bDd4F751303c3306289", + "stakingToken": "0x4699614928639b94cc291dEB9c69617D60d49F3b", + "vest": "0xF202b20dcE12A060C90A60EdE809C7ee2DA44dC8", + "vestedRewardsDistribution": "0xfbDCBd7085093b3A5dEcf2158e3873422fF07A0e" +} diff --git a/src/L1FarmProxy.sol b/src/L1FarmProxy.sol new file mode 100644 index 0000000..79c4bdd --- /dev/null +++ b/src/L1FarmProxy.sol @@ -0,0 +1,101 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later + +// Copyright (C) 2024 Dai Foundation +// +// 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 . + +pragma solidity ^0.8.21; + +interface GemLike { + function approve(address, uint256) external; + function transfer(address, uint256) external; +} + +interface L1TokenBridgeLike { + function bridgeERC20To( + address _localToken, + address _remoteToken, + address _to, + uint256 _amount, + uint32 _minGasLimit, + bytes calldata _extraData + ) external; +} + +contract L1FarmProxy { + mapping (address => uint256) public wards; + uint32 public minGasLimit; + uint224 public rewardThreshold; // A threshold is not strictly required but aligns with other L2 farm proxies + + address public immutable rewardsToken; + address public immutable remoteToken; + address public immutable l2Proxy; + L1TokenBridgeLike public immutable l1Bridge; + + event Rely(address indexed usr); + event Deny(address indexed usr); + event File(bytes32 indexed what, uint256 data); + event RewardAdded(uint256 reward); + + constructor(address _rewardsToken, address _remoteToken, address _l2Proxy, address _l1Bridge) { + rewardsToken = _rewardsToken; + remoteToken = _remoteToken; + l2Proxy = _l2Proxy; + l1Bridge = L1TokenBridgeLike(_l1Bridge); + + GemLike(_rewardsToken).approve(_l1Bridge, type(uint256).max); + + wards[msg.sender] = 1; + emit Rely(msg.sender); + } + + modifier auth { + require(wards[msg.sender] == 1, "L1FarmProxy/not-authorized"); + _; + } + + function rely(address usr) external auth { wards[usr] = 1; emit Rely(usr); } + function deny(address usr) external auth { wards[usr] = 0; emit Deny(usr); } + + // @notice Validation of the `data` boundaries is outside the scope of this + // contract and is assumed to be carried out in the corresponding spell process + function file(bytes32 what, uint256 data) external auth { + if (what == "minGasLimit") minGasLimit = uint32(data); + else if (what == "rewardThreshold") rewardThreshold = uint224(data); + else revert("L1FarmProxy/file-unrecognized-param"); + emit File(what, data); + } + + // @notice Allow governance to recover potentially stuck tokens + function recover(address token, address receiver, uint256 amount) external auth { + GemLike(token).transfer(receiver, amount); + } + + // @notice Send reward to L2 farm proxy + function notifyRewardAmount(uint256 reward) external { + (uint32 minGasLimit_, uint256 rewardThreshold_) = (minGasLimit, rewardThreshold); + require(reward > rewardThreshold_, "L1FarmProxy/reward-too-small"); + + l1Bridge.bridgeERC20To({ + _localToken: rewardsToken, + _remoteToken: remoteToken, + _to : l2Proxy, + _amount : reward, + _minGasLimit: minGasLimit_, + _extraData : bytes("") + }); + + emit RewardAdded(reward); + } +} diff --git a/src/L2FarmProxy.sol b/src/L2FarmProxy.sol new file mode 100644 index 0000000..4b1f610 --- /dev/null +++ b/src/L2FarmProxy.sol @@ -0,0 +1,76 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later + +// Copyright (C) 2024 Dai Foundation +// +// 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 . + +pragma solidity ^0.8.21; + +interface FarmLike { + function rewardsToken() external view returns (address); + function notifyRewardAmount(uint256 reward) external; +} + +interface GemLike { + function balanceOf(address) external view returns (uint256); + function transfer(address, uint256) external; +} + +contract L2FarmProxy { + mapping (address => uint256) public wards; + uint256 public rewardThreshold; + + GemLike public immutable rewardsToken; + FarmLike public immutable farm; + + event Rely(address indexed usr); + event Deny(address indexed usr); + event File(bytes32 indexed what, uint256 data); + + constructor(address _farm) { + farm = FarmLike(_farm); + rewardsToken = GemLike(farm.rewardsToken()); + + wards[msg.sender] = 1; + emit Rely(msg.sender); + } + + modifier auth { + require(wards[msg.sender] == 1, "L2FarmProxy/not-authorized"); + _; + } + + 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, uint256 data) external auth { + if (what == "rewardThreshold") rewardThreshold = data; + else revert("L2FarmProxy/file-unrecognized-param"); + emit File(what, data); + } + + // @notice Allow governance to recover potentially stuck tokens + function recover(address token, address receiver, uint256 amount) external auth { + GemLike(token).transfer(receiver, amount); + } + + // @notice The transferred reward must exceed a minimum threshold to reduce the impact of + // calling this function too frequently in an attempt to reduce the rewardRate of the farm + function forwardReward() external { + uint256 reward = rewardsToken.balanceOf(address(this)); + require(reward > rewardThreshold, "L2FarmProxy/reward-too-small"); + rewardsToken.transfer(address(farm), reward); + farm.notifyRewardAmount(reward); + } +} diff --git a/test/Integration.t.sol b/test/Integration.t.sol new file mode 100644 index 0000000..1e5f674 --- /dev/null +++ b/test/Integration.t.sol @@ -0,0 +1,256 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later + +// Copyright (C) 2024 Dai Foundation +// +// 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 . + +pragma solidity ^0.8.21; + +import "dss-test/DssTest.sol"; + +import { Domain } from "dss-test/domains/Domain.sol"; +import { OptimismDomain } from "dss-test/domains/OptimismDomain.sol"; + +import { TokenBridgeDeploy } from "lib/op-token-bridge/deploy/TokenBridgeDeploy.sol"; +import { L2TokenBridgeSpell } from "lib/op-token-bridge/deploy/L2TokenBridgeSpell.sol"; +import { L1TokenBridgeInstance } from "lib/op-token-bridge/deploy/L1TokenBridgeInstance.sol"; +import { L2TokenBridgeInstance } from "lib/op-token-bridge/deploy/L2TokenBridgeInstance.sol"; +import { TokenBridgeInit, BridgesConfig } from "lib/op-token-bridge/deploy/TokenBridgeInit.sol"; +import { StakingRewards, StakingRewardsDeploy, StakingRewardsDeployParams } from "lib/endgame-toolkit/script/dependencies/StakingRewardsDeploy.sol"; +import { VestedRewardsDistributionDeploy, VestedRewardsDistributionDeployParams } from "lib/endgame-toolkit/script/dependencies/VestedRewardsDistributionDeploy.sol"; +import { VestedRewardsDistribution } from "lib/endgame-toolkit/src/VestedRewardsDistribution.sol"; +import { GemMock } from "test/mocks/GemMock.sol"; +import { DssVestMintableMock } from "test/mocks/DssVestMock.sol"; +import { FarmProxyDeploy } from "deploy/FarmProxyDeploy.sol"; +import { L2FarmProxySpell } from "deploy/L2FarmProxySpell.sol"; +import { FarmProxyInit, ProxiesConfig } from "deploy/FarmProxyInit.sol"; +import { L1FarmProxy } from "src/L1FarmProxy.sol"; +import { L2FarmProxy } from "src/L2FarmProxy.sol"; + +interface L1RelayLike { + function l2GovernanceRelay() external view returns (address); +} + +contract IntegrationTest is DssTest { + string config; + Domain l1Domain; + OptimismDomain l2Domain; + + // L1-side + DssInstance dss; + address PAUSE_PROXY; + address escrow; + address l1GovRelay; + address l1Messenger; + GemMock l1Token; + address l1Bridge; + L1FarmProxy l1Proxy; + DssVestMintableMock vest; + uint256 vestId; + VestedRewardsDistribution vestedRewardsDistribution; + + // L2-side + address l2GovRelay; + address l2Messenger; + GemMock l2Token; + address l2Bridge; + L2FarmProxy l2Proxy; + StakingRewards farm; + + constructor() { + vm.setEnv("FOUNDRY_ROOT_CHAINID", "1"); // used by ScriptTools to determine config path + // Note: need to set the domains here instead of in setUp() to make sure their storages are actually persistent + config = ScriptTools.loadConfig("config"); + + l1Domain = new Domain(config, getChain("mainnet")); + l2Domain = new OptimismDomain(config, getChain("base"), l1Domain); + } + + function setupGateways() internal { + l1Messenger = address(l2Domain.l1Messenger()); + l2Messenger = address(l2Domain.l2Messenger()); + + l1GovRelay = vm.computeCreateAddress(address(this), vm.getNonce(address(this)) + 3); // foundry increments a global nonce across domains + l1Bridge = vm.computeCreateAddress(address(this), vm.getNonce(address(this)) + 5); + + l2Domain.selectFork(); + L2TokenBridgeInstance memory l2BridgeInstance = TokenBridgeDeploy.deployL2({ + deployer: address(this), + l1GovRelay: l1GovRelay, + l1Bridge: l1Bridge, + l2Messenger: l2Messenger + }); + l2Bridge = l2BridgeInstance.bridge; + l2GovRelay = l2BridgeInstance.govRelay; + + assertEq(address(L2TokenBridgeSpell(l2BridgeInstance.spell).l2Bridge()), address(l2Bridge)); + + l1Domain.selectFork(); + L1TokenBridgeInstance memory l1BridgeInstance = TokenBridgeDeploy.deployL1({ + deployer: address(this), + owner: PAUSE_PROXY, + l2GovRelay: l2GovRelay, + l2Bridge: address(l2Bridge), + l1Messenger: l1Messenger + }); + assertEq(l1BridgeInstance.bridge, l1Bridge); + assertEq(l1BridgeInstance.govRelay, l1GovRelay); + escrow = l1BridgeInstance.escrow; + + l2Domain.selectFork(); + l2Token = new GemMock(0); + l2Token.rely(l2GovRelay); + l2Token.deny(address(this)); + + address[] memory l1Tokens = new address[](1); + l1Tokens[0] = address(l1Token); + address[] memory l2Tokens = new address[](1); + l2Tokens[0] = address(l2Token); + + BridgesConfig memory cfg = BridgesConfig({ + l1Messenger: l1Messenger, + l2Messenger: l2Messenger, + l1Tokens: l1Tokens, + l2Tokens: l2Tokens, + minGasLimit: 1_000_000, + govRelayCLKey: "BASE_GOV_RELAY", + escrowCLKey: "BASE_ESCROW", + l1BridgeCLKey: "BASE_TOKEN_BRIDGE" + }); + + l1Domain.selectFork(); + vm.startPrank(PAUSE_PROXY); + TokenBridgeInit.initBridges(dss, l1BridgeInstance, l2BridgeInstance, cfg); + vm.stopPrank(); + + } + + function setUp() public { + l1Domain.selectFork(); + l1Domain.loadDssFromChainlog(); + dss = l1Domain.dss(); + PAUSE_PROXY = dss.chainlog.getAddress("MCD_PAUSE_PROXY"); + + vm.startPrank(PAUSE_PROXY); + l1Token = new GemMock(100 ether); + vest = new DssVestMintableMock(address(l1Token)); + l1Token.rely(address(vest)); + vest.file("cap", type(uint256).max); + vm.stopPrank(); + + setupGateways(); + + l2Domain.selectFork(); + + address stakingToken = address(new GemMock(100 ether)); + StakingRewardsDeployParams memory farmParams = StakingRewardsDeployParams({ + owner: l2GovRelay, + stakingToken: stakingToken, + rewardsToken: address(l2Token) + }); + farm = StakingRewards(StakingRewardsDeploy.deploy(farmParams)); + + l2Proxy = L2FarmProxy(FarmProxyDeploy.deployL2Proxy({ + deployer: address(this), + owner: l2GovRelay, + farm: address(farm) + })); + address l2Spell = FarmProxyDeploy.deployL2ProxySpell(); + + l1Domain.selectFork(); + l1Proxy = L1FarmProxy(FarmProxyDeploy.deployL1Proxy({ + deployer: address(this), + owner: PAUSE_PROXY, + rewardsToken: address(l1Token), + remoteToken: address(l2Token), + l2Proxy: address(l2Proxy), + l1Bridge: l1Bridge + })); + + VestedRewardsDistributionDeployParams memory distributionParams = VestedRewardsDistributionDeployParams({ + deployer: address(this), + owner: PAUSE_PROXY, + vest: address(vest), + rewards: address(l1Proxy) + }); + vestedRewardsDistribution = VestedRewardsDistribution(VestedRewardsDistributionDeploy.deploy(distributionParams)); + + ProxiesConfig memory cfg = ProxiesConfig({ + vest: address(vest), + vestTot: 100 * 1e18, + vestBgn: block.timestamp, + vestTau: 100 days, + vestedRewardsDistribution: address(vestedRewardsDistribution), + l1RewardsToken: address(l1Token), + l2RewardsToken: address(l2Token), + l2StakingToken: stakingToken, + l1Bridge: l1Bridge, + minGasLimit: 1_000_000, + rewardThreshold: 1 ether, + farm: address(farm), + rewardsDuration: 1 days, + initMinGasLimit: 1_000_000, + proxyChainlogKey: "FARM_PROXY_TKA_TKB_BASE", + distrChainlogKey: "REWARDS_DIST_TKA_TKB_BASE" + }); + + vm.startPrank(PAUSE_PROXY); + FarmProxyInit.initProxies(dss, l1GovRelay, address(l1Proxy), address(l2Proxy), l2Spell, cfg); + vm.stopPrank(); + + // test L1 side of initProxies + vestId = vestedRewardsDistribution.vestId(); + assertEq(vest.usr(vestId), cfg.vestedRewardsDistribution); + assertEq(vest.bgn(vestId), cfg.vestBgn); + assertEq(vest.clf(vestId), cfg.vestBgn); + assertEq(vest.fin(vestId), cfg.vestBgn + cfg.vestTau); + assertEq(vest.tot(vestId), cfg.vestTot); + assertEq(vest.mgr(vestId), address(0)); + assertEq(vest.res(vestId), 1); + assertEq(l1Proxy.minGasLimit(), cfg.minGasLimit); + assertEq(l1Proxy.rewardThreshold(), cfg.rewardThreshold); + assertEq(dss.chainlog.getAddress("FARM_PROXY_TKA_TKB_BASE"), address(l1Proxy)); + assertEq(dss.chainlog.getAddress("REWARDS_DIST_TKA_TKB_BASE"), cfg.vestedRewardsDistribution); + + l2Domain.relayFromHost(true); + + // test L2 side of initProxies + assertEq(l2Proxy.rewardThreshold(), cfg.rewardThreshold); + assertEq(farm.rewardsDistribution(), address(l2Proxy)); + assertEq(farm.rewardsDuration(), cfg.rewardsDuration); + } + + function testDistribution() public { + l1Domain.selectFork(); + uint256 rewardThreshold = l1Proxy.rewardThreshold(); + vm.warp(vest.bgn(vestId) + rewardThreshold * (vest.fin(vestId) - vest.bgn(vestId)) / vest.tot(vestId) + 1); + uint256 amount = vest.unpaid(vestId); + assertGt(amount, rewardThreshold); + assertEq(l1Token.balanceOf(escrow), 0); + + vestedRewardsDistribution.distribute(); + + assertEq(l1Token.balanceOf(escrow), amount); + + l2Domain.relayFromHost(true); + + assertEq(l2Token.balanceOf(address(l2Proxy)), amount); + + l2Proxy.forwardReward(); + + assertEq(l2Token.balanceOf(address(l2Proxy)), 0); + assertEq(l2Token.balanceOf(address(farm)), amount); + assertEq(farm.rewardRate(), amount / farm.rewardsDuration()); + } +} diff --git a/test/L1FarmProxy.t.sol b/test/L1FarmProxy.t.sol new file mode 100644 index 0000000..97b3335 --- /dev/null +++ b/test/L1FarmProxy.t.sol @@ -0,0 +1,102 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later + +// Copyright (C) 2024 Dai Foundation +// +// 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 . + +pragma solidity ^0.8.21; + +import "dss-test/DssTest.sol"; + +import { L1FarmProxy } from "src/L1FarmProxy.sol"; +import { GemMock } from "test/mocks/GemMock.sol"; +import { L1TokenBridgeMock } from "test/mocks/L1TokenBridgeMock.sol"; + +contract L1FarmProxyTest is DssTest { + + GemMock rewardsToken; + L1FarmProxy l1Proxy; + address bridge; + address escrow = address(0xeee); + address l2Proxy = address(0x222); + address remoteToken = address(0x333); + + event RewardAdded(uint256 rewards); + + function setUp() public { + bridge = address(new L1TokenBridgeMock(escrow)); + rewardsToken = new GemMock(1_000_000 ether); + l1Proxy = new L1FarmProxy(address(rewardsToken), remoteToken, l2Proxy, bridge); + } + + function testConstructor() public { + vm.expectEmit(true, true, true, true); + emit Rely(address(this)); + L1FarmProxy p = new L1FarmProxy(address(rewardsToken), remoteToken, l2Proxy, bridge); + + assertEq(p.rewardsToken(), address(rewardsToken)); + assertEq(p.remoteToken(), remoteToken); + assertEq(p.l2Proxy(), l2Proxy); + assertEq(address(p.l1Bridge()), bridge); + assertEq(rewardsToken.allowance(address(p), bridge), type(uint256).max); + assertEq(p.wards(address(this)), 1); + } + + function testAuth() public { + checkAuth(address(l1Proxy), "L1FarmProxy"); + } + + function testFile() public { + checkFileUint(address(l1Proxy), "L1FarmProxy", ["minGasLimit", "rewardThreshold"]); + } + + function testAuthModifiers() public virtual { + l1Proxy.deny(address(this)); + + checkModifier(address(l1Proxy), string(abi.encodePacked("L1FarmProxy", "/not-authorized")), [ + l1Proxy.recover.selector + ]); + } + + function testRecover() public { + address receiver = address(0x123); + rewardsToken.transfer(address(l1Proxy), 1 ether); + + assertEq(rewardsToken.balanceOf(receiver), 0); + assertEq(rewardsToken.balanceOf(address(l1Proxy)), 1 ether); + + l1Proxy.recover(address(rewardsToken), receiver, 1 ether); + + assertEq(rewardsToken.balanceOf(receiver), 1 ether); + assertEq(rewardsToken.balanceOf(address(l1Proxy)), 0); + } + + function testNotifyRewardAmount() public { + l1Proxy.file("rewardThreshold", 100 ether); + + vm.expectRevert("L1FarmProxy/reward-too-small"); + l1Proxy.notifyRewardAmount(100 ether); + + rewardsToken.transfer(address(l1Proxy), 101 ether); + assertEq(rewardsToken.balanceOf(escrow), 0); + assertEq(rewardsToken.balanceOf(address(l1Proxy)), 101 ether); + + vm.expectEmit(true, true, true, true); + emit RewardAdded(101 ether); + l1Proxy.notifyRewardAmount(101 ether); + + assertEq(rewardsToken.balanceOf(escrow), 101 ether); + assertEq(rewardsToken.balanceOf(address(l1Proxy)), 0); + } +} diff --git a/test/L2FarmProxy.t.sol b/test/L2FarmProxy.t.sol new file mode 100644 index 0000000..6037c55 --- /dev/null +++ b/test/L2FarmProxy.t.sol @@ -0,0 +1,96 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later + +// Copyright (C) 2024 Dai Foundation +// +// 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 . + +pragma solidity ^0.8.21; + +import "dss-test/DssTest.sol"; + +import { L2FarmProxy } from "src/L2FarmProxy.sol"; +import { FarmMock } from "test/mocks/FarmMock.sol"; +import { GemMock } from "test/mocks/GemMock.sol"; + +contract L2FarmProxyTest is DssTest { + + GemMock rewardsToken; + L2FarmProxy l2Proxy; + address farm; + + event RewardAdded(uint256 rewards); + + function setUp() public { + rewardsToken = new GemMock(1_000_000 ether); + farm = address(new FarmMock(address(rewardsToken), address(123))); + l2Proxy = new L2FarmProxy(farm); + } + + function testConstructor() public { + vm.expectEmit(true, true, true, true); + emit Rely(address(this)); + L2FarmProxy p = new L2FarmProxy(farm); + assertEq(address(p.farm()), farm); + assertEq(address(p.rewardsToken()), address(rewardsToken)); + assertEq(p.wards(address(this)), 1); + } + + function testAuth() public { + checkAuth(address(l2Proxy), "L2FarmProxy"); + } + + function testFile() public { + checkFileUint(address(l2Proxy), "L2FarmProxy", ["rewardThreshold"]); + } + + function testAuthModifiers() public virtual { + l2Proxy.deny(address(this)); + + checkModifier(address(l2Proxy), string(abi.encodePacked("L2FarmProxy", "/not-authorized")), [ + l2Proxy.recover.selector + ]); + } + + function testRecover() public { + address receiver = address(0x123); + rewardsToken.transfer(address(l2Proxy), 1 ether); + + assertEq(rewardsToken.balanceOf(receiver), 0); + assertEq(rewardsToken.balanceOf(address(l2Proxy)), 1 ether); + + l2Proxy.recover(address(rewardsToken), receiver, 1 ether); + + assertEq(rewardsToken.balanceOf(receiver), 1 ether); + assertEq(rewardsToken.balanceOf(address(l2Proxy)), 0); + } + + function testForwardReward() public { + l2Proxy.file("rewardThreshold", 100 ether); + rewardsToken.transfer(address(l2Proxy), 100 ether); + + vm.expectRevert("L2FarmProxy/reward-too-small"); + l2Proxy.forwardReward(); + + rewardsToken.transfer(address(l2Proxy), 1 ether); + assertEq(rewardsToken.balanceOf(farm), 0); + assertEq(rewardsToken.balanceOf(address(l2Proxy)), 101 ether); + + vm.expectEmit(true, true, true, true); + emit RewardAdded(101 ether); + l2Proxy.forwardReward(); + + assertEq(rewardsToken.balanceOf(farm), 101 ether); + assertEq(rewardsToken.balanceOf(address(l2Proxy)), 0); + } +} diff --git a/test/L2FarmProxySpell.t.sol b/test/L2FarmProxySpell.t.sol new file mode 100644 index 0000000..df7ff4f --- /dev/null +++ b/test/L2FarmProxySpell.t.sol @@ -0,0 +1,180 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later + +// Copyright (C) 2024 Dai Foundation +// +// 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 . + +pragma solidity ^0.8.21; + +import "dss-test/DssTest.sol"; + +import { L2FarmProxy } from "src/L2FarmProxy.sol"; +import { L2FarmProxySpell } from "deploy/L2FarmProxySpell.sol"; +import { FarmMock } from "test/mocks/FarmMock.sol"; +import { GemMock } from "test/mocks/GemMock.sol"; + +contract L2FarmProxySpellTest is DssTest { + + GemMock rewardsToken; + address stakingToken = address(444); + address l2Proxy; + L2FarmProxySpell l2Spell; + address farm; + + event OwnerNominated(address newOwner); + event PauseChanged(bool isPaused); + event RewardsDurationUpdated(uint256 newDuration); + event RewardsDistributionUpdated(address newRewardsDistribution); + event Recovered(address token, uint256 amount); + + function setUp() public { + rewardsToken = new GemMock(1_000_000 ether); + farm = address(new FarmMock(address(rewardsToken), stakingToken)); + l2Proxy = address(new L2FarmProxy(farm)); + l2Spell = new L2FarmProxySpell(); + } + + function testL2ProxyFunctions() public { + bool success; + address usr = address(123); + + vm.expectEmit(true, true, true, true); + emit Rely(usr); + (success,) = address(l2Spell).delegatecall(abi.encodeCall(L2FarmProxySpell.rely, (l2Proxy, usr))); + assertTrue(success); + + vm.expectEmit(true, true, true, true); + emit Deny(usr); + (success,) = address(l2Spell).delegatecall(abi.encodeCall(L2FarmProxySpell.deny, (l2Proxy, usr))); + assertTrue(success); + + bytes32 what = "rewardThreshold"; + uint256 data = 456; + vm.expectEmit(true, true, true, true); + emit File(what, data); + (success,) = address(l2Spell).delegatecall(abi.encodeCall(L2FarmProxySpell.file, (l2Proxy, what, data))); + assertTrue(success); + + uint256 amount = 789 ether; + rewardsToken.transfer(l2Proxy, amount); + (success,) = address(l2Spell).delegatecall(abi.encodeCall(L2FarmProxySpell.recover, (l2Proxy, address(rewardsToken), usr, amount))); + assertTrue(success); + assertEq(rewardsToken.balanceOf(usr), amount); + } + + function testFarmFunctions() public { + bool success; + address usr = address(123); + + vm.expectEmit(true, true, true, true); + emit OwnerNominated(usr); + (success,) = address(l2Spell).delegatecall(abi.encodeCall(L2FarmProxySpell.nominateNewOwner, (farm, usr))); + assertTrue(success); + + vm.expectEmit(true, true, true, true); + emit PauseChanged(true); + (success,) = address(l2Spell).delegatecall(abi.encodeCall(L2FarmProxySpell.setPaused, (farm, true))); + assertTrue(success); + + uint256 amount = 456 ether; + vm.expectEmit(true, true, true, true); + emit Recovered(address(rewardsToken), amount); + (success,) = address(l2Spell).delegatecall(abi.encodeCall(L2FarmProxySpell.recoverERC20, (farm, address(rewardsToken), amount))); + assertTrue(success); + + vm.expectEmit(true, true, true, true); + emit RewardsDurationUpdated(amount); + (success,) = address(l2Spell).delegatecall(abi.encodeCall(L2FarmProxySpell.setRewardsDuration, (farm, amount))); + assertTrue(success); + + vm.expectEmit(true, true, true, true); + emit RewardsDistributionUpdated(usr); + (success,) = address(l2Spell).delegatecall(abi.encodeCall(L2FarmProxySpell.setRewardsDistribution, (farm, usr))); + assertTrue(success); + } + + // from https://ethereum.stackexchange.com/a/83577 + function _getRevertMsg(bytes memory _returnData) internal pure returns (string memory) { + if (_returnData.length < 68) return 'Transaction reverted silently'; + assembly { _returnData := add(_returnData, 0x04) } + return abi.decode(_returnData, (string)); + } + + function testInit() public { + bool success; + bytes memory response; + + (success, response) = address(l2Spell).delegatecall(abi.encodeCall(L2FarmProxySpell.init, ( + l2Proxy, + address(0xb4d), + stakingToken, + farm, + 0, + 7 days + ))); + assertFalse(success); + assertEq(_getRevertMsg(response), "L2FarmProxySpell/rewards-token-mismatch"); + + (success, response) = address(l2Spell).delegatecall(abi.encodeCall(L2FarmProxySpell.init, ( + l2Proxy, + address(rewardsToken), + stakingToken, + address(0xb4d), + 0, + 7 days + ))); + assertFalse(success); + assertEq(_getRevertMsg(response), "L2FarmProxySpell/farm-mismatch"); + + (success, response) = address(l2Spell).delegatecall(abi.encodeCall(L2FarmProxySpell.init, ( + l2Proxy, + address(rewardsToken), + address(0xb4d), + farm, + 0, + 7 days + ))); + assertFalse(success); + assertEq(_getRevertMsg(response), "L2FarmProxySpell/farm-staking-token-mismatch"); + + address badFarm = address(new FarmMock(address(rewardsToken), address(rewardsToken))); + address badL2Proxy = address(new L2FarmProxy(badFarm)); + (success, response) = address(l2Spell).delegatecall(abi.encodeCall(L2FarmProxySpell.init, ( + badL2Proxy, + address(rewardsToken), + address(rewardsToken), + badFarm, + 0, + 7 days + ))); + assertFalse(success); + assertEq(_getRevertMsg(response), "L2FarmProxySpell/rewards-token-same-as-staking-token"); + + vm.expectEmit(true, true, true, true); + emit File("rewardThreshold", 888); + vm.expectEmit(true, true, true, true); + emit RewardsDistributionUpdated(l2Proxy); + vm.expectEmit(true, true, true, true); + emit RewardsDurationUpdated(7 days); + (success, response) = address(l2Spell).delegatecall(abi.encodeCall(L2FarmProxySpell.init, ( + l2Proxy, + address(rewardsToken), + stakingToken, + farm, + 888, + 7 days + ))); + assertTrue(success); + } +} diff --git a/test/mocks/DssVestMock.sol b/test/mocks/DssVestMock.sol new file mode 100644 index 0000000..affdb1c --- /dev/null +++ b/test/mocks/DssVestMock.sol @@ -0,0 +1,478 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later +// +// DssVestMock - Mock of DssVest, a token vesting contract +// +// Copyright (C) 2021 Dai Foundation +// +// 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 . + +pragma solidity ^0.8.21; + +interface MintLike { + function mint(address, uint256) external; +} + +interface ChainlogLike { + function getAddress(bytes32) external view returns (address); +} + +interface DaiJoinLike { + function exit(address, uint256) external; +} + +interface VatLike { + function hope(address) external; + function suck(address, address, uint256) external; + function live() external view returns (uint256); +} + +interface TokenLike { + function transferFrom(address, address, uint256) external returns (bool); +} + +abstract contract DssVestMock { + // --- Data --- + mapping (address => uint256) public wards; + + struct Award { + address usr; // Vesting recipient + uint48 bgn; // Start of vesting period [timestamp] + uint48 clf; // The cliff date [timestamp] + uint48 fin; // End of vesting period [timestamp] + address mgr; // A manager address that can yank + uint8 res; // Restricted + uint128 tot; // Total reward amount + uint128 rxd; // Amount of vest claimed + } + mapping (uint256 => Award) public awards; + + uint256 public cap; // Maximum per-second issuance token rate + + uint256 public ids; // Total vestings + + uint256 internal locked; + + uint256 public constant TWENTY_YEARS = 20 * 365 days; + + // --- Events --- + event Rely(address indexed usr); + event Deny(address indexed usr); + + event File(bytes32 indexed what, uint256 data); + + event Init(uint256 indexed id, address indexed usr); + event Vest(uint256 indexed id, uint256 amt); + event Restrict(uint256 indexed id); + event Unrestrict(uint256 indexed id); + event Yank(uint256 indexed id, uint256 end); + event Move(uint256 indexed id, address indexed dst); + + // Getters to access only to the value desired + function usr(uint256 _id) external view returns (address) { + return awards[_id].usr; + } + + function bgn(uint256 _id) external view returns (uint256) { + return awards[_id].bgn; + } + + function clf(uint256 _id) external view returns (uint256) { + return awards[_id].clf; + } + + function fin(uint256 _id) external view returns (uint256) { + return awards[_id].fin; + } + + function mgr(uint256 _id) external view returns (address) { + return awards[_id].mgr; + } + + function res(uint256 _id) external view returns (uint256) { + return awards[_id].res; + } + + function tot(uint256 _id) external view returns (uint256) { + return awards[_id].tot; + } + + function rxd(uint256 _id) external view returns (uint256) { + return awards[_id].rxd; + } + + /** + @dev Base vesting logic contract constructor + */ + constructor() { + wards[msg.sender] = 1; + emit Rely(msg.sender); + } + + // --- Mutex --- + modifier lock { + require(locked == 0, "DssVest/system-locked"); + locked = 1; + _; + locked = 0; + } + + // --- Auth --- + modifier auth { + require(wards[msg.sender] == 1, "DssVest/not-authorized"); + _; + } + + function rely(address _usr) external auth { + wards[_usr] = 1; + emit Rely(_usr); + } + function deny(address _usr) external auth { + wards[_usr] = 0; + emit Deny(_usr); + } + + /** + @dev (Required) Set the per-second token issuance rate. + @param what The tag of the value to change (ex. bytes32("cap")) + @param data The value to update (ex. cap of 1000 tokens/yr == 1000*WAD/365 days) + */ + function file(bytes32 what, uint256 data) external lock auth { + if (what == "cap") cap = data; // The maximum amount of tokens that can be streamed per-second per vest + else revert("DssVest/file-unrecognized-param"); + emit File(what, data); + } + + function min(uint256 x, uint256 y) internal pure returns (uint256 z) { + z = x > y ? y : x; + } + function toUint48(uint256 x) internal pure returns (uint48 z) { + require((z = uint48(x)) == x, "DssVest/uint48-overflow"); + } + function toUint128(uint256 x) internal pure returns (uint128 z) { + require((z = uint128(x)) == x, "DssVest/uint128-overflow"); + } + + /** + @dev Govanance adds a vesting contract + @param _usr The recipient of the reward + @param _tot The total amount of the vest + @param _bgn The starting timestamp of the vest + @param _tau The duration of the vest (in seconds) + @param _eta The cliff duration in seconds (i.e. 1 years) + @param _mgr An optional manager for the contract. Can yank if vesting ends prematurely. + @return id The id of the vesting contract + */ + function create(address _usr, uint256 _tot, uint256 _bgn, uint256 _tau, uint256 _eta, address _mgr) external lock auth returns (uint256 id) { + require(_usr != address(0), "DssVest/invalid-user"); + require(_tot > 0, "DssVest/no-vest-total-amount"); + require(_bgn < block.timestamp + TWENTY_YEARS, "DssVest/bgn-too-far"); + require(_bgn > block.timestamp - TWENTY_YEARS, "DssVest/bgn-too-long-ago"); + require(_tau > 0, "DssVest/tau-zero"); + require(_tot / _tau <= cap, "DssVest/rate-too-high"); + require(_tau <= TWENTY_YEARS, "DssVest/tau-too-long"); + require(_eta <= _tau, "DssVest/eta-too-long"); + require(ids < type(uint256).max, "DssVest/ids-overflow"); + + unchecked { + id = ++ids; + } + awards[id] = Award({ + usr: _usr, + bgn: toUint48(_bgn), + clf: toUint48(_bgn + _eta), + fin: toUint48(_bgn + _tau), + tot: toUint128(_tot), + rxd: 0, + mgr: _mgr, + res: 0 + }); + emit Init(id, _usr); + } + + /** + @dev Anyone (or only owner of a vesting contract if restricted) calls this to claim all available rewards + @param _id The id of the vesting contract + */ + function vest(uint256 _id) external { + _vest(_id, type(uint256).max); + } + + /** + @dev Anyone (or only owner of a vesting contract if restricted) calls this to claim rewards + @param _id The id of the vesting contract + @param _maxAmt The maximum amount to vest + */ + function vest(uint256 _id, uint256 _maxAmt) external { + _vest(_id, _maxAmt); + } + + /** + @dev Anyone (or only owner of a vesting contract if restricted) calls this to claim rewards + @param _id The id of the vesting contract + @param _maxAmt The maximum amount to vest + */ + function _vest(uint256 _id, uint256 _maxAmt) internal lock { + Award memory _award = awards[_id]; + require(_award.usr != address(0), "DssVest/invalid-award"); + require(_award.res == 0 || _award.usr == msg.sender, "DssVest/only-user-can-claim"); + uint256 amt = unpaid(block.timestamp, _award.bgn, _award.clf, _award.fin, _award.tot, _award.rxd); + amt = min(amt, _maxAmt); + awards[_id].rxd = toUint128(_award.rxd + amt); + pay(_award.usr, amt); + emit Vest(_id, amt); + } + + /** + @dev amount of tokens accrued, not accounting for tokens paid + @param _id The id of the vesting contract + @return amt The accrued amount + */ + function accrued(uint256 _id) external view returns (uint256 amt) { + Award memory _award = awards[_id]; + require(_award.usr != address(0), "DssVest/invalid-award"); + amt = accrued(block.timestamp, _award.bgn, _award.fin, _award.tot); + } + + /** + @dev amount of tokens accrued, not accounting for tokens paid + @param _time The timestamp to perform the calculation + @param _bgn The start time of the contract + @param _fin The end time of the contract + @param _tot The total amount of the contract + @return amt The accrued amount + */ + function accrued(uint256 _time, uint48 _bgn, uint48 _fin, uint128 _tot) internal pure returns (uint256 amt) { + if (_time < _bgn) { + amt = 0; + } else if (_time >= _fin) { + amt = _tot; + } else { + amt = (_tot * (_time - _bgn)) / (_fin - _bgn); // 0 <= amt < _award.tot + } + } + + /** + @dev return the amount of vested, claimable GEM for a given ID + @param _id The id of the vesting contract + @return amt The claimable amount + */ + function unpaid(uint256 _id) external view returns (uint256 amt) { + Award memory _award = awards[_id]; + require(_award.usr != address(0), "DssVest/invalid-award"); + amt = unpaid(block.timestamp, _award.bgn, _award.clf, _award.fin, _award.tot, _award.rxd); + } + + /** + @dev amount of tokens accrued, not accounting for tokens paid + @param _time The timestamp to perform the calculation + @param _bgn The start time of the contract + @param _clf The timestamp of the cliff + @param _fin The end time of the contract + @param _tot The total amount of the contract + @param _rxd The number of gems received + @return amt The claimable amount + */ + function unpaid(uint256 _time, uint48 _bgn, uint48 _clf, uint48 _fin, uint128 _tot, uint128 _rxd) internal pure returns (uint256 amt) { + amt = _time < _clf ? 0 : accrued(_time, _bgn, _fin, _tot) - _rxd; + } + + /** + @dev Allows governance or the owner to restrict vesting to the owner only + @param _id The id of the vesting contract + */ + function restrict(uint256 _id) external lock { + address usr_ = awards[_id].usr; + require(usr_ != address(0), "DssVest/invalid-award"); + require(wards[msg.sender] == 1 || usr_ == msg.sender, "DssVest/not-authorized"); + awards[_id].res = 1; + emit Restrict(_id); + } + + /** + @dev Allows governance or the owner to enable permissionless vesting + @param _id The id of the vesting contract + */ + function unrestrict(uint256 _id) external lock { + address usr_ = awards[_id].usr; + require(usr_ != address(0), "DssVest/invalid-award"); + require(wards[msg.sender] == 1 || usr_ == msg.sender, "DssVest/not-authorized"); + awards[_id].res = 0; + emit Unrestrict(_id); + } + + /** + @dev Allows governance or the manager to remove a vesting contract immediately + @param _id The id of the vesting contract + */ + function yank(uint256 _id) external { + _yank(_id, block.timestamp); + } + + /** + @dev Allows governance or the manager to remove a vesting contract at a future time + @param _id The id of the vesting contract + @param _end A scheduled time to end the vest + */ + function yank(uint256 _id, uint256 _end) external { + _yank(_id, _end); + } + + /** + @dev Allows governance or the manager to end pre-maturely a vesting contract + @param _id The id of the vesting contract + @param _end A scheduled time to end the vest + */ + function _yank(uint256 _id, uint256 _end) internal lock { + require(wards[msg.sender] == 1 || awards[_id].mgr == msg.sender, "DssVest/not-authorized"); + Award memory _award = awards[_id]; + require(_award.usr != address(0), "DssVest/invalid-award"); + if (_end < block.timestamp) { + _end = block.timestamp; + } + if (_end < _award.fin) { + uint48 end = toUint48(_end); + awards[_id].fin = end; + if (end < _award.bgn) { + awards[_id].bgn = end; + awards[_id].clf = end; + awards[_id].tot = 0; + } else if (end < _award.clf) { + awards[_id].clf = end; + awards[_id].tot = 0; + } else { + awards[_id].tot = toUint128( + unpaid(_end, _award.bgn, _award.clf, _award.fin, _award.tot, _award.rxd) + _award.rxd + ); + } + } + + emit Yank(_id, _end); + } + + /** + @dev Allows owner to move a contract to a different address + @param _id The id of the vesting contract + @param _dst The address to send ownership of the contract to + */ + function move(uint256 _id, address _dst) external lock { + require(awards[_id].usr == msg.sender, "DssVest/only-user-can-move"); + require(_dst != address(0), "DssVest/zero-address-invalid"); + awards[_id].usr = _dst; + emit Move(_id, _dst); + } + + /** + @dev Return true if a contract is valid + @param _id The id of the vesting contract + @return isValid True for valid contract + */ + function valid(uint256 _id) external view returns (bool isValid) { + isValid = awards[_id].rxd < awards[_id].tot; + } + + /** + @dev Override this to implement payment logic. + @param _guy The payment target. + @param _amt The payment amount. [units are implementation-specific] + */ + function pay(address _guy, uint256 _amt) virtual internal; +} + +contract DssVestMintableMock is DssVestMock { + + MintLike public immutable gem; + + /** + @dev This contract must be authorized to 'mint' on the token + @param _gem The contract address of the mintable token + */ + constructor(address _gem) DssVestMock() { + require(_gem != address(0), "DssVestMintable/Invalid-token-address"); + gem = MintLike(_gem); + } + + /** + @dev Override pay to handle mint logic + @param _guy The recipient of the minted token + @param _amt The amount of token units to send to the _guy + */ + function pay(address _guy, uint256 _amt) override internal { + gem.mint(_guy, _amt); + } +} + +contract DssVestSuckableMock is DssVestMock { + + uint256 internal constant RAY = 10**27; + + ChainlogLike public immutable chainlog; + VatLike public immutable vat; + DaiJoinLike public immutable daiJoin; + + /** + @dev This contract must be authorized to 'suck' on the vat + @param _chainlog The contract address of the MCD chainlog + */ + constructor(address _chainlog) DssVestMock() { + require(_chainlog != address(0), "DssVestSuckable/Invalid-chainlog-address"); + ChainlogLike chainlog_ = chainlog = ChainlogLike(_chainlog); + VatLike vat_ = vat = VatLike(chainlog_.getAddress("MCD_VAT")); + DaiJoinLike daiJoin_ = daiJoin = DaiJoinLike(chainlog_.getAddress("MCD_JOIN_DAI")); + + vat_.hope(address(daiJoin_)); + } + + /** + @dev Override pay to handle suck logic + @param _guy The recipient of the ERC-20 Dai + @param _amt The amount of Dai to send to the _guy [WAD] + */ + function pay(address _guy, uint256 _amt) override internal { + require(vat.live() == 1, "DssVestSuckable/vat-not-live"); + vat.suck(chainlog.getAddress("MCD_VOW"), address(this), _amt * RAY); + daiJoin.exit(_guy, _amt); + } +} + +/* + Transferrable token DssVest. Can be used to enable streaming payments of + any arbitrary token from an address (i.e. CU multisig) to individual + contributors. +*/ +contract DssVestTransferrableMock is DssVestMock { + + address public immutable czar; + TokenLike public immutable gem; + + /** + @dev This contract must be approved for transfer of the gem on the czar + @param _czar The owner of the tokens to be distributed + @param _gem The token to be distributed + */ + constructor(address _czar, address _gem) DssVestMock() { + require(_czar != address(0), "DssVestTransferrable/Invalid-distributor-address"); + require(_gem != address(0), "DssVestTransferrable/Invalid-token-address"); + czar = _czar; + gem = TokenLike(_gem); + } + + /** + @dev Override pay to handle transfer logic + @param _guy The recipient of the ERC-20 Dai + @param _amt The amount of gem to send to the _guy (in native token units) + */ + function pay(address _guy, uint256 _amt) override internal { + require(gem.transferFrom(czar, _guy, _amt), "DssVestTransferrable/failed-transfer"); + } +} diff --git a/test/mocks/FarmMock.sol b/test/mocks/FarmMock.sol new file mode 100644 index 0000000..151c89e --- /dev/null +++ b/test/mocks/FarmMock.sol @@ -0,0 +1,59 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later + +// Copyright (C) 2024 Dai Foundation +// +// 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 . + +pragma solidity ^0.8.21; + +contract FarmMock { + address public immutable rewardsToken; + address public immutable stakingToken; + + event OwnerNominated(address newOwner); + event PauseChanged(bool isPaused); + event RewardAdded(uint256 rewards); + event RewardsDurationUpdated(uint256 newDuration); + event RewardsDistributionUpdated(address newRewardsDistribution); + event Recovered(address token, uint256 amount); + + constructor(address _rewardsToken, address _stakingToken) { + rewardsToken = _rewardsToken; + stakingToken = _stakingToken; + } + + function nominateNewOwner(address _owner) external { + emit OwnerNominated(_owner); + } + + function setPaused(bool _paused) external { + emit PauseChanged(_paused); + } + + function notifyRewardAmount(uint256 reward) external { + emit RewardAdded(reward); + } + + function recoverERC20(address tokenAddress, uint256 tokenAmount) external { + emit Recovered(tokenAddress, tokenAmount); + } + + function setRewardsDuration(uint256 _rewardsDuration) external { + emit RewardsDurationUpdated(_rewardsDuration); + } + + function setRewardsDistribution(address _rewardsDistribution) external { + emit RewardsDistributionUpdated(_rewardsDistribution); + } +} diff --git a/test/mocks/GemMock.sol b/test/mocks/GemMock.sol new file mode 100644 index 0000000..f5d2ed0 --- /dev/null +++ b/test/mocks/GemMock.sol @@ -0,0 +1,106 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later + +// Copyright (C) 2024 Dai Foundation +// +// 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 . + +pragma solidity ^0.8.21; + +contract GemMock { + mapping (address => uint256) public wards; + mapping (address => uint256) public balanceOf; + mapping (address => mapping (address => uint256)) public allowance; + + uint256 public totalSupply; + + constructor(uint256 initialSupply) { + wards[msg.sender] = 1; + + mint(msg.sender, initialSupply); + } + + modifier auth() { + require(wards[msg.sender] == 1, "Gem/not-authorized"); + _; + } + + function rely(address usr) external auth { wards[usr] = 1; } + function deny(address usr) external auth { wards[usr] = 0; } + + function approve(address spender, uint256 value) external returns (bool) { + allowance[msg.sender][spender] = value; + return true; + } + + function transfer(address to, uint256 value) external returns (bool) { + uint256 balance = balanceOf[msg.sender]; + require(balance >= value, "Gem/insufficient-balance"); + + unchecked { + balanceOf[msg.sender] = balance - value; + balanceOf[to] += value; + } + return true; + } + + function transferFrom(address from, address to, uint256 value) external returns (bool) { + uint256 balance = balanceOf[from]; + require(balance >= value, "Gem/insufficient-balance"); + + if (from != msg.sender) { + uint256 allowed = allowance[from][msg.sender]; + if (allowed != type(uint256).max) { + require(allowed >= value, "Gem/insufficient-allowance"); + + unchecked { + allowance[from][msg.sender] = allowed - value; + } + } + } + + unchecked { + balanceOf[from] = balance - value; + balanceOf[to] += value; + } + return true; + } + + function mint(address to, uint256 value) public auth { + unchecked { + balanceOf[to] = balanceOf[to] + value; + } + totalSupply = totalSupply + value; + } + + function burn(address from, uint256 value) external { + uint256 balance = balanceOf[from]; + require(balance >= value, "Gem/insufficient-balance"); + + if (from != msg.sender) { + uint256 allowed = allowance[from][msg.sender]; + if (allowed != type(uint256).max) { + require(allowed >= value, "Gem/insufficient-allowance"); + + unchecked { + allowance[from][msg.sender] = allowed - value; + } + } + } + + unchecked { + balanceOf[from] = balance - value; + totalSupply = totalSupply - value; + } + } +} diff --git a/test/mocks/L1TokenBridgeMock.sol b/test/mocks/L1TokenBridgeMock.sol new file mode 100644 index 0000000..03b6ca5 --- /dev/null +++ b/test/mocks/L1TokenBridgeMock.sol @@ -0,0 +1,41 @@ +// SPDX-License-Identifier: AGPL-3.0-or-later + +// Copyright (C) 2024 Dai Foundation +// +// 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 . + +pragma solidity ^0.8.21; + +interface TokenLike { + function transferFrom(address, address, uint256) external; +} + +contract L1TokenBridgeMock { + address public immutable escrow; + + constructor(address _escrow) { + escrow = _escrow; + } + + function bridgeERC20To( + address _localToken, + address /* _remoteToken */, + address /* _to */, + uint256 _amount, + uint32 /* _minGasLimit */, + bytes calldata /* _extraData */ + ) public { + TokenLike(_localToken).transferFrom(msg.sender, escrow, _amount); + } +}