updates async filler storage reads for isExecutor and asyncOrder

Author: mmsaki

src/AsyncSwapCSMM.sol

@@ -26,13 +26,12 @@ contract AsyncSwapCSMM is BaseHook, IAsyncSwapAMM {
   using SafeCast for *;
   using CurrencySettler for Currency;
   using PoolIdLibrary for PoolKey;
+  using AsyncFiller for AsyncOrder;
 
-  /// @notice Algorithm used for ordering transactions in our Async Swap AMM.
-  IAlgorithm public algorithm;
   /// @notice Mapping to store async orders.
   mapping(PoolId poolId => AsyncFiller.State) public asyncOrders;
-  /// @notice Mapping to store executor permissions for users.
-  mapping(address owner => mapping(address executor => bool)) public setExecutor;
+  /// Ordering algortim
+  IAlgorithm public immutable algorithm;
 
   /// Event emitted when a swap is executed.
   /// @param id The poolId of the pool where the swap occurred.
@@ -63,6 +62,9 @@ contract AsyncSwapCSMM is BaseHook, IAsyncSwapAMM {
   /// @inheritdoc BaseHook
   function _beforeInitialize(address, PoolKey calldata key, uint160) internal virtual override returns (bytes4) {
     require(key.fee == LPFeeLibrary.DYNAMIC_FEE_FLAG, "Dude use dynamic fees flag");
+    /// set algorithm for the pool being initialized
+    asyncOrders[key.toId()].algorithm = algorithm;
+    asyncOrders[key.toId()].poolManager = poolManager;
     return this.beforeInitialize.selector;
   }
 
@@ -96,13 +98,14 @@ contract AsyncSwapCSMM is BaseHook, IAsyncSwapAMM {
     revert UnsupportedLiquidity();
   }
 
-  /// @inheritdoc IAsyncSwapOrder
-  function isExecutor(address owner, address executor) public view returns (bool) {
-    return setExecutor[owner][executor];
+  function asyncOrder(PoolId poolId, address user, bool zeroForOne) external view returns (uint256 claimable) {
+    AsyncFiller.State storage state = asyncOrders[poolId];
+    return state.asyncOrders[user][zeroForOne];
   }
 
-  function asyncOrder(PoolId poolId, address user, bool zeroForOne) external view returns (uint256 claimable) {
-    return asyncOrders[poolId].asyncOrders[user][zeroForOne];
+  function isExecutor(PoolId poolId, address user, address executor) external view returns (bool) {
+    AsyncFiller.State storage state = asyncOrders[poolId];
+    return state.setExecutor[user][executor];
   }
 
   function calculateHookFee(uint256) public pure returns (uint256) {
@@ -120,7 +123,7 @@ contract AsyncSwapCSMM is BaseHook, IAsyncSwapAMM {
     for (uint8 i = 0; i < orders.length; i++) {
       AsyncOrder calldata order = orders[i];
       // Use transaction ordering algorithm to ensure correct execution order
-      algorithm.orderingRule(order.zeroForOne, uint256(order.amountIn));
+      asyncOrders[order.key.toId()].algorithm.orderingRule(order.zeroForOne, uint256(order.amountIn));
       this.executeOrder(order, userParams);
     }
   }
@@ -138,10 +141,10 @@ contract AsyncSwapCSMM is BaseHook, IAsyncSwapAMM {
 
     /// TODO: Document what this does
     uint256 amountToFill = uint256(amountIn);
-    // AsyncFiller.State storage _asyncOrders = asyncOrders[poolId];
     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");
+    AsyncFiller.State storage state = asyncOrders[poolId];
+    require(order.isExecutor(state, msg.sender), "Caller is valid not excutor");
 
     /// @dev Transfer currency of async order to user
     Currency currencyTake;
@@ -190,7 +193,7 @@ contract AsyncSwapCSMM is BaseHook, IAsyncSwapAMM {
     /// @dev Take pool fee for LP
     uint256 feeAmount = calculatePoolFee(key.fee, amountTaken);
     uint256 finalTaken = amountTaken - feeAmount;
-    setExecutor[hookData.user][hookData.executor] = true;
+    asyncOrders[poolId].setExecutor[hookData.user][hookData.executor] = true;
     emit AsyncSwapOrder(poolId, hookData.user, params.zeroForOne, finalTaken.toInt256());
 
     /// @dev Issue 1:1 claimableAmount - pool fee to user

src/interfaces/IAsyncSwapOrder.sol

@@ -40,9 +40,10 @@ interface IAsyncSwapOrder {
   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 poolId The poolId the executor is interacting with.
   /// @param owner The async order owner be checked against.
   /// @param executor The address of the executor to be checked.
   /// @return isExecutor True if the executor is valid for the async order, false otherwise.
-  function isExecutor(address owner, address executor) external returns (bool);
+  function isExecutor(PoolId poolId, address owner, address executor) external returns (bool);
 
 }

src/libraries/AsyncFiller.sol

@@ -43,6 +43,11 @@ library AsyncFiller {
   /// @notice Error thrown when an order is of zero amount.
   error ZeroFillOrder();
 
+  /// @notice Checks if the given executor is valid for the async order.
+  /// @param order The async order to be filled.
+  /// @param self The storage slot that controls the state of orders.
+  /// @param executor The address of the executor to be checked.
+  /// @return isExecutor True if the executor is valid for the async order, false otherwise.
   function isExecutor(AsyncOrder calldata order, State storage self, address executor) internal view returns (bool) {
     return self.setExecutor[order.owner][executor];
   }

test/Algorithm2Test.t.sol

@@ -15,6 +15,9 @@ contract Algorithm2Test is SetupHook {
     algorithm = hook.algorithm();
   }
 
+  /// this should test the intialized algoritm was selected
+  function testCheckSetAlgorithm() public { }
+
   function testExecuteOrderBuy() public {
     // Test setup for a buy order
     bool zeroForOne = true;

test/AsyncCSMM.t.sol

@@ -4,6 +4,7 @@ pragma solidity ^0.8.13;
 import { SetupHook } from "./SetupHook.sol";
 import { AsyncSwapCSMM } from "@async-swap/AsyncSwapCSMM.sol";
 import { IRouter } from "@async-swap/interfaces/IRouter.sol";
+import { AsyncFiller } from "@async-swap/libraries/AsyncFiller.sol";
 import { AsyncOrder } from "@async-swap/types/AsyncOrder.sol";
 import { console } from "forge-std/Test.sol";
 import { Currency, IHooks, IPoolManager } from "v4-core/interfaces/IPoolManager.sol";
@@ -15,6 +16,7 @@ import { PoolKey } from "v4-core/types/PoolKey.sol";
 contract AsyncCsmmTest is SetupHook {
 
   using CurrencyLibrary for Currency;
+  using AsyncFiller for AsyncOrder;
 
   address asyncFiller = makeAddr("asyncFiller");
   address user = makeAddr("user");
@@ -62,7 +64,7 @@ contract AsyncCsmmTest is SetupHook {
 
   function testFuzzAsyncSwapAndFillOrder(address _user, uint256 amountIn, bool zeroForOne) public {
     vm.assume(amountIn >= 1);
-    vm.assume(amountIn < 2 ** 96 / 2);
+    vm.assume(amountIn < 2 ** 96);
     user = _user;
     topUp(user, amountIn);
     topUp(user2, amountIn);
@@ -87,7 +89,7 @@ contract AsyncCsmmTest is SetupHook {
       assertEq(balance0Before, balance0After);
     }
     assertEq(hook.asyncOrder(poolId, user, zeroForOne), amountIn);
-    assertEq(hook.setExecutor(user, asyncFiller), true);
+    assertEq(hook.isExecutor(poolId, user, asyncFiller), true);
 
     balance0Before = currency0.balanceOf(user2);
     balance1Before = currency1.balanceOf(user2);