Compounding support via ERC4626

.gitmodules

@@ -19,3 +19,6 @@
 	path = lib/base58-solidity
 	url = https://github.com/storyicon/base58-solidity
 	branch = v1.0.2
+[submodule "lib/@aave/aave-vault"]
+	path = lib/@aave/aave-vault
+	url = https://github.com/zkBob/Aave-Vault

foundry.toml

@@ -6,6 +6,7 @@ fs_permissions = [
     { access = "read", path = "./out" },
     { access = "read", path = "./scripts/vanityaddr/contracts" }
 ]
+auto_detect_remappings = false
 
 [fmt]
 line_length = 120

remappings.txt

@@ -1,3 +1,15 @@
-@openzeppelin/contracts/=lib/@openzeppelin/contracts/contracts/
-@gnosis/auction/=lib/@gnosis/auction/contracts/
+@aave/=lib/@aave/
 @base58-solidity/=lib/base58-solidity/contracts/
+@gnosis/=lib/@gnosis/
+@gnosis/auction/=lib/@gnosis/auction/contracts/
+@openzeppelin/interfaces/=lib/@openzeppelin/contracts/contracts/interfaces/
+@openzeppelin/contracts/=lib/@openzeppelin/contracts/contracts
+@uniswap/=lib/@uniswap/
+@aave-v3-core/=lib/@aave/aave-vault/lib/aave-v3-core/contracts
+@aave-v3-periphery/=lib/@aave/aave-vault/lib/aave-v3-periphery/contracts/
+ds-test/=lib/forge-std/lib/ds-test/src/
+erc4626-tests/=lib/@aave/aave-vault/lib/erc4626-tests/
+forge-std/=lib/forge-std/src/
+@openzeppelin-upgradeable/=lib/@aave/aave-vault/lib/openzeppelin-contracts-upgradeable/contracts
+openzeppelin-contracts/=lib/@aave/aave-vault/lib/openzeppelin-contracts/
+solmate/=lib/@aave/aave-vault/lib/solmate/src/

src/zkbob/ZkBobCompoundingMixin.sol

