chore: update README & package version

Author: luchobonatti

README.md

@@ -125,14 +125,40 @@ const poolKey = await uniDevKit.getPoolKeyFromPoolId({
 ```
 
 ### `buildSwapCallData`
-Construct calldata and value for a Universal Router swap.
+Construct calldata for a Universal Router swap.
 ```ts
+// Basic swap
 const { calldata, value } = await uniDevKit.buildSwapCallData({
-  tokenIn,
-  tokenOut,
-  amountIn: "1000000000000000000",
-  recipient,
-  slippageBips: 50
+  tokenIn: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
+  amountIn: parseUnits("100", 6), // 100 USDC
+  pool: pool,
+  slippageTolerance: 50, // 0.5%
+  recipient: "0x..."
+});
+
+// Swap with permit2
+const permitData = await uniDevKit.preparePermit2Data({
+  token: tokenIn,
+  spender: uniDevKit.getContractAddress('universalRouter'),
+  owner: userAddress
+});
+
+const signature = await signer._signTypedData(permitData.toSign);
+const permitWithSignature = permitData.buildPermit2DataWithSignature(signature);
+
+const { calldata: calldataWithPermit, value: valueWithPermit } = await uniDevKit.buildSwapCallData({
+  tokenIn: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+  amountIn: parseUnits("100", 6),
+  pool: pool,
+  slippageTolerance: 50,
+  recipient: "0x...",
+  permit2Signature: permitWithSignature
+});
+
+const tx = await sendTransaction({
+  to: uniDevKit.getContractAddress('universalRouter'),
+  data: calldata,
+  value
 });
 ```
 
@@ -208,4 +234,4 @@ See [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines.
 - Releases are automated with [semantic-release](https://semantic-release.gitbook.io/semantic-release/).
 
 ## License
-MIT
+MIT

package.json

@@ -1,6 +1,6 @@
 {
   "name": "uniswap-dev-kit",
-  "version": "1.0.9",
+  "version": "1.0.10",
   "description": "A modern TypeScript library for integrating Uniswap into your dapp.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

src/utils/__tests__/preparePermit2Data.test.ts

@@ -0,0 +1,104 @@
+import { createMockSdkInstance } from "@/test/helpers/sdkInstance";
+import { PERMIT2_ADDRESS } from "@uniswap/permit2-sdk";
+import { type Block, zeroAddress } from "viem";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { preparePermit2Data } from "../preparePermit2Data";
+
+describe("preparePermit2Data", () => {
+	const mockInstance = createMockSdkInstance();
+	const mockBlockTimestamp = 1234567890n;
+
+	const mockParams = {
+		token: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
+		spender: "0x1234567890123456789012345678901234567890",
+		owner: "0x0987654321098765432109876543210987654321",
+	};
+
+	beforeEach(() => {
+		vi.spyOn(mockInstance.client, "readContract").mockImplementation(
+			async () => ({
+				amount: "0",
+				expiration: "0",
+				nonce: "0",
+			}),
+		);
+		vi.spyOn(mockInstance.client, "getBlock").mockResolvedValue({
+			timestamp: mockBlockTimestamp,
+		} as Block);
+	});
+
+	it("should throw error for native token", async () => {
+		await expect(
+			preparePermit2Data(
+				{
+					...mockParams,
+					token: zeroAddress,
+				},
+				mockInstance,
+			),
+		).rejects.toThrow("Native tokens are not supported for permit2");
+	});
+
+	it("should prepare permit2 data with default sigDeadline", async () => {
+		const result = await preparePermit2Data(mockParams, mockInstance);
+
+		expect(result.owner).toBe(mockParams.owner);
+		expect(result.permit.details.token).toBe(mockParams.token);
+		expect(result.permit.spender).toBe(mockParams.spender);
+		expect(result.permit.sigDeadline).toBe(Number(mockBlockTimestamp) + 3600); // block timestamp + 1 hour
+		expect(result.toSign.domain).toBeDefined();
+		expect(result.toSign.types).toBeDefined();
+		expect(result.toSign.values).toBeDefined();
+		expect(result.buildPermit2DataWithSignature).toBeDefined();
+	});
+
+	it("should prepare permit2 data with custom sigDeadline", async () => {
+		const customDeadline = Number(mockBlockTimestamp) + 7200; // 2 hours from now
+		const result = await preparePermit2Data(
+			{
+				...mockParams,
+				sigDeadline: customDeadline,
+			},
+			mockInstance,
+		);
+
+		expect(result.permit.sigDeadline).toBe(customDeadline);
+	});
+
+	it("should build permit2 data with signature", async () => {
+		const result = await preparePermit2Data(mockParams, mockInstance);
+		const signature =
+			"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef";
+		const permitWithSignature = result.buildPermit2DataWithSignature(signature);
+
+		expect(permitWithSignature).toEqual({
+			owner: mockParams.owner,
+			permit: result.permit,
+			signature,
+		});
+	});
+
+	it("should fetch current allowance details", async () => {
+		const mockAllowance = {
+			amount: "1000000",
+			expiration: "1234567890",
+			nonce: "42",
+		};
+
+		vi.spyOn(mockInstance.client, "readContract").mockImplementationOnce(
+			async () => mockAllowance,
+		);
+
+		const result = await preparePermit2Data(mockParams, mockInstance);
+
+		expect(mockInstance.client.readContract).toHaveBeenCalledWith({
+			address: PERMIT2_ADDRESS,
+			abi: expect.any(Array),
+			functionName: "allowance",
+			args: [mockParams.owner, mockParams.token, mockParams.spender],
+		});
+
+		expect(result.permit.details.expiration).toBe(mockAllowance.expiration);
+		expect(result.permit.details.nonce).toBe(mockAllowance.nonce);
+	});
+});

src/utils/buildSwapCallData.ts

@@ -36,14 +36,32 @@ const buildPermit2StructInput = (permit: PermitSingle, signature: Hex) => {
  *
  * @example
  * ```typescript
+ * // Basic swap
  * const swapParams = {
  *   tokenIn: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
  *   amountIn: parseUnits("100", 6), // 100 USDC
  *   pool: pool,
  *   slippageTolerance: 50, // 0.5%
  * };
  *
- * const calldata = await buildSwapCallData(swapParams);
+ * const calldata = await buildSwapCallData(swapParams, instance);
+ *
+ * // Swap with permit2
+ * const permitData = await preparePermit2Data({
+ *   token: tokenIn,
+ *   spender: universalRouterAddress,
+ *   owner: userAddress
+ * }, instance);
+ *
+ * const signature = await signer._signTypedData(permitData.toSign);
+ * const permitWithSignature = permitData.buildPermit2DataWithSignature(signature);
+ *
+ * const swapParamsWithPermit = {
+ *   ...swapParams,
+ *   permit2Signature: permitWithSignature
+ * };
+ *
+ * const calldataWithPermit = await buildSwapCallData(swapParamsWithPermit, instance);
  *
  * // Send transaction
  * const tx = await sendTransaction({