@circle-fin/usdckit 0.21.1 → 0.23.0

package/dist/esm/providers/solana/utils/toBase64EncodedWireTransaction.test.js

@@ -0,0 +1,106 @@
+// 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 { expect, describe, it } from 'vitest';
+import { toBase64EncodedWireTransaction } from './toBase64EncodedWireTransaction.js';
+describe.concurrent('toBase64EncodedWireTransaction', () => {
+    it('should convert Buffer to base64 string', () => {
+        const txBytes = new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100]); // "Hello World"
+        const buffer = Buffer.from(txBytes);
+        const expected = 'SGVsbG8gV29ybGQ=';
+        const result = toBase64EncodedWireTransaction(buffer);
+        expect(result).toBe(expected);
+        expect(typeof result).toBe('string');
+    });
+    it('should convert Buffer with transaction-like data to base64', () => {
+        // Simulate a more realistic transaction buffer with binary data
+        const txBytes = new Uint8Array([
+            0x01, 0x00, 0x01, 0x03, 0xff, 0xfe, 0xfd, 0xfc, 0xfb, 0xfa, 0xf9, 0xf8, 0xf7, 0xf6, 0xf5, 0xf4, 0xf3, 0xf2, 0xf1,
+            0xf0, 0xef, 0xee, 0xed, 0xec,
+        ]);
+        const buffer = Buffer.from(txBytes);
+        const expected = buffer.toString('base64');
+        const result = toBase64EncodedWireTransaction(buffer);
+        expect(result).toBe(expected);
+        expect(typeof result).toBe('string');
+    });
+    it('should pass through string input unchanged', () => {
+        const base64String = 'SGVsbG8gV29ybGQ=';
+        const result = toBase64EncodedWireTransaction(base64String);
+        expect(result).toBe(base64String);
+        expect(typeof result).toBe('string');
+    });
+    it('should pass through already encoded transaction string', () => {
+        const encodedTx = 'AQABAxYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYW';
+        const result = toBase64EncodedWireTransaction(encodedTx);
+        expect(result).toBe(encodedTx);
+        expect(typeof result).toBe('string');
+    });
+    it('should pass through Base64EncodedWireTransaction type unchanged', () => {
+        const encodedTx = 'SGVsbG8gV29ybGQ=';
+        const result = toBase64EncodedWireTransaction(encodedTx);
+        expect(result).toBe(encodedTx);
+        expect(typeof result).toBe('string');
+    });
+    it('should handle empty Buffer', () => {
+        const buffer = Buffer.from([]);
+        const expected = '';
+        const result = toBase64EncodedWireTransaction(buffer);
+        expect(result).toBe(expected);
+        expect(typeof result).toBe('string');
+    });
+    it('should handle empty string', () => {
+        const emptyString = '';
+        const result = toBase64EncodedWireTransaction(emptyString);
+        expect(result).toBe(emptyString);
+        expect(typeof result).toBe('string');
+    });
+    it('should handle single byte Buffer', () => {
+        const buffer = Buffer.from([65]); // 'A' in ASCII
+        const expected = 'QQ==';
+        const result = toBase64EncodedWireTransaction(buffer);
+        expect(result).toBe(expected);
+        expect(typeof result).toBe('string');
+    });
+    it('should handle large Buffer data', () => {
+        // Create a larger buffer to test with more realistic transaction sizes
+        const largeArray = new Array(1000).fill(0).map((_, i) => i % 256);
+        const buffer = Buffer.from(largeArray);
+        const expected = buffer.toString('base64');
+        const result = toBase64EncodedWireTransaction(buffer);
+        expect(result).toBe(expected);
+        expect(typeof result).toBe('string');
+        expect(result.length).toBeGreaterThan(0);
+    });
+    it('should maintain type safety with Base64EncodedWireTransaction return type', () => {
+        const buffer = Buffer.from('test');
+        const stringInput = 'dGVzdA==';
+        const typedInput = 'dGVzdA==';
+        // All should return the same type
+        const result1 = toBase64EncodedWireTransaction(buffer);
+        const result2 = toBase64EncodedWireTransaction(stringInput);
+        const result3 = toBase64EncodedWireTransaction(typedInput);
+        expect(typeof result1).toBe('string');
+        expect(typeof result2).toBe('string');
+        expect(typeof result3).toBe('string');
+    });
+    it('should produce consistent results for equivalent inputs', () => {
+        const originalData = 'Hello, Solana!';
+        const buffer = Buffer.from(originalData, 'utf8');
+        const expectedBase64 = buffer.toString('base64');
+        // Test that buffer conversion produces the same result as manual base64 encoding
+        const result = toBase64EncodedWireTransaction(buffer);
+        expect(result).toBe(expectedBase64);
+        // Test that passing the base64 string returns the same value
+        const stringResult = toBase64EncodedWireTransaction(expectedBase64);
+        expect(stringResult).toBe(expectedBase64);
+        expect(stringResult).toBe(result);
+    });
+});

