feat: first version of the Rebalancer with flashloan

contracts/helpers/Rebalancer.sol

@@ -70,9 +70,7 @@ contract Rebalancer is IRebalancer, AccessControl {
         IERC20(tokenIn).safeTransferFrom(msg.sender, address(this), amountIn);
         // First, dealing with the allowance of the rebalancer to the Transmuter: this allowance is made infinite
         // by default
-        uint256 allowance = IERC20(tokenIn).allowance(address(this), address(TRANSMUTER));
-        if (allowance < amountIn)
-            IERC20(tokenIn).safeIncreaseAllowance(address(TRANSMUTER), type(uint256).max - allowance);
+        _adjustAllowance(tokenIn, address(TRANSMUTER), amountIn);
         // Mint agToken from `tokenIn`
         uint256 amountAgToken = TRANSMUTER.swapExactInput(
             amountIn,
@@ -199,4 +197,13 @@ contract Rebalancer is IRebalancer, AccessControl {
             revert InvalidParam();
         IERC20(token).safeTransfer(to, amount);
     }
+
+    /*//////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+                                                        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);
+    }
 }

contracts/helpers/RebalancerFlashloan.sol

@@ -0,0 +1,95 @@
+// SPDX-License-Identifier: GPL-3.0
+
+pragma solidity ^0.8.19;
+
+import "./Rebalancer.sol";
+import { IERC4626 } from "interfaces/external/IERC4626.sol";
+import { IERC3156FlashBorrower } from "oz/interfaces/IERC3156FlashBorrower.sol";
+import { IERC3156FlashLender } from "oz/interfaces/IERC3156FlashLender.sol";
+
+/// @title RebalancerFlashloan
+/// @author Angle Labs, Inc.
+/// @dev Rebalancer contract for a Transmuter with as collaterals a liquid stablecoin and an ERC4626 token
+/// using this liquid stablecoin as an asset
+contract RebalancerFlashloan is Rebalancer, IERC3156FlashBorrower {
+    using SafeERC20 for IERC20;
+    using SafeCast for uint256;
+    bytes32 public constant CALLBACK_SUCCESS = keccak256("ERC3156FlashBorrower.onFlashLoan");
+
+    /// @notice Angle stablecoin flashloan contract
+    IERC3156FlashLender public immutable FLASHLOAN;
+
+    constructor(
+        IAccessControlManager _accessControlManager,
+        ITransmuter _transmuter,
+        IERC3156FlashLender _flashloan
+    ) Rebalancer(_accessControlManager, _transmuter) {
+        if (address(_flashloan) == address(0)) revert ZeroAddress();
+        FLASHLOAN = _flashloan;
+        IERC20(AGTOKEN).safeApprove(address(_flashloan), type(uint256).max);
+    }
+
+    /// @notice Burns `amountStablecoins` for one collateral asset and mints stablecoins from the proceeds of the
+    /// first burn
+    /// @dev If `increase` is 1, then the system tries to increase its exposure to the yield bearing asset which means
+    /// burning stablecoin for the liquid asset, depositing into the ERC4626 vault, then minting the stablecoin
+    function adjustYieldExposure(
+        uint256 amountStablecoins,
+        uint8 increase,
+        address collateral,
+        address vault
+    ) external {
+        if (!TRANSMUTER.isTrustedSeller(msg.sender)) revert NotTrusted();
+        FLASHLOAN.flashLoan(
+            IERC3156FlashBorrower(address(this)),
+            address(AGTOKEN),
+            amountStablecoins,
+            abi.encode(increase, collateral, vault)
+        );
+    }
+
+    /// @inheritdoc IERC3156FlashBorrower
+    function onFlashLoan(
+        address initiator,
+        address,
+        uint256 amount,
+        uint256 fee,
+        bytes calldata data
+    ) external returns (bytes32) {
+        if (msg.sender != address(FLASHLOAN) || initiator != address(this) || fee != 0) revert NotTrusted();
+        (uint256 typeAction, address collateral, address vault) = abi.decode(data, (uint256, address, address));
+        address tokenOut;
+        address tokenIn;
+        if (typeAction == 1) {
+            // Increase yield exposure action: we bring in the ERC4626 token
+            tokenOut = collateral;
+            tokenIn = vault;
+        } else {
+            // Decrease yield exposure action: we bring in the liquid asset
+            tokenIn = collateral;
+            tokenOut = vault;
+        }
+        uint256 amountOut = TRANSMUTER.swapExactInput(amount, 0, AGTOKEN, tokenOut, address(this), block.timestamp);
+        if (typeAction == 1) {
+            // Granting allowance with the collateral for the vault asset
+            _adjustAllowance(collateral, vault, amountOut);
+            amountOut = IERC4626(vault).deposit(amountOut, address(this));
+        } else amountOut = IERC4626(vault).redeem(amountOut, address(this), address(this));
+        _adjustAllowance(tokenIn, address(TRANSMUTER), amountOut);
+        uint256 amountStableOut = TRANSMUTER.swapExactInput(
+            amountOut,
+            0,
+            tokenIn,
+            AGTOKEN,
+            address(this),
+            block.timestamp
+        );
+        if (amount > amountStableOut) {
+            uint256 subsidy = amount - amountStableOut;
+            orders[tokenIn][tokenOut].subsidyBudget -= subsidy.toUint112();
+            budget -= subsidy;
+            emit SubsidyPaid(tokenIn, tokenOut, subsidy);
+        }
+        return CALLBACK_SUCCESS;
+    }
+}

scripts/Helpers.s.sol

@@ -27,9 +27,9 @@ contract Helpers is Utils {
     address public sweeper;
 
     function setUp() public virtual {
+        ethereumFork = vm.createFork(vm.envString("ETH_NODE_URI_MAINNET"));
         arbitrumFork = vm.createFork(vm.envString("ETH_NODE_URI_ARBITRUM"));
         avalancheFork = vm.createFork(vm.envString("ETH_NODE_URI_AVALANCHE"));
-        ethereumFork = vm.createFork(vm.envString("ETH_NODE_URI_MAINNET"));
         optimismFork = vm.createFork(vm.envString("ETH_NODE_URI_OPTIMISM"));
         polygonFork = vm.createFork(vm.envString("ETH_NODE_URI_POLYGON"));
         gnosisFork = vm.createFork(vm.envString("ETH_NODE_URI_GNOSIS"));
@@ -39,9 +39,9 @@ contract Helpers is Utils {
         baseFork = vm.createFork(vm.envString("ETH_NODE_URI_BASE"));
         lineaFork = vm.createFork(vm.envString("ETH_NODE_URI_LINEA"));
 
+        forkIdentifier[CHAIN_ETHEREUM] = ethereumFork;
         forkIdentifier[CHAIN_ARBITRUM] = arbitrumFork;
         forkIdentifier[CHAIN_AVALANCHE] = avalancheFork;
-        forkIdentifier[CHAIN_ETHEREUM] = ethereumFork;
         forkIdentifier[CHAIN_OPTIMISM] = optimismFork;
         forkIdentifier[CHAIN_POLYGON] = polygonFork;
         forkIdentifier[CHAIN_GNOSIS] = gnosisFork;

scripts/UpdateTransmuterFacets.s.sol

@@ -34,7 +34,7 @@ contract UpdateTransmuterFacets is Helpers {
     function run() external {
         // TODO: make sure that selectors are well generated `yarn generate` before running this script
         // Here the `selectors.json` file is normally up to date
-        uint256 deployerPrivateKey = vm.envUint("DEPLOYER_PRIVATE_KEY");
+        uint256 deployerPrivateKey = vm.envUint("KEEPER_PRIVATE_KEY");
         vm.startBroadcast(deployerPrivateKey);
 
         Storage.FacetCut[] memory replaceCut;

test/fuzz/RebalancerFlashloanTest.t.sol

@@ -0,0 +1,89 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.19;
+
+import { SafeERC20 } from "oz/token/ERC20/utils/SafeERC20.sol";
+
+import { stdError } from "forge-std/Test.sol";
+
+import "contracts/utils/Errors.sol" as Errors;
+
+import "../Fixture.sol";
+import { IERC20Metadata } from "../mock/MockTokenPermit.sol";
+import "../utils/FunctionUtils.sol";
+
+import "contracts/savings/Savings.sol";
+import "../mock/MockTokenPermit.sol";
+import "contracts/helpers/RebalancerFlashloan.sol";
+
+contract RebalancerFlashloanTest is Fixture, FunctionUtils {
+    using SafeERC20 for IERC20;
+
+    RebalancerFlashloan public rebalancer;
+    Savings internal _saving;
+    string internal _name;
+    string internal _symbol;
+    address public collat;
+
+    function setUp() public override {
+        super.setUp();
+
+        MockTokenPermit token = new MockTokenPermit("EURC", "EURC", 6);
+        collat = address(token);
+
+        address _savingImplementation = address(new Savings());
+        bytes memory data;
+        _saving = Savings(_deployUpgradeable(address(proxyAdmin), address(_savingImplementation), data));
+        _name = "savingAgEUR";
+        _symbol = "SAGEUR";
+
+        vm.startPrank(governor);
+        token.mint(governor, 1e12);
+        token.approve(address(_saving), 1e12);
+        _saving.initialize(accessControlManager, IERC20MetadataUpgradeable(address(token)), _name, _symbol, BASE_6);
+        vm.stopPrank();
+
+        rebalancer = new RebalancerFlashloan(accessControlManager, transmuter, IERC3156FlashLender(governor));
+    }
+
+    function test_RebalancerInitialization() public {
+        assertEq(address(rebalancer.accessControlManager()), address(accessControlManager));
+        assertEq(address(rebalancer.AGTOKEN()), address(agToken));
+        assertEq(address(rebalancer.TRANSMUTER()), address(transmuter));
+        assertEq(address(rebalancer.FLASHLOAN()), governor);
+        assertEq(IERC20Metadata(address(agToken)).allowance(address(rebalancer), address(governor)), type(uint256).max);
+        assertEq(IERC20Metadata(address(collat)).allowance(address(rebalancer), address(_saving)), 0);
+    }
+
+    function test_Constructor_RevertWhen_ZeroAddress() public {
+        vm.expectRevert(Errors.ZeroAddress.selector);
+        new RebalancerFlashloan(accessControlManager, transmuter, IERC3156FlashLender(address(0)));
+    }
+
+    function test_adjustYieldExposure_RevertWhen_NotTrusted() public {
+        vm.expectRevert(Errors.NotTrusted.selector);
+        rebalancer.adjustYieldExposure(1, 1, address(0), address(0));
+    }
+
+    function test_onFlashLoan_RevertWhen_NotTrusted() public {
+        vm.expectRevert(Errors.NotTrusted.selector);
+        rebalancer.onFlashLoan(address(rebalancer), address(0), 1, 0, abi.encode(1));
+
+        vm.expectRevert(Errors.NotTrusted.selector);
+        rebalancer.onFlashLoan(address(rebalancer), address(0), 1, 1, abi.encode(1));
+
+        vm.expectRevert(Errors.NotTrusted.selector);
+        vm.startPrank(governor);
+        rebalancer.onFlashLoan(address(0), address(0), 1, 0, abi.encode(1));
+        vm.stopPrank();
+
+        vm.expectRevert(Errors.NotTrusted.selector);
+        vm.startPrank(governor);
+        rebalancer.onFlashLoan(address(rebalancer), address(0), 1, 1, abi.encode(1));
+        vm.stopPrank();
+
+        vm.expectRevert();
+        vm.startPrank(governor);
+        rebalancer.onFlashLoan(address(rebalancer), address(0), 1, 0, abi.encode(1, 2));
+        vm.stopPrank();
+    }
+}