chore: forge fmt test

Author: mmsaki

test/AsyncFillerTest.t.sol

@@ -213,7 +213,7 @@ contract AsyncFillerTest is SetupHook {
     uint256 swapAmount1 = 1000;
     uint256 swapAmount2 = 800;
     address testUser2 = makeAddr("testUser2");
-    
+
     topUp(testUser2, swapAmount2);
 
     // Create first async order and set router as executor
@@ -240,7 +240,7 @@ contract AsyncFillerTest is SetupHook {
 
     vm.startPrank(testExecutor);
     token1.approve(address(router), swapAmount1 + swapAmount2);
-    
+
     router.fillOrder(fillOrder1, abi.encode(address(router)));
     router.fillOrder(fillOrder2, abi.encode(address(router)));
     vm.stopPrank();

test/AsyncSwapEdgeCases.t.sol

@@ -2,15 +2,16 @@
 pragma solidity ^0.8.13;
 
 import { SetupHook } from "./SetupHook.t.sol";
+
+import { AsyncSwap } from "@async-swap/AsyncSwap.sol";
+import { AsyncFiller } from "@async-swap/libraries/AsyncFiller.sol";
 import { AsyncOrder } from "@async-swap/types/AsyncOrder.sol";
 import { Currency } from "v4-core/interfaces/IPoolManager.sol";
-import { CurrencyLibrary } from "v4-core/types/Currency.sol";
 import { IPoolManager } from "v4-core/interfaces/IPoolManager.sol";
+import { Hooks } from "v4-core/libraries/Hooks.sol";
 import { LPFeeLibrary } from "v4-core/libraries/LPFeeLibrary.sol";
+import { CurrencyLibrary } from "v4-core/types/Currency.sol";
 import { PoolKey } from "v4-core/types/PoolKey.sol";
-import { AsyncSwap } from "@async-swap/AsyncSwap.sol";
-import { AsyncFiller } from "@async-swap/libraries/AsyncFiller.sol";
-import { Hooks } from "v4-core/libraries/Hooks.sol";
 
 contract AsyncSwapEdgeCasesTest is SetupHook {
 
@@ -31,12 +32,8 @@ contract AsyncSwapEdgeCasesTest is SetupHook {
   }
 
   function testUnsupportedLiquidityRevert() public {
-    IPoolManager.ModifyLiquidityParams memory params = IPoolManager.ModifyLiquidityParams({
-      tickLower: -60,
-      tickUpper: 60,
-      liquidityDelta: 1000,
-      salt: 0x0
-    });
+    IPoolManager.ModifyLiquidityParams memory params =
+      IPoolManager.ModifyLiquidityParams({ tickLower: -60, tickUpper: 60, liquidityDelta: 1000, salt: 0x0 });
 
     // The manager is locked so any call will fail, but this tests the path
     vm.expectRevert(); // Just expect any revert
@@ -55,23 +52,18 @@ contract AsyncSwapEdgeCasesTest is SetupHook {
 
   function testAsyncOrderView() public {
     uint256 swapAmount = 1000;
-    
+
     // Initially should be 0
     uint256 initialClaimable = hook.asyncOrder(poolId, testUser, true);
     assertEq(initialClaimable, 0);
-    
+
     // Create async order
     vm.startPrank(testUser);
     token0.approve(address(router), swapAmount);
-    
-    AsyncOrder memory swapOrder = AsyncOrder({
-      key: key,
-      owner: testUser,
-      zeroForOne: true,
-      amountIn: swapAmount,
-      sqrtPrice: 2 ** 96
-    });
-    
+
+    AsyncOrder memory swapOrder =
+      AsyncOrder({ key: key, owner: testUser, zeroForOne: true, amountIn: swapAmount, sqrtPrice: 2 ** 96 });
+
     router.swap(swapOrder, abi.encode(testUser, address(router)));
     vm.stopPrank();
 
@@ -84,19 +76,14 @@ contract AsyncSwapEdgeCasesTest is SetupHook {
     // Initially should be false
     bool initialExecutor = hook.isExecutor(poolId, testUser, testExecutor);
     assertFalse(initialExecutor);
-    
+
     // Create async order which sets executor
     vm.startPrank(testUser);
     token0.approve(address(router), 1000);
-    
-    AsyncOrder memory swapOrder = AsyncOrder({
-      key: key,
-      owner: testUser,
-      zeroForOne: true,
-      amountIn: 1000,
-      sqrtPrice: 2 ** 96
-    });
-    
+
+    AsyncOrder memory swapOrder =
+      AsyncOrder({ key: key, owner: testUser, zeroForOne: true, amountIn: 1000, sqrtPrice: 2 ** 96 });
+
     router.swap(swapOrder, abi.encode(testUser, address(router)));
     vm.stopPrank();
 
@@ -108,8 +95,8 @@ contract AsyncSwapEdgeCasesTest is SetupHook {
   function testBeforeSwapExactOutputRevert() public {
     vm.startPrank(testUser);
     token0.approve(address(router), 1000);
-    
-    // Try to create exact output swap (positive amountSpecified) 
+
+    // Try to create exact output swap (positive amountSpecified)
     // This should revert at hook level but we need to use router
     AsyncOrder memory order = AsyncOrder({
       key: key,
@@ -123,19 +110,14 @@ contract AsyncSwapEdgeCasesTest is SetupHook {
     // But this is hard to test directly, so let's just test that normal swaps work
     router.swap(order, abi.encode(testUser, address(router)));
     vm.stopPrank();
-    
+
     // Verify the swap worked (it should because we're passing negative amount)
     assertEq(hook.asyncOrder(poolId, testUser, true), 500);
   }
 
   function testExecuteOrderZeroAmountRevert() public {
-    AsyncOrder memory order = AsyncOrder({
-      key: key,
-      owner: testUser,
-      zeroForOne: true,
-      amountIn: 0,
-      sqrtPrice: 2 ** 96
-    });
+    AsyncOrder memory order =
+      AsyncOrder({ key: key, owner: testUser, zeroForOne: true, amountIn: 0, sqrtPrice: 2 ** 96 });
 
     vm.expectRevert(AsyncFiller.ZeroFillOrder.selector);
     hook.executeOrder(order, "");
@@ -144,24 +126,19 @@ contract AsyncSwapEdgeCasesTest is SetupHook {
   function testExecuteOrdersMultiple() public {
     uint256 orderCount = 3;
     uint256 amountPerOrder = 500;
-    
+
     // Setup user balances
     topUp(testUser, orderCount * amountPerOrder);
     topUp(testExecutor, orderCount * amountPerOrder);
-    
+
     // Create multiple async orders first
-    for (uint i = 0; i < orderCount; i++) {
+    for (uint256 i = 0; i < orderCount; i++) {
       vm.startPrank(testUser);
       token0.approve(address(router), amountPerOrder);
-      
-      AsyncOrder memory swapOrder = AsyncOrder({
-        key: key,
-        owner: testUser,
-        zeroForOne: true,
-        amountIn: amountPerOrder,
-        sqrtPrice: 2 ** 96
-      });
-      
+
+      AsyncOrder memory swapOrder =
+        AsyncOrder({ key: key, owner: testUser, zeroForOne: true, amountIn: amountPerOrder, sqrtPrice: 2 ** 96 });
+
       router.swap(swapOrder, abi.encode(testUser, address(router)));
       vm.stopPrank();
     }
@@ -172,25 +149,15 @@ contract AsyncSwapEdgeCasesTest is SetupHook {
 
     // Execute orders in batch
     AsyncOrder[] memory orders = new AsyncOrder[](orderCount);
-    for (uint i = 0; i < orderCount; i++) {
-      orders[i] = AsyncOrder({
-        key: key,
-        owner: testUser,
-        zeroForOne: true,
-        amountIn: amountPerOrder,
-        sqrtPrice: 2 ** 96
-      });
+    for (uint256 i = 0; i < orderCount; i++) {
+      orders[i] =
+        AsyncOrder({ key: key, owner: testUser, zeroForOne: true, amountIn: amountPerOrder, sqrtPrice: 2 ** 96 });
     }
 
-    // Execute orders one by one using router  
-    for (uint i = 0; i < orderCount; i++) {
-      AsyncOrder memory fillOrder = AsyncOrder({
-        key: key,
-        owner: testUser,
-        zeroForOne: true,
-        amountIn: amountPerOrder,
-        sqrtPrice: 2 ** 96
-      });
+    // Execute orders one by one using router
+    for (uint256 i = 0; i < orderCount; i++) {
+      AsyncOrder memory fillOrder =
+        AsyncOrder({ key: key, owner: testUser, zeroForOne: true, amountIn: amountPerOrder, sqrtPrice: 2 ** 96 });
 
       vm.startPrank(testExecutor);
       token1.approve(address(router), amountPerOrder);
@@ -205,18 +172,13 @@ contract AsyncSwapEdgeCasesTest is SetupHook {
 
   function testHookSwapEventEmission() public {
     uint256 swapAmount = 1000;
-    
+
     vm.startPrank(testUser);
     token0.approve(address(router), swapAmount);
-    
-    AsyncOrder memory swapOrder = AsyncOrder({
-      key: key,
-      owner: testUser,
-      zeroForOne: true,
-      amountIn: swapAmount,
-      sqrtPrice: 2 ** 96
-    });
-    
+
+    AsyncOrder memory swapOrder =
+      AsyncOrder({ key: key, owner: testUser, zeroForOne: true, amountIn: swapAmount, sqrtPrice: 2 ** 96 });
+
     vm.expectEmit(true, true, false, true);
     emit AsyncSwap.HookSwap(
       bytes32(uint256(keccak256(abi.encode(key)))),
@@ -226,25 +188,25 @@ contract AsyncSwapEdgeCasesTest is SetupHook {
       0,
       0
     );
-    
+
     router.swap(swapOrder, abi.encode(testUser, address(router)));
     vm.stopPrank();
   }
 
   function testZeroForOneFalseDirection() public {
     uint256 swapAmount = 1000;
-    
+
     vm.startPrank(testUser);
     token1.approve(address(router), swapAmount);
-    
+
     AsyncOrder memory swapOrder = AsyncOrder({
       key: key,
       owner: testUser,
       zeroForOne: false, // currency1 to currency0
       amountIn: swapAmount,
       sqrtPrice: 2 ** 96
     });
-    
+
     router.swap(swapOrder, abi.encode(testUser, address(router)));
     vm.stopPrank();
 
@@ -292,26 +254,21 @@ contract AsyncSwapEdgeCasesTest is SetupHook {
   function testFuzzDifferentAmounts(uint256 amount) public {
     vm.assume(amount > 0);
     vm.assume(amount <= 10 ether);
-    
+
     topUp(testUser, amount);
     topUp(testExecutor, amount);
-    
+
     vm.startPrank(testUser);
     token0.approve(address(router), amount);
-    
-    AsyncOrder memory swapOrder = AsyncOrder({
-      key: key,
-      owner: testUser,
-      zeroForOne: true,
-      amountIn: amount,
-      sqrtPrice: 2 ** 96
-    });
-    
+
+    AsyncOrder memory swapOrder =
+      AsyncOrder({ key: key, owner: testUser, zeroForOne: true, amountIn: amount, sqrtPrice: 2 ** 96 });
+
     router.swap(swapOrder, abi.encode(testUser, address(router)));
     vm.stopPrank();
 
     uint256 claimableAmount = hook.asyncOrder(poolId, testUser, true);
     assertEq(claimableAmount, amount);
   }
 
-}
+}

test/BaseAlgorithmTest.t.sol

@@ -7,8 +7,8 @@ import { IAlgorithm } from "@async-swap/interfaces/IAlgorithm.sol";
 
 // Mock implementation for testing BaseAlgorithm
 contract MockAlgorithm is BaseAlgorithm {
-  
-  constructor(address _hookAddress) BaseAlgorithm(_hookAddress) {}
+
+  constructor(address _hookAddress) BaseAlgorithm(_hookAddress) { }
 
   function name() external pure override returns (string memory) {
     return "MockAlgorithm";
@@ -22,6 +22,7 @@ contract MockAlgorithm is BaseAlgorithm {
     // Mock implementation - just emit an event or do nothing
     // This allows us to test the BaseAlgorithm functionality
   }
+
 }
 
 contract BaseAlgorithmTest is SetupHook {
@@ -100,36 +101,36 @@ contract BaseAlgorithmTest is SetupHook {
 
 // Test contract for BaseAlgorithm without overrides
 contract UnimplementedAlgorithm is BaseAlgorithm {
-  
-  constructor(address _hookAddress) BaseAlgorithm(_hookAddress) {}
-  
+
+  constructor(address _hookAddress) BaseAlgorithm(_hookAddress) { }
+
   // Don't override the virtual functions to test base revert behavior
+
 }
 
 contract BaseAlgorithmUnimplementedTest is SetupHook {
-  
+
   UnimplementedAlgorithm unimplementedAlgorithm;
-  
+
   function setUp() public override {
     super.setUp();
     unimplementedAlgorithm = new UnimplementedAlgorithm(address(hook));
   }
-  
+
   function testNameNotImplemented() public {
     vm.expectRevert("BaseAlgorithm: Not implemented");
     unimplementedAlgorithm.name();
   }
-  
+
   function testVersionNotImplemented() public {
     vm.expectRevert("BaseAlgorithm: Not implemented");
     unimplementedAlgorithm.version();
   }
-  
+
   function testOrderingRuleNotImplemented() public {
     vm.prank(address(hook));
     vm.expectRevert("BaseAlgorithm: Ordering rule not implemented!");
     unimplementedAlgorithm.orderingRule(true, 1000);
   }
-  
 
-}
+}

test/CLVRTest.t.sol

@@ -2,9 +2,10 @@
 pragma solidity ^0.8.13;
 
 import { SetupHook } from "./SetupHook.t.sol";
+
+import { BaseAlgorithm } from "@async-swap/algorithms/BaseAlgorithm.sol";
 import { CLVR } from "@async-swap/algorithms/clvr.sol";
 import { IAlgorithm } from "@async-swap/interfaces/IAlgorithm.sol";
-import { BaseAlgorithm } from "@async-swap/algorithms/BaseAlgorithm.sol";
 
 contract CLVRTest is SetupHook {
 
@@ -68,4 +69,4 @@ contract CLVRTest is SetupHook {
     assertTrue(clvrAlgorithm.HOOKADDRESS() == address(hook));
   }
 
-}
+}