Feat/generic harvester

contracts/helpers/BaseHarvester.sol → contracts/helpers/BaseRebalancer.sol

@@ -2,18 +2,16 @@
 
 pragma solidity ^0.8.23;
 
-import { SafeCast } from "oz/utils/math/SafeCast.sol";
-
-import { ITransmuter } from "interfaces/ITransmuter.sol";
-
+import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
 import { AccessControl, IAccessControlManager } from "../utils/AccessControl.sol";
-import "../utils/Constants.sol";
-import "../utils/Errors.sol";
+import { IERC20 } from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import { ITransmuter } from "../interfaces/ITransmuter.sol";
+import { IAgToken } from "../interfaces/IAgToken.sol";
 
-import { IRebalancerFlashloan } from "../interfaces/IRebalancerFlashloan.sol";
+import "../utils/Errors.sol";
 
 struct CollatParams {
-    // Yield bearing asset associated to the collateral
+    // Address of the collateral
     address asset;
     // Target exposure to the collateral asset used
     uint64 targetExposure;
@@ -26,39 +24,84 @@
     uint64 overrideExposures;
 }
 
-/// @title BaseHarvester
-/// @author Angle Labs, Inc.
-/// @dev Generic contract for anyone to permissionlessly adjust the reserves of Angle Transmuter through
-contract BaseHarvester is AccessControl {
-    using SafeCast for uint256;
+abstract contract BaseRebalancer is AccessControl {
+    using SafeERC20 for IERC20;
+
+    /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                                                       VARIABLES
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
 
     /// @notice Reference to the `transmuter` implementation this contract aims at rebalancing
-    ITransmuter public immutable TRANSMUTER;
-    /// @notice Permissioned rebalancer contract
-    IRebalancerFlashloan public rebalancer;
+    ITransmuter public immutable transmuter;
+    /// @notice AgToken handled by the `transmuter` of interest
+    IAgToken public immutable agToken;
     /// @notice Max slippage when dealing with the Transmuter
     uint96 public maxSlippage;
     /// @notice Data associated to a collateral
     mapping(address => CollatParams) public collateralData;
 
     /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-                                                    INITIALIZATION                                                  
+                                                       CONSTRUCTOR
     //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
 
     constructor(
-        address _rebalancer,
+        uint96 initialMaxSlippage,
+        IAccessControlManager definitiveAccessControlManager,
+        IAgToken definitiveAgToken,
+        ITransmuter definitiveTransmuter
+    ) {
+        _setMaxSlippage(initialMaxSlippage);
+        accessControlManager = definitiveAccessControlManager;
+        agToken = definitiveAgToken;
+        transmuter = definitiveTransmuter;
+    }
+    /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                                                        GUARDIAN FUNCTIONS
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
+
+    /**
+     * @notice Set the collateral data
+     * @param collateral address of the collateral
+     * @param targetExposure target exposure to the collateral asset used
+     * @param minExposureYieldAsset minimum exposure within the Transmuter to the asset
+     * @param maxExposureYieldAsset maximum exposure within the Transmuter to the asset
+     * @param overrideExposures whether limit exposures should be overriden or read onchain through the Transmuter
+     * This value should be 1 to override exposures or 2 if these shouldn't be overriden
+     */
+    function setCollateralData(
         address collateral,
-        address asset,
         uint64 targetExposure,
-        uint64 overrideExposures,
+        uint64 minExposureYieldAsset,
         uint64 maxExposureYieldAsset,
+        uint64 overrideExposures
+    ) external onlyGuardian {
+        _setCollateralData(
+            collateral,
+            collateral,
+            targetExposure,
+            minExposureYieldAsset,
+            maxExposureYieldAsset,
+            overrideExposures
+        );
+    }
+
+    /**
+     * @notice Set the collateral data
+     * @param collateral address of the collateral
+     * @param asset address of the asset
+     * @param targetExposure target exposure to the collateral asset used
+     * @param minExposureYieldAsset minimum exposure within the Transmuter to the asset
+     * @param maxExposureYieldAsset maximum exposure within the Transmuter to the asset
+     * @param overrideExposures whether limit exposures should be overriden or read onchain through the Transmuter
+     */
+    function setCollateralData(
+        address collateral,
+        address asset,
+        uint64 targetExposure,
         uint64 minExposureYieldAsset,
-        uint96 _maxSlippage
-    ) {
-        ITransmuter transmuter = IRebalancerFlashloan(_rebalancer).TRANSMUTER();
-        TRANSMUTER = transmuter;
-        rebalancer = IRebalancerFlashloan(_rebalancer);
-        accessControlManager = IAccessControlManager(transmuter.accessControlManager());
+        uint64 maxExposureYieldAsset,
+        uint64 overrideExposures
+    ) external onlyGuardian {
         _setCollateralData(
             collateral,
             asset,
@@ -67,26 +110,35 @@
             maxExposureYieldAsset,
             overrideExposures
         );
-        _setMaxSlippage(_maxSlippage);
+    }
+
+    /**
+     * @notice Set the limit exposures to the yield bearing asset
+     * @param collateral address of the collateral
+     */
+    function updateLimitExposuresYieldAsset(address collateral) public virtual onlyGuardian {
+        CollatParams storage collatInfo = collateralData[collateral];
+        if (collatInfo.overrideExposures == 2) _updateLimitExposuresYieldAsset(collatInfo);
+    }
+
+    /**
+     * @notice Set the max allowed slippage
+     * @param newMaxSlippage new max allowed slippage
+     */
+    function setMaxSlippage(uint96 newMaxSlippage) external onlyGuardian {
+        _setMaxSlippage(newMaxSlippage);
     }
 
     /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-                                                        HARVEST                                                     
+                                                        INTERNAL FUNCTIONS
     //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
 
-    /// @notice Invests or divests from the yield asset associated to `collateral` based on the current exposure to this
-    /// collateral
-    /// @dev This transaction either reduces the exposure to `collateral` in the Transmuter or frees up some collateral
-    /// that can then be used for people looking to burn stablecoins
-    /// @dev Due to potential transaction fees within the Transmuter, this function doesn't exactly bring `collateral`
-    /// to the target exposure
-    function harvest(address collateral, uint256 scale, bytes calldata extraData) public virtual {
-        if (scale > 1e9) revert InvalidParam();
-        (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued) = TRANSMUTER.getIssuedByCollateral(collateral);
-        CollatParams memory collatInfo = collateralData[collateral];
-        (uint256 stablecoinsFromAsset, ) = TRANSMUTER.getIssuedByCollateral(collatInfo.asset);
-        uint8 increase;
-        uint256 amount;
+    function _computeRebalanceAmount(
+        address collateral,
+        CollatParams memory collatInfo
+    ) internal view returns (uint8 increase, uint256 amount) {
+        (uint256 stablecoinsFromCollateral, uint256 stablecoinsIssued) = transmuter.getIssuedByCollateral(collateral);
+        (uint256 stablecoinsFromAsset, ) = transmuter.getIssuedByCollateral(collatInfo.asset);
         uint256 targetExposureScaled = collatInfo.targetExposure * stablecoinsIssued;
         if (stablecoinsFromCollateral * 1e9 > targetExposureScaled) {
             // Need to increase exposure to yield bearing asset
@@ -107,60 +159,6 @@
             else if (stablecoinsFromAsset * 1e9 < minValueScaled + amount * 1e9)
                 amount = stablecoinsFromAsset - minValueScaled / 1e9;
         }
-        amount = (amount * scale) / 1e9;
-        if (amount > 0) {
-            try TRANSMUTER.updateOracle(collatInfo.asset) {} catch {}
-
-            rebalancer.adjustYieldExposure(
-                amount,
-                increase,
-                collateral,
-                collatInfo.asset,
-                (amount * (1e9 - maxSlippage)) / 1e9,
-                extraData
-            );
-        }
-    }
-
-    /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-                                                        SETTERS                                                     
-    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
-
-    function setRebalancer(address _newRebalancer) public virtual onlyGuardian {
-        if (_newRebalancer == address(0)) revert ZeroAddress();
-        rebalancer = IRebalancerFlashloan(_newRebalancer);
-    }
-
-    function setCollateralData(
-        address collateral,
-        address asset,
-        uint64 targetExposure,
-        uint64 minExposureYieldAsset,
-        uint64 maxExposureYieldAsset,
-        uint64 overrideExposures
-    ) public virtual onlyGuardian {
-        _setCollateralData(
-            collateral,
-            asset,
-            targetExposure,
-            minExposureYieldAsset,
-            maxExposureYieldAsset,
-            overrideExposures
-        );
-    }
-
-    function setMaxSlippage(uint96 _maxSlippage) public virtual onlyGuardian {
-        _setMaxSlippage(_maxSlippage);
-    }
-
-    function updateLimitExposuresYieldAsset(address collateral) public virtual {
-        CollatParams storage collatInfo = collateralData[collateral];
-        if (collatInfo.overrideExposures == 2) _updateLimitExposuresYieldAsset(collatInfo);
-    }
-
-    function _setMaxSlippage(uint96 _maxSlippage) internal virtual {
-        if (_maxSlippage > 1e9) revert InvalidParam();
-        maxSlippage = _maxSlippage;
     }
 
     function _setCollateralData(
@@ -188,15 +186,29 @@
 
     function _updateLimitExposuresYieldAsset(CollatParams storage collatInfo) internal virtual {
         uint64[] memory xFeeMint;
-        (xFeeMint, ) = TRANSMUTER.getCollateralMintFees(collatInfo.asset);
+        (xFeeMint, ) = transmuter.getCollateralMintFees(collatInfo.asset);
         uint256 length = xFeeMint.length;
         if (length <= 1) collatInfo.maxExposureYieldAsset = 1e9;
         else collatInfo.maxExposureYieldAsset = xFeeMint[length - 2];
 
         uint64[] memory xFeeBurn;
-        (xFeeBurn, ) = TRANSMUTER.getCollateralBurnFees(collatInfo.asset);
+        (xFeeBurn, ) = transmuter.getCollateralBurnFees(collatInfo.asset);
         length = xFeeBurn.length;
         if (length <= 1) collatInfo.minExposureYieldAsset = 0;
         else collatInfo.minExposureYieldAsset = xFeeBurn[length - 2];
     }
+
+    function _setMaxSlippage(uint96 newMaxSlippage) internal virtual {
+        if (newMaxSlippage > 1e9) revert InvalidParam();
+        maxSlippage = newMaxSlippage;
+    }
+
+    /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                                                        HELPER                                                      
+    //////////////////////////////////////////////////////////////////////////////////////////////////////////////////*/
+
+    function _adjustAllowance(address token, address sender, uint256 amountIn) internal {
+        uint256 allowance = IERC20(token).allowance(address(this), sender);
+        if (allowance < amountIn) IERC20(token).safeIncreaseAllowance(sender, type(uint256).max - allowance);
+    }
 }