Add Simplified Harvester

contracts/contracts/harvest/OETHBaseHarvester.sol

@@ -0,0 +1,232 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+import { Governable } from "../governance/Governable.sol";
+
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+import { IVault } from "../interfaces/IVault.sol";
+import { IStrategy } from "../interfaces/IStrategy.sol";
+import { ISwapRouter } from "../interfaces/aerodrome/ISwapRouter.sol";
+
+contract OETHBaseHarvester is Governable {
+    using SafeERC20 for IERC20;
+
+    IVault public immutable vault;
+    IStrategy public immutable amoStrategy;
+    IERC20 public immutable aero;
+    IERC20 public immutable weth;
+    ISwapRouter public immutable swapRouter;
+
+    address public operatorAddr;
+
+    // Similar sig to `AbstractHarvester.RewardTokenSwapped` for
+    // future compatibility with monitoring
+    event RewardTokenSwapped(
+        address indexed rewardToken,
+        address indexed swappedInto,
+        uint8 swapPlatform,
+        uint256 amountIn,
+        uint256 amountOut
+    );
+
+    event OperatorChanged(address oldOperator, address newOperator);
+
+    /**
+     * @notice Verifies that the caller is either Governor or Strategist.
+     */
+    modifier onlyGovernorOrStrategist() {
+        require(
+            msg.sender == vault.strategistAddr() || isGovernor(),
+            "Caller is not the Strategist or Governor"
+        );
+        _;
+    }
+
+    /**
+     * @notice Verifies that the caller is either Governor or Strategist.
+     */
+    modifier onlyGovernorOrStrategistOrOperator() {
+        require(
+            msg.sender == operatorAddr ||
+                msg.sender == vault.strategistAddr() ||
+                isGovernor(),
+            "Caller is not the Operator or Strategist or Governor"
+        );
+        _;
+    }
+
+    constructor(
+        address _vault,
+        address _amoStrategy,
+        address _aero,
+        address _weth,
+        address _swapRouter
+    ) {
+        vault = IVault(_vault);
+        amoStrategy = IStrategy(_amoStrategy);
+        aero = IERC20(_aero);
+        weth = IERC20(_weth);
+        swapRouter = ISwapRouter(_swapRouter);
+    }
+
+    /**
+     * @dev Changes the operator address which can call `harvest`
+     * @param _operatorAddr New operator address
+     */
+    function setOperatorAddr(address _operatorAddr) external onlyGovernor {
+        emit OperatorChanged(operatorAddr, _operatorAddr);
+        operatorAddr = _operatorAddr;
+    }
+
+    /**
+     * @notice Collects AERO from AMO strategy and
+     *      sends it to the Strategist multisig.
+     *      Anyone can call it.
+     */
+    function harvest() external onlyGovernorOrStrategistOrOperator {
+        address strategistAddr = vault.strategistAddr();
+        require(strategistAddr != address(0), "Guardian address not set");
+
+        // Collect all AERO
+        amoStrategy.collectRewardTokens();
+
+        uint256 aeroBalance = aero.balanceOf(address(this));
+        if (aeroBalance == 0) {
+            // Do nothing if there's no AERO to transfer
+            return;
+        }
+
+        // Transfer everything to Strategist
+        aero.safeTransfer(strategistAddr, aeroBalance);
+    }
+
+    /**
+     * @notice Harvests AERO from AMO strategy and then swaps some (or all)
+     *          of it into WETH to distribute yield and fee.
+     *         When `feeBps` is set to 10000 (100%), all WETH received is
+     *          sent to strategist.
+     *
+     * @param aeroToSwap Amount of AERO to swap
+     * @param minWETHExpected Min. amount of WETH to expect
+     * @param feeBps Performance fee bps (Sent to strategist)
+     * @param yieldRecipient Yield recipient (must be Vault or Dripper)
+     */
+    function harvestAndSwap(
+        uint256 aeroToSwap,
+        uint256 minWETHExpected,
+        uint256 feeBps,
+        address yieldRecipient
+    ) external onlyGovernorOrStrategist {
+        address strategistAddr = vault.strategistAddr();
+        require(strategistAddr != address(0), "Guardian address not set");
+
+        require(feeBps <= 10000, "Invalid Fee Bps");
+
+        // Collect all AERO
+        amoStrategy.collectRewardTokens();
+
+        uint256 aeroBalance = aero.balanceOf(address(this));
+        if (aeroBalance == 0) {
+            // Do nothing if there's no AERO to transfer/swap
+            return;
+        }
+
+        if (aeroToSwap > 0) {
+            if (aeroBalance < aeroToSwap) {
+                // Transfer in balance from the multisig as needed
+                // slither-disable-next-line unchecked-transfer arbitrary-send-erc20
+                aero.safeTransferFrom(
+                    strategistAddr,
+                    address(this),
+                    aeroToSwap - aeroBalance
+                );
+            }
+
+            _doSwap(aeroToSwap, minWETHExpected);
+
+            // Figure out AERO left in contract after swap
+            aeroBalance = aero.balanceOf(address(this));
+        }
+
+        // Transfer out any leftover AERO after swap
+        if (aeroBalance > 0) {
+            aero.safeTransfer(strategistAddr, aeroBalance);
+        }
+
+        // Computes using all balance the contract holds,
+        // not just the WETH received from swap. Use `transferToken`
+        // if there's any WETH left that needs to be taken out
+        uint256 availableWETHBalance = weth.balanceOf(address(this));
+        // Computation rounds in favor of protocol
+        uint256 fee = (availableWETHBalance * feeBps) / 10000;
+        uint256 yield = availableWETHBalance - fee;
+
+        // Transfer yield to yield recipient if any
+        if (yield > 0) {
+            // Yields can only be sent to the Vault or the Dripper.
+            // There's no address(0) check since Vault will break if there's
+            // no Dripper address set.
+            require(
+                yieldRecipient != address(0) &&
+                    (yieldRecipient == address(vault) ||
+                        yieldRecipient == vault.dripper()),
+                "Invalid yield recipient"
+            );
+            weth.safeTransfer(yieldRecipient, yield);
+        }
+
+        // Transfer fee to Guardian if any
+        if (fee > 0) {
+            weth.safeTransfer(strategistAddr, fee);
+        }
+    }
+
+    /**
+     * @notice Swaps AERO to WETH on Aerodrome
+     * @param aeroToSwap Amount of AERO to swap
+     * @param minWETHExpected Min. amount of WETH to expect
+     */
+    function _doSwap(uint256 aeroToSwap, uint256 minWETHExpected) internal {
+        // Let the swap router move funds
+        aero.approve(address(swapRouter), aeroToSwap);
+
+        // Do the swap
+        uint256 wethReceived = swapRouter.exactInputSingle(
+            ISwapRouter.ExactInputSingleParams({
+                tokenIn: address(aero),
+                tokenOut: address(weth),
+                tickSpacing: 200, // From AERO/WETH pool contract
+                recipient: address(this),
+                deadline: block.timestamp,
+                amountIn: aeroToSwap,
+                amountOutMinimum: minWETHExpected,
+                sqrtPriceLimitX96: 0
+            })
+        );
+
+        emit RewardTokenSwapped(
+            address(aero),
+            address(weth),
+            0,
+            aeroToSwap,
+            wethReceived
+        );
+    }
+
+    /**
+     * @notice Transfer token to governor. Intended for recovering tokens stuck in
+     *      the contract, i.e. mistaken sends.
+     *      Also, allows to transfer any AERO left in the contract.
+     * @param _asset Address for the asset
+     * @param _amount Amount of the asset to transfer
+     */
+    function transferToken(address _asset, uint256 _amount)
+        external
+        virtual
+        onlyGovernor
+    {
+        IERC20(_asset).safeTransfer(governor(), _amount);
+    }
+}