package/dist/esm/providers/uniswap/actions/exactInputSingle.d.ts

@@ -1,6 +1,6 @@
-import type { Address, Account, ControlFlowOptions, ExtendedViemClient, BaseUnits } from '../../../types.js';
+import type { Address, Account, ControlFlowOptions, BaseUnits } from '../../../types.js';
 import type { Chain } from '../index.js';
-import type { Abi, FeeValuesEIP1559 } from 'viem';
+import type { Abi, Client, FeeValuesEIP1559 } from 'viem';
 /**
  * Parameters for the {@link exactInputSingle} function.
  */
@@ -53,4 +53,4 @@ export type ExactInputSingleParams = {
  * // => '0xTransactionHash'
  * ```
  */
-export declare function exactInputSingle(client: ExtendedViemClient, params: ExactInputSingleParams & ControlFlowOptions): Promise<`0x${string}`>;
+export declare function exactInputSingle(client: Client, params: ExactInputSingleParams & ControlFlowOptions): Promise<`0x${string}`>;

package/dist/esm/providers/uniswap/actions/exactInputSingle.js

@@ -8,10 +8,11 @@
 // 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 { createPublicClient, erc20Abi, http } from 'viem';
+import { erc20Abi } from 'viem';
 import { simulateContract as _simulateContract, waitForTransactionReceipt as _waitForTransactionReceipt, } from 'viem/actions';
 import { getAction } from 'viem/utils';
 import { UnsupportedChainError } from '../../../errors/UnsupportedChainError.js';
+import { getClient } from '../../../utils/getClient.js';
 import { getContract } from '../../../utils/getContract.js';
 import { parseAccount } from '../../../utils/parseAccount.js';
 import { parseAddress } from '../../../utils/parseAddress.js';
@@ -41,15 +42,14 @@ export async function exactInputSingle(client, params) {
     // REF: https://docs.uniswap.org/contracts/v3/reference/periphery/lens/QuoterV2#quoteexactinputsingle
     const { tokenIn: _tokenIn, tokenOut: _tokenOut, amountIn, amountOutMinimum = 0n, fee = 3000, sqrtPriceLimitX96 = 0n, withApprove = true, chain: _chain = client.chain, gas, fees, account: _account, } = params;
     const chain = extractChain(_chain) ?? raise(new UnsupportedChainError());
-    const publicClient = createPublicClient({ chain, transport: http() });
+    const _client = getClient(client, chain);
     const writeContract = getAction(client, _writeContract, 'writeContract');
     const waitForTransactionReceipt = getAction(client, _waitForTransactionReceipt, 'waitForTransactionReceipt');
-    // HACK: `simulateContract` does not support `chain` parameter
-    const simulateContract = getAction(publicClient, _simulateContract, 'simulateContract');
+    const simulateContract = getAction(_client, _simulateContract, 'simulateContract');
     const router = getContract({
         address: chain.contracts.SwapRouter02.address,
         abi: chain.contracts.SwapRouter02.abi,
-        client: publicClient,
+        client: _client,
     });
     const tokenIn = parseAddress(_tokenIn);
     const tokenOut = parseAddress(_tokenOut);

package/dist/esm/providers/uniswap/actions/getPool.d.ts

@@ -1,5 +1,6 @@
-import type { Address, ChainContract, ExtendedViemClient } from '../../../types.js';
+import type { Address, ChainContract } from '../../../types.js';
 import type { Chain } from '../index.js';
+import type { Client } from 'viem';
 /**
  * Parameters for the {@link getPool} function.
  */
@@ -36,7 +37,7 @@ export type GetPoolParams = {
  * // }
  * ```
  */
-export declare function getPool(client: ExtendedViemClient, params: GetPoolParams): Promise<{
+export declare function getPool(client: Client, params: GetPoolParams): Promise<{
     address: `0x${string}`;
     tokenIn: Address;
     tokenOut: Address;

package/dist/esm/providers/uniswap/actions/quoteExactInputSingle.d.ts

@@ -1,5 +1,6 @@
-import type { Address, ChainContract, ExtendedViemClient, NativeUnits, BaseUnits } from '../../../types.js';
+import type { Address, ChainContract, NativeUnits, BaseUnits } from '../../../types.js';
 import type { Chain } from '../index.js';
+import type { Client } from 'viem';
 /**
  * Parameters for the {@link quoteExactInputSingle} function.
  */
@@ -40,7 +41,7 @@ export type QuoteExactInputSingleParams = {
  * // }
  * ```
  */
-export declare function quoteExactInputSingle(client: ExtendedViemClient, params: QuoteExactInputSingleParams): Promise<{
+export declare function quoteExactInputSingle(client: Client, params: QuoteExactInputSingleParams): Promise<{
     tokenOutAmount: bigint;
     sqrtPriceX96After: bigint;
     initializedTicksCrossed: bigint;

package/dist/esm/types.d.ts

@@ -1,20 +1,12 @@
-import type { Actions as CoreActions } from './actions/index.js';
-import type * as chains from './chains/index.js';
-import type { Actions as CircleWalletsActions } from './providers/circle-wallets/actions/index.js';
-import type { EIP1474Methods as CircleWalletsMethods } from './providers/circle-wallets/transports/index.js';
-import type { Actions as CrossChainTransferProtocolActions } from './providers/cross-chain-transfer-protocol/actions/index.js';
-import type { EIP1474Methods as CrossChainTransferMethods } from './providers/cross-chain-transfer-protocol/transports/index.js';
-import type { Actions as UniswapActions } from './providers/uniswap/actions/index.js';
-import type { Logger } from 'pino';
-import type { Account, Client, EIP1474Methods, PublicActions, Transport, WalletActions } from 'viem';
 export type { Account, Address, ChainContract, GetContractReturnType as Contract, FeeValuesEIP1559, Assign as Merge, } from 'viem';
-export type Chain = (typeof chains)[keyof typeof chains];
-export type ExtendedEIP1474Methods = [...CircleWalletsMethods, ...CrossChainTransferMethods, ...EIP1474Methods];
-export type ExtendedViemClient<transport extends Transport = Transport, chain extends Chain = Chain> = Client<transport, chain, Account, ExtendedEIP1474Methods>;
-export type CircleClient = Omit<Client, 'chain'> & {
-    logger: Logger;
-    chain: Chain;
-} & PublicActions & WalletActions & UniswapActions & CircleWalletsActions & CrossChainTransferProtocolActions & CoreActions;
+/**
+ * Utility type that returns a tuple type with the first element removed.
+ *
+ * @example
+ * type Args = [string, number, boolean];
+ * type Rest = DropFirst<Args>; // [number, boolean]
+ */
+export type DropFirst<T extends unknown[]> = T extends [unknown, ...infer R] ? R : never;
 /**
  * The primary denomination of a blockchain’s currency
  *

package/dist/esm/types.js

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

package/dist/esm/utils/createConfig.d.ts

@@ -0,0 +1,36 @@
+import type { Chain } from '../chains.js';
+import type { Transport } from 'viem';
+export interface TransportFactoryParams {
+    /** Required chain ID for the transport */
+    chainId: number;
+}
+/**
+ * Configuration parameters for creating a wagmi config with transport factory.
+ */
+type CreateConfigParams = {
+    /** Array of blockchain chains to support. Must contain at least one chain. */
+    chains: Chain[];
+    /** Factory function that creates a transport for a given chain ID. */
+    transportFactory: (params: TransportFactoryParams) => Transport;
+};
+/**
+ * Creates a wagmi configuration with fallback transport support for multiple chains.
+ *
+ * @param params - Configuration parameters including chains and transport factory
+ * @returns Wagmi configuration object ready for use with clients
+ * @throws Will throw an error when chains array is empty
+ *
+ * @example
+ * ```typescript
+ * const config = createConfig({
+ *   chains: [chains.ETH_SEPOLIA, chains.MATIC_AMOY],
+ *   transportFactory: ({ chainId }) => circleWalletsTransport({
+ *     apiKey: 'your-api-key',
+ *     entitySecret: 'your-entity-secret',
+ *     chainId
+ *   })
+ * })
+ * ```
+ */
+export declare function createConfig(params: CreateConfigParams): import("@wagmi/core").Config<[Chain, ...Chain[]], Record<number, Transport>, readonly import("@wagmi/core").CreateConnectorFn[]>;
+export {};

package/dist/esm/utils/createConfig.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 { createConfig as createWagmiConfig } from '@wagmi/core';
+import { fallback } from 'viem';
+import { http as cctpTransport } from '../providers/cross-chain-transfer-protocol/index.js';
+import { http as solanaTransport } from '../providers/solana/index.js';
+/**
+ * Creates a wagmi configuration with fallback transport support for multiple chains.
+ *
+ * @param params - Configuration parameters including chains and transport factory
+ * @returns Wagmi configuration object ready for use with clients
+ * @throws Will throw an error when chains array is empty
+ *
+ * @example
+ * ```typescript
+ * const config = createConfig({
+ *   chains: [chains.ETH_SEPOLIA, chains.MATIC_AMOY],
+ *   transportFactory: ({ chainId }) => circleWalletsTransport({
+ *     apiKey: 'your-api-key',
+ *     entitySecret: 'your-entity-secret',
+ *     chainId
+ *   })
+ * })
+ * ```
+ */
+export function createConfig(params) {
+    const { chains, transportFactory } = params;
+    if (chains.length === 0) {
+        throw new Error('At least one chain must be provided');
+    }
+    const transports = chains.reduce((acc, chain) => {
+        const transportProviders = [cctpTransport({}), solanaTransport({}), transportFactory({ chainId: chain.id })];
+        acc[chain.id] = fallback(transportProviders);
+        return acc;
+    }, {});
+    return createWagmiConfig({
+        chains: chains,
+        transports,
+    });
+}

package/dist/esm/utils/createConfig.test.d.ts

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

package/dist/esm/utils/createConfig.test.js

@@ -0,0 +1,64 @@
+// 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 { http } from 'viem';
+import { describe, test, expect, vi } from 'vitest';
+import { ETH_SEPOLIA, MATIC_AMOY } from '../chains/index.js';
+import { createConfig } from './createConfig.js';
+// Mock transport providers
+vi.mock('../providers/circle-wallets/index.js', () => ({
+    http: vi.fn(() => ({ type: 'circle-wallets' })),
+}));
+vi.mock('../providers/cross-chain-transfer-protocol/index.js', () => ({
+    http: vi.fn(() => ({ type: 'cctp' })),
+}));
+vi.mock('../providers/solana/index.js', () => ({
+    http: vi.fn(() => ({ type: 'solana' })),
+}));
+describe('createConfig', () => {
+    test('should create config with provided chains', () => {
+        const config = createConfig({
+            chains: [ETH_SEPOLIA, MATIC_AMOY],
+            transportFactory: ({ chainId }) => http(`https://rpc-${chainId}.example.com`),
+        });
+        expect(config).toBeDefined();
+        expect(config.chains).toEqual([ETH_SEPOLIA, MATIC_AMOY]);
+    });
+    test('should throw error for empty chains array', () => {
+        expect(() => createConfig({
+            chains: [],
+            transportFactory: ({ chainId }) => http(`https://rpc-${chainId}.example.com`),
+        })).toThrow('At least one chain must be provided');
+    });
+    test('should handle single chain', () => {
+        const config = createConfig({
+            chains: [ETH_SEPOLIA],
+            transportFactory: ({ chainId }) => http(`https://rpc-${chainId}.example.com`),
+        });
+        expect(config).toBeDefined();
+        expect(config.chains).toEqual([ETH_SEPOLIA]);
+    });
+    test('should work with Circle Wallets transport factory', () => {
+        const config = createConfig({
+            chains: [ETH_SEPOLIA, MATIC_AMOY],
+            transportFactory: ({ chainId }) => http(`https://circle-wallets-${chainId}.example.com`),
+        });
+        expect(config).toBeDefined();
+        expect(config.chains).toEqual([ETH_SEPOLIA, MATIC_AMOY]);
+    });
+    test('should work with custom transport factory', () => {
+        const config = createConfig({
+            chains: [ETH_SEPOLIA],
+            transportFactory: ({ chainId }) => http(`https://custom-rpc-${chainId}.example.com`),
+        });
+        expect(config).toBeDefined();
+        expect(config.chains).toEqual([ETH_SEPOLIA]);
+    });
+});

