✨ use async filler lib, updated public method for claimable amount

Author: mmsaki

src/AsyncSwapCSMM.sol

@@ -30,8 +30,7 @@ contract AsyncSwapCSMM is BaseHook, IAsyncSwapAMM {
   /// @notice Algorithm used for ordering transactions in our Async Swap AMM.
   IAlgorithm public algorithm;
   /// @notice Mapping to store async orders.
-  mapping(PoolId poolId => mapping(address user => mapping(bool zeroForOne => uint256 claimable))) public asyncOrders;
-  // mapping(PoolId poolId => AsyncFiller.State) public asyncOrders;
+  mapping(PoolId poolId => AsyncFiller.State) public asyncOrders;
   /// @notice Mapping to store executor permissions for users.
   mapping(address owner => mapping(address executor => bool)) public setExecutor;
 
@@ -102,6 +101,10 @@ contract AsyncSwapCSMM is BaseHook, IAsyncSwapAMM {
     return setExecutor[owner][executor];
   }
 
+  function asyncOrder(PoolId poolId, address user, bool zeroForOne) external view returns (uint256 claimable) {
+    return asyncOrders[poolId].asyncOrders[user][zeroForOne];
+  }
+
   function calculateHookFee(uint256) public pure returns (uint256) {
     return 0;
   }
@@ -136,7 +139,7 @@ contract AsyncSwapCSMM is BaseHook, IAsyncSwapAMM {
     /// TODO: Document what this does
     uint256 amountToFill = uint256(amountIn);
     // AsyncFiller.State storage _asyncOrders = asyncOrders[poolId];
-    uint256 claimableAmount = asyncOrders[poolId][owner][zeroForOne];
+    uint256 claimableAmount = asyncOrders[poolId].asyncOrders[owner][zeroForOne];
     require(amountToFill <= claimableAmount, "Max fill order limit exceed");
     require(isExecutor(owner, msg.sender), "Caller is valid not excutor");
 
@@ -151,7 +154,7 @@ contract AsyncSwapCSMM is BaseHook, IAsyncSwapAMM {
       currencyFill = currency0;
     }
 
-    asyncOrders[poolId][owner][zeroForOne] -= amountToFill;
+    asyncOrders[poolId].asyncOrders[owner][zeroForOne] -= amountToFill;
     /// TODO: check if this is needed, we could just burn
     poolManager.transfer(owner, currencyTake.toId(), amountToFill);
     emit AsyncOrderFilled(poolId, owner, zeroForOne, amountToFill);
@@ -192,8 +195,8 @@ contract AsyncSwapCSMM is BaseHook, IAsyncSwapAMM {
 
     /// @dev Issue 1:1 claimableAmount - pool fee to user
     /// @dev Add amount taken to previous claimableAmount
-    uint256 currClaimables = asyncOrders[poolId][hookData.user][params.zeroForOne];
-    asyncOrders[poolId][hookData.user][params.zeroForOne] = currClaimables + finalTaken;
+    uint256 currClaimables = asyncOrders[poolId].asyncOrders[hookData.user][params.zeroForOne];
+    asyncOrders[poolId].asyncOrders[hookData.user][params.zeroForOne] = currClaimables + finalTaken;
 
     /// @dev Hook event
     /// @reference

src/interfaces/IAsyncSwapOrder.sol

@@ -37,7 +37,7 @@ interface IAsyncSwapOrder {
   /// @param zeroForOne Whether the order is for a swap from currency0 to currency1 (true) or currency1 to currency0
   /// (false).
   /// @return claimable The amount that can be claimed by the user.
-  function asyncOrders(PoolId poolId, address user, bool zeroForOne) external view returns (uint256 claimable);
+  function asyncOrder(PoolId poolId, address user, bool zeroForOne) external view returns (uint256 claimable);
 
   /// @notice Checks if the given executor is valid for the async order.
   /// @param owner The async order owner be checked against.

test/AsyncCSMM.t.sol

@@ -62,7 +62,7 @@ contract AsyncCsmmTest is SetupHook {
 
   function testFuzzAsyncSwapAndFillOrder(address _user, uint256 amountIn, bool zeroForOne) public {
     vm.assume(amountIn >= 1);
-    vm.assume(amountIn < 2 ** 128 / 2);
+    vm.assume(amountIn < 2 ** 96 / 2);
     user = _user;
     topUp(user, amountIn);
     topUp(user2, amountIn);
@@ -86,7 +86,7 @@ contract AsyncCsmmTest is SetupHook {
       assertEq(balance1Before - balance1After, amountIn);
       assertEq(balance0Before, balance0After);
     }
-    assertEq(hook.asyncOrders(poolId, user, zeroForOne), amountIn);
+    assertEq(hook.asyncOrder(poolId, user, zeroForOne), amountIn);
     assertEq(hook.setExecutor(user, asyncFiller), true);
 
     balance0Before = currency0.balanceOf(user2);
@@ -101,11 +101,11 @@ contract AsyncCsmmTest is SetupHook {
     if (zeroForOne) {
       assertEq(balance0Before, balance0After);
       assertEq(balance1Before - balance1After, amountIn);
-      assertEq(hook.asyncOrders(poolId, user, zeroForOne), 0);
+      assertEq(hook.asyncOrder(poolId, user, zeroForOne), 0);
     } else {
       assertEq(balance1Before, balance1After);
       assertEq(balance0Before - balance0After, amountIn);
-      assertEq(hook.asyncOrders(poolId, user, zeroForOne), 0);
+      assertEq(hook.asyncOrder(poolId, user, zeroForOne), 0);
     }
     if (zeroForOne) {
       assertEq(manager.balanceOf(user, currency0.toId()), uint256(amountIn));
@@ -148,7 +148,7 @@ contract AsyncCsmmTest is SetupHook {
       assertEq(manager.balanceOf(address(hook), currency1.toId()), balance1Before + uint256(amount));
     }
 
-    assertEq(hook.asyncOrders(poolId, user, zeroForOne), uint256(amount));
+    assertEq(hook.asyncOrder(poolId, user, zeroForOne), uint256(amount));
   }
 
 }