feat(rollover-vault): finishing rollover vault and refactoring redemptions to be proportional claims from a list

Author: SocksNFlops

src/FulfillmentVault.sol

@@ -11,6 +11,7 @@ import {IWNT} from "./interfaces/IWNT.sol";
 import {IFulfillmentVault} from "./interfaces/IFulfillmentVault/IFulfillmentVault.sol";
 import {IUSDX} from "@core/interfaces/IUSDX/IUSDX.sol";
 import {IOrderPool} from "@core/interfaces/IOrderPool/IOrderPool.sol";
+import {IGeneralManager} from "@core/interfaces/IGeneralManager/IGeneralManager.sol";
 
 /**
  * @title FulfillmentVault
@@ -21,19 +22,20 @@ contract FulfillmentVault is LiquidityVault, IFulfillmentVault {
   using Math for uint256;
   using CoreWriterLib for *;
 
-  /// @notice Allow the contract to receive ETH (HYPE bridged from Core)
+  /// @notice Allow the contract to receive network native tokens (HYPE bridged from Core)
   receive() external payable {}
 
   /**
    * @custom:storage-location erc7201:buttonwood.storage.FulfillmentVault
    * @notice The storage for the FulfillmentVault contract
    * @param _wrappedNativeToken The address of the wrapped native token
-   * @param _orderPool The address of the order pool
+   * @param _generalManager The address of the general manager
    * @param _nonce The ongoing nonce that generates distinct cloid values for exchanges on core
    */
   struct FulfillmentVaultStorage {
     address _wrappedNativeToken;
-    address _orderPool;
+    address _generalManager;
+    address _usdx;
     uint128 _nonce;
   }
 
@@ -65,22 +67,25 @@ contract FulfillmentVault is LiquidityVault, IFulfillmentVault {
     string memory symbol,
     uint8 _decimals,
     uint8 _decimalsOffset,
-    address _usdx,
     address _wrappedNativeToken,
-    address _orderPool
+    address _generalManager
   ) internal onlyInitializing {
     __ERC20_init_unchained(name, symbol);
-    __LiquidityVault_init_unchained(_decimals, _decimalsOffset, _usdx, _usdx);
-    __FulfillmentVault_init_unchained(_wrappedNativeToken, _orderPool);
+    address[] memory assets = new address[](1);
+    assets[0] = IGeneralManager(_generalManager).usdx();
+    __LiquidityVault_init_unchained(_decimals, _decimalsOffset, assets, assets);
+    __FulfillmentVault_init_unchained(_wrappedNativeToken, _generalManager);
   }
 
   /**
    * @dev Initializes the FulfillmentVault contract only
    */
   // solhint-disable-next-line func-name-mixedcase
