fix: pool instace as param & add test

Author: luchobonatti

src/core/uniDevKitV4.ts

@@ -211,6 +211,6 @@ export class UniDevKitV4 {
 	}
 
 	async buildSwapCallData(params: BuildSwapCallDataParams): Promise<Hex> {
-		return buildSwapCallData(params, this.instance);
+		return buildSwapCallData(params);
 	}
 }

src/test/utils/buildSwapCallData.test.ts

@@ -0,0 +1,94 @@
+import { buildSwapCallData } from "@/utils/buildSwapCallData";
+import { Token } from "@uniswap/sdk-core";
+import { Pool } from "@uniswap/v4-sdk";
+import { type Address, zeroAddress } from "viem";
+import { describe, expect, it } from "vitest";
+
+describe("buildSwapCallData", () => {
+	// USDC and WETH on Mainnet
+	const mockTokens: [Address, Address] = [
+		"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
+		"0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
+	];
+
+	const mockTokenInstances = [
+		new Token(1, mockTokens[0], 6, "USDC", "USD Coin"),
+		new Token(1, mockTokens[1], 18, "WETH", "Wrapped Ether"),
+	];
+
+	const mockPool = new Pool(
+		mockTokenInstances[0],
+		mockTokenInstances[1],
+		3000,
+		60,
+		zeroAddress,
+		"79228162514264337593543950336",
+		"1000000",
+		0,
+	);
+
+	it("should build swap calldata for token0 to token1", async () => {
+		const params = {
+			tokenIn: mockTokens[0],
+			amountIn: BigInt(1000000), // 1 USDC
+			amountOutMin: BigInt(0),
+			pool: mockPool,
+		};
+
+		const calldata = await buildSwapCallData(params);
+		expect(calldata).toBeDefined();
+		expect(calldata).toMatch(/^0x/); // Should be a hex string
+	});
+
+	it("should build swap calldata for token1 to token0", async () => {
+		const params = {
+			tokenIn: mockTokens[1],
+			amountIn: BigInt(1000000000000000000), // 1 WETH
+			amountOutMin: BigInt(0),
+			pool: mockPool,
+		};
+
+		const calldata = await buildSwapCallData(params);
+		expect(calldata).toBeDefined();
+		expect(calldata).toMatch(/^0x/);
+	});
+
+	it("should include minimum output amount in calldata", async () => {
+		const params = {
+			tokenIn: mockTokens[0],
+			amountIn: BigInt(1000000),
+			amountOutMin: BigInt(500000), // 0.5 WETH minimum
+			pool: mockPool,
+		};
+
+		const calldata = await buildSwapCallData(params);
+		expect(calldata).toBeDefined();
+		expect(calldata).toMatch(/^0x/);
+	});
+
+	it("should handle zero minimum output amount", async () => {
+		const params = {
+			tokenIn: mockTokens[0],
+			amountIn: BigInt(1000000),
+			amountOutMin: BigInt(0),
+			pool: mockPool,
+		};
+
+		const calldata = await buildSwapCallData(params);
+		expect(calldata).toBeDefined();
+		expect(calldata).toMatch(/^0x/);
+	});
+
+	it("should include deadline in calldata", async () => {
+		const params = {
+			tokenIn: mockTokens[0],
+			amountIn: BigInt(1000000),
+			amountOutMin: BigInt(0),
+			pool: mockPool,
+		};
+
+		const calldata = await buildSwapCallData(params);
+		expect(calldata).toBeDefined();
+		expect(calldata).toMatch(/^0x/);
+	});
+});

src/test/utils/getPoolKeyFromPoolId.test.ts

@@ -37,7 +37,7 @@ describe("getPoolKeyFromPoolId", () => {
 		});
 		expect(mockDeps.client.readContract).toHaveBeenCalledWith({
 			address: mockDeps.contracts.positionManager,
-			abi: undefined,
+			abi: expect.any(Object),
 			functionName: "poolKeys",
 			args: ["0x123"],
 		});

src/types/utils/buildPermit2CallData.ts