@@ -0,0 +1,164 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.15;
+
+import "@openzeppelin/contracts/interfaces/IERC4626.sol";
+import "./ZkBobPool.sol";
+
+/**
+ * @title ZkBobCompoundingMixin
+ */
+abstract contract ZkBobCompoundingMixin is ZkBobPool {
+    using SafeERC20 for IERC20;
+
+    uint256 public investedAssetsAmount;
+
+    struct YieldParams {
+        // ERC4626 vault address (or address(0) if not set)
+        address yield;
+        // expected amount of underlying tokens to be left at the pool after successful rebalance
+        uint96 buffer;
+        // operator address (or address(0) if permissionless)
+        address yieldOperator;
+        // slippage/rounding protection buffer, small part of accumulated interest that is non-claimable
+        uint96 dust;
+        // address to receive accumulated interest during the rebalance
+        address interestReceiver;
+        // maximum amount of underlying tokens that can be invested into vault
+        uint256 maxInvestedAmount;
+    }
+
+    YieldParams public yieldParams;
+
+    event UpdateYieldParams(YieldParams yieldParams);
+    event Claimed(address indexed yield, uint256 amount);
+    event Rebalance(address indexed yield, uint256 withdrawn, uint256 deposited);
+
+    // @inheritdoc ZkBobPool
+    function _withdrawToken(address _user, uint256 _tokenAmount) internal override {
+        uint256 underlyingBalance = IERC20(token).balanceOf(address(this));
+        if (underlyingBalance < _tokenAmount) {
+            (address yieldAddress, uint256 buffer) = (yieldParams.yield, yieldParams.buffer);
+            uint256 remainder = _tokenAmount - underlyingBalance;
+            uint256 investedAssets = investedAssetsAmount;
+            uint256 withdrawAmount = investedAssets > remainder + buffer ? remainder + buffer : investedAssets;
+            investedAssetsAmount = investedAssets - withdrawAmount;
+            IERC4626(yieldAddress).withdraw(withdrawAmount, address(this), address(this));
+            emit Rebalance(yieldAddress, withdrawAmount, 0);
+        }
+        IERC20(token).safeTransfer(_user, _tokenAmount);
+    }
+
+    /**
+     * @dev Updates yield parameters.
+     * Callable only by the contract owner / proxy admin.
+     * @param _yieldParams new yield parameters.
+     */
+    function updateYieldParams(YieldParams memory _yieldParams) external onlyOwner {
+        address yieldAddress = yieldParams.yield;
+        require(
+            _yieldParams.yield == yieldAddress || investedAssetsAmount == 0, "ZkBobCompounding: another yield is active"
+        );
+        require(
+            _yieldParams.yield == address(0) || _yieldParams.interestReceiver != address(0),
+            "ZkBobCompounding: zero interest receiver"
+        );
+
+        if (_yieldParams.yield != yieldAddress && yieldAddress != address(0)) {
+            _claim(yieldAddress, yieldParams.interestReceiver, 0);
+        }
+
+        yieldParams = _yieldParams;
+
+        emit UpdateYieldParams(_yieldParams);
+    }
+
+    /**
+     * @dev Rebalances yield bearing tokens.
+     * @param minRebalanceAmount minimum amount of token to move between underlying balance and yield.
+     * @param maxRebalanceAmount maximum amount of token to move between underlying balance and yield.
+     */
+    function rebalance(uint256 minRebalanceAmount, uint256 maxRebalanceAmount) external {
+        (address yieldAddress, address operator, uint256 buffer, uint256 maxInvestedAmount) =
+            (yieldParams.yield, yieldParams.yieldOperator, yieldParams.buffer, yieldParams.maxInvestedAmount);
+
+        require(yieldAddress != address(0), "ZkBobCompounding: yield not enabled");
+        require(operator == address(0) || operator == msg.sender || _isOwner(), "ZkBobCompounding: not authorized");
+
+        uint256 underlyingBalance = IERC20(token).balanceOf(address(this));
+        uint256 investedAssets = investedAssetsAmount;
+
+        if (underlyingBalance < buffer || investedAssets > maxInvestedAmount) {
+            uint256 withdrawAmount;
+            if (underlyingBalance < buffer) {
+                withdrawAmount = buffer - underlyingBalance;
+                if (withdrawAmount > investedAssets) {
+                    withdrawAmount = investedAssets;
+                }
+            } else {
+                withdrawAmount = investedAssets - maxInvestedAmount;
+            }
+            if (withdrawAmount > maxRebalanceAmount) {
+                withdrawAmount = maxRebalanceAmount;
+            }
+            require(
+                withdrawAmount > 0 && withdrawAmount >= minRebalanceAmount, "ZkBobCompounding: insufficient rebalance"
+            );
+            investedAssetsAmount = investedAssets - withdrawAmount;
+            IERC4626(yieldAddress).withdraw(withdrawAmount, address(this), address(this));
+            emit Rebalance(yieldAddress, withdrawAmount, 0);
+        } else {
+            uint256 depositAmount = underlyingBalance - buffer;
+            if (investedAssets + depositAmount > maxInvestedAmount) {
+                depositAmount = maxInvestedAmount - investedAssets;
+            }
+            if (depositAmount > maxRebalanceAmount) {
+                depositAmount = maxRebalanceAmount;
+            }
+            require(
+                depositAmount > 0 && depositAmount >= minRebalanceAmount, "ZkBobCompounding: insufficient rebalance"
+            );
+            investedAssetsAmount = investedAssets + depositAmount;
+            IERC20(token).approve(yieldAddress, depositAmount);
+            IERC4626(yieldAddress).deposit(depositAmount, address(this));
+            emit Rebalance(yieldAddress, 0, depositAmount);
+        }
+    }
+
+    /**
+     * @dev Collects accumulated fees and generated yield for the specific collateral.
+     * Callable only by the contract owner / proxy admin / yield admin.
+     * @param minClaimAmount minimum amount of token to claim.
+     * @return Claimed amount.
+     */
+    function claim(uint256 minClaimAmount) external returns (uint256) {
+        (address yieldAddress, address operator, uint256 dust, address interestReceiver) =
+            (yieldParams.yield, yieldParams.yieldOperator, yieldParams.dust, yieldParams.interestReceiver);
+
+        require(yieldAddress != address(0), "ZkBobCompounding: yield not enabled");
+        require(operator == address(0) || operator == msg.sender || _isOwner(), "ZkBobCompounding: not authorized");
+
+        uint256 claimed = _claim(yieldAddress, interestReceiver, dust);
+
+        require(claimed > 0 && claimed >= minClaimAmount, "ZkBobCompounding: not enough to claim");
+
+        return claimed;
+    }
+
+    function _claim(address yieldAddress, address interestReceiver, uint256 dust) internal returns (uint256) {
+        uint256 shares = IERC4626(yieldAddress).balanceOf(address(this));
+        uint256 lockedAssets = investedAssetsAmount + dust;
+        uint256 availableAssets = IERC4626(yieldAddress).convertToAssets(shares);
+
+        if (availableAssets <= lockedAssets) {
+            return 0;
+        }
+
+        uint256 claimAmount = availableAssets - lockedAssets;
+        IERC4626(yieldAddress).withdraw(claimAmount, interestReceiver, address(this));
+
+        emit Claimed(yieldAddress, claimAmount);
+
+        return claimAmount;
+    }
+}