-  function __FulfillmentVault_init_unchained(address _wrappedNativeToken, address _orderPool) internal onlyInitializing {
-    _getFulfillmentVaultStorage()._wrappedNativeToken = _wrappedNativeToken;
-    _getFulfillmentVaultStorage()._orderPool = _orderPool;
+  function __FulfillmentVault_init_unchained(address _wrappedNativeToken, address _generalManager) internal onlyInitializing {
+    FulfillmentVaultStorage storage $ = _getFulfillmentVaultStorage();
+    $._wrappedNativeToken = _wrappedNativeToken;
+    $._generalManager = _generalManager;
+    $._usdx = IGeneralManager(generalManager()).usdx();
   }
 
   /**
@@ -89,20 +94,18 @@ contract FulfillmentVault is LiquidityVault, IFulfillmentVault {
    * @param symbol The symbol of the liquidity vault
    * @param _decimals The decimals of the liquidity vault
    * @param _decimalsOffset The decimals offset for measuring internal precision of shares
-   * @param _usdx The address of the usdx
    * @param _wrappedNativeToken The address of the wrapped native token
-   * @param _orderPool The address of the order pool
+   * @param _generalManager The address of the general manager
    */
   function initialize(
     string memory name,
     string memory symbol,
     uint8 _decimals,
     uint8 _decimalsOffset,
-    address _usdx,
     address _wrappedNativeToken,
-    address _orderPool
+    address _generalManager
   ) external initializer {
-    __FulfillmentVault_init(name, symbol, _decimals, _decimalsOffset, _usdx, _wrappedNativeToken, _orderPool);
+    __FulfillmentVault_init(name, symbol, _decimals, _decimalsOffset, _wrappedNativeToken, _generalManager);
     _grantRole(DEFAULT_ADMIN_ROLE, _msgSender());
   }
 
@@ -114,17 +117,27 @@ contract FulfillmentVault is LiquidityVault, IFulfillmentVault {
   /// @inheritdoc LiquidityVault
   /// @dev Both depositable and redeemable assets are the same asset, so we override totalAssets to return the balance of only the redeemable asset.
   function _totalAssets() internal view override returns (uint256) {
-    return IERC20(redeemableAsset()).balanceOf(address(this));
+    return IERC20(usdx()).balanceOf(address(this));
   }
 
   /// @inheritdoc IFulfillmentVault
   function wrappedNativeToken() public view override returns (address) {
     return _getFulfillmentVaultStorage()._wrappedNativeToken;
   }
 
+  /// @inheritdoc IFulfillmentVault
+  function generalManager() public view override returns (address) {
+    return _getFulfillmentVaultStorage()._generalManager;
+  }
+
   /// @inheritdoc IFulfillmentVault
   function orderPool() public view override returns (address) {
-    return _getFulfillmentVaultStorage()._orderPool;
+    return IGeneralManager(generalManager()).orderPool();
+  }
+
+  /// @inheritdoc IFulfillmentVault
+  function usdx() public view override returns (address) {
+    return _getFulfillmentVaultStorage()._usdx;
   }
 
   /// @inheritdoc IFulfillmentVault
@@ -152,12 +165,12 @@ contract FulfillmentVault is LiquidityVault, IFulfillmentVault {
 
   /// @inheritdoc IFulfillmentVault
   function burnUsdx(uint256 amount) external override onlyRole(KEEPER_ROLE) whenPaused {
-    IUSDX(redeemableAsset()).burn(amount);
+    IUSDX(usdx()).burn(amount);
   }
 
   // @inheritdoc IFulfillmentVault
   function withdrawUsdTokenFromUsdx(address usdToken, uint256 amount) external override onlyRole(KEEPER_ROLE) whenPaused {
-    IUSDX(redeemableAsset()).withdraw(usdToken, amount);
+    IUSDX(usdx()).withdraw(usdToken, amount);
   }
 
   /// @inheritdoc IFulfillmentVault

src/LiquidityVault.sol

@@ -44,14 +44,19 @@ abstract contract LiquidityVault is
    * @notice The storage for the LiquidityVault contract
    * @param _decimals The decimals of the vault
    * @param _decimalsOffset The decimals offset for measuring internal precision of shares
-   * @param _depositableAsset The address of the depositable asset
-   * @param _redeemableAsset The address of the redeemable asset
+   * @param _depositableAssets The addresses of the depositable assets
+   * @param _depositableAssetIndex The index of the depositable assets (one-indexed)
+   * @param _redeemableAssets The addresses of the redeemable assets
+   * @param _redeemableAssetIndex The index of the redeemable assets (one-indexed)
    */
   struct LiquidityVaultStorage {
     uint8 _decimals;
     uint8 _decimalsOffset;
-    address _depositableAsset;
-    address _redeemableAsset;
+    address[] _depositableAssets;
+    mapping(address => uint256) _depositableAssetIndex;
+    address[] _redeemableAssets;
+    mapping(address => uint256) _redeemableAssetIndex;
+
     bool _whitelistEnforced;
   }
 
@@ -83,11 +88,11 @@ abstract contract LiquidityVault is
     string memory symbol,
     uint8 _decimals,
     uint8 _decimalsOffset,
-    address _depositableAsset,
-    address _redeemableAsset
+    address[] memory _depositableAssets,
+    address[] memory _redeemableAssets
   ) internal onlyInitializing {
     __ERC20_init_unchained(name, symbol);
-    __LiquidityVault_init_unchained(_decimals, _decimalsOffset, _depositableAsset, _redeemableAsset);
+    __LiquidityVault_init_unchained(_decimals, _decimalsOffset, _depositableAssets, _redeemableAssets);
   }
 
   /**
@@ -97,14 +102,20 @@ abstract contract LiquidityVault is
   function __LiquidityVault_init_unchained(
     uint8 _decimals,
     uint8 _decimalsOffset,
-    address _depositableAsset,
-    address _redeemableAsset
+    address[] memory _depositableAssets,
+    address[] memory _redeemableAssets
   ) internal onlyInitializing {
     LiquidityVaultStorage storage $ = _getLiquidityVaultStorage();
     $._decimals = _decimals;
     $._decimalsOffset = _decimalsOffset;
-    $._depositableAsset = _depositableAsset;
-    $._redeemableAsset = _redeemableAsset;
+    $._depositableAssets = _depositableAssets;
+    for (uint256 i = 0; i < _depositableAssets.length; i++) {
+      $._depositableAssetIndex[_depositableAssets[i]] = i + 1;
+    }
+    $._redeemableAssets = _redeemableAssets;
+    for (uint256 i = 0; i < _redeemableAssets.length; i++) {
+      $._redeemableAssetIndex[_redeemableAssets[i]] = i + 1;
+    }
     $._whitelistEnforced = false;
   }
 
@@ -114,18 +125,18 @@ abstract contract LiquidityVault is
    * @param symbol The symbol of the liquidity vault
    * @param _decimals The decimals of the liquidity vault
    * @param _decimalsOffset The decimals offset for measuring internal precision of shares
-   * @param _depositableAsset The address of the depositable asset
-   * @param _redeemableAsset The address of the redeemable asset
+   * @param _depositableAssets The addresses of the depositable assets
+   * @param _redeemableAssets The addresses of the redeemable assets
    */
   function initialize(
     string memory name,
     string memory symbol,
     uint8 _decimals,
     uint8 _decimalsOffset,
-    address _depositableAsset,
-    address _redeemableAsset
+    address[] memory _depositableAssets,
+    address[] memory _redeemableAssets
   ) external virtual initializer {
-    __LiquidityVault_init(name, symbol, _decimals, _decimalsOffset, _depositableAsset, _redeemableAsset);
+    __LiquidityVault_init(name, symbol, _decimals, _decimalsOffset, _depositableAssets, _redeemableAssets);
     _grantRole(DEFAULT_ADMIN_ROLE, _msgSender());
   }
 
@@ -184,13 +195,13 @@ abstract contract LiquidityVault is
   }
 
   /// @inheritdoc ILiquidityVault
-  function depositableAsset() public view virtual override returns (address) {
-    return _getLiquidityVaultStorage()._depositableAsset;
+  function depositableAssets() public view virtual override returns (address[] memory) {
+    return _getLiquidityVaultStorage()._depositableAssets;
   }
 
   /// @inheritdoc ILiquidityVault
-  function redeemableAsset() public view virtual override returns (address) {
-    return _getLiquidityVaultStorage()._redeemableAsset;
+  function redeemableAssets() public view virtual override returns (address[] memory) {
+    return _getLiquidityVaultStorage()._redeemableAssets;
   }
 
   function _totalAssets() internal view virtual returns (uint256);
@@ -206,8 +217,12 @@ abstract contract LiquidityVault is
   }
 
   /// @dev Internal conversion function (from shares to assets) with support for rounding direction.
-  function _convertToAssets(uint256 shares, Math.Rounding rounding) internal view virtual returns (uint256) {
-    return shares.mulDiv(totalAssets() + 1, totalSupply() + 10 ** decimalsOffset(), rounding);
+  function _convertToAssets(uint256 shares, Math.Rounding rounding) internal view virtual returns (uint256[] memory) {
+    uint256[] memory assets = new uint256[](redeemableAssets().length);
+    for (uint256 i = 0; i < redeemableAssets().length; i++) {
+      assets[i] = shares.mulDiv(IERC20(redeemableAssets()[i]).balanceOf(address(this)) + 1, totalSupply() + 10 ** decimalsOffset(), rounding);
+    }
+    return assets;
   }
 
   /// @inheritdoc ILiquidityVault
@@ -220,28 +235,39 @@ abstract contract LiquidityVault is
   }
 
   /// @inheritdoc ILiquidityVault
-  function deposit(uint256 assets) external virtual override whenNotPaused checkWhitelistEnforced {
+  function deposit(address depositableAsset, uint256 assets) external virtual override whenNotPaused checkWhitelistEnforced {
+    // Validate the depositable asset is in the depositable assets list
+    if (_getLiquidityVaultStorage()._depositableAssetIndex[depositableAsset] == 0) {
+      revert AssetNotDepositable(depositableAsset);
+    }
     // Calculate the corresponding amount of shares for the deposited amount
     uint256 shares = _convertToShares(assets, Math.Rounding.Floor);
     // Mint the corresponding amount of shares to the sender
     _mint(msg.sender, shares);
     // Emit the deposited event
-    emit Deposited(msg.sender, depositableAsset(), assets, shares);
+    emit Deposited(msg.sender, depositableAsset, assets, shares);
     // Transfer the depositable asset from the sender to the vault
-    IERC20(depositableAsset()).safeTransferFrom(msg.sender, address(this), assets);
+    IERC20(depositableAsset).safeTransferFrom(msg.sender, address(this), assets);
   }
 
   /// @inheritdoc ILiquidityVault
   /// @dev No whitelist enforcement for redeeming. This prevents funds from being locked in the vault.
   function redeem(uint256 shares) external virtual override whenNotPaused {
     // Calculate the corresponding amount of assets for the redeemed shares
-    uint256 assets = _convertToAssets(shares, Math.Rounding.Floor);
+    uint256[] memory assetAmounts = _convertToAssets(shares, Math.Rounding.Floor);
     // Burn the corresponding amount of shares
     _burn(msg.sender, shares);
+
+    // Cache the redeemable assets array
+    address[] memory rAssets = redeemableAssets();
+
     // Emit the redeemed event
-    emit Redeemed(msg.sender, redeemableAsset(), assets, shares);
-    // Transfer the redeemable asset from the vault to the sender
-    IERC20(redeemableAsset()).safeTransfer(msg.sender, assets);
+    emit Redeemed(msg.sender, rAssets, assetAmounts, shares);
+
+    // Transfer the corresponding amount of redeemable assets to the sender
+    for (uint256 i = 0; i < rAssets.length; i++) {
+      IERC20(rAssets[i]).safeTransfer(msg.sender, assetAmounts[i]);
+    }
   }
 }