@@ -0,0 +1,84 @@
+import type { Address } from "viem";
+
+/**
+ * Token permissions structure for Permit2 SignatureTransfer
+ * @public
+ */
+export interface TokenPermissions {
+	/** The token contract address */
+	token: Address;
+	/** The amount to be transferred */
+	amount: bigint;
+}
+
+/**
+ * Permit data structure for SignatureTransfer operations
+ * @public
+ */
+export interface PermitTransferFrom {
+	/** Token and amount permissions */
+	permitted: TokenPermissions;
+	/** Unique nonce for replay protection */
+	nonce: bigint;
+	/** Unix timestamp when the permit expires */
+	deadline: bigint;
+}
+
+/**
+ * EIP-712 typed data structure for PermitTransferFrom signatures
+ * @public
+ */
+export interface PermitTransferFromTypedData {
+	/** EIP-712 domain separator */
+	domain: {
+		/** Domain name */
+		name: string;
+		/** Domain version */
+		version: string;
+		/** Chain ID */
+		chainId: number;
+		/** Verifying contract address */
+		verifyingContract: Address;
+	};
+	/** EIP-712 type definitions */
+	types: {
+		/** PermitTransferFrom type definition */
+		PermitTransferFrom: readonly [
+			{ readonly name: "permitted"; readonly type: "TokenPermissions" },
+			{ readonly name: "spender"; readonly type: "address" },
+			{ readonly name: "nonce"; readonly type: "uint256" },
+			{ readonly name: "deadline"; readonly type: "uint256" },
+		];
+		/** TokenPermissions type definition */
+		TokenPermissions: readonly [
+			{ readonly name: "token"; readonly type: "address" },
+			{ readonly name: "amount"; readonly type: "uint256" },
+		];
+	};
+	/** Primary type for signing */
+	primaryType: "PermitTransferFrom";
+	/** Message data to be signed */
+	message: PermitTransferFrom & {
+		/** Address authorized to execute the transfer */
+		spender: Address;
+	};
+}
+
+/**
+ * Permit parameters for building typed data
+ * @public
+ */
+export interface PermitParams {
+	/** Token contract address */
+	token: Address;
+	/** Amount to be permitted for transfer */
+	amount: bigint;
+	/** Token owner address */
+	owner: Address;
+	/** Address authorized to execute the transfer */
+	spender: Address;
+	/** Optional unique nonce for replay protection (auto-fetched if not provided) */
+	nonce?: bigint;
+	/** Optional deadline in seconds from now (defaults to 30 minutes) */
+	deadlineSeconds?: number;
+}

src/types/utils/buildSwapCallData.ts

@@ -1,4 +1,4 @@
-import type { FeeTier } from "@/types";
+import type { Pool } from "@uniswap/v4-sdk";
 import type { Address } from "viem";
 
 /**
@@ -18,16 +18,10 @@ export const COMMANDS = {
 export type BuildSwapCallDataParams = {
 	/** Input token address */
 	tokenIn: Address;
-	/** Output token address */
-	tokenOut: Address;
 	/** Amount of input tokens to swap (in token's smallest unit) */
 	amountIn: bigint;
 	/** Minimum amount of output tokens to receive (in token's smallest unit) */
 	amountOutMin?: bigint;
-	/** Pool fee tier (e.g., 3000 for 0.3%) */
-	fee?: FeeTier;
-	/** Pool tick spacing */
-	tickSpacing?: number;
-	/** Hook contract address (use zero address if no hooks) */
-	hooks?: Address;
+	/** Pool */
+	pool: Pool;
 };

src/utils/buildSwapCallData.ts

@@ -1,12 +1,5 @@
 import type { BuildSwapCallDataParams } from "@/types";
-import {
-	COMMANDS,
-	FeeTier,
-	TICK_SPACING_BY_FEE,
-	type UniDevKitV4Instance,
-} from "@/types";
-import { DEFAULT_HOOKS, getPool } from "@/utils/getPool";
-import { getTokens } from "@/utils/getTokens";
+import { COMMANDS } from "@/types";
 import { ethers } from "ethers";
 import type { Hex } from "viem";
 