contracts/contracts/proxies/Proxies.sol

@@ -309,6 +309,13 @@ contract MetaMorphoStrategyProxy is InitializeGovernedUpgradeabilityProxy {
 
 }
 
+/**
+ * @notice OETHBaseHarvesterProxy delegates calls to a OETHBaseHarvester implementation
+ */
+contract OETHBaseHarvesterProxy is InitializeGovernedUpgradeabilityProxy {
+
+}
+
 /**
  * @notice ARMBuybackProxy delegates calls to Buyback implementation
  */

contracts/deploy/base/013_harvester.js

@@ -0,0 +1,62 @@
+const { deployOnBaseWithGuardian } = require("../../utils/deploy-l2");
+const {
+  deployWithConfirmation,
+  withConfirmation,
+} = require("../../utils/deploy");
+const addresses = require("../../utils/addresses");
+
+module.exports = deployOnBaseWithGuardian(
+  {
+    deployName: "013_harvester",
+    useTimelock: true,
+  },
+  async ({ ethers }) => {
+    const { deployerAddr } = await getNamedAccounts();
+    const sDeployer = await ethers.provider.getSigner(deployerAddr);
+
+    const cOETHbVaultProxy = await ethers.getContract("OETHBaseVaultProxy");
+    const cAMOStrategyProxy = await ethers.getContract(
+      "AerodromeAMOStrategyProxy"
+    );
+
+    // Deploy proxy
+    await deployWithConfirmation("OETHBaseHarvesterProxy");
+    const cHarvesterProxy = await ethers.getContract("OETHBaseHarvesterProxy");
+
+    // Deploy implementation
+    const dHarvesterImpl = await deployWithConfirmation("OETHBaseHarvester", [
+      cOETHbVaultProxy.address,
+      cAMOStrategyProxy.address,
+      addresses.base.AERO,
+      addresses.base.WETH,
+      addresses.base.swapRouter,
+    ]);
+
+    const cAMOStrategy = await ethers.getContractAt(
+      "AerodromeAMOStrategy",
+      cAMOStrategyProxy.address
+    );
+
+    // prettier-ignore
+    await withConfirmation(
+      cHarvesterProxy
+        .connect(sDeployer)["initialize(address,address,bytes)"](
+          dHarvesterImpl.address,
+          addresses.base.timelock,
+          "0x"
+        )
+    );
+    console.log("Initialized OETHBaseHarvesterProxy");
+
+    return {
+      actions: [
+        {
+          // 1. Set as harvester address on the strategy
+          contract: cAMOStrategy,
+          signature: "setHarvesterAddress(address)",
+          args: [cHarvesterProxy.address],
+        },
+      ],
+    };
+  }
+);