package/dist/esm/utils/createCustomWalletClient.d.ts

@@ -0,0 +1,46 @@
+import type { Chain } from '../chains.js';
+import type { CustomWalletClient } from '../client.js';
+import type { TransportFactoryParams } from './createConfig.js';
+import type { Transport } from 'viem';
+export type CreateCustomWalletClientParams = {
+    /** Default chain for operations when no chain is specified, defaults to {@link ETH_SEPOLIA} */
+    defaultChain?: Chain;
+    /** Chains this client will work with */
+    chains?: Chain[];
+    /** Factory function that creates transport for a given chain */
+    customTransportFactory: (params: TransportFactoryParams) => Transport;
+};
+/**
+ * Creates a client with a custom wallet provider transport.
+ *
+ * @param params - The parameters for creating the client
+ * @returns A configured Circle client instance with custom wallet support
+ *
+ * @example
+ * Initialize a client with Fireblocks provider
+ * ```typescript
+ * import { createCustomWalletClient } from '@circle-fin/usdckit/utils'
+ * import { custom } from 'viem'
+ * import { FireblocksWeb3Provider } from '@fireblocks/fireblocks-web3-provider'
+ *
+ * const config = {
+ *   apiKey: process.env.FIREBLOCKS_API_KEY || '',
+ *   privateKey: process.env.FIREBLOCKS_API_PRIVATE_KEY_PATH || '',
+ *   vaultAccountIds: ['2'],
+ *   apiBaseUrl: ApiBaseUrl.Sandbox,
+ * };
+ *
+ * const client = createCustomWalletClient({
+ *   defaultChain: chains.ETH_SEPOLIA,
+ *   chains: [chains.ETH_SEPOLIA, chains.MATIC_AMOY],
+ *   customTransportFactory: ({ chainId }) =>
+ *     custom(
+ *       new FireblocksWeb3Provider({
+ *         ...config,
+ *         chainId,
+ *       }),
+ *     ),
+ * });
+ * ```
+ */
+export declare function createCustomWalletClient(params: CreateCustomWalletClientParams): CustomWalletClient;

