Supply vaults - tested

.gitmodules

@@ -1,6 +1,6 @@
 [submodule "packages/contracts/lib/forge-std"]
 path = packages/contracts/lib/forge-std
-url = https://github.com/brockelmore/forge-std
+url = https://github.com/foundry-rs/forge-std
 [submodule "packages/contracts/lib/openzeppelin-contracts-upgradeable"]
 path = packages/contracts/lib/openzeppelin-contracts-upgradeable
 url = https://github.com/OpenZeppelin/openzeppelin-contracts-upgradeable

packages/contracts/contracts/ionic/strategies/CompoundMarketERC4626.sol

@@ -0,0 +1,184 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.10;
+
+import { IonicERC4626 } from "./IonicERC4626.sol";
+import { ICErc20 } from "../../compound/CTokenInterfaces.sol";
+import { IonicComptroller } from "../../compound/ComptrollerInterface.sol";
+import { IGenericLender } from "../../external/angle/IGenericLender.sol";
+import { OptimizedVaultsRegistry } from "../vault/OptimizedVaultsRegistry.sol";
+import { OptimizedAPRVaultBase } from "../vault/OptimizedAPRVaultBase.sol";
+import { IonicFlywheel } from "./flywheel/IonicFlywheel.sol";
+import { IonicFlywheelLensRouter } from "./flywheel/IonicFlywheelLensRouter.sol";
+
+import { ERC20Upgradeable } from "openzeppelin-contracts-upgradeable/contracts/token/ERC20/ERC20Upgradeable.sol";
+import { ERC20 } from "solmate/tokens/ERC20.sol";
+
+contract CompoundMarketERC4626 is IonicERC4626, IGenericLender {
+  ICErc20 public market;
+  uint256 public blocksPerYear;
+  OptimizedVaultsRegistry public registry;
+
+  event ClaimedVaultRewards(address indexed rewardToken, address indexed vault, uint256 amount);
+
+  modifier onlyRegisteredVaults() {
+    OptimizedAPRVaultBase[] memory vaults = registry.getAllVaults();
+    bool isMsgSender = false;
+    for (uint256 i = 0; i < vaults.length; i++) {
+      if (msg.sender == address(vaults[i])) {
+        isMsgSender = true;
+        break;
+      }
+    }
+    require(isMsgSender, "!caller not a vault");
+    _;
+  }
+
+  constructor() {
+    _disableInitializers();
+  }
+
+  function initialize(
+    ICErc20 market_,
+    uint256 blocksPerYear_,
+    OptimizedVaultsRegistry registry_
+  ) public initializer {
+    __IonicER4626_init(ERC20Upgradeable(market_.underlying()));
+    market = market_;
+    blocksPerYear = blocksPerYear_;
+    registry = registry_;
+  }
+
+  function reinitialize(address registry_) public onlyOwnerOrAdmin {
+    registry = OptimizedVaultsRegistry(registry_);
+  }
+
+  function lenderName() public view returns (string memory) {
+    return string(bytes.concat("Ionic Optimized ", bytes(name())));
+  }
+
+  function totalAssets() public view override returns (uint256) {
+    return market.balanceOfUnderlying(address(this));
+  }
+
+  function balanceOfUnderlying(address account) public view returns (uint256) {
+    return convertToAssets(balanceOf(account));
+  }
+
+  function afterDeposit(uint256 amount, uint256) internal override onlyRegisteredVaults {
+    ERC20Upgradeable(asset()).approve(address(market), amount);
+    require(market.mint(amount) == 0, "deposit to market failed");
+  }
+
+  function beforeWithdraw(uint256 amount, uint256) internal override onlyRegisteredVaults {
+    require(market.redeemUnderlying(amount) == 0, "redeem from market failed");
+  }
+
+  function aprAfterDeposit(uint256 amount) public view returns (uint256) {
+    return _rewardsApr() + market.supplyRatePerBlockAfterDeposit(amount) * blocksPerYear;
+  }
+
+  function aprAfterWithdraw(uint256 amount) public view override returns (uint256) {
+    return _rewardsApr() + market.supplyRatePerBlockAfterWithdraw(amount) * blocksPerYear;
+  }
+
+  function emergencyWithdrawAndPause() external override {
+    require(msg.sender == owner() || msg.sender == address(registry), "not owner or vaults registry");
+    require(market.redeemUnderlying(type(uint256).max) == 0, "redeem all failed");
+    _pause();
+  }
+
+  function unpause() external override onlyOwner {
+    _unpause();
+  }
+
+  /*------------------------------------------------------------
+                        IGenericLender FNs
+    ------------------------------------------------------------*/
+
+  function rewardsApr() public view returns (uint256) {
+    return _rewardsApr();
+  }
+
+  /// @notice Returns an estimation of the current Annual Percentage Rate on the lender
+  function apr() public view override returns (uint256) {
+    return _rewardsApr() + market.supplyRatePerBlock() * blocksPerYear;
+  }
+
+  function _rewardsApr() internal view returns (uint256) {
+    return uint256(registry.flr().getRewardsAprForMarket(market));
+  }
+
+  /// @notice Returns an estimation of the current Annual Percentage Rate weighted by the assets under
+  /// management of the lender
+  function weightedApr() external view returns (uint256) {
+    return (apr() * totalAssets()) / 1e18;
+  }
+
+  /// @notice Returns an estimation of the hypothetical Annual Percentage Rate weighted by the assets under
+  /// management of the lender plus the amount, if deposited
+  function weightedAprAfterDeposit(uint256 amount) public view returns (uint256) {
+    return (aprAfterDeposit(amount) * (totalAssets() + amount)) / 1e18;
+  }
+
+  /// @notice Withdraws a given amount from lender
+  /// @param amount The amount the caller wants to withdraw
+  /// @return Amount actually withdrawn
+  function withdraw(uint256 amount) public override returns (uint256) {
+    withdraw(amount, msg.sender, msg.sender);
+    return amount;
+  }
+
+  /// @notice Withdraws as much as possible from the lending platform
+  /// @return Whether everything was withdrawn or not
+  function withdrawAll() public override returns (bool) {
+    return withdraw(maxWithdraw(msg.sender), msg.sender, msg.sender) > 0;
+  }
+
+  /// @notice Removes tokens from this Strategy that are not the type of tokens
+  /// managed by this Strategy. This may be used in case of accidentally
+  /// sending the wrong kind of token to this Strategy.
+  ///
+  /// @param _token The token to transfer out of this poolManager.
+  /// @param to Address to send the tokens to.
+  function sweep(address _token, address to) public onlyOwner {
+    require(_token != asset(), "!asset");
+
+    ERC20Upgradeable token = ERC20Upgradeable(_token);
+    token.transfer(to, token.balanceOf(address(this)));
+  }
+
+  function claimRewards() public onlyRegisteredVaults {
+    IonicComptroller pool = IonicComptroller(market.comptroller());
+    address[] memory poolFlywheels = pool.getRewardsDistributors();
+
+    for (uint256 j = 0; j < poolFlywheels.length; j++) {
+      IonicFlywheel flywheel = IonicFlywheel(poolFlywheels[j]);
+      ERC20 rewardToken = flywheel.rewardToken();
+
+      // accrue and claim the rewards
+      flywheel.accrue(ERC20(address(market)), address(this));
+      flywheel.claimRewards(address(this));
+
+      uint256 totalRewards = rewardToken.balanceOf(address(this));
+      // avoid rounding errors for too little amounts
+      if (totalRewards > 1000) {
+        // the rewards that are in the underlying asset are autocompounded
+        if (address(rewardToken) == address(asset())) {
+          afterDeposit(totalRewards, 0);
+        } else {
+          // redistribute the claimed rewards among the vaults
+          OptimizedAPRVaultBase[] memory vaults = registry.getAllVaults();
+          for (uint256 i = 0; i < vaults.length; i++) {
+            address vaultAddress = address(vaults[i]);
+            uint256 vaultSharesInAdapter = balanceOf(vaultAddress);
+            uint256 vaultShareOfRewards = (vaultSharesInAdapter * totalRewards) / totalSupply();
+            if (vaultShareOfRewards > 0) {
+              rewardToken.transfer(vaultAddress, vaultShareOfRewards);
+              emit ClaimedVaultRewards(address(rewardToken), vaultAddress, vaultShareOfRewards);
+            }
+          }
+        }
+      }
+    }
+  }
+}

