@circle-fin/usdckit 0.22.0 → 0.23.1

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

@@ -0,0 +1,434 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+const viem_1 = require("viem");
+const vitest_1 = require("vitest");
+// Create mock functions using vi.hoisted() to handle hoisting properly
+const mockGetContract = vitest_1.vi.hoisted(() => vitest_1.vi.fn());
+const mockSignTypedData = vitest_1.vi.hoisted(() => vitest_1.vi.fn());
+const mockGetAction = vitest_1.vi.hoisted(() => vitest_1.vi.fn());
+const index_js_1 = require("../chains/index.js");
+const signEIP2612Permit_js_1 = require("./signEIP2612Permit.js");
+// Mock viem with factory function
+vitest_1.vi.mock('viem', async (importOriginal) => {
+    return {
+        ...(await importOriginal()),
+        getContract: mockGetContract,
+    };
+});
+// Mock viem/actions
+vitest_1.vi.mock('viem/actions', async (importOriginal) => {
+    return {
+        ...(await importOriginal()),
+        signTypedData: mockSignTypedData,
+    };
+});
+// Mock viem/utils
+vitest_1.vi.mock('viem/utils', async (importOriginal) => {
+    return {
+        ...(await importOriginal()),
+        getAction: mockGetAction,
+    };
+});
+vitest_1.describe.concurrent('signEIP2612Permit', () => {
+    const mockClient = {
+        chain: index_js_1.ETH_SEPOLIA,
+    };
+    const mockContract = {
+        address: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+        read: {
+            name: vitest_1.vi.fn(),
+            version: vitest_1.vi.fn(),
+            nonces: vitest_1.vi.fn(),
+            decimals: vitest_1.vi.fn(),
+        },
+    };
+    (0, vitest_1.beforeEach)(() => {
+        vitest_1.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');
+    });
+    (0, vitest_1.test)('should be defined and be a function', () => {
+        (0, vitest_1.expect)(typeof signEIP2612Permit_js_1.signEIP2612Permit).toBe('function');
+    });
+    (0, vitest_1.test)('should create permit with basic parameters', async () => {
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '1.0',
+        };
+        const result = await (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+        (0, vitest_1.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(index_js_1.ETH_SEPOLIA.id),
+                verifyingContract: mockContract.address,
+            },
+            message: {
+                owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+                spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+                value: 1000000n,
+                nonce: 0n,
+                deadline: viem_1.maxUint256,
+            },
+        });
+        (0, vitest_1.expect)(result.signature).toBe('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef1b');
+        (0, vitest_1.expect)(result.v).toBe(27);
+        (0, vitest_1.expect)(result.yParity).toBe(0);
+        (0, vitest_1.expect)(result.r).toBe('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef');
+        (0, vitest_1.expect)(result.s).toBe('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef');
+    });
+    (0, vitest_1.test)('should handle token as contract object', async () => {
+        const params = {
+            token: { address: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D' },
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '1.0',
+        };
+        const result = await (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+        (0, vitest_1.expect)(result.typedData.domain.verifyingContract).toBe('0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D');
+    });
+    (0, vitest_1.test)('should handle BaseUnits (bigint) value', async () => {
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: 1000000n,
+        };
+        const result = await (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+        (0, vitest_1.expect)(result.typedData.message.value).toBe(1000000n); // Should pass through unchanged for bigint
+    });
+    (0, vitest_1.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 (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+        (0, vitest_1.expect)(result.typedData.message.owner).toBe(ownerAccount);
+        (0, vitest_1.expect)(result.typedData.message.spender).toBe(spenderAccount);
+    });
+    (0, vitest_1.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 (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+        (0, vitest_1.expect)(result.typedData.message.deadline).toBe(customDeadline);
+    });
+    (0, vitest_1.test)('should use maxUint256 as default deadline', async () => {
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '1.0',
+        };
+        const result = await (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+        (0, vitest_1.expect)(result.typedData.message.deadline).toBe(viem_1.maxUint256);
+    });
+    (0, vitest_1.test)('should use custom chain when provided', async () => {
+        const customChain = index_js_1.ETH_SEPOLIA;
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '1.0',
+            chain: customChain,
+        };
+        const result = await (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+        (0, vitest_1.expect)(result.typedData.domain.chainId).toBe(BigInt(customChain.id));
+    });
+    (0, vitest_1.test)('should construct correct EIP-712 typed data', async () => {
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '1.0',
+        };
+        const result = await (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+        (0, vitest_1.expect)(result.typedData.primaryType).toBe('Permit');
+        (0, vitest_1.expect)(result.typedData.domain).toEqual({
+            name: 'USD Coin',
+            version: '2',
+            chainId: BigInt(index_js_1.ETH_SEPOLIA.id),
+            verifyingContract: mockContract.address,
+        });
+        (0, vitest_1.expect)(result.typedData.message).toEqual({
+            owner: params.owner,
+            spender: params.spender,
+            value: 1000000n,
+            nonce: 0n,
+            deadline: viem_1.maxUint256,
+        });
+    });
+    (0, vitest_1.test)('should fetch contract metadata', async () => {
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '1.0',
+        };
+        await (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+        (0, vitest_1.expect)(mockContract.read.name).toHaveBeenCalled();
+        (0, vitest_1.expect)(mockContract.read.version).toHaveBeenCalled();
+        (0, vitest_1.expect)(mockContract.read.nonces).toHaveBeenCalledWith([params.owner]);
+        (0, vitest_1.expect)(mockContract.read.decimals).toHaveBeenCalled();
+    });
+    (0, vitest_1.test)('should call signTypedData with correct params', async () => {
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '1.0',
+        };
+        await (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+        (0, vitest_1.expect)(mockSignTypedData).toHaveBeenCalledTimes(1);
+        const callArgs = mockSignTypedData.mock.calls[0];
+        const signedData = callArgs[0];
+        (0, vitest_1.expect)(signedData.account.address).toBe(params.owner);
+        (0, vitest_1.expect)(signedData.primaryType).toBe('Permit');
+        (0, vitest_1.expect)(signedData.message).toEqual({
+            owner: params.owner,
+            spender: params.spender,
+            value: 1000000n, // 1.0 with 6 decimals
+            nonce: 0n,
+            deadline: viem_1.maxUint256,
+        });
+    });
+    (0, vitest_1.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 (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+        // With 18 decimals, '1.0' should be converted to 1000000000000000000n
+        (0, vitest_1.expect)(result.typedData.message.value).toBe(1000000000000000000n);
+    });
+    (0, vitest_1.test)('should fetch and use nonce from contract', async () => {
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '1.0',
+        };
+        const result = await (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+        (0, vitest_1.expect)(mockContract.read.nonces).toHaveBeenCalledWith([params.owner]);
+        (0, vitest_1.expect)(result.typedData.message.nonce).toBe(0n); // Default mock value
+    });
+    (0, vitest_1.test)('should handle different contract metadata', async () => {
+        const params = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '1.0',
+        };
+        const result = await (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+        // Verify the result contains the expected domain values from our mocks
+        (0, vitest_1.expect)(result.typedData.domain.name).toBe('USD Coin'); // Default mock value
+        (0, vitest_1.expect)(result.typedData.domain.version).toBe('2'); // Default mock value
+    });
+    (0, vitest_1.test)('should handle zero value permits', async () => {
+        const zeroParams = {
+            token: '0xA0b86a33E6411E4C3c04E5b72c5F3E6b2A6E1C3D',
+            owner: '0x742d35Cc6634C0532925a3b8D40745c5F5d78F6e',
+            spender: '0x8ba1f109551bD432803012645Hac136c22C57B9',
+            value: '0',
+        };
+        const result = await (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, zeroParams);
+        // With 6 decimals, '0' should be converted to 0n
+        (0, vitest_1.expect)(result.typedData.message.value).toBe(0n);
+    });
+    (0, vitest_1.describe)('yParity and v conversion logic', () => {
+        (0, vitest_1.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 (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+            (0, vitest_1.expect)(result.v).toBe(27);
+            (0, vitest_1.expect)(result.yParity).toBe(0);
+            (0, vitest_1.expect)(result.r).toBe('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef');
+            (0, vitest_1.expect)(result.s).toBe('0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef');
+        });
+    });
+    (0, vitest_1.describe)('edge cases and error scenarios', () => {
+        (0, vitest_1.test)('should handle custom name parameter', async () => {
+            vitest_1.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 (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+            // Should use custom name provided in params
+            (0, vitest_1.expect)(result.typedData.domain.name).toBe('Custom Token Name');
+        });
+        (0, vitest_1.test)('should handle custom version parameter', async () => {
+            vitest_1.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 (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+            // Should use custom version provided in params
+            (0, vitest_1.expect)(result.typedData.domain.version).toBe('3');
+        });
+        (0, vitest_1.test)('should handle both custom name and version', async () => {
+            vitest_1.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 (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+            // Should use both custom values provided in params
+            (0, vitest_1.expect)(result.typedData.domain.name).toBe('Custom Token');
+            (0, vitest_1.expect)(result.typedData.domain.version).toBe('4');
+        });
+        (0, vitest_1.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 (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+            (0, vitest_1.expect)(result.typedData.domain.version).toBe('1');
+        });
+        (0, vitest_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 (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+            // Should handle large numbers correctly
+            (0, vitest_1.expect)(result.typedData.message.value).toBe(BigInt(Number.MAX_SAFE_INTEGER) * BigInt(1000000));
+        });
+        (0, vitest_1.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 (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+            (0, vitest_1.expect)(result.typedData.message.deadline).toBe(customDeadline);
+        });
+        (0, vitest_1.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 (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+            // 1.0 with 30 decimals should be 10^30
+            const expectedValue = BigInt('1000000000000000000000000000000');
+            (0, vitest_1.expect)(result.typedData.message.value).toBe(expectedValue);
+        });
+        (0, vitest_1.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 (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+            // With 0 decimals, '123' should remain 123n
+            (0, vitest_1.expect)(result.typedData.message.value).toBe(123n);
+        });
+        (0, vitest_1.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 (0, signEIP2612Permit_js_1.signEIP2612Permit)(mockClient, params);
+            (0, vitest_1.expect)(result.typedData.message.value).toBe(1n);
+        });
+    });
+});

package/dist/cjs/chains/ARC_TESTNET.d.ts

@@ -0,0 +1,180 @@
+export declare const chain: {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "ArcScan";
+            readonly url: "https://testnet.arcscan.app";
+            readonly apiUrl: "https://testnet.arcscan.app/api";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+        readonly USDC: {
+            readonly address: "0x3600000000000000000000000000000000000000";
+            readonly abi: readonly [{
+                readonly type: "event";
+                readonly name: "Approval";
+                readonly inputs: readonly [{
+                    readonly indexed: true;
+                    readonly name: "owner";
+                    readonly type: "address";
+                }, {
+                    readonly indexed: true;
+                    readonly name: "spender";
+                    readonly type: "address";
+                }, {
+                    readonly indexed: false;
+                    readonly name: "value";
+                    readonly type: "uint256";
+                }];
+            }, {
+                readonly type: "event";
+                readonly name: "Transfer";
+                readonly inputs: readonly [{
+                    readonly indexed: true;
+                    readonly name: "from";
+                    readonly type: "address";
+                }, {
+                    readonly indexed: true;
+                    readonly name: "to";
+                    readonly type: "address";
+                }, {
+                    readonly indexed: false;
+                    readonly name: "value";
+                    readonly type: "uint256";
+                }];
+            }, {
+                readonly type: "function";
+                readonly name: "allowance";
+                readonly stateMutability: "view";
+                readonly inputs: readonly [{
+                    readonly name: "owner";
+                    readonly type: "address";
+                }, {
+                    readonly name: "spender";
+                    readonly type: "address";
+                }];
+                readonly outputs: readonly [{
+                    readonly type: "uint256";
+                }];
+            }, {
+                readonly type: "function";
+                readonly name: "approve";
+                readonly stateMutability: "nonpayable";
+                readonly inputs: readonly [{
+                    readonly name: "spender";
+                    readonly type: "address";
+                }, {
+                    readonly name: "amount";
+                    readonly type: "uint256";
+                }];
+                readonly outputs: readonly [{
+                    readonly type: "bool";
+                }];
+            }, {
+                readonly type: "function";
+                readonly name: "balanceOf";
+                readonly stateMutability: "view";
+                readonly inputs: readonly [{
+                    readonly name: "account";
+                    readonly type: "address";
+                }];
+                readonly outputs: readonly [{
+                    readonly type: "uint256";
+                }];
+            }, {
+                readonly type: "function";
+                readonly name: "decimals";
+                readonly stateMutability: "view";
+                readonly inputs: readonly [];
+                readonly outputs: readonly [{
+                    readonly type: "uint8";
+                }];
+            }, {
+                readonly type: "function";
+                readonly name: "name";
+                readonly stateMutability: "view";
+                readonly inputs: readonly [];
+                readonly outputs: readonly [{
+                    readonly type: "string";
+                }];
+            }, {
+                readonly type: "function";
+                readonly name: "symbol";
+                readonly stateMutability: "view";
+                readonly inputs: readonly [];
+                readonly outputs: readonly [{
+                    readonly type: "string";
+                }];
+            }, {
+                readonly type: "function";
+                readonly name: "totalSupply";
+                readonly stateMutability: "view";
+                readonly inputs: readonly [];
+                readonly outputs: readonly [{
+                    readonly type: "uint256";
+                }];
+            }, {
+                readonly type: "function";
+                readonly name: "transfer";
+                readonly stateMutability: "nonpayable";
+                readonly inputs: readonly [{
+                    readonly name: "recipient";
+                    readonly type: "address";
+                }, {
+                    readonly name: "amount";
+                    readonly type: "uint256";
+                }];
+                readonly outputs: readonly [{
+                    readonly type: "bool";
+                }];
+            }, {
+                readonly type: "function";
+                readonly name: "transferFrom";
+                readonly stateMutability: "nonpayable";
+                readonly inputs: readonly [{
+                    readonly name: "sender";
+                    readonly type: "address";
+                }, {
+                    readonly name: "recipient";
+                    readonly type: "address";
+                }, {
+                    readonly name: "amount";
+                    readonly type: "uint256";
+                }];
+                readonly outputs: readonly [{
+                    readonly type: "bool";
+                }];
+            }];
+            readonly read: {
+                readonly decimals: () => 6;
+            };
+        };
+        readonly multicall3: {
+            readonly address: "0xcA11bde05977b3631167028862bE2a173976CA11";
+            readonly blockCreated: 0;
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: 5042002;
+    name: "Arc Testnet";
+    nativeCurrency: {
+        readonly name: "USDC";
+        readonly symbol: "USDC";
+        readonly decimals: 18;
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://rpc.testnet.arc.network", "https://rpc.quicknode.testnet.arc.network", "https://rpc.blockdaemon.testnet.arc.network"];
+            readonly webSocket: readonly ["wss://rpc.testnet.arc.network", "wss://rpc.quicknode.testnet.arc.network"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    readonly blockchainId: "ARC-TESTNET";
+    readonly blockchainVm: "EVM";
+    readonly formatters?: undefined;
+};

package/dist/cjs/chains/ARC_TESTNET.js

@@ -0,0 +1,57 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chain = void 0;
+const viem_1 = require("viem");
+// REF: https://github.com/wevm/viem/blob/00dd2e80646f6253c6d09be6acb7f57b7373737f/src/chains/definitions/arcTestnet.ts#L5
+const arcTestnet = /*#__PURE__*/ (0, viem_1.defineChain)({
+    id: 5042002,
+    name: 'Arc Testnet',
+    nativeCurrency: {
+        name: 'USDC',
+        symbol: 'USDC',
+        decimals: 18,
+    },
+    rpcUrls: {
+        default: {
+            http: [
+                'https://rpc.testnet.arc.network',
+                'https://rpc.quicknode.testnet.arc.network',
+                'https://rpc.blockdaemon.testnet.arc.network',
+            ],
+            webSocket: ['wss://rpc.testnet.arc.network', 'wss://rpc.quicknode.testnet.arc.network'],
+        },
+    },
+    blockExplorers: {
+        default: {
+            name: 'ArcScan',
+            url: 'https://testnet.arcscan.app',
+            apiUrl: 'https://testnet.arcscan.app/api',
+        },
+    },
+    contracts: {
+        multicall3: {
+            address: '0xcA11bde05977b3631167028862bE2a173976CA11',
+            blockCreated: 0,
+        },
+    },
+    testnet: true,
+});
+exports.chain = (0, viem_1.defineChain)({
+    ...arcTestnet,
+    blockchainId: 'ARC-TESTNET',
+    blockchainVm: 'EVM',
+    contracts: {
+        ...arcTestnet.contracts,
+        USDC: { address: '0x3600000000000000000000000000000000000000', abi: viem_1.erc20Abi, read: { decimals: () => 6 } },
+    },
+});