package/dist/esm/utils/createCustomWalletClient.js

@@ -0,0 +1,78 @@
+// 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 { createClient as createViemClient, fallback, publicActions, walletActions } from 'viem';
+import { actions as coreActions } from '../actions/index.js';
+import * as chains from '../chains/index.js';
+import { actions as crossChainTransferProtocolActions, http as crossChainTransferProtocolTransport, } from '../providers/cross-chain-transfer-protocol/index.js';
+import { actions as solanaActions, http as solanaTransport } from '../providers/solana/index.js';
+import { actions as uniswapActions } from '../providers/uniswap/index.js';
+import { createConfig } from './createConfig.js';
+/**
+ * Creates a client with a custom wallet provider transport.
+ *
+ * @param params - The parameters for creating the client
+ * @returns A configured Circle client instance with custom wallet support
+ *
+ * @example
+ * Initialize a client with Fireblocks provider
+ * ```typescript
+ * import { createCustomWalletClient } from '@circle-fin/usdckit/utils'
+ * import { custom } from 'viem'
+ * import { FireblocksWeb3Provider } from '@fireblocks/fireblocks-web3-provider'
+ *
+ * const config = {
+ *   apiKey: process.env.FIREBLOCKS_API_KEY || '',
+ *   privateKey: process.env.FIREBLOCKS_API_PRIVATE_KEY_PATH || '',
+ *   vaultAccountIds: ['2'],
+ *   apiBaseUrl: ApiBaseUrl.Sandbox,
+ * };
+ *
+ * const client = createCustomWalletClient({
+ *   defaultChain: chains.ETH_SEPOLIA,
+ *   chains: [chains.ETH_SEPOLIA, chains.MATIC_AMOY],
+ *   customTransportFactory: ({ chainId }) =>
+ *     custom(
+ *       new FireblocksWeb3Provider({
+ *         ...config,
+ *         chainId,
+ *       }),
+ *     ),
+ * });
+ * ```
+ */
+export function createCustomWalletClient(params) {
+    const { defaultChain = chains.ETH_SEPOLIA, chains: userChains = Object.values(chains), customTransportFactory, } = params;
+    const configuredChains = userChains.some((chain) => chain.id === defaultChain.id)
+        ? userChains
+        : [defaultChain, ...userChains];
+    const transportProviders = [
+        crossChainTransferProtocolTransport({}),
+        solanaTransport({}),
+        customTransportFactory({ chainId: defaultChain.id }),
+    ];
+    const transport = fallback(transportProviders);
+    const _client = createViemClient({ chain: defaultChain, transport });
+    // Create a config and bind it onto the client.
+    // Note: By default, we build config with configured chains only.
+    // Note: this step must occur before extending actions, otherwise the config won't be closured into each action calls.
+    _client.config = createConfig({
+        chains: configuredChains,
+        transportFactory: customTransportFactory,
+    });
+    const client = _client
+        .extend(publicActions)
+        .extend(walletActions)
+        .extend(solanaActions)
+        .extend(crossChainTransferProtocolActions)
+        .extend(uniswapActions)
+        .extend(coreActions);
+    return client;
+}

