@circle-fin/usdckit 0.21.1 → 0.22.0

package/dist/cjs/utils/index.test.js

@@ -52,6 +52,7 @@ vitest_1.describe.concurrent('utils', () => {
     (0, vitest_1.it)('should return an object with the expected methods', () => {
         (0, vitest_1.expect)(new Set(Object.keys(mod))).toEqual(new Set([
             'InvalidDecimalNumberError',
+            'createCustomWalletClient',
             'formatUnits',
             'generateIdempotencyKey',
             'getChainContractByAddress',
@@ -65,6 +66,7 @@ vitest_1.describe.concurrent('utils', () => {
             'wrapAsync',
         ]));
         (0, vitest_1.expect)(mod.InvalidDecimalNumberError).toBeDefined();
+        (0, vitest_1.expect)(mod.createCustomWalletClient).toEqual(vitest_1.expect.any(Function));
         (0, vitest_1.expect)(mod.formatUnits).toEqual(vitest_1.expect.any(Function));
         (0, vitest_1.expect)(mod.generateIdempotencyKey).toEqual(vitest_1.expect.any(Function));
         (0, vitest_1.expect)(mod.getChainContractByAddress).toEqual(vitest_1.expect.any(Function));

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

@@ -1,5 +1,5 @@
-import type { Account, Address, NativeUnits, BaseUnits, ExtendedViemClient } from '../types.js';
-import type { Abi, Chain as ViemChain } from 'viem';
+import type { Account, Address, NativeUnits, BaseUnits } from '../types.js';
+import type { Abi, Chain as ViemChain, Client } from 'viem';
 export type GenerateTransferLinkParams = {
     /** The recipient address. */
     to: Address | Account;
@@ -32,4 +32,4 @@ export type GenerateTransferLinkParams = {
  * // => 'ethereum:0xRecipientAddress@11155111?value=100&token=0xTokenAddress'
  * ```
  */
-export declare function generateTransferLink(client: ExtendedViemClient, params: GenerateTransferLinkParams): Promise<string>;
+export declare function generateTransferLink(client: Client, params: GenerateTransferLinkParams): Promise<string>;

package/dist/esm/actions/generateTransferLink.js

@@ -34,6 +34,9 @@ import { toERC681 } from '../utils/toERC681.js';
  */
 export async function generateTransferLink(client, params) {
     const { to, amount: _amount, chain: _chain = client.chain } = params;
+    if (_chain === undefined) {
+        throw new Error('chain is required');
+    }
     const toAccount = parseAccount(to, { chain: _chain });
     const chain = toAccount.chain;
     const token = params.token != null ? parseAddress(params.token) : null;

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

@@ -59,4 +59,21 @@ describe.concurrent('generateTransferLink', () => {
     ])('return a valid URL', async (params, expectedResult) => {
         await expect(generateTransferLink(client, params)).resolves.toBe(expectedResult);
     });
+    test('should throw error when chain is undefined', async () => {
+        const clientWithoutChain = {
+            chain: undefined,
+            getContract: vi.fn(({ address }) => ({
+                address,
+                read: {
+                    decimals: vi.fn(() => 6),
+                },
+                abi: erc20Abi,
+            })),
+        };
+        const params = {
+            to: '0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238',
+            amount: '1',
+        };
+        await expect(generateTransferLink(clientWithoutChain, params)).rejects.toThrow('chain is required');
+    });
 });

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

@@ -1,6 +1,6 @@
 import type { Chain } from '../providers/uniswap/index.js';
-import type { Address, BaseUnits, ControlFlowOptions, ExtendedViemClient, NativeUnits } from '../types.js';
-import type { Abi } from 'viem';
+import type { Address, BaseUnits, ControlFlowOptions, NativeUnits } from '../types.js';
+import type { Abi, Client } from 'viem';
 /**
  * Parameters for the {@link getSwapExactInQuote} function.
  */
@@ -68,4 +68,4 @@ export type GetSwapExactInQuoteReturnType = {
  * await client.swap({ ...quote, account })
  * ```
  */
-export declare function getSwapExactInQuote(client: ExtendedViemClient, params: GetSwapExactInQuoteParams & ControlFlowOptions): Promise<GetSwapExactInQuoteReturnType>;
+export declare function getSwapExactInQuote(client: Client, params: GetSwapExactInQuoteParams & ControlFlowOptions): Promise<GetSwapExactInQuoteReturnType>;

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

@@ -0,0 +1,30 @@
+import type { Account, Address, BaseUnits, ChainContract, NativeUnits } from '../types.js';
+import type { Chain, Client } from 'viem';
+export type GetTokenBalanceInput = {
+    account: Account;
+    chain?: Chain;
+    token?: Address | ChainContract;
+};
+export type GetTokenBalanceReturnType = {
+    /**
+     * The token address, or undefined for native token
+     */
+    token: Address | undefined;
+    /**
+     * The number of decimals used by the token
+     */
+    decimals: number | undefined;
+    /**
+     * The token symbol (e.g., "ETH", "USDC")
+     */
+    symbol: string | undefined;
+    /**
+     * The balance value in the smallest indivisible unit
+     */
+    value: BaseUnits;
+    /**
+     * The formatted balance
+     */
+    formatted: NativeUnits;
+};
+export declare function getTokenBalance(client: Client, params: GetTokenBalanceInput): Promise<GetTokenBalanceReturnType>;

package/dist/esm/actions/getTokenBalance.js

@@ -0,0 +1,48 @@
+// 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 { erc20Abi } from 'viem';
+import { getBalance as _getBalance, readContract as _readContract } from 'viem/actions';
+import { formatUnits, getAction } from 'viem/utils';
+import { getClient } from '../utils/getClient.js';
+export async function getTokenBalance(client, params) {
+    const { account, token } = params;
+    // Get the client for the given chain.
+    const chain = (account['chain'] ?? params.chain ?? client.chain);
+    const _client = getClient(client, chain);
+    const readContract = getAction(_client, _readContract, 'readContract');
+    const getBalance = getAction(_client, _getBalance, 'getBalance');
+    // If token is given, get the balance of the given token from reading the contract.
+    if (token !== undefined) {
+        const address = typeof token === 'string' ? token : token.address;
+        const abi = erc20Abi;
+        const [balance, decimals, symbol] = await Promise.all([
+            readContract({ address, abi, functionName: 'balanceOf', args: [account.address] }),
+            readContract({ address, abi, functionName: 'decimals' }),
+            readContract({ address, abi, functionName: 'symbol' }),
+        ]);
+        return {
+            token: address,
+            decimals,
+            symbol,
+            value: balance,
+            formatted: formatUnits(balance, decimals),
+        };
+    }
+    // Get the balance of the native token.
+    const balance = await getBalance({ address: account.address });
+    return {
+        token: undefined,
+        decimals: chain.nativeCurrency.decimals,
+        symbol: chain.nativeCurrency.symbol,
+        value: balance,
+        formatted: formatUnits(balance, chain.nativeCurrency.decimals),
+    };
+}

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

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

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

@@ -0,0 +1,163 @@
+// 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 { erc20Abi } from 'viem';
+import { describe, expect, vi, beforeEach, it } from 'vitest';
+import { ETH_SEPOLIA, MATIC_AMOY } from '../chains/index.js';
+import { getTokenBalance as action } from './getTokenBalance.js';
+vi.mock('../utils/getClient.js', () => ({
+    getClient: vi.fn((client, _chain) => client),
+}));
+describe('getTokenBalance()', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    const mockClient = {
+        chain: ETH_SEPOLIA,
+        readContract: vi.fn(),
+        getBalance: vi.fn(),
+    };
+    it('should get ERC20 token balance', async () => {
+        const account = { address: '0x123' };
+        const tokenAddress = '0xabc';
+        mockClient.readContract
+            .mockResolvedValueOnce(1000000n) // balanceOf
+            .mockResolvedValueOnce(6) // decimals
+            .mockResolvedValueOnce('USDC'); // symbol
+        const result = await action(mockClient, {
+            account,
+            token: tokenAddress,
+        });
+        expect(mockClient.readContract).toHaveBeenCalledTimes(3);
+        expect(mockClient.readContract).toHaveBeenNthCalledWith(1, {
+            address: tokenAddress,
+            abi: erc20Abi,
+            functionName: 'balanceOf',
+            args: [account.address],
+        });
+        expect(mockClient.readContract).toHaveBeenNthCalledWith(2, {
+            address: tokenAddress,
+            abi: erc20Abi,
+            functionName: 'decimals',
+        });
+        expect(mockClient.readContract).toHaveBeenNthCalledWith(3, {
+            address: tokenAddress,
+            abi: erc20Abi,
+            functionName: 'symbol',
+        });
+        expect(result).toEqual({
+            token: tokenAddress,
+            decimals: 6,
+            symbol: 'USDC',
+            value: 1000000n,
+            formatted: '1',
+        });
+    });
+    it('should get ERC20 token balance with ChainContract input', async () => {
+        const account = { address: '0x123' };
+        const token = { address: '0xabc' };
+        mockClient.readContract
+            .mockResolvedValueOnce(500000n) // balanceOf
+            .mockResolvedValueOnce(18) // decimals
+            .mockResolvedValueOnce('WETH'); // symbol
+        const result = await action(mockClient, {
+            account,
+            token,
+        });
+        expect(result).toEqual({
+            token: token.address,
+            decimals: 18,
+            symbol: 'WETH',
+            value: 500000n,
+            formatted: '0.0000000000005',
+        });
+    });
+    it('should get native token balance', async () => {
+        const account = { address: '0x123' };
+        mockClient.getBalance.mockResolvedValueOnce(2000000000000000000n); // 2 ETH
+        const result = await action(mockClient, {
+            account,
+        });
+        expect(mockClient.getBalance).toHaveBeenCalledWith({
+            address: account.address,
+        });
+        expect(result).toEqual({
+            token: undefined,
+            decimals: ETH_SEPOLIA.nativeCurrency.decimals,
+            symbol: ETH_SEPOLIA.nativeCurrency.symbol,
+            value: 2000000000000000000n,
+            formatted: '2',
+        });
+    });
+    it('should use account chain when provided', async () => {
+        const account = { address: '0x123', chain: MATIC_AMOY };
+        mockClient.getBalance.mockResolvedValueOnce(1000000000000000000n); // 1 MATIC
+        const result = await action(mockClient, {
+            account,
+        });
+        expect(result).toEqual({
+            token: undefined,
+            decimals: MATIC_AMOY.nativeCurrency.decimals,
+            symbol: MATIC_AMOY.nativeCurrency.symbol,
+            value: 1000000000000000000n,
+            formatted: '1',
+        });
+    });
+    it('should use explicit chain parameter', async () => {
+        const account = { address: '0x123' };
+        mockClient.getBalance.mockResolvedValueOnce(1500000000000000000n); // 1.5 MATIC
+        const result = await action(mockClient, {
+            account,
+            chain: MATIC_AMOY,
+        });
+        expect(result).toEqual({
+            token: undefined,
+            decimals: MATIC_AMOY.nativeCurrency.decimals,
+            symbol: MATIC_AMOY.nativeCurrency.symbol,
+            value: 1500000000000000000n,
+            formatted: '1.5',
+        });
+    });
+    it('should handle string token address', async () => {
+        const account = { address: '0x123' };
+        const token = '0xdef';
+        mockClient.readContract
+            .mockResolvedValueOnce(750000n) // balanceOf
+            .mockResolvedValueOnce(8) // decimals
+            .mockResolvedValueOnce('DAI'); // symbol
+        const result = await action(mockClient, {
+            account,
+            token,
+        });
+        expect(result.token).toBe(token);
+        expect(result.decimals).toBe(8);
+        expect(result.symbol).toBe('DAI');
+        expect(result.value).toBe(750000n);
+        expect(result.formatted).toBe('0.0075');
+    });
+    it('should handle zero balances', async () => {
+        const account = { address: '0x123' };
+        mockClient.getBalance.mockResolvedValueOnce(0n);
+        const result = await action(mockClient, {
+            account,
+        });
+        expect(result.value).toBe(0n);
+        expect(result.formatted).toBe('0');
+    });
+    it('should handle contract call failures', async () => {
+        const account = { address: '0x123' };
+        const tokenAddress = '0xabc';
+        mockClient.readContract.mockRejectedValueOnce(new Error('Contract call failed'));
+        await expect(action(mockClient, {
+            account,
+            token: tokenAddress,
+        })).rejects.toThrow('Contract call failed');
+    });
+});

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

@@ -1,11 +1,14 @@
 import { generateTransferLink } from './generateTransferLink.js';
 import { getSwapExactInQuote } from './getSwapExactInQuote.js';
+import { getTokenBalance } from './getTokenBalance.js';
 import { swapExactIn } from './swapExactIn.js';
 import { sweep } from './sweep.js';
 import { transfer } from './transfer.js';
-import type { Account, Chain } from '../types.js';
+import type { Chain } from '../chains.js';
+import type { Account } from '../types.js';
 import type { GenerateTransferLinkParams } from './generateTransferLink.js';
 import type { GetSwapExactInQuoteParams } from './getSwapExactInQuote.js';
+import type { GetTokenBalanceInput } from './getTokenBalance.js';
 import type { SwapExactInParams } from './swapExactIn.js';
 import type { SweepParams } from './sweep.js';
 import type { TransferParams } from './transfer.js';
@@ -14,6 +17,7 @@ export * from './transfer.js';
 export * from './sweep.js';
 export * from './generateTransferLink.js';
 export * from './getSwapExactInQuote.js';
+export * from './getTokenBalance.js';
 export * from './swapExactIn.js';
 export { FEE_LEVEL_WITH_PREPARE } from '../providers/circle-wallets/actions/index.js';
 export type Actions<transport extends Transport = Transport, chain extends ViemChain | undefined = Chain | undefined, account extends Account | undefined = Account | undefined> = {
@@ -29,6 +33,8 @@ export type Actions<transport extends Transport = Transport, chain extends ViemC
     getSwapQuote: (params: Parameters<typeof getSwapExactInQuote>[1]) => ReturnType<typeof getSwapExactInQuote>;
     /** See {@link getSwapExactInQuote} action */
     getSwapExactInQuote: (params: Parameters<typeof getSwapExactInQuote>[1]) => ReturnType<typeof getSwapExactInQuote>;
+    /** See {@link getTokenBalance} action */
+    getTokenBalance: (params: Parameters<typeof getTokenBalance>[1]) => ReturnType<typeof getTokenBalance>;
     /** See {@link swapExactIn} action */
     swap: (params: Parameters<typeof swapExactIn>[1]) => ReturnType<typeof swapExactIn>;
     /** See {@link swapExactIn} action */
@@ -53,6 +59,8 @@ export declare function actions(client: Client): {
     getSwapQuote: (params: GetSwapExactInQuoteParams) => Promise<import("./getSwapExactInQuote.js").GetSwapExactInQuoteReturnType>;
     /** See {@link getSwapExactInQuote} action */
     getSwapExactInQuote: (params: GetSwapExactInQuoteParams) => Promise<import("./getSwapExactInQuote.js").GetSwapExactInQuoteReturnType>;
+    /** See {@link getTokenBalance} action */
+    getTokenBalance: (params: GetTokenBalanceInput) => Promise<import("./getTokenBalance.js").GetTokenBalanceReturnType>;
     /** See {@link swapExactIn} action */
     swap: (params: SwapExactInParams) => Promise<`0x${string}`>;
     /** See {@link swapExactIn} action */

package/dist/esm/actions/index.js

@@ -10,6 +10,7 @@
 // prohibited without the express written permission of Circle Internet Group, Inc.
 import { generateTransferLink } from './generateTransferLink.js';
 import { getSwapExactInQuote } from './getSwapExactInQuote.js';
+import { getTokenBalance } from './getTokenBalance.js';
 import { swapExactIn } from './swapExactIn.js';
 import { sweep } from './sweep.js';
 import { transfer } from './transfer.js';
@@ -17,6 +18,7 @@ export * from './transfer.js';
 export * from './sweep.js';
 export * from './generateTransferLink.js';
 export * from './getSwapExactInQuote.js';
+export * from './getTokenBalance.js';
 export * from './swapExactIn.js';
 export { FEE_LEVEL_WITH_PREPARE } from '../providers/circle-wallets/actions/index.js';
 /**
@@ -26,23 +28,24 @@ export { FEE_LEVEL_WITH_PREPARE } from '../providers/circle-wallets/actions/inde
  * @returns An object containing the bound action functions.
  */
 export function actions(client) {
-    const _client = client;
     return {
         /** See {@link sweep} action */
-        sweep: (params) => sweep(_client, params),
+        sweep: (params) => sweep(client, params),
         /** See {@link sweep} action */
-        drainFrom: (params) => sweep(_client, params),
+        drainFrom: (params) => sweep(client, params),
         /** See {@link transfer} action */
-        transfer: (params) => transfer(_client, params),
+        transfer: (params) => transfer(client, params),
         /** See {@link generateTransferLink} action */
-        generateTransferLink: (params) => generateTransferLink(_client, params),
+        generateTransferLink: (params) => generateTransferLink(client, params),
         /** See {@link getSwapExactInQuote} action */
-        getSwapQuote: (params) => getSwapExactInQuote(_client, params),
+        getSwapQuote: (params) => getSwapExactInQuote(client, params),
         /** See {@link getSwapExactInQuote} action */
-        getSwapExactInQuote: (params) => getSwapExactInQuote(_client, params),
+        getSwapExactInQuote: (params) => getSwapExactInQuote(client, params),
+        /** See {@link getTokenBalance} action */
+        getTokenBalance: (params) => getTokenBalance(client, params),
         /** See {@link swapExactIn} action */
-        swap: (params) => swapExactIn(_client, params),
+        swap: (params) => swapExactIn(client, params),
         /** See {@link swapExactIn} action */
-        swapExactIn: (params) => swapExactIn(_client, params),
+        swapExactIn: (params) => swapExactIn(client, params),
     };
 }

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

@@ -34,6 +34,8 @@ describe.concurrent('actions', () => {
             swap: expect.any(Function),
             // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
             swapExactIn: expect.any(Function),
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            getTokenBalance: expect.any(Function),
         });
     });
 });

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

@@ -1,6 +1,6 @@
 import type { Chain } from '../providers/uniswap/index.js';
-import type { Account, Address, BaseUnits, ControlFlowOptions, ExtendedViemClient, FeeValuesEIP1559, NativeUnits } from '../types.js';
-import type { Abi } from 'viem';
+import type { Account, Address, BaseUnits, ControlFlowOptions, FeeValuesEIP1559, NativeUnits } from '../types.js';
+import type { Abi, Client } from 'viem';
 /**
  * Parameters for the {@link swapExactIn} function.
  */
@@ -36,4 +36,4 @@ export type SwapExactInParamsReturnType = Address;
  * @param params - Parameters for the operation
  * @returns The address of the transaction that was executed.
  */
-export declare function swapExactIn(client: ExtendedViemClient, params: SwapExactInParams & ControlFlowOptions): Promise<SwapExactInParamsReturnType>;
+export declare function swapExactIn(client: Client, params: SwapExactInParams & ControlFlowOptions): Promise<SwapExactInParamsReturnType>;

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

@@ -1,5 +1,6 @@
 import type { TransferReturnType, TransferParams } from './transfer.js';
-import type { ControlFlowOptions, ExtendedViemClient } from '../types.js';
+import type { ControlFlowOptions } from '../types.js';
+import type { Client } from 'viem';
 /**
  * Parameters for sweeping tokens from accounts
  */
@@ -13,4 +14,4 @@ export type SweepReturnType = TransferReturnType;
  * @param params - Parameters for the sweep operation
  * @returns An array of transfer results.
  */
-export declare function sweep(client: ExtendedViemClient, params: SweepParams & ControlFlowOptions): Promise<SweepReturnType>;
+export declare function sweep(client: Client, params: SweepParams & ControlFlowOptions): Promise<SweepReturnType>;

package/dist/esm/actions/sweep.js

@@ -9,7 +9,7 @@
 // of this source code or any related proprietary information is strictly
 // prohibited without the express written permission of Circle Internet Group, Inc.
 import { getAction } from 'viem/utils';
-import { getTokenBalances as _getTokenBalances } from '../providers/circle-wallets/actions/getTokenBalances.js';
+import { getTokenBalance as _getTokenBalance } from './getTokenBalance.js';
 import { transfer } from './transfer.js';
 /**
  * Sweeps the specified token balance to the destination wallet.
@@ -20,8 +20,8 @@ import { transfer } from './transfer.js';
  * @returns An array of transfer results.
  */
 export async function sweep(client, params) {
-    const getTokenBalances = getAction(client, _getTokenBalances, 'getTokenBalances');
-    const { token = null } = params;
+    const getTokenBalance = getAction(client, _getTokenBalance, 'getTokenBalance');
+    const { token } = params;
     /**
      * Gets the current balance of tokens for an account to be transferred.
      *
@@ -29,8 +29,8 @@ export async function sweep(client, params) {
      * @returns The current balance in base units, or 0n if no balance is found
      */
     async function zeroAmount(account) {
-        const balances = (await getTokenBalances({ account, token }));
-        return balances.at(0)?.value ?? 0n;
+        const balance = await getTokenBalance({ account, token: token ?? undefined });
+        return balance.value;
     }
     return await transfer(client, { ...params, amount: zeroAmount });
 }

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

@@ -10,26 +10,21 @@
 // prohibited without the express written permission of Circle Internet Group, Inc.
 import { describe, expect, vi, beforeEach, it } from 'vitest';
 import { ETH_SEPOLIA } from '../chains/index.js';
+import { getTokenBalance } from './getTokenBalance.js';
 import { sweep } from './sweep.js';
 import { transfer } from './transfer.js';
 vi.mock('./transfer.js', () => ({
     transfer: vi.fn(),
 }));
+vi.mock('./getTokenBalance.js', () => ({
+    getTokenBalance: vi.fn(),
+}));
 describe('sweep()', () => {
     beforeEach(() => {
         vi.restoreAllMocks();
     });
     const client = {
         chain: ETH_SEPOLIA,
-        getTokenBalances: vi.fn(() => [
-            {
-                token: '0x1c7d4b196cb0c7b01d743fbc6116a902379c7238',
-                decimals: 6,
-                symbol: 'USDC',
-                value: 1237999924n,
-                formatted: '1237.999924',
-            },
-        ]),
     };
     it('should call transfer() with the full amount of account', async () => {
         const params = {
@@ -38,6 +33,14 @@ describe('sweep()', () => {
             token: ETH_SEPOLIA.contracts.USDC,
         };
         const expectedResult = [{ hash: '0xtx-hash' }];
+        // Mock getTokenBalance to return a specific balance
+        vi.mocked(getTokenBalance).mockResolvedValue({
+            token: '0x1c7d4b196cb0c7b01d743fbc6116a902379c7238',
+            decimals: 6,
+            symbol: 'USDC',
+            value: 1237999924n,
+            formatted: '1237.999924',
+        });
         vi.mocked(transfer).mockImplementation(async (_, { amount, from }) => {
             if (typeof amount === 'function') {
                 expect(await amount(from)).toBe(1237999924n);
@@ -51,6 +54,6 @@ describe('sweep()', () => {
             to: { address: '0x321', type: 'json-rpc' },
             token: ETH_SEPOLIA.contracts.USDC,
         }));
-        expect(client.getTokenBalances).toHaveBeenCalled();
+        expect(getTokenBalance).toHaveBeenCalled();
     });
 });

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

@@ -1,5 +1,5 @@
 import type { Chain } from '../providers/circle-wallets/index.js';
-import type { Account, Address, Contract, ControlFlowOptions, NativeUnits, BaseUnits, FeeValuesEIP1559, ExtendedViemClient } from '../types.js';
+import type { Account, Address, Contract, ControlFlowOptions, NativeUnits, BaseUnits, FeeValuesEIP1559 } from '../types.js';
 import type { Abi, Client } from 'viem';
 /**
  * Parameters for the {@link transfer} function.
@@ -121,4 +121,4 @@ export type EstimateFeesPerGasParams = {
  * })
  * ```
  */
-export declare function transfer(client: ExtendedViemClient, params: TransferParams & ControlFlowOptions): Promise<TransferReturnType>;
+export declare function transfer(client: Client, params: TransferParams & ControlFlowOptions): Promise<TransferReturnType>;