src/zkbob/ZkBobNonCompoudingMixin.sol

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.15;
+
+import "./ZkBobPool.sol";
+
+/**
+ * @title ZkBobNonCompoundingMixin
+ */
+abstract contract ZkBobNonCompoundingMixin is ZkBobPool {
+    using SafeERC20 for IERC20;
+
+    // @inheritdoc ZkBobPool
+    function _withdrawToken(address _user, uint256 _tokenAmount) internal override {
+        IERC20(token).safeTransfer(_user, _tokenAmount);
+    }
+}

src/zkbob/ZkBobPool.sol

@@ -186,6 +186,13 @@ abstract contract ZkBobPool is IZkBobPool, EIP1967Admin, Ownable, Parameters, Ex
      */
     function _withdrawNative(address _user, uint256 _tokenAmount) internal virtual returns (uint256);
 
+    /**
+     * @dev Withdraws given amount of tokens to the provided address.
+     * @param _user token receiver address.
+     * @param _tokenAmount amount to tokens to withdraw.
+     */
+    function _withdrawToken(address _user, uint256 _tokenAmount) internal virtual;
+
     /**
      * @dev Performs token transfer using a signed permit signature.
      * @param _user token depositor address, should correspond to the signature author.
@@ -270,7 +277,7 @@ abstract contract ZkBobPool is IZkBobPool, EIP1967Admin, Ownable, Parameters, Ex
             }
 
             if (withdraw_amount > 0) {
-                IERC20(token).safeTransfer(user, withdraw_amount);
+                _withdrawToken(user, withdraw_amount);
             }
 
             if (energy_amount < 0) {
@@ -431,7 +438,7 @@ abstract contract ZkBobPool is IZkBobPool, EIP1967Admin, Ownable, Parameters, Ex
         }
         nullifiers[_nullifier] = poolIndex | uint256(0xdeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddeaddead0000000000000000);
 
-        IERC20(token).safeTransfer(_to, _amount * TOKEN_DENOMINATOR / TOKEN_NUMERATOR);
+        _withdrawToken(_to, _amount * TOKEN_DENOMINATOR / TOKEN_NUMERATOR);
 
         emit ForcedExit(poolIndex, _nullifier, _to, _amount);
     }
@@ -463,7 +470,7 @@ abstract contract ZkBobPool is IZkBobPool, EIP1967Admin, Ownable, Parameters, Ex
         );
         uint256 fee = accumulatedFee[_operator] * TOKEN_DENOMINATOR / TOKEN_NUMERATOR;
         require(fee > 0, "ZkBobPool: no fee to withdraw");
-        IERC20(token).safeTransfer(_to, fee);
+        _withdrawToken(_to, fee);
         accumulatedFee[_operator] = 0;
         emit WithdrawFee(_operator, fee);
     }

src/zkbob/ZkBobPoolBOB.sol

@@ -5,12 +5,13 @@ pragma solidity 0.8.15;
 import "./ZkBobPool.sol";
 import "./ZkBobTokenSellerMixin.sol";
 import "./ZkBobSaltedPermitMixin.sol";
+import "./ZkBobNonCompoudingMixin.sol";
 
 /**
  * @title ZkBobPoolBOB
  * Shielded transactions pool for BOB tokens.
  */
