@circle-fin/usdckit 0.21.0 → 0.22.0

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

@@ -8,22 +8,23 @@
 // 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 { erc20Abi, encodeFunctionData } from 'viem';
 import { describe, expect, vi, beforeEach, it, test } from 'vitest';
 import { ETH_SEPOLIA, MATIC_AMOY } from '../chains/index.js';
 import { UnsupportedChainError } from '../errors/UnsupportedChainError.js';
-import { ESTIMATE_GAS, HIGH } from '../providers/circle-wallets/actions/estimateTransferFee.js';
+import { getClient } from '../utils/getClient.js';
 import { transfer as action } from './transfer.js';
 vi.mock('../utils/getContract.js', () => ({
-    getContract: vi.fn(({ address }) => ({
+    getContract: vi.fn(({ address, abi }) => ({
         address: address,
+        abi,
         read: {
             decimals: vi.fn(() => 6),
         },
     })),
 }));
-vi.mock('../providers/circle-wallets/actions/estimateTransferFee.js', () => ({
-    ESTIMATE_GAS: vi.fn(() => 3n),
-    HIGH: vi.fn(() => ({ gas: 3n, maxFeePerGas: 6000000000n, maxPriorityFeePerGas: 9000000000n })),
+vi.mock('../utils/getClient.js', () => ({
+    getClient: vi.fn((client, _chain) => client),
 }));
 describe('transfer()', () => {
     beforeEach(() => {
@@ -31,16 +32,9 @@ describe('transfer()', () => {
     });
     const client = {
         chain: ETH_SEPOLIA,
-        createTransaction: vi.fn(() => ({
-            id: 'transaction-id',
-            state: 'COMPLETE',
-            txHash: 'tx-hash',
-        })),
-        waitForTransactionHash: vi.fn(({ id }) => ({
-            id,
-            state: 'COMPLETE',
-            txHash: 'tx-hash',
-        })),
+        writeContract: vi.fn(() => 'tx-hash'),
+        sendTransaction: vi.fn(() => 'tx-hash'),
+        estimateGas: vi.fn(() => 3n),
         waitForTransactionReceipt: vi.fn(() => { }),
         getTokenBalances: vi.fn(() => []),
         transfer: vi.fn(() => [{ hash: 'tx-hash' }]),
@@ -48,67 +42,76 @@ describe('transfer()', () => {
     };
     it('should transfer native tokens', async () => {
         const params = {
-            from: { address: '0x123' },
-            to: { address: '0x321' },
+            from: { address: '0x1234567890123456789012345678901234567890' },
+            to: { address: '0x3210987654321098765432109876543210987654' },
             amount: '0.00000001',
         };
         const expectedResult = [{ hash: 'tx-hash' }];
         const { from, to } = params;
         const result = await action(client, params);
-        expect(client.createTransaction).toHaveBeenCalledWith({
-            sourceAddress: from.address,
-            destinationAddress: to.address,
-            blockchain: client.chain.blockchainId,
-            amounts: ['0.00000001'],
-            fee: { type: 'absolute', config: { gasLimit: '3', maxFee: '6', priorityFee: '9' } },
+        expect(client.sendTransaction).toHaveBeenCalledWith({
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            account: expect.objectContaining({
+                address: from.address,
+            }),
+            to: to.address,
+            value: 10000000000n,
+            chain: ETH_SEPOLIA,
+            gas: 3n,
         });
         expect(result).toEqual(expectedResult);
     });
     it('should support bigint for amount', async () => {
         const params = {
-            from: { address: '0x123' },
-            to: { address: '0x321' },
+            from: { address: '0x1234567890123456789012345678901234567890' },
+            to: { address: '0x3210987654321098765432109876543210987654' },
             amount: 1000000n,
         };
         const expectedResult = [{ hash: 'tx-hash' }];
         const { from, to } = params;
         const result = await action(client, params);
-        expect(client.createTransaction).toHaveBeenCalledWith({
-            sourceAddress: from.address,
-            destinationAddress: to.address,
-            blockchain: 'ETH-SEPOLIA',
-            amounts: ['0.000000000001'],
-            fee: { type: 'absolute', config: { gasLimit: '3', maxFee: '6', priorityFee: '9' } },
+        expect(client.sendTransaction).toHaveBeenCalledWith({
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            account: expect.objectContaining({
+                address: from.address,
+            }),
+            to: to.address,
+            value: 1000000n,
+            chain: ETH_SEPOLIA,
+            gas: 3n,
         });
         expect(result).toEqual(expectedResult);
     });
     test.each([
         // eslint-disable-next-line @typescript-eslint/require-await
-        [async () => 1000000n, '0.000000000001'],
+        [async () => 1000000n, 1000000n],
         // eslint-disable-next-line @typescript-eslint/require-await
-        [async () => '0.000000000001', '0.000000000001'],
-    ])('should support callable for amount', async (amount, amountFormated) => {
+        [async () => '0.000000000001', 1000000n],
+    ])('should support callable for amount', async (amount, expectedAmount) => {
         const params = {
-            from: { address: '0x123' },
-            to: { address: '0x321' },
+            from: { address: '0x1234567890123456789012345678901234567890' },
+            to: { address: '0x3210987654321098765432109876543210987654' },
             amount,
         };
         const expectedResult = [{ hash: 'tx-hash' }];
         const { from, to } = params;
         const result = await action(client, params);
-        expect(client.createTransaction).toHaveBeenCalledWith({
-            sourceAddress: from.address,
-            destinationAddress: to.address,
-            blockchain: 'ETH-SEPOLIA',
-            amounts: [amountFormated],
-            fee: { type: 'absolute', config: { gasLimit: '3', maxFee: '6', priorityFee: '9' } },
+        expect(client.sendTransaction).toHaveBeenCalledWith({
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            account: expect.objectContaining({
+                address: from.address,
+            }),
+            to: to.address,
+            value: expectedAmount,
+            chain: ETH_SEPOLIA,
+            gas: 3n,
         });
         expect(result).toEqual(expectedResult);
     });
     it('should support the gas argument as unformatted', async () => {
         const params = {
-            from: { address: '0x123' },
-            to: { address: '0x321' },
+            from: { address: '0x1234567890123456789012345678901234567890' },
+            to: { address: '0x3210987654321098765432109876543210987654' },
             amount: 1000000n,
             gas: 111n,
             fees: {
@@ -119,36 +122,34 @@ describe('transfer()', () => {
         const expectedResult = [{ hash: 'tx-hash' }];
         const { from, to } = params;
         const result = await action(client, params);
-        expect(client.createTransaction).toHaveBeenCalledWith({
-            sourceAddress: from.address,
-            destinationAddress: to.address,
-            blockchain: 'ETH-SEPOLIA',
-            amounts: ['0.000000000001'],
-            fee: {
-                type: 'absolute',
-                config: {
-                    gasLimit: '111',
-                    maxFee: '0.000000222',
-                    priorityFee: '0.000000333',
-                },
-            },
+        expect(client.sendTransaction).toHaveBeenCalledWith({
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            account: expect.objectContaining({
+                address: from.address,
+            }),
+            to: to.address,
+            value: 1000000n,
+            chain: ETH_SEPOLIA,
+            gas: 111n,
+            maxFeePerGas: 222n,
+            maxPriorityFeePerGas: 333n,
         });
         expect(result).toEqual(expectedResult);
     });
     test.each([
         [
             { maxFeePerGas: 222n, maxPriorityFeePerGas: 333n },
-            { maxFee: '0.000000222', priorityFee: '0.000000333' },
+            { maxFeePerGas: 222n, maxPriorityFeePerGas: 333n },
         ],
         [
             // eslint-disable-next-line @typescript-eslint/require-await
             async () => ({ maxFeePerGas: 222n, maxPriorityFeePerGas: 333n }),
-            { maxFee: '0.000000222', priorityFee: '0.000000333' },
+            { maxFeePerGas: 222n, maxPriorityFeePerGas: 333n },
         ],
-    ])('should support the fees argument', async (fees, { maxFee, priorityFee }) => {
+    ])('should support the fees argument', async (fees, { maxFeePerGas, maxPriorityFeePerGas }) => {
         const params = {
-            from: { address: '0x123' },
-            to: { address: '0x321' },
+            from: { address: '0x1234567890123456789012345678901234567890' },
+            to: { address: '0x3210987654321098765432109876543210987654' },
             amount: 1000000n,
             gas: 111n,
             fees,
@@ -156,43 +157,37 @@ describe('transfer()', () => {
         const expectedResult = [{ hash: 'tx-hash' }];
         const { from, to } = params;
         const result = await action(client, params);
-        expect(ESTIMATE_GAS).not.toHaveBeenCalled();
-        expect(HIGH).not.toHaveBeenCalled();
-        expect(client.createTransaction).toHaveBeenCalledWith({
-            sourceAddress: from.address,
-            destinationAddress: to.address,
-            blockchain: 'ETH-SEPOLIA',
-            amounts: ['0.000000000001'],
-            fee: {
-                type: 'absolute',
-                config: {
-                    gasLimit: '111',
-                    maxFee,
-                    priorityFee,
-                },
-            },
+        expect(client.sendTransaction).toHaveBeenCalledWith({
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            account: expect.objectContaining({
+                address: from.address,
+            }),
+            to: to.address,
+            value: 1000000n,
+            chain: ETH_SEPOLIA,
+            gas: 111n,
+            maxFeePerGas,
+            maxPriorityFeePerGas,
         });
         expect(result).toEqual(expectedResult);
     });
     test.each([
         [
             {
-                from: { address: '0x123' },
-                to: { address: '0x321' },
+                from: { address: '0x1234567890123456789012345678901234567890' },
+                to: { address: '0x3210987654321098765432109876543210987654' },
                 amount: 1000000n,
                 gas: 111n,
                 fees: undefined,
             },
             {
-                gasLimit: '111',
-                maxFee: '6',
-                priorityFee: '9',
+                gas: 111n,
             },
         ],
         [
             {
-                from: { address: '0x123' },
-                to: { address: '0x321' },
+                from: { address: '0x1234567890123456789012345678901234567890' },
+                to: { address: '0x3210987654321098765432109876543210987654' },
                 amount: 1000000n,
                 gas: undefined,
                 fees: {
@@ -201,93 +196,113 @@ describe('transfer()', () => {
                 },
             },
             {
-                gasLimit: '3',
-                maxFee: '0.000000222',
-                priorityFee: '0.000000333',
+                gas: 3n,
+                maxFeePerGas: 222n,
+                maxPriorityFeePerGas: 333n,
             },
         ],
-    ])('should support the gas argument with partial gas fields', async (params, gasEstimation) => {
+    ])('should support the gas argument with partial gas fields', async (params, expectedTxParams) => {
         await action(client, params);
-        if (params.gas !== undefined)
-            expect(ESTIMATE_GAS).not.toHaveBeenCalled();
-        if (params.fees !== undefined)
-            expect(HIGH).not.toHaveBeenCalled();
-        expect(client.createTransaction).toHaveBeenCalledWith({
-            sourceAddress: params.from.address,
-            destinationAddress: params.to.address,
-            blockchain: 'ETH-SEPOLIA',
-            amounts: ['0.000000000001'],
-            fee: {
-                type: 'absolute',
-                config: gasEstimation,
-            },
-            tokenAddress: undefined,
+        expect(client.sendTransaction).toHaveBeenCalledWith({
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            account: expect.objectContaining({
+                address: params.from.address,
+            }),
+            to: params.to.address,
+            value: 1000000n,
+            chain: ETH_SEPOLIA,
+            ...expectedTxParams,
         });
     });
     it('should support the token argument', async () => {
         const params = {
-            from: { address: '0x123' },
-            to: { address: '0x321' },
+            from: { address: '0x1230000000000000000000000000000000000000' },
+            to: { address: '0x3210000000000000000000000000000000000000' },
             amount: 12250000n,
-            token: { address: '0xabc' },
+            token: { address: '0xabc0000000000000000000000000000000000000' },
         };
         const expectedResult = [{ hash: 'tx-hash' }];
         const { from, to } = params;
         const result = await action(client, params);
-        expect(client.createTransaction).toHaveBeenCalledWith({
-            sourceAddress: from.address,
-            destinationAddress: to.address,
-            blockchain: 'ETH-SEPOLIA',
-            amounts: ['12.25'],
-            tokenAddress: params.token.address,
-            fee: { type: 'absolute', config: { gasLimit: '3', maxFee: '6', priorityFee: '9' } },
+        expect(client.writeContract).toHaveBeenCalledWith({
+            address: params.token.address,
+            abi: erc20Abi,
+            functionName: 'transfer',
+            args: [to.address, 12250000n],
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            account: expect.objectContaining({
+                address: from.address,
+            }),
+            chain: ETH_SEPOLIA,
+            gas: 3n,
         });
         expect(result).toEqual(expectedResult);
     });
     it('should support the token argument as string', async () => {
         const params = {
-            from: { address: '0x123' },
-            to: { address: '0x321' },
+            from: { address: '0x1230000000000000000000000000000000000000' },
+            to: { address: '0x3210000000000000000000000000000000000000' },
             amount: 12250000n,
-            token: '0xabc',
+            token: '0xabc0000000000000000000000000000000000000',
         };
         const expectedResult = [{ hash: 'tx-hash' }];
         const { from, to } = params;
         const result = await action(client, params);
         expect(result).toEqual(expectedResult);
-        expect(client.createTransaction).toHaveBeenCalledWith({
-            sourceAddress: from.address,
-            destinationAddress: to.address,
-            blockchain: 'ETH-SEPOLIA',
-            amounts: ['12.25'],
-            tokenAddress: params.token,
-            fee: { type: 'absolute', config: { gasLimit: '3', maxFee: '6', priorityFee: '9' } },
+        expect(client.writeContract).toHaveBeenCalledWith({
+            address: params.token,
+            abi: erc20Abi,
+            functionName: 'transfer',
+            args: [to.address, 12250000n],
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            account: expect.objectContaining({
+                address: from.address,
+            }),
+            chain: ETH_SEPOLIA,
+            gas: 3n,
         });
     });
     it('should support batch transfer with multiple from addresses and dynamic amount', async () => {
         const params = {
-            from: [{ address: '0x123' }, { address: '0x456' }],
-            to: { address: '0x321' },
+            from: [
+                { address: '0x1234567890123456789012345678901234567890' },
+                { address: '0x4567890123456789012345678901234567890123' },
+            ],
+            to: { address: '0x3210987654321098765432109876543210987654' },
             // eslint-disable-next-line @typescript-eslint/require-await
-            amount: async ({ address }) => (address === '0x123' ? 1000000n : 2000000n),
+            amount: async ({ address }) => (address === '0x1234567890123456789012345678901234567890' ? 1000000n : 2000000n),
         };
         const expectedResult = [{ hash: 'tx-hash' }, { hash: 'tx-hash' }];
         const { from, to } = params;
         const result = await action(client, params);
-        expect(client.createTransaction).toHaveBeenCalledWith({
-            sourceAddress: from[1].address,
-            destinationAddress: to.address,
-            blockchain: 'ETH-SEPOLIA',
-            amounts: ['0.000000000002'],
-            fee: { type: 'absolute', config: { gasLimit: '3', maxFee: '6', priorityFee: '9' } },
+        expect(client.sendTransaction).toHaveBeenCalledTimes(2);
+        expect(client.sendTransaction).toHaveBeenNthCalledWith(1, {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            account: expect.objectContaining({
+                address: from[0].address,
+            }),
+            to: to.address,
+            value: 1000000n,
+            chain: ETH_SEPOLIA,
+            gas: 3n,
+        });
+        expect(client.sendTransaction).toHaveBeenNthCalledWith(2, {
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            account: expect.objectContaining({
+                address: from[1].address,
+            }),
+            to: to.address,
+            value: 2000000n,
+            chain: ETH_SEPOLIA,
+            gas: 3n,
         });
         expect(result).toEqual(expectedResult);
     });
     it('should throw UnsupportedChainError for unsupported chain', async () => {
         const chain = { id: -1 };
         await expect(action(client, {
-            from: { address: '0x123' },
-            to: { address: '0x321' },
+            from: { address: '0x1234567890123456789012345678901234567890' },
+            to: { address: '0x3210987654321098765432109876543210987654' },
             amount: 1000000n,
             gas: 111n,
             chain,
@@ -295,8 +310,8 @@ describe('transfer()', () => {
     });
     it('should transfer using bridge', async () => {
         const params = {
-            from: { address: '0x123', chain: MATIC_AMOY },
-            to: { address: '0x321', chain: ETH_SEPOLIA },
+            from: { address: '0x1234567890123456789012345678901234567890', chain: MATIC_AMOY },
+            to: { address: '0x3210987654321098765432109876543210987654', chain: ETH_SEPOLIA },
             amount: '1',
             token: MATIC_AMOY.contracts.USDC.address,
         };
@@ -314,4 +329,188 @@ describe('transfer()', () => {
         });
         expect(result).toEqual(expectedResult);
     });
+    it('should handle transaction failures', async () => {
+        client.sendTransaction.mockRejectedValueOnce(new Error('Transaction failed'));
+        const params = {
+            from: { address: '0x1234567890123456789012345678901234567890' },
+            to: { address: '0x3210987654321098765432109876543210987654' },
+            amount: '0.00000001',
+        };
+        await expect(action(client, params)).rejects.toThrow();
+    });
+    it('should handle contract call failures', async () => {
+        client.writeContract.mockRejectedValueOnce(new Error('Contract call failed'));
+        const params = {
+            from: { address: '0x1234567890123456789012345678901234567890' },
+            to: { address: '0x3210987654321098765432109876543210987654' },
+            amount: '1',
+            token: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd',
+        };
+        await expect(action(client, params)).rejects.toThrow();
+    });
+    it('should use getClient for chain-specific operations', async () => {
+        const params = {
+            from: { address: '0x1234567890123456789012345678901234567890' },
+            to: { address: '0x3210987654321098765432109876543210987654' },
+            amount: '0.00000001',
+        };
+        await action(client, params);
+        expect(vi.mocked(getClient)).toHaveBeenCalledWith(client, ETH_SEPOLIA);
+    });
+    it('should use getClient with correct chain parameter for different chains', async () => {
+        const params = {
+            from: { address: '0x1234567890123456789012345678901234567890' },
+            to: { address: '0x3210987654321098765432109876543210987654' },
+            amount: '0.00000001',
+            chain: MATIC_AMOY,
+        };
+        await action(client, params);
+        expect(vi.mocked(getClient)).toHaveBeenCalledWith(client, MATIC_AMOY);
+    });
+    it('should use getClient for token transfers on specific chains', async () => {
+        const params = {
+            from: { address: '0x1234567890123456789012345678901234567890' },
+            to: { address: '0x3210987654321098765432109876543210987654' },
+            amount: '1',
+            token: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd',
+            chain: MATIC_AMOY,
+        };
+        await action(client, params);
+        expect(vi.mocked(getClient)).toHaveBeenCalledWith(client, MATIC_AMOY);
+        expect(client.writeContract).toHaveBeenCalledWith({
+            address: '0xabcdefabcdefabcdefabcdefabcdefabcdefabcd',
+            abi: erc20Abi,
+            functionName: 'transfer',
+            args: ['0x3210987654321098765432109876543210987654', 1000000n],
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            account: expect.objectContaining({
+                address: '0x1234567890123456789012345678901234567890',
+            }),
+            chain: MATIC_AMOY,
+            gas: 3n,
+        });
+    });
+    it('should use estimateGas for native token transfers when gas is not provided', async () => {
+        const params = {
+            from: { address: '0x1234567890123456789012345678901234567890' },
+            to: { address: '0x3210987654321098765432109876543210987654' },
+            amount: 1000000n,
+        };
+        await action(client, params);
+        expect(client.estimateGas).toHaveBeenCalledWith({
+            account: params.from.address,
+            to: params.to.address,
+            value: 1000000n,
+        });
+    });
+    it('should use estimateGas for ERC20 token transfers when gas is not provided', async () => {
+        const params = {
+            from: { address: '0x1234567890123456789012345678901234567890' },
+            to: { address: '0x3210987654321098765432109876543210987654' },
+            amount: 1000000n,
+            token: { address: '0xabc0000000000000000000000000000000000000', abi: erc20Abi },
+        };
+        await action(client, params);
+        // Generate expected encoded data for ERC20 transfer function
+        const expectedData = encodeFunctionData({
+            abi: erc20Abi,
+            functionName: 'transfer',
+            args: [params.to.address, params.amount],
+        });
+        // Verify estimateGas was called for ERC20 transfer (with contract address and encoded data)
+        expect(client.estimateGas).toHaveBeenCalledWith({
+            account: params.from.address,
+            to: params.token.address,
+            data: expectedData,
+        });
+    });
+    it('should not call estimateGas when gas is explicitly provided', async () => {
+        const params = {
+            from: { address: '0x1234567890123456789012345678901234567890' },
+            to: { address: '0x3210987654321098765432109876543210987654' },
+            amount: 1000000n,
+            gas: 50000n,
+        };
+        await action(client, params);
+        expect(client.estimateGas).not.toHaveBeenCalled();
+    });
+    it('should use estimateGas with correct chain context', async () => {
+        const params = {
+            from: { address: '0x1234567890123456789012345678901234567890' },
+            to: { address: '0x3210987654321098765432109876543210987654' },
+            amount: 1000000n,
+            chain: MATIC_AMOY,
+        };
+        await action(client, params);
+        expect(vi.mocked(getClient)).toHaveBeenCalledWith(client, MATIC_AMOY);
+        expect(client.estimateGas).toHaveBeenCalledWith({
+            account: params.from.address,
+            to: params.to.address,
+            value: 1000000n,
+        });
+    });
+    it('should use provided fee function when fees are specified', async () => {
+        const mockFeeFunction = vi.fn().mockResolvedValue({
+            maxFeePerGas: 500n,
+            maxPriorityFeePerGas: 100n,
+        });
+        const params = {
+            from: { address: '0x1234567890123456789012345678901234567890' },
+            to: { address: '0x3210987654321098765432109876543210987654' },
+            amount: 1000000n,
+            fees: mockFeeFunction,
+        };
+        const result = await action(client, params);
+        expect(result).toEqual([{ hash: 'tx-hash' }]);
+        // Custom fee function should be called with correct parameters
+        expect(mockFeeFunction).toHaveBeenCalledWith({
+            client,
+            request: {
+                from: expect.objectContaining({ address: params.from.address }),
+                to: expect.objectContaining({ address: params.to.address }),
+                token: undefined,
+                amount: 1000000n,
+                chain: ETH_SEPOLIA,
+            },
+        });
+        // sendTransaction should be called with custom fees
+        expect(client.sendTransaction).toHaveBeenCalledWith({
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            account: expect.objectContaining({
+                address: params.from.address,
+            }),
+            to: params.to.address,
+            value: 1000000n,
+            chain: ETH_SEPOLIA,
+            gas: 3n,
+            maxFeePerGas: 500n,
+            maxPriorityFeePerGas: 100n,
+        });
+    });
+    it('should handle fees parameter as object for token transfers', async () => {
+        const params = {
+            from: { address: '0x1234567890123456789012345678901234567890' },
+            to: { address: '0x3210987654321098765432109876543210987654' },
+            amount: 1000000n,
+            token: { address: '0xabc0000000000000000000000000000000000000' },
+            fees: { maxFeePerGas: 400n, maxPriorityFeePerGas: 50n },
+        };
+        const result = await action(client, params);
+        expect(result).toEqual([{ hash: 'tx-hash' }]);
+        // writeContract should be called with provided fee object
+        expect(client.writeContract).toHaveBeenCalledWith({
+            address: params.token.address,
+            abi: erc20Abi,
+            functionName: 'transfer',
+            args: [params.to.address, 1000000n],
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            account: expect.objectContaining({
+                address: params.from.address,
+            }),
+            chain: ETH_SEPOLIA,
+            gas: 3n,
+            maxFeePerGas: 400n,
+            maxPriorityFeePerGas: 50n,
+        });
+    });
 });

package/dist/esm/chains.d.ts

@@ -0,0 +1,2 @@
+import type * as chains from './chains/index.js';
+export type Chain = (typeof chains)[keyof typeof chains];

package/dist/esm/chains.js

@@ -0,0 +1,11 @@
+// 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.
+export {};