packages/contracts/contracts/ionic/strategies/IonicERC4626.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: AGPL-3.0-only
-pragma solidity >=0.8.0;
+pragma solidity ^0.8.10;
 
 import { FixedPointMathLib } from "solmate/utils/FixedPointMathLib.sol";
 

packages/contracts/contracts/ionic/strategies/flywheel/IIonicFlywheel.sol

@@ -4,9 +4,9 @@ pragma solidity ^0.8.10;
 import { ERC20 } from "solmate/tokens/ERC20.sol";
 
 interface IIonicFlywheel {
-  function isRewardsDistributor() external returns (bool);
+  function isRewardsDistributor() external view returns (bool);
 
-  function isFlywheel() external returns (bool);
+  function isFlywheel() external view returns (bool);
 
   function flywheelPreSupplierAction(address market, address supplier) external;
 

packages/contracts/contracts/ionic/strategies/flywheel/IonicFlywheelBorrowBooster.sol

@@ -1,19 +1,22 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 pragma solidity ^0.8.10;
 
+import {ERC20} from "solmate/tokens/ERC20.sol";
+
 import { ICErc20 } from "../../../compound/CTokenInterfaces.sol";
-import "./IIonicFlywheelBorrowBooster.sol";
+import "./IFlywheelBooster.sol";
 
-contract IonicFlywheelBorrowBooster is IIonicFlywheelBorrowBooster {
-  string public constant BOOSTER_TYPE = "FlywheelBorrowBooster";
+contract IonicFlywheelBorrowBooster is IFlywheelBooster {
+  string public constant BOOSTER_TYPE = "IonicFlywheelBorrowBooster";
 
   /**
       @notice calculate the boosted supply of a strategy.
       @param strategy the strategy to calculate boosted supply of
       @return the boosted supply
      */
-  function boostedTotalSupply(ICErc20 strategy) external view returns (uint256) {
-    return strategy.totalBorrows();
+  function boostedTotalSupply(ERC20 strategy) external view returns (uint256) {
+    ICErc20 asMarket = ICErc20(address(strategy));
+    return asMarket.totalBorrows();
   }
 
   /**
@@ -22,7 +25,8 @@ contract IonicFlywheelBorrowBooster is IIonicFlywheelBorrowBooster {
       @param user the user to calculate boosted balance of
       @return the boosted balance
      */
-  function boostedBalanceOf(ICErc20 strategy, address user) external view returns (uint256) {
-    return strategy.borrowBalanceCurrent(user);
+  function boostedBalanceOf(ERC20 strategy, address user) external view returns (uint256) {
+    ICErc20 asMarket = ICErc20(address(strategy));
+    return asMarket.borrowBalanceCurrent(user);
   }
 }

packages/contracts/contracts/ionic/strategies/flywheel/IonicFlywheelCore.sol

@@ -252,7 +252,7 @@ contract IonicFlywheelCore is SafeOwnableUpgradeable {
 
     if (strategyRewardsAccrued > 0) {
       // use the booster or token supply to calculate reward index denominator
-      uint256 supplyTokens = address(flywheelBooster) != address(0)
+      uint256 totalTokens = address(flywheelBooster) != address(0)
         ? flywheelBooster.boostedTotalSupply(strategy)
         : strategy.totalSupply();
 
@@ -264,8 +264,8 @@ contract IonicFlywheelCore is SafeOwnableUpgradeable {
 
       uint224 deltaIndex;
 
-      if (supplyTokens != 0)
-        deltaIndex = ((strategyRewardsAccrued * (10**strategy.decimals())) / supplyTokens).safeCastTo224();
+      if (totalTokens != 0)
+        deltaIndex = ((strategyRewardsAccrued * (10**strategy.decimals())) / totalTokens).safeCastTo224();
 
       // accumulate rewards per token onto the index, multiplied by fixed-point factor
       rewardsState = RewardsState({
@@ -312,15 +312,23 @@ contract IonicFlywheelCore is SafeOwnableUpgradeable {
     return supplierAccrued;
   }
 
-  function rewardsAccrued(address user) public virtual returns (uint256) {
+  function rewardsAccrued(address user) public view virtual returns (uint256) {
     return _rewardsAccrued[user];
   }
 
-  function userIndex(ERC20 strategy, address user) public virtual returns (uint224) {
+  function userIndex(ERC20 strategy, address user) public view virtual returns (uint224) {
     return _userIndex[strategy][user];
   }
 
-  function strategyState(ERC20 strategy) public virtual returns (uint224 index, uint32 lastUpdatedTimestamp) {
+  function strategyState(ERC20 strategy) public view virtual returns (uint224 index, uint32 lastUpdatedTimestamp) {
     return (_strategyState[strategy].index, _strategyState[strategy].lastUpdatedTimestamp);
   }
+
+  function getRewardsPerSecondPerToken(ERC20 strategy) external view returns (uint256) {
+    uint256 totalTokens = address(flywheelBooster) != address(0)
+      ? flywheelBooster.boostedTotalSupply(strategy)
+      : strategy.totalSupply();
+    if (totalTokens == 0) return 0;
+    return (flywheelRewards.getRewardsPerSecond(strategy) * 1e18) / totalTokens;
+  }
 }