-contract ZkBobPoolBOB is ZkBobPool, ZkBobTokenSellerMixin, ZkBobSaltedPermitMixin {
+contract ZkBobPoolBOB is ZkBobPool, ZkBobTokenSellerMixin, ZkBobSaltedPermitMixin, ZkBobNonCompoundingMixin {
     constructor(
         uint256 __pool_id,
         address _token,

src/zkbob/ZkBobPoolERC20.sol

@@ -5,12 +5,13 @@ pragma solidity 0.8.15;
 import "./ZkBobPool.sol";
 import "./ZkBobTokenSellerMixin.sol";
 import "./ZkBobPermit2Mixin.sol";
+import "./ZkBobCompoundingMixin.sol";
 
 /**
  * @title ZkBobPoolERC20
  * Shielded transactions pool for ERC20 tokens
  */
-contract ZkBobPoolERC20 is ZkBobPool, ZkBobTokenSellerMixin, ZkBobPermit2Mixin {
+contract ZkBobPoolERC20 is ZkBobPool, ZkBobTokenSellerMixin, ZkBobPermit2Mixin, ZkBobCompoundingMixin {
     constructor(
         uint256 __pool_id,
         address _token,

src/zkbob/ZkBobPoolETH.sol

@@ -5,12 +5,13 @@ pragma solidity 0.8.15;
 import "./ZkBobPool.sol";
 import "./ZkBobWETHMixin.sol";
 import "./ZkBobPermit2Mixin.sol";
+import "./ZkBobCompoundingMixin.sol";
 
 /**
  * @title ZkBobPoolETH
  * Shielded transactions pool for native and wrapped native tokens.
  */
-contract ZkBobPoolETH is ZkBobPool, ZkBobWETHMixin, ZkBobPermit2Mixin {
+contract ZkBobPoolETH is ZkBobPool, ZkBobWETHMixin, ZkBobPermit2Mixin, ZkBobCompoundingMixin {
     constructor(
         uint256 __pool_id,
         address _token,

src/zkbob/ZkBobPoolUSDC.sol

@@ -5,12 +5,13 @@ pragma solidity 0.8.15;
 import "./ZkBobPool.sol";
 import "./ZkBobTokenSellerMixin.sol";
 import "./ZkBobUSDCPermitMixin.sol";
+import "./ZkBobCompoundingMixin.sol";
 
 /**
  * @title ZkBobPoolUSDC
  * Shielded transactions pool for USDC tokens supporting USDC transfer authorizations
  */
-contract ZkBobPoolUSDC is ZkBobPool, ZkBobTokenSellerMixin, ZkBobUSDCPermitMixin {
+contract ZkBobPoolUSDC is ZkBobPool, ZkBobTokenSellerMixin, ZkBobUSDCPermitMixin, ZkBobCompoundingMixin {
     constructor(
         uint256 __pool_id,
         address _token,

test/interfaces/IZkBobPoolAdmin.sol

@@ -7,6 +7,21 @@ import "../../src/interfaces/IOperatorManager.sol";
 import "../../src/interfaces/IEnergyRedeemer.sol";
 
 interface IZkBobPoolAdmin {
+    struct YieldParams {
+        // ERC4626 vault address (or address(0) if not set)
+        address yield;
+        // expected amount of underlying tokens to be left at the pool after successful rebalance
+        uint96 buffer;
+        // operator address (or address(0) if permissionless)
+        address yieldOperator;
+        // slippage/rounding protection buffer, small part of accumulated interest that is non-claimable
+        uint96 dust;
+        // address to receive accumulated interest during the rebalance
+        address interestReceiver;
+        // maximum amount of underlying tokens that can be invested into vault
+        uint256 maxInvestedAmount;
+    }
+
     function denominator() external pure returns (uint256);
 
     function pool_index() external view returns (uint256);
@@ -82,4 +97,16 @@ interface IZkBobPoolAdmin {
     function direct_deposit_queue() external view returns (address);
 
     function pool_id() external view returns (uint256);
+
+    function investedAssetsAmount() external view returns (uint256);
+
+    function yieldParams() external view returns (YieldParams memory);
+
+    function updateYieldParams(YieldParams memory _yieldParams) external;
+
+    function rebalance(uint256 minRebalanceAmount, uint256 maxRebalanceAmount) external;
+
+    function claim(uint256 minClaimAmount) external returns (uint256);
+
+    function emergencyWithdraw(uint256 targetAmount) external;
 }

test/shared/Env.t.sol

@@ -16,9 +16,11 @@ address constant mockImpl = address(0xdead);
 address constant bobVanityAddr = address(0xB0B195aEFA3650A6908f15CdaC7D92F8a5791B0B);
 bytes32 constant bobSalt = bytes32(uint256(285834900769));
 
-uint256 constant forkBlockMainnet = 16200000;
-string constant forkRpcUrlMainnet = "https://rpc.ankr.com/eth";
+uint256 constant forkBlockMainnet = 17000000;
+string constant forkRpcUrlMainnet =
+    "https://rpc.ankr.com/eth/9459a7b0289d1177790c6d0e02b5d2c852d173cfae0ce30ba12b1e7ad3b73cc8";
 uint256 constant forkBlockPolygon = 37000000;
-string constant forkRpcUrlPolygon = "https://rpc.ankr.com/polygon";
+string constant forkRpcUrlPolygon =
+    "https://rpc.ankr.com/polygon/9459a7b0289d1177790c6d0e02b5d2c852d173cfae0ce30ba12b1e7ad3b73cc8";
 uint256 constant forkBlockOptimism = 52000000;
 string constant forkRpcUrlOptimism = "https://1rpc.io/op";