package/dist/esm/utils/createCustomWalletClient.test.d.ts

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

package/dist/esm/utils/createCustomWalletClient.test.js

@@ -0,0 +1,98 @@
+// 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 { http } from 'viem';
+import { describe, it, expect } from 'vitest';
+import { ETH_SEPOLIA, MATIC_AMOY } from '../chains/index.js';
+import { createCustomWalletClient } from './createCustomWalletClient.js';
+describe('createCustomWalletClient', () => {
+    it('should create successfully with basic configuration', () => {
+        const client = createCustomWalletClient({
+            customTransportFactory: ({ chainId }) => http(`https://rpc-${chainId}.example.com`),
+        });
+        expect(client).toBeDefined();
+        expect(client.config).toBeDefined();
+        expect(client.chain).toBe(ETH_SEPOLIA); // Default chain
+    });
+    it('should create successfully with specified default chain', () => {
+        const client = createCustomWalletClient({
+            defaultChain: MATIC_AMOY,
+            customTransportFactory: ({ chainId }) => http(`https://rpc-${chainId}.example.com`),
+        });
+        expect(client).toBeDefined();
+        expect(client.config).toBeDefined();
+        expect(client.chain).toBe(MATIC_AMOY);
+    });
+    it('should create successfully with custom chains', () => {
+        const customChains = [ETH_SEPOLIA, MATIC_AMOY];
+        const client = createCustomWalletClient({
+            chains: customChains,
+            customTransportFactory: ({ chainId }) => http(`https://rpc-${chainId}.example.com`),
+        });
+        expect(client).toBeDefined();
+        expect(client.config).toBeDefined();
+        expect(client.chain).toBe(ETH_SEPOLIA); // Default chain
+    });
+    it('should handle Fireblocks configuration using closures', () => {
+        // Configuration is now handled in the closure
+        const config = {
+            apiKey: 'fireblocks-api-key',
+            privateKey: 'fireblocks-private-key',
+            vaultAccountIds: 'fireblocks-vault-ids',
+        };
+        const client = createCustomWalletClient({
+            customTransportFactory: ({ chainId }) => http(`https://fireblocks-${chainId}.example.com?apiKey=${config.apiKey}`),
+        });
+        expect(client).toBeDefined();
+        expect(client.config).toBeDefined();
+        expect(client.chain).toBe(ETH_SEPOLIA);
+    });
+    it('should have required client properties and methods', () => {
+        const client = createCustomWalletClient({
+            customTransportFactory: ({ chainId }) => http(`https://rpc-${chainId}.example.com`),
+        });
+        // Check that the client has the expected properties
+        expect(client.chain).toBeDefined();
+        expect(client.config).toBeDefined();
+        // Check that common viem methods exist
+        expect(typeof client.getBlock).toBe('function');
+        expect(typeof client.getBalance).toBe('function');
+        expect(typeof client.sendTransaction).toBe('function');
+    });
+    it('should automatically include defaultChain in chains when not present', () => {
+        const client = createCustomWalletClient({
+            defaultChain: ETH_SEPOLIA,
+            chains: [MATIC_AMOY], // ETH_SEPOLIA not included - should be added automatically
+            customTransportFactory: ({ chainId }) => http(`https://rpc-${chainId}.example.com`),
+        });
+        expect(client).toBeDefined();
+        expect(client.config).toBeDefined();
+        expect(client.chain).toBe(ETH_SEPOLIA); // Should be the default chain
+        const configChains = client.config.chains;
+        expect(configChains).toContainEqual(ETH_SEPOLIA);
+        expect(configChains).toContainEqual(MATIC_AMOY);
+        expect(configChains).toHaveLength(2);
+    });
+    it('should not duplicate defaultChain when it is already in chains', () => {
+        const client = createCustomWalletClient({
+            defaultChain: ETH_SEPOLIA,
+            chains: [ETH_SEPOLIA, MATIC_AMOY], // ETH_SEPOLIA already included
+            customTransportFactory: ({ chainId }) => http(`https://rpc-${chainId}.example.com`),
+        });
+        expect(client).toBeDefined();
+        expect(client.config).toBeDefined();
+        expect(client.chain).toBe(ETH_SEPOLIA);
+        // Verify that ETH_SEPOLIA is not duplicated
+        const configChains = client.config.chains;
+        expect(configChains).toContainEqual(ETH_SEPOLIA);
+        expect(configChains).toContainEqual(MATIC_AMOY);
+        expect(configChains).toHaveLength(2); // Should still be only 2 chains, not 3
+    });
+});

package/dist/esm/utils/getChainContractByAddress.d.ts

@@ -1,4 +1,5 @@
-import type { Address, Chain, ChainContract } from '../types.js';
+import type { Chain } from '../chains.js';
+import type { Address, ChainContract } from '../types.js';
 /**
  * Retrieves the contract associated with a given address from the specified chain.
  *