@circle-fin/usdckit 0.22.0 → 0.23.0

package/dist/esm/actions/signEIP2612Permit.d.ts

@@ -0,0 +1,130 @@
+import { signTypedData as _signTypedData } from 'viem/actions';
+import type { Account, Address, BaseUnits, NativeUnits } from '../types.js';
+import type { Chain, Client } from 'viem';
+/**
+ * Parameters for the {@link signEIP2612Permit} function.
+ */
+export type SignEIP2612PermitParams = {
+    /**
+     * The token contract address or contract object that supports EIP-2612 permit functionality.
+     */
+    token: Address | {
+        address: Address;
+    };
+    /**
+     * The account that owns the tokens and will sign the permit.
+     */
+    owner: Address | Account;
+    /**
+     * The account that will be granted permission to spend the tokens.
+     */
+    spender: Address | Account;
+    /**
+     * The amount of tokens to permit for spending.
+     */
+    value: NativeUnits | BaseUnits;
+    /**
+     * The deadline timestamp for the permit. Defaults to maximum uint256 value.
+     */
+    deadline?: bigint;
+    /**
+     * The blockchain network on which the permit will be created.
+     */
+    chain?: Chain;
+    /**
+     * The name of the token. Defaults to the name of the token contract.
+     */
+    name?: string;
+    /**
+     * The version of the token. Defaults to the version of the token contract. If the token contract does not have a version, defaults to '1'.
+     */
+    version?: string;
+};
+/**
+ * Return type for the signEIP2612Permit function.
+ */
+export type SignEIP2612PermitReturnType = ReturnType<typeof _signTypedData>;
+/**
+ * Creates a signed EIP-2612 permit
+ *
+ * @param client - The client instance.
+ * @param params - The permit parameters.
+ * @returns An object containing the typed data structure and signature.
+ *
+ * @example
+ * Creating a permit for USDC spending
+ * ```typescript
+ * const permit = await client.signEIP2612Permit({
+ *   token: client.chain.contracts.USDC,
+ *   owner: '0x0000000000000000000000000000000000000000',
+ *   spender: '0x1111111111111111111111111111111111111111',
+ *   value: 1000000n, // 1 USDC (6 decimals)
+ * })
+ * ```
+ *
+ * @example
+ * Creating a permit with custom deadline
+ * ```typescript
+ * const permit = await client.signEIP2612Permit({
+ *   token: '0x...',
+ *   owner: account1,
+ *   spender: account2,
+ *   value: '100',
+ *   deadline: BigInt(Math.floor(Date.now() / 1000) + 3600), // 1 hour from now
+ * })
+ * ```
+ */
+export declare function signEIP2612Permit(client: Client, params: SignEIP2612PermitParams): Promise<{
+    typedData: {
+        readonly types: {
+            readonly EIP712Domain: readonly [{
+                readonly name: "name";
+                readonly type: "string";
+            }, {
+                readonly name: "version";
+                readonly type: "string";
+            }, {
+                readonly name: "chainId";
+                readonly type: "uint256";
+            }, {
+                readonly name: "verifyingContract";
+                readonly type: "address";
+            }];
+            readonly Permit: readonly [{
+                readonly name: "owner";
+                readonly type: "address";
+            }, {
+                readonly name: "spender";
+                readonly type: "address";
+            }, {
+                readonly name: "value";
+                readonly type: "uint256";
+            }, {
+                readonly name: "nonce";
+                readonly type: "uint256";
+            }, {
+                readonly name: "deadline";
+                readonly type: "uint256";
+            }];
+        };
+        readonly primaryType: "Permit";
+        readonly domain: {
+            readonly name: string;
+            readonly version: string;
+            readonly chainId: bigint;
+            readonly verifyingContract: `0x${string}`;
+        };
+        readonly message: {
+            readonly owner: `0x${string}`;
+            readonly spender: `0x${string}`;
+            readonly value: bigint;
+            readonly nonce: bigint;
+            readonly deadline: bigint;
+        };
+    };
+    signature: `0x${string}`;
+    r: `0x${string}`;
+    s: `0x${string}`;
+    yParity: number;
+    v: number;
+}>;

package/dist/esm/actions/signEIP2612Permit.js