@@ -27,51 +20,29 @@ import type { Hex } from "viem";
  * ```typescript
  * const swapParams = {
  *   tokenIn: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
- *   tokenOut: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2", // WETH
  *   amountIn: parseUnits("100", 6), // 100 USDC
  *   amountOutMin: parseUnits("0.05", 18), // Min 0.05 WETH
+ *   pool: pool,
  * };
  *
- * const calldata = await buildSwapCallData(swapParams, instance);
+ * const calldata = await buildSwapCallData(swapParams);
  *
  * // Send transaction
  * const tx = await sendTransaction({
- *   to: instance.contracts.universalRouter,
+ *   to: universalRouterAddress,
  *   data: calldata,
  *   value: 0,
  * });
  * ```
  */
 export async function buildSwapCallData(
 	params: BuildSwapCallDataParams,
-	instance: UniDevKitV4Instance,
 ): Promise<Hex> {
 	// Extract and set default parameters
-	const {
-		tokenIn,
-		tokenOut,
-		amountIn,
-		amountOutMin = 0n,
-		fee = FeeTier.MEDIUM,
-		tickSpacing = TICK_SPACING_BY_FEE[fee],
-		hooks = DEFAULT_HOOKS,
-	} = params;
+	const { tokenIn, amountIn, amountOutMin = 0n, pool } = params;
 
-	// Get pool information
-	const pool = await getPool(
-		{ tokens: [tokenIn, tokenOut], fee, tickSpacing, hooks },
-		instance,
-	);
-	if (!pool) {
-		throw new Error("No swapable pool found");
-	}
-
-	// Get token instances for address comparison
-	const tokenInstances = await getTokens(
-		{ addresses: [tokenIn, tokenOut] },
-		instance,
-	);
-	const zeroForOne = tokenInstances[0].address === tokenIn;
+	const zeroForOne =
+		tokenIn.toLowerCase() === pool.poolKey.currency0.toLowerCase();
 
 	// Encode Universal Router commands
 	const commands = ethers.utils.solidityPack(
@@ -94,8 +65,8 @@ export async function buildSwapCallData(
 			{
 				poolKey: pool.poolKey,
 				zeroForOne,
-				amountIn: ethers.BigNumber.from(amountIn),
-				amountOutMinimum: ethers.BigNumber.from(amountOutMin),
+				amountIn: ethers.BigNumber.from(amountIn.toString()),
+				amountOutMinimum: ethers.BigNumber.from(amountOutMin.toString()),
 				hookData: "0x",
 			},
 		],
@@ -106,11 +77,13 @@ export async function buildSwapCallData(
 		exactInputSingleParams,
 		ethers.utils.defaultAbiCoder.encode(
 			["address", "uint128"],
-			[pool.poolKey.currency0, amountIn],
+			zeroForOne
+				? [pool.poolKey.currency0, amountIn]
+				: [pool.poolKey.currency1, amountIn],
 		),
 		ethers.utils.defaultAbiCoder.encode(
 			["address", "uint128"],
-			[pool.poolKey.currency1, 0],
+			zeroForOne ? [pool.poolKey.currency1, 0] : [pool.poolKey.currency0, 0],
 		),
 	];
 

src/utils/getPool.ts

@@ -8,7 +8,7 @@ import { getTokens } from "@/utils/getTokens";
 import { Pool } from "@uniswap/v4-sdk";
 import { slice, zeroAddress } from "viem";
 
-const DEFAULT_HOOKS = zeroAddress;
+export const DEFAULT_HOOKS = zeroAddress;
 
 /**
  * Retrieves a Uniswap V4 pool instance for a given token pair, fee tier, tick spacing, and hooks configuration.

src/utils/getPoolKeyFromPoolId.ts

@@ -1,9 +1,7 @@
-import { V4PositionManagerAbi } from "@/constants/abis/V4PositionMananger";
+import V4PositionManagerAbi from "@/constants/abis/V4PositionMananger";
 import type { UniDevKitV4Instance } from "@/types/core";
-import type {
-	GetPoolKeyFromPoolIdParams,
-	PoolKey,
-} from "@/types/utils/getPoolKeyFromPoolId";
+import type { GetPoolKeyFromPoolIdParams } from "@/types/utils/getPoolKeyFromPoolId";
+import type { PoolKey } from "@uniswap/v4-sdk";
 
 /**
  * Retrieves the pool key information for a given pool ID.