contracts/test/_fixture-base.js

@@ -11,7 +11,6 @@ const log = require("../utils/logger")("test:fixtures-arb");
 
 const aeroSwapRouterAbi = require("./abi/aerodromeSwapRouter.json");
 const aeroNonfungiblePositionManagerAbi = require("./abi/aerodromeNonfungiblePositionManager.json");
-const aerodromeClGaugeAbi = require("./abi/aerodromeClGauge.json");
 
 const MINTER_ROLE =
   "0x9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a6";
@@ -20,8 +19,6 @@ const BURNER_ROLE =
 
 let snapshotId;
 const defaultBaseFixture = deployments.createFixture(async () => {
-  let aerodromeAmoStrategy;
-
   if (!snapshotId && !isFork) {
     snapshotId = await nodeSnapshot();
   }
@@ -62,6 +59,7 @@ const defaultBaseFixture = deployments.createFixture(async () => {
     oethbVaultProxy.address
   );
 
+  let aerodromeAmoStrategy, harvester;
   if (isFork) {
     // Aerodrome AMO Strategy
     const aerodromeAmoStrategyProxy = await ethers.getContract(
@@ -71,6 +69,13 @@ const defaultBaseFixture = deployments.createFixture(async () => {
       "AerodromeAMOStrategy",
       aerodromeAmoStrategyProxy.address
     );
+
+    // Harvester
+    const harvesterProxy = await ethers.getContract("OETHBaseHarvesterProxy");
+    harvester = await ethers.getContractAt(
+      "OETHBaseHarvester",
+      harvesterProxy.address
+    );
   }
 
   // Bridged wOETH
@@ -132,7 +137,7 @@ const defaultBaseFixture = deployments.createFixture(async () => {
   await woeth.connect(governor).grantRole(MINTER_ROLE, minter.address);
   await woeth.connect(governor).grantRole(BURNER_ROLE, burner.address);
 
-  for (const user of [rafael, nick]) {
+  for (const user of [rafael, nick, clement]) {
     // Mint some bridged WOETH
     await woeth.connect(minter).mint(user.address, oethUnits("1"));
     await weth.connect(user).deposit({ value: oethUnits("100") });
@@ -153,7 +158,7 @@ const defaultBaseFixture = deployments.createFixture(async () => {
     addresses.base.swapRouter
   );
   const aeroClGauge = await ethers.getContractAt(
-    aerodromeClGaugeAbi,
+    "ICLGauge",
     addresses.base.aerodromeOETHbWETHClGauge
   );
   const aeroNftManager = await ethers.getContractAt(
@@ -167,11 +172,13 @@ const defaultBaseFixture = deployments.createFixture(async () => {
     aeroNftManager,
     aeroClGauge,
     aero,
+
     // OETHb
     oethb,
     oethbVault,
     wOETHb,
     zapper,
+    harvester,
 
     // Bridged WOETH
     woeth,