refactor(liquidity-vault): refactoring so that redeemable-assets changes for rollover-vaults

Author: SocksNFlops

src/LiquidityVault.sol

@@ -202,6 +202,33 @@ abstract contract LiquidityVault is
     return _getLiquidityVaultStorage()._redeemableAssets;
   }
 
+  function _updateAssets(address asset, bool isRedeemable, bool add) internal {
+    // Fetch storage
+    LiquidityVaultStorage storage $ = _getLiquidityVaultStorage();
+
+    if (isRedeemable) {
+      if (add) {
+        $._redeemableAssets.push(asset);
+        $._redeemableAssetIndex[asset] = $._redeemableAssets.length;
+      } else {
+        $._redeemableAssets[$._redeemableAssetIndex[asset] - 1] = $._redeemableAssets[$._redeemableAssets.length - 1];
+        $._redeemableAssetIndex[$._redeemableAssets[$._redeemableAssets.length - 1]] = $._redeemableAssetIndex[asset];
+        $._redeemableAssets.pop();
+        $._redeemableAssetIndex[asset] = 0;
+      }
+    } else {
+      if (add) {
+        $._depositableAssets.push(asset);
+        $._depositableAssetIndex[asset] = $._depositableAssets.length;
+      } else {
+        $._depositableAssets[$._depositableAssetIndex[asset] - 1] = $._depositableAssets[$._depositableAssets.length - 1];
+        $._depositableAssetIndex[$._depositableAssets[$._depositableAssets.length - 1]] = $._depositableAssetIndex[asset];
+        $._depositableAssets.pop();
+        $._depositableAssetIndex[asset] = 0;
+      }
+    }
+  }
+
   function _totalAssets() internal view virtual returns (uint256);
 
   /// @inheritdoc ILiquidityVault

src/RolloverVault.sol

@@ -8,6 +8,7 @@ import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
 import {IGeneralManager} from "@core/interfaces/IGeneralManager/IGeneralManager.sol";
 import {IOriginationPool} from "@core/interfaces/IOriginationPool/IOriginationPool.sol";
 import {IOriginationPoolScheduler} from "@core/interfaces/IOriginationPoolScheduler/IOriginationPoolScheduler.sol";