@@ -0,0 +1,122 @@
+// Copyright (c) 2025, Circle Internet Group, Inc.
+// All rights reserved.
+//
+// Circle Internet Group, Inc. CONFIDENTIAL
+//
+// This file includes unpublished proprietary source code of Circle Internet
+// Group, Inc. The copyright notice above does not
+// evidence any actual or intended publication of such source code. Disclosure
+// of this source code or any related proprietary information is strictly
+// prohibited without the express written permission of Circle Internet Group, Inc.
+import { maxUint256, getContract, parseSignature } from 'viem';
+import { signTypedData as _signTypedData } from 'viem/actions';
+import { getAction } from 'viem/utils';
+import EIP2612 from '../abis/EIP2612.js';
+import { getClient } from '../utils/getClient.js';
+import { parseAccount } from '../utils/parseAccount.js';
+import { parseAddress } from '../utils/parseAddress.js';
+import { parseUnits } from '../utils/parseUnits.js';
+import { raise } from '../utils/raise.js';
+/**
+ * Creates a signed EIP-2612 permit
+ *
+ * @param client - The client instance.
+ * @param params - The permit parameters.
+ * @returns An object containing the typed data structure and signature.
+ *
+ * @example
+ * Creating a permit for USDC spending
+ * ```typescript
+ * const permit = await client.signEIP2612Permit({
+ *   token: client.chain.contracts.USDC,
+ *   owner: '0x0000000000000000000000000000000000000000',
+ *   spender: '0x1111111111111111111111111111111111111111',
+ *   value: 1000000n, // 1 USDC (6 decimals)
+ * })
+ * ```
+ *
+ * @example
+ * Creating a permit with custom deadline
+ * ```typescript
+ * const permit = await client.signEIP2612Permit({
+ *   token: '0x...',
+ *   owner: account1,
+ *   spender: account2,
+ *   value: '100',
+ *   deadline: BigInt(Math.floor(Date.now() / 1000) + 3600), // 1 hour from now
+ * })
+ * ```
+ */
+export async function signEIP2612Permit(client, params) {
+    const { token: _token, owner: _owner, spender: _spender, value: _value, deadline = maxUint256, chain = client.chain, name: _name, version: _version, } = params;
+    const _client = getClient(client, chain);
+    const signTypedData = getAction(_client, _signTypedData, 'signTypedData');
+    // Parse addresses and accounts
+    const { address: verifyingContractAddress } = parseAddress(_token);
+    const owner = parseAccount(_owner, { chain });
+    const spender = parseAccount(_spender, { chain });
+    // Create contract instance with EIP-2612 ABI
+    const verifyingContract = getContract({
+        address: verifyingContractAddress,
+        abi: EIP2612,
+        client,
+    });
+    // Fetch token metadata and owner's nonce
+    const [name, version, nonce, decimals] = await Promise.all([
+        _name ?? verifyingContract.read.name(),
+        // Default version to '1' if `version()` fails
+        _version ?? verifyingContract.read.version().catch(() => '1'),
+        verifyingContract.read.nonces([owner.address]),
+        verifyingContract.read.decimals(),
+    ]);
+    const value = parseUnits(_value, decimals);
+    const typedData = {
+        types: {
+            EIP712Domain: [
+                { name: 'name', type: 'string' },
+                { name: 'version', type: 'string' },
+                { name: 'chainId', type: 'uint256' },
+                { name: 'verifyingContract', type: 'address' },
+            ],
+            Permit: [
+                { name: 'owner', type: 'address' },
+                { name: 'spender', type: 'address' },
+                { name: 'value', type: 'uint256' },
+                { name: 'nonce', type: 'uint256' },
+                { name: 'deadline', type: 'uint256' },
+            ],
+        },
+        primaryType: 'Permit',
+        domain: {
+            name,
+            version,
+            chainId: BigInt(chain.id),
+            verifyingContract: verifyingContract.address,
+        },
+        message: {
+            owner: owner.address,
+            spender: spender.address,
+            value,
+            nonce,
+            deadline,
+        },
+    };
+    const signature = await signTypedData({
+        ...typedData,
+        account: owner,
+    });
+    const { r, s, v, yParity } = parseSignature(signature);
+    return {
+        typedData,
+        signature,
+        r,
+        s,
+        yParity,
+        // Backfill `v` from `yParity` if not present
+        // REF: https://github.com/ethereum/go-ethereum/blob/1487a8577d1566497e161a04f8cee3204d4b3d36/core/types/transaction_marshalling.go#L63-L79
+        v: Number(v ??
+            (yParity === 0 ? 27n : undefined) ??
+            (yParity === 1 ? 28n : undefined) ??
+            raise(new Error('v is missing and yParity must be 0 or 1'))),
+    };
+}

package/dist/esm/actions/signEIP2612Permit.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/actions/signEIP2612Permit.test.js

@@ -0,0 +1,432 @@
+// Copyright (c) 2025, Circle Internet Group, Inc.
+// All rights reserved.
+//
+// Circle Internet Group, Inc. CONFIDENTIAL
+//
+// This file includes unpublished proprietary source code of Circle Internet
+// Group, Inc. The copyright notice above does not
+// evidence any actual or intended publication of such source code. Disclosure
+// of this source code or any related proprietary information is strictly
+// prohibited without the express written permission of Circle Internet Group, Inc.
+import { maxUint256 } from 'viem';
+import { describe, test, expect, vi, beforeEach } from 'vitest';
+// Create mock functions using vi.hoisted() to handle hoisting properly
+const mockGetContract = vi.hoisted(() => vi.fn());
+const mockSignTypedData = vi.hoisted(() => vi.fn());
+const mockGetAction = vi.hoisted(() => vi.fn());
+import { ETH_SEPOLIA } from '../chains/index.js';
+import { signEIP2612Permit } from './signEIP2612Permit.js';
+// Mock viem with factory function
+vi.mock('viem', async (importOriginal) => {
+    return {
+        ...(await importOriginal()),
+        getContract: mockGetContract,
+    };
+});
+// Mock viem/actions
+vi.mock('viem/actions', async (importOriginal) => {
+    return {
+        ...(await importOriginal()),
+        signTypedData: mockSignTypedData,
+    };
+});
+// Mock viem/utils
+vi.mock('viem/utils', async (importOriginal) => {
+    return {
+        ...(await importOriginal()),
+        getAction: mockGetAction,
+    };
+});
+describe.concurrent('signEIP2612Permit', () => {
+    const mockClient = {
+        chain: ETH_SEPOLIA,
+    };
+    const mockContract = {
+        address: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+        read: {
+            name: vi.fn(),
+            version: vi.fn(),
+            nonces: vi.fn(),
+            decimals: vi.fn(),
+        },
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        // Setup default mocks
+        mockGetContract.mockReturnValue(mockContract);
+        mockGetAction.mockReturnValue(mockSignTypedData);
+        // Mock contract calls
+        mockContract.read.name.mockResolvedValue('USD Coin');
+        mockContract.read.version.mockResolvedValue('2');
+        mockContract.read.nonces.mockResolvedValue(0n);
+        mockContract.read.decimals.mockResolvedValue(6);
+        mockSignTypedData.mockResolvedValue('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1b');
+    });
+    test('should be defined and be a function', () => {
+        expect(typeof signEIP2612Permit).toBe('function');
+    });
+    test('should create permit with basic parameters', async () => {
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '1.0',
+        };
+        const result = await signEIP2612Permit(mockClient, params);
+        expect(result.typedData).toEqual({
+            types: {
+                EIP712Domain: [
+                    { name: 'name', type: 'string' },
+                    { name: 'version', type: 'string' },
+                    { name: 'chainId', type: 'uint256' },
+                    { name: 'verifyingContract', type: 'address' },
+                ],
+                Permit: [
+                    { name: 'owner', type: 'address' },
+                    { name: 'spender', type: 'address' },
+                    { name: 'value', type: 'uint256' },
+                    { name: 'nonce', type: 'uint256' },
+                    { name: 'deadline', type: 'uint256' },
+                ],
+            },
+            primaryType: 'Permit',
+            domain: {
+                name: 'USD Coin',
+                version: '2',
+                chainId: BigInt(ETH_SEPOLIA.id),
+                verifyingContract: mockContract.address,
+            },
+            message: {
+                owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+                spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+                value: 1000000n,
+                nonce: 0n,
+                deadline: maxUint256,
+            },
+        });
+        expect(result.signature).toBe('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1b');
+        expect(result.v).toBe(27);
+        expect(result.yParity).toBe(0);
+        expect(result.r).toBe('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef');
+        expect(result.s).toBe('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef');
+    });
+    test('should handle token as contract object', async () => {
+        const params = {
+            token: { address: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D' },
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '1.0',
+        };
+        const result = await signEIP2612Permit(mockClient, params);
+        expect(result.typedData.domain.verifyingContract).toBe('0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D');
+    });
+    test('should handle BaseUnits (bigint) value', async () => {
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: 1000000n,
+        };
+        const result = await signEIP2612Permit(mockClient, params);
+        expect(result.typedData.message.value).toBe(1000000n); // Should pass through unchanged for bigint
+    });
+    test('should handle address strings for owner and spender', async () => {
+        const ownerAccount = '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e';
+        const spenderAccount = '0x8ba1f109551bD432803012645Hac136c22C57B9';
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: ownerAccount,
+            spender: spenderAccount,
+            value: '1.0',
+        };
+        const result = await signEIP2612Permit(mockClient, params);
+        expect(result.typedData.message.owner).toBe(ownerAccount);
+        expect(result.typedData.message.spender).toBe(spenderAccount);
+    });
+    test('should use custom deadline when provided', async () => {
+        const customDeadline = BigInt(Math.floor(Date.now() / 1000) + 3600);
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '1.0',
+            deadline: customDeadline,
+        };
+        const result = await signEIP2612Permit(mockClient, params);
+        expect(result.typedData.message.deadline).toBe(customDeadline);
+    });
+    test('should use maxUint256 as default deadline', async () => {
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '1.0',
+        };
+        const result = await signEIP2612Permit(mockClient, params);
+        expect(result.typedData.message.deadline).toBe(maxUint256);
+    });
+    test('should use custom chain when provided', async () => {
+        const customChain = ETH_SEPOLIA;
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '1.0',
+            chain: customChain,
+        };
+        const result = await signEIP2612Permit(mockClient, params);
+        expect(result.typedData.domain.chainId).toBe(BigInt(customChain.id));
+    });
+    test('should construct correct EIP-712 typed data', async () => {
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '1.0',
+        };
+        const result = await signEIP2612Permit(mockClient, params);
+        expect(result.typedData.primaryType).toBe('Permit');
+        expect(result.typedData.domain).toEqual({
+            name: 'USD Coin',
+            version: '2',
+            chainId: BigInt(ETH_SEPOLIA.id),
+            verifyingContract: mockContract.address,
+        });
+        expect(result.typedData.message).toEqual({
+            owner: params.owner,
+            spender: params.spender,
+            value: 1000000n,
+            nonce: 0n,
+            deadline: maxUint256,
+        });
+    });
+    test('should fetch contract metadata', async () => {
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '1.0',
+        };
+        await signEIP2612Permit(mockClient, params);
+        expect(mockContract.read.name).toHaveBeenCalled();
+        expect(mockContract.read.version).toHaveBeenCalled();
+        expect(mockContract.read.nonces).toHaveBeenCalledWith([params.owner]);
+        expect(mockContract.read.decimals).toHaveBeenCalled();
+    });
+    test('should call signTypedData with correct params', async () => {
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '1.0',
+        };
+        await signEIP2612Permit(mockClient, params);
+        expect(mockSignTypedData).toHaveBeenCalledTimes(1);
+        const callArgs = mockSignTypedData.mock.calls[0];
+        const signedData = callArgs[0];
+        expect(signedData.account.address).toBe(params.owner);
+        expect(signedData.primaryType).toBe('Permit');
+        expect(signedData.message).toEqual({
+            owner: params.owner,
+            spender: params.spender,
+            value: 1000000n, // 1.0 with 6 decimals
+            nonce: 0n,
+            deadline: maxUint256,
+        });
+    });
+    test('should handle different token decimals', async () => {
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '1.0',
+        };
+        // Override contract decimals for this test
+        mockContract.read.decimals.mockResolvedValue(18);
+        const result = await signEIP2612Permit(mockClient, params);
+        // With 18 decimals, '1.0' should be converted to 1000000000000000000n
+        expect(result.typedData.message.value).toBe(1000000000000000000n);
+    });
+    test('should fetch and use nonce from contract', async () => {
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '1.0',
+        };
+        const result = await signEIP2612Permit(mockClient, params);
+        expect(mockContract.read.nonces).toHaveBeenCalledWith([params.owner]);
+        expect(result.typedData.message.nonce).toBe(0n); // Default mock value
+    });
+    test('should handle different contract metadata', async () => {
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '1.0',
+        };
+        const result = await signEIP2612Permit(mockClient, params);
+        // Verify the result contains the expected domain values from our mocks
+        expect(result.typedData.domain.name).toBe('USD Coin'); // Default mock value
+        expect(result.typedData.domain.version).toBe('2'); // Default mock value
+    });
+    test('should handle zero value permits', async () => {
+        const zeroParams = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '0',
+        };
+        const result = await signEIP2612Permit(mockClient, zeroParams);
+        // With 6 decimals, '0' should be converted to 0n
+        expect(result.typedData.message.value).toBe(0n);
+    });
+    describe('yParity and v conversion logic', () => {
+        test('should parse signature and return v/yParity values', async () => {
+            mockSignTypedData.mockResolvedValue('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1c');
+            const params = {
+                token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+                owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+                spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+                value: '1.0',
+            };
+            const result = await signEIP2612Permit(mockClient, params);
+            expect(result.v).toBe(27);
+            expect(result.yParity).toBe(0);
+            expect(result.r).toBe('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef');
+            expect(result.s).toBe('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef');
+        });
+    });
+    describe('edge cases and error scenarios', () => {
+        test('should handle custom name parameter', async () => {
+            vi.clearAllMocks();
+            mockGetContract.mockReturnValue(mockContract);
+            mockGetAction.mockReturnValue(mockSignTypedData);
+            mockContract.read.version.mockResolvedValue('2');
+            mockContract.read.nonces.mockResolvedValue(0n);
+            mockContract.read.decimals.mockResolvedValue(6);
+            mockSignTypedData.mockResolvedValue('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1b');
+            const params = {
+                token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+                owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+                spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+                value: '1.0',
+                name: 'Custom Token Name',
+            };
+            const result = await signEIP2612Permit(mockClient, params);
+            // Should use custom name provided in params
+            expect(result.typedData.domain.name).toBe('Custom Token Name');
+        });
+        test('should handle custom version parameter', async () => {
+            vi.clearAllMocks();
+            mockGetContract.mockReturnValue(mockContract);
+            mockGetAction.mockReturnValue(mockSignTypedData);
+            mockContract.read.name.mockResolvedValue('USD Coin');
+            mockContract.read.nonces.mockResolvedValue(0n);
+            mockContract.read.decimals.mockResolvedValue(6);
+            mockSignTypedData.mockResolvedValue('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1b');
+            const params = {
+                token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+                owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+                spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+                value: '1.0',
+                version: '3',
+            };
+            const result = await signEIP2612Permit(mockClient, params);
+            // Should use custom version provided in params
+            expect(result.typedData.domain.version).toBe('3');
+        });
+        test('should handle both custom name and version', async () => {
+            vi.restoreAllMocks();
+            mockGetContract.mockReturnValue(mockContract);
+            mockGetAction.mockReturnValue(mockSignTypedData);
+            mockContract.read.nonces.mockResolvedValue(0n);
+            mockContract.read.decimals.mockResolvedValue(6);
+            mockSignTypedData.mockResolvedValue('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1b');
+            const params = {
+                token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+                owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+                spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+                value: '1.0',
+                name: 'Custom Token',
+                version: '4',
+            };
+            const result = await signEIP2612Permit(mockClient, params);
+            // Should use both custom values provided in params
+            expect(result.typedData.domain.name).toBe('Custom Token');
+            expect(result.typedData.domain.version).toBe('4');
+        });
+        test('should fallback to version "1" when contract.version() throws', async () => {
+            // Mock version call to throw an error
+            mockContract.read.version.mockRejectedValue(new Error('Version not supported'));
+            const params = {
+                token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+                owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+                spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+                value: '1.0',
+            };
+            const result = await signEIP2612Permit(mockClient, params);
+            expect(result.typedData.domain.version).toBe('1');
+        });
+        test('should handle maximum safe integer values', async () => {
+            const params = {
+                token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+                owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+                spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+                value: Number.MAX_SAFE_INTEGER.toString(),
+            };
+            const result = await signEIP2612Permit(mockClient, params);
+            // Should handle large numbers correctly
+            expect(result.typedData.message.value).toBe(BigInt(Number.MAX_SAFE_INTEGER) * BigInt(1000000));
+        });
+        test('should handle custom deadline values', async () => {
+            const customDeadline = 1n;
+            const params = {
+                token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+                owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+                spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+                value: '1.0',
+                deadline: customDeadline,
+            };
+            const result = await signEIP2612Permit(mockClient, params);
+            expect(result.typedData.message.deadline).toBe(customDeadline);
+        });
+        test('should handle tokens with very high decimals', async () => {
+            const highDecimals = 30;
+            mockContract.read.decimals.mockResolvedValue(highDecimals);
+            const params = {
+                token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+                owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+                spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+                value: '1.0',
+            };
+            const result = await signEIP2612Permit(mockClient, params);
+            // 1.0 with 30 decimals should be 10^30
+            const expectedValue = BigInt('1000000000000000000000000000000');
+            expect(result.typedData.message.value).toBe(expectedValue);
+        });
+        test('should handle tokens with zero decimals', async () => {
+            mockContract.read.decimals.mockResolvedValue(0);
+            const params = {
+                token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+                owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+                spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+                value: '123',
+            };
+            const result = await signEIP2612Permit(mockClient, params);
+            // With 0 decimals, '123' should remain 123n
+            expect(result.typedData.message.value).toBe(123n);
+        });
+        test('should handle fractional values with high precision', async () => {
+            mockContract.read.decimals.mockResolvedValue(18);
+            const params = {
+                token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+                owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+                spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+                value: '0.000000000000000001', // 1 wei
+            };
+            const result = await signEIP2612Permit(mockClient, params);
+            expect(result.typedData.message.value).toBe(1n);
+        });
+    });
+});