+
 /**
  * @title FulfillmentVault
  * @author @SocksNFlops
@@ -179,6 +180,8 @@ contract RolloverVault is LiquidityVault, IRolloverVault {
     if ($._poolIndex[originationPool] == 0) {
       $._poolIndex[originationPool] = $._originationPools.length + 1;
       $._originationPools.push(originationPool);
+      // Update the assets
+      _updateAssets(originationPool, true, true);
       // Emit the origination pool added event
       emit OriginationPoolAdded(originationPool);
     }
@@ -207,6 +210,9 @@ contract RolloverVault is LiquidityVault, IRolloverVault {
     delete $._poolIndex[originationPool];
     $._originationPools.pop();
 
+    // Update the assets
+    _updateAssets(originationPool, true, false);
+
     // Emit the redeem event
     uint256 ogPoolBalance = IOriginationPool(originationPool).balanceOf(address(this));
     emit OriginationPoolRedeemed(originationPool, ogPoolBalance);

test/LiquidityVault.t.sol

@@ -395,4 +395,40 @@ contract LiquidityVaultTest is Test {
     assertEq(depositableAsset.balanceOf(user), 0, "Depositable asset balance of user should be 0");
     assertEq(redeemableAsset.balanceOf(user), depositAmount, "Redeemable asset balance of user should be depositAmount");
   }
+
+  function test_updateAsset_add(address asset, bool isRedeemable) public {
+    // Update the assets
+    MockLiquidityVault(address(liquidityVault)).updateAssets(asset, isRedeemable, true);
+
+    if (isRedeemable) {
+      assertEq(liquidityVault.redeemableAssets().length, 2, "Redeemable assets should have length 2");
+      assertEq(liquidityVault.redeemableAssets()[0], address(redeemableAsset), "redeemableAssets[0] should be the redeemable asset");
+      assertEq(liquidityVault.redeemableAssets()[1], asset, "redeemableAssets[1] should be the asset passed in");
+    } else {
+      assertEq(liquidityVault.depositableAssets().length, 2, "Depositable assets should have length 2");
+      assertEq(liquidityVault.depositableAssets()[0], address(depositableAsset), "depositableAssets[0] should be the depositable asset");
+      assertEq(liquidityVault.depositableAssets()[1], asset, "depositableAssets[1] should be the asset passed in");
+    }
+  }
+
+  function test_updateAsset_remove(bool isRedeemable) public {
+    // Update the assets
+    address asset = isRedeemable ? address(redeemableAsset) : address(depositableAsset);
+    MockLiquidityVault(address(liquidityVault)).updateAssets(asset, isRedeemable, false);
+
+    if (isRedeemable) {
+      assertEq(liquidityVault.redeemableAssets().length, 0, "Redeemable assets should have length 2");
+    } else {
+      assertEq(liquidityVault.depositableAssets().length, 0, "Depositable assets should have length 0");
+    }
+  }
+
+  function test_updateAsset_removeMissingAsset(address asset, bool isRedeemable) public {
+    // Make sure the asset is not the depositable asset or redeemable asset
+    vm.assume(asset != address(depositableAsset) && asset != address(redeemableAsset));
+
+    // Attempt to remove a missing asset
+    vm.expectRevert();
+    MockLiquidityVault(address(liquidityVault)).updateAssets(asset, isRedeemable, false);
+  }
 }

test/RolloverVault.t.sol

@@ -27,8 +27,10 @@ import {Router} from "../src/Router.sol";
 import {MockPriceOracle} from "./mocks/MockPriceOracle.sol";
 import {CreationRequest, BaseRequest} from "@core/types/orders/OrderRequests.sol";
 import {IOriginationPoolScheduler} from "@core/interfaces/IOriginationPoolScheduler/IOriginationPoolScheduler.sol";
+import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
 
 contract RolloverVaultTest is BaseTest {
+  using Math for uint256;
   HyperCore public hyperCore;
 
   using PrecompileLib for address;
@@ -393,6 +395,13 @@ contract RolloverVaultTest is BaseTest {
       vm.stopPrank();
     }
 
+    // Check that redeemable assets are set correctly
+    {
+      assertEq(rolloverVault.redeemableAssets().length, 2, "RolloverVault should have 2 redeemable assets");
+      assertEq(rolloverVault.redeemableAssets()[0], address(usdx), "RolloverVault should have usdx as the first redeemable asset");
+      assertEq(rolloverVault.redeemableAssets()[1], address(consol), "RolloverVault should have consol as the second redeemable asset");
+    }
+
     // Keeper pauses the rolloverVault and deposits the entire usdx balance into the origination pool
     {
       vm.startPrank(keeper);
@@ -401,6 +410,14 @@ contract RolloverVaultTest is BaseTest {
       vm.stopPrank();
     }
 
+    // Check that redeemable assets have been updated correctly
+    {
+      assertEq(rolloverVault.redeemableAssets().length, 3, "RolloverVault should have 3 redeemable assets");
+      assertEq(rolloverVault.redeemableAssets()[0], address(usdx), "RolloverVault should have usdx as the first redeemable asset");
+      assertEq(rolloverVault.redeemableAssets()[1], address(consol), "RolloverVault should have consol as the second redeemable asset");
+      assertEq(rolloverVault.redeemableAssets()[2], address(originationPool), "RolloverVault should have the origination pool as the third redeemable asset");
+    }
+
     // Skip time ahead to the origination pool's redemption period
     vm.warp(originationPool.redemptionPhaseTimestamp());
 
@@ -411,9 +428,120 @@ contract RolloverVaultTest is BaseTest {
     rolloverVault.redeemOriginationPool(address(originationPool));
     vm.stopPrank();
 
+    // Check that redeemable assets have been updated correctly
+    {
+      assertEq(rolloverVault.redeemableAssets().length, 2, "RolloverVault should have 2 redeemable assets");
+      assertEq(rolloverVault.redeemableAssets()[0], address(usdx), "RolloverVault should have usdx as the first redeemable asset");
+      assertEq(rolloverVault.redeemableAssets()[1], address(consol), "RolloverVault should have consol as the second redeemable asset");
+    }
+
     // Validate that the origination pool has been removed
     assertFalse(rolloverVault.isTracked(address(originationPool)), "Origination pool should not be tracked");
     assertEq(rolloverVault.originationPools().length, 0, "Origination pool should not be tracked");
     assertEq(originationPool.balanceOf(address(rolloverVault)), 0, "Origination pool should have no balance");
   }
+
+  function test_totalAssets_whileTrackingOriginationPool(uint256 depositAmount) public {
+    // Ensure the depositAmount is at least $1 but less than the origination pool limit
+    depositAmount = uint256(bound(depositAmount, 1e18, originationPool.poolLimit()));
+
+    // User deposits depositAmount of usdx into the rolloverVault
+    {
+      vm.startPrank(user);
+      uint256 usdtAmount = usdx.convertUnderlying(address(usdt), depositAmount);
+      deal(address(usdt), user, usdtAmount);
+      usdt.approve(address(usdx), usdtAmount);
+      usdx.deposit(address(usdt), usdtAmount);
+      usdx.approve(address(rolloverVault), depositAmount);
+      rolloverVault.deposit(address(usdx), depositAmount);
+      vm.stopPrank();
+    }
+
+    // Query total assets in the rolloverVault
+    uint256 totalAssetsBefore = rolloverVault.totalAssets();
+
+    // Keeper pauses the rolloverVault and deposits the entire usdx balance into the origination pool
+    {
+      vm.startPrank(keeper);
+      rolloverVault.setPaused(true);
+      rolloverVault.depositOriginationPool(address(originationPool), depositAmount);
+      vm.stopPrank();
+    }
+
+    // Query total assets in the rolloverVault
+    uint256 totalAssetsAfter = rolloverVault.totalAssets();
+
+    // Validate that total assets have not changed
+    assertEq(totalAssetsAfter, totalAssetsBefore, "Total assets should not have changed");
+  }
+
+  function test_withdraw_whileTrackingOriginationPool(uint256 depositAmount) public {
+    // Ensure the depositAmount is at least $1 but less than the origination pool limit
+    depositAmount = uint256(bound(depositAmount, 1e18, originationPool.poolLimit()));
+
+    // Validate that the user has 0 usdx balance to start with
+    assertEq(usdx.balanceOf(user), 0, "User should have 0 usdx balance to start with");
+
+    // User deposits depositAmount of usdx into the rolloverVault
+    {
+      vm.startPrank(user);
+      uint256 usdtAmount = usdx.convertUnderlying(address(usdt), depositAmount);
+      deal(address(usdt), user, usdtAmount);
+      usdt.approve(address(usdx), usdtAmount);
+      usdx.deposit(address(usdt), usdtAmount);
+      usdx.approve(address(rolloverVault), usdx.balanceOf(user));
+      rolloverVault.deposit(address(usdx), usdx.balanceOf(user));
+      vm.stopPrank();
+    }
+
+    // Validate that the user has 0 usdx balance
+    assertEq(usdx.balanceOf(user), 0, "User should have 0 usdx balance");
+
+    // Keeper pauses the rolloverVault and deposits the entire usdx balance into the origination pool
+    {
+      vm.startPrank(keeper);
+      rolloverVault.setPaused(true);
+      rolloverVault.depositOriginationPool(address(originationPool), depositAmount);
+      vm.stopPrank();
+    }
+
+    // Keeper unpauses the rolloverVault
+    {
+      vm.startPrank(keeper);
+      rolloverVault.setPaused(false);
+      vm.stopPrank();
+    }
+
+    // Calculate expected redemption amounts
+    uint256 expectedUsdxRedemption = Math.mulDiv(rolloverVault.balanceOf(user), usdx.balanceOf(address(rolloverVault)), rolloverVault.totalSupply());
+    uint256 expectedOgpRedemption = Math.mulDiv(rolloverVault.balanceOf(user), originationPool.balanceOf(address(rolloverVault)), rolloverVault.totalSupply());
+
+    // Expected total assets amount
+    uint256 expectedTotalAssets = Math.mulDiv(rolloverVault.balanceOf(user), rolloverVault.totalAssets(), rolloverVault.totalSupply());
+
+    // User withdraws their entire balance of the rolloverVault
+    {
+      vm.startPrank(user);
+      rolloverVault.redeem(rolloverVault.balanceOf(user));
+      vm.stopPrank();
+    }
+
+    // Validate that the user has the expected redemption amounts
+    assertApproxEqAbs(usdx.balanceOf(user), expectedUsdxRedemption, 1, "User should get expectedUsdxRedemption usdx out of the rolloverVault");
+    assertApproxEqAbs(originationPool.balanceOf(user), expectedOgpRedemption, 1, "User should get expectedOgpRedemption origination pool out of the rolloverVault");
+
+    // Skip ahead to the origination pool's redemption period
+    vm.warp(originationPool.redemptionPhaseTimestamp());
+
+    // User redeems the entire origination pool balance
+    {
+      vm.startPrank(user);
+      originationPool.redeem(originationPool.balanceOf(user));
+      vm.stopPrank();
+    }
+
+    // Validate that the user has the expected redemption amounts
+    assertEq(originationPool.balanceOf(user), 0, "User should have 0 origination pool balance");
+    assertApproxEqAbs(usdx.balanceOf(user), expectedTotalAssets, 1, "User should have expectedTotalAssets of usdx");
+  }
 }

test/mocks/MockLiquidityVault.sol

@@ -17,4 +17,8 @@ contract MockLiquidityVault is LiquidityVault {
     }
     return total;
   }
+
+  function updateAssets(address asset, bool isRedeemable, bool isAdd) public {
+    _updateAssets(asset, isRedeemable, isAdd);
+  }
 }

test/mocks/MockLiquidityVault2.sol

@@ -18,6 +18,10 @@ contract MockLiquidityVault2 is LiquidityVault {
     return total;
   }
 
+  function updateAssets(address asset, bool isRedeemable, bool isAdd) public {
+    _updateAssets(asset, isRedeemable, isAdd);
+  }
+
   function newFunction() public pure returns (bool) {
     return true;
   }