@circle-fin/usdckit 0.21.1 → 0.22.0

package/dist/esm/providers/solana/actions/simulateTransaction.test.js

@@ -0,0 +1,80 @@
+// 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 { describe, expect, it, vi, beforeEach } from 'vitest';
+import { simulateTransaction } from './simulateTransaction.js';
+describe('simulateTransaction', () => {
+    const mockClient = {
+        request: vi.fn(),
+    };
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    it('should call client.request with base64 encoded transaction', async () => {
+        const txBase64 = 'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDArczbMIA1sNQiUQLoupO4LkRSz2nUOUt9sQ3PQ86KLuwmPCLOHSyXQhgbFxBjuDCfN6xAwGzw8tq7DjJHMLtLmIL1lOH8RBJb+HrcBl6aLNBKm6JY9LPK1pQ8RYNG6i8';
+        const config = { commitment: 'confirmed', replaceRecentBlockhash: true, encoding: 'base64' };
+        const mockResponse = { value: { err: null, logs: [], accounts: null } };
+        vi.mocked(mockClient.request).mockResolvedValue(mockResponse);
+        const result = await simulateTransaction(mockClient, txBase64, config);
+        expect(mockClient.request).toHaveBeenCalledWith({
+            method: 'sol_simulateTransaction',
+            params: [txBase64, { ...config, encoding: 'base64' }],
+        });
+        expect(result).toBe(mockResponse);
+    });
+    it('should handle Buffer input and convert to base64', async () => {
+        const txBuffer = Buffer.from('test transaction data', 'utf8');
+        const expectedBase64 = txBuffer.toString('base64');
+        const mockResponse = { value: { err: null, logs: [], accounts: null } };
+        vi.mocked(mockClient.request).mockResolvedValue(mockResponse);
+        await simulateTransaction(mockClient, txBuffer);
+        expect(mockClient.request).toHaveBeenCalledWith({
+            method: 'sol_simulateTransaction',
+            params: [expectedBase64, { encoding: 'base64' }],
+        });
+    });
+    it('should handle string input directly', async () => {
+        const txString = 'test-transaction-string';
+        const mockResponse = { value: { err: null, logs: [], accounts: null } };
+        vi.mocked(mockClient.request).mockResolvedValue(mockResponse);
+        await simulateTransaction(mockClient, txString);
+        expect(mockClient.request).toHaveBeenCalledWith({
+            method: 'sol_simulateTransaction',
+            params: [txString, { encoding: 'base64' }],
+        });
+    });
+    it('should override encoding to base64 even if provided in config', async () => {
+        const txBase64 = 'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDArczbMIA1sNQiUQLoupO4LkRSz2nUOUt9sQ3PQ86KLuwmPCLOHSyXQhgbFxBjuDCfN6xAwGzw8tq7DjJHMLtLmIL1lOH8RBJb+HrcBl6aLNBKm6JY9LPK1pQ8RYNG6i8';
+        // Create a config with a different encoding to test that it gets overridden
+        const config = { encoding: 'hex', commitment: 'confirmed', sigVerify: false };
+        vi.mocked(mockClient.request).mockResolvedValue({ value: { err: null } });
+        // Cast to bypass the type constraint since we're testing the override behavior
+        await simulateTransaction(mockClient, txBase64, config);
+        expect(mockClient.request).toHaveBeenCalledWith({
+            method: 'sol_simulateTransaction',
+            params: [txBase64, { ...config, encoding: 'base64' }],
+        });
+    });
+    it('should work without config parameter', async () => {
+        const txBase64 = 'AQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABAAEDArczbMIA1sNQiUQLoupO4LkRSz2nUOUt9sQ3PQ86KLuwmPCLOHSyXQhgbFxBjuDCfN6xAwGzw8tq7DjJHMLtLmIL1lOH8RBJb+HrcBl6aLNBKm6JY9LPK1pQ8RYNG6i8';
+        vi.mocked(mockClient.request).mockResolvedValue({ value: { err: null } });
+        await simulateTransaction(mockClient, txBase64);
+        expect(mockClient.request).toHaveBeenCalledWith({
+            method: 'sol_simulateTransaction',
+            params: [txBase64, { encoding: 'base64' }],
+        });
+    });
+    it('should handle request errors', async () => {
+        const txBase64 = 'invalid-transaction';
+        const error = new Error('RPC Error');
+        vi.mocked(mockClient.request).mockRejectedValue(error);
+        await expect(simulateTransaction(mockClient, txBase64)).rejects.toThrow('RPC Error');
+    });
+});

package/dist/esm/providers/solana/actions/switchCluster.d.ts

@@ -0,0 +1,10 @@
+import type { ExtendedViemClient } from '../../../client.js';
+import type { Provider } from '../transports/index.js';
+/**
+ * Switches the active cluster endpoint for Solana operations
+ *
+ * @param client - Extended Viem client
+ * @param clusterName - Cluster name to switch to
+ * @returns Promise resolving to the new RPC client
+ */
+export declare function switchCluster(client: ExtendedViemClient, clusterName: Parameters<Provider['sol_switchCluster']>[0]): Promise<import("@solana/rpc-spec").Rpc<import("@solana/rpc-api").GetAccountInfoApi & import("@solana/rpc-api").GetBalanceApi & import("@solana/rpc-api").GetBlockApi & import("@solana/rpc-api").GetBlockCommitmentApi & import("@solana/rpc-api").GetBlockHeightApi & import("@solana/rpc-api").GetBlockProductionApi & import("@solana/rpc-api").GetBlocksApi & import("@solana/rpc-api").GetBlocksWithLimitApi & import("@solana/rpc-api").GetBlockTimeApi & import("@solana/rpc-api").GetClusterNodesApi & import("@solana/rpc-api").GetEpochInfoApi & import("@solana/rpc-api").GetEpochScheduleApi & import("@solana/rpc-api").GetFeeForMessageApi & import("@solana/rpc-api").GetFirstAvailableBlockApi & import("@solana/rpc-api").GetGenesisHashApi & import("@solana/rpc-api").GetHealthApi & import("@solana/rpc-api").GetHighestSnapshotSlotApi & import("@solana/rpc-api").GetIdentityApi & import("@solana/rpc-api").GetInflationGovernorApi & import("@solana/rpc-api").GetInflationRateApi & import("@solana/rpc-api").GetInflationRewardApi & import("@solana/rpc-api").GetLargestAccountsApi & import("@solana/rpc-api").GetLatestBlockhashApi & import("@solana/rpc-api").GetLeaderScheduleApi & import("@solana/rpc-api").GetMaxRetransmitSlotApi & import("@solana/rpc-api").GetMaxShredInsertSlotApi & import("@solana/rpc-api").GetMinimumBalanceForRentExemptionApi & import("@solana/rpc-api").GetMultipleAccountsApi & import("@solana/rpc-api").GetProgramAccountsApi & import("@solana/rpc-api").GetRecentPerformanceSamplesApi & import("@solana/rpc-api").GetRecentPrioritizationFeesApi & import("@solana/rpc-api").GetSignaturesForAddressApi & import("@solana/rpc-api").GetSignatureStatusesApi & import("@solana/rpc-api").GetSlotApi & import("@solana/rpc-api").GetSlotLeaderApi & import("@solana/rpc-api").GetSlotLeadersApi & import("@solana/rpc-api").GetStakeMinimumDelegationApi & import("@solana/rpc-api").GetSupplyApi & import("@solana/rpc-api").GetTokenAccountBalanceApi & import("@solana/rpc-api").GetTokenAccountsByDelegateApi & import("@solana/rpc-api").GetTokenAccountsByOwnerApi & import("@solana/rpc-api").GetTokenLargestAccountsApi & import("@solana/rpc-api").GetTokenSupplyApi & import("@solana/rpc-api").GetTransactionApi & import("@solana/rpc-api").GetTransactionCountApi & import("@solana/rpc-api").GetVersionApi & import("@solana/rpc-api").GetVoteAccountsApi & import("@solana/rpc-api").IsBlockhashValidApi & import("@solana/rpc-api").MinimumLedgerSlotApi & import("@solana/rpc-api").SendTransactionApi & import("@solana/rpc-api").SimulateTransactionApi>>;

package/dist/esm/providers/solana/actions/switchCluster.js

@@ -0,0 +1,23 @@
+// 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.
+/**
+ * Switches the active cluster endpoint for Solana operations
+ *
+ * @param client - Extended Viem client
+ * @param clusterName - Cluster name to switch to
+ * @returns Promise resolving to the new RPC client
+ */
+export async function switchCluster(client, clusterName) {
+    return await client.request({
+        method: 'sol_switchCluster',
+        params: [clusterName],
+    });
+}

package/dist/esm/providers/solana/actions/switchCluster.test.d.ts

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

package/dist/esm/providers/solana/actions/switchCluster.test.js

@@ -0,0 +1,31 @@
+// 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 { describe, expect, it, vi, beforeEach } from 'vitest';
+import { switchCluster } from './switchCluster.js';
+describe('switchCluster', () => {
+    const mockClient = {
+        request: vi.fn(),
+    };
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    it('should forward all parameters to client.request', async () => {
+        const clusterName = 'mainnet-beta';
+        const mockResponse = {};
+        vi.mocked(mockClient.request).mockResolvedValue(mockResponse);
+        const result = await switchCluster(mockClient, clusterName);
+        expect(mockClient.request).toHaveBeenCalledWith({
+            method: 'sol_switchCluster',
+            params: [clusterName],
+        });
+        expect(result).toBe(mockResponse);
+    });
+});

package/dist/esm/providers/solana/constants.d.ts

@@ -0,0 +1,6 @@
+export { TOKEN_PROGRAM_ADDRESS, ASSOCIATED_TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
+export { TOKEN_2022_PROGRAM_ADDRESS } from '@solana-program/token-2022';
+/** Address of the special mint for wrapped native SOL in spl-token */
+export declare const NATIVE_MINT_ADDRESS: import("@solana/kit").Address<"So11111111111111111111111111111111111111112">;
+/** Address of the special mint for wrapped native SOL in spl-token-2022 */
+export declare const NATIVE_MINT_2022_ADDRESS: import("@solana/kit").Address<"9pan9bMn5HatX4EJdBwg9VgCa7Uz5HL8N1m5D3NdXejP">;

package/dist/esm/providers/solana/constants.js

@@ -0,0 +1,17 @@
+// 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 { address } from '@solana/kit';
+export { TOKEN_PROGRAM_ADDRESS, ASSOCIATED_TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
+export { TOKEN_2022_PROGRAM_ADDRESS } from '@solana-program/token-2022';
+/** Address of the special mint for wrapped native SOL in spl-token */
+export const NATIVE_MINT_ADDRESS = address('So11111111111111111111111111111111111111112');
+/** Address of the special mint for wrapped native SOL in spl-token-2022 */
+export const NATIVE_MINT_2022_ADDRESS = address('9pan9bMn5HatX4EJdBwg9VgCa7Uz5HL8N1m5D3NdXejP');

package/dist/esm/providers/solana/index.d.ts

@@ -0,0 +1,101 @@
+export declare const NAME = "solana";
+export declare const SUPPORTED_CHAINS: readonly [{
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Solscan";
+            readonly url: "https://solscan.io/";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+        readonly USDC: {
+            readonly address: import("abitype").Address;
+            readonly read: {
+                readonly decimals: () => 6;
+            };
+        };
+        readonly EURC: {
+            readonly address: import("abitype").Address;
+            readonly read: {
+                readonly decimals: () => 6;
+            };
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: number;
+    name: "Solana Mainnet";
+    nativeCurrency: {
+        readonly decimals: 9;
+        readonly name: "Solana";
+        readonly symbol: "SOL";
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://api.mainnet-beta.solana.com"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet?: boolean | undefined | undefined;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    readonly blockchainId: "SOL";
+    readonly blockchainVm: "SVM";
+}, {
+    blockExplorers: {
+        readonly default: {
+            readonly name: "Solscan";
+            readonly url: "https://solscan.io/?cluster=devnet";
+        };
+    };
+    blockTime?: number | undefined | undefined;
+    contracts: {
+        readonly USDC: {
+            readonly address: import("abitype").Address;
+            readonly abi: undefined;
+            readonly read: {
+                readonly decimals: () => 6;
+            };
+        };
+        readonly EURC: {
+            readonly address: import("abitype").Address;
+            readonly read: {
+                readonly decimals: () => 6;
+            };
+        };
+    };
+    ensTlds?: readonly string[] | undefined;
+    id: number;
+    name: "Solana Devnet";
+    nativeCurrency: {
+        readonly decimals: 9;
+        readonly name: "Solana";
+        readonly symbol: "SOL";
+    };
+    experimental_preconfirmationTime?: number | undefined | undefined;
+    rpcUrls: {
+        readonly default: {
+            readonly http: readonly ["https://api.devnet.solana.com"];
+        };
+    };
+    sourceId?: number | undefined | undefined;
+    testnet: true;
+    custom?: Record<string, unknown> | undefined;
+    fees?: import("viem").ChainFees<undefined> | undefined;
+    formatters?: undefined;
+    serializers?: import("viem").ChainSerializers<undefined, import("viem").TransactionSerializable> | undefined;
+    readonly blockchainId: "SOL-DEVNET";
+    readonly blockchainVm: "SVM";
+}];
+export type Chain = (typeof SUPPORTED_CHAINS)[number];
+export declare function extractChain<const chains extends Chain[], chain extends chains[number], chainId extends chain['id']>({ id, }: {
+    id: chainId;
+}): Extract<chain, {
+    id: chainId;
+}>;
+export * from './actions/index.js';
+export * from './constants.js';
+export * from './transports/index.js';
+export * from './utils/index.js';

package/dist/esm/providers/solana/index.js

@@ -0,0 +1,21 @@
+// 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 { SOL, SOL_DEVNET } from '../../chains/index.js';
+import { extractChain as _extractChain } from '../../extractChain.js';
+export const NAME = 'solana';
+export const SUPPORTED_CHAINS = [SOL, SOL_DEVNET];
+export function extractChain({ id, }) {
+    return _extractChain({ id, chains: SUPPORTED_CHAINS });
+}
+export * from './actions/index.js';
+export * from './constants.js';
+export * from './transports/index.js';
+export * from './utils/index.js';

package/dist/esm/providers/solana/index.test.d.ts

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

package/dist/esm/providers/solana/index.test.js

@@ -0,0 +1,166 @@
+// 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 { beforeEach, describe, expect, it, vi } from 'vitest';
+import { SOL, SOL_DEVNET } from '../../chains/index.js';
+import { extractChain as _extractChain } from '../../extractChain.js';
+import * as solanaIndex from './index.js';
+import { NAME, SUPPORTED_CHAINS, extractChain } from './index.js';
+// Mock the extractChain dependency
+vi.mock('../../extractChain.js', () => ({
+    extractChain: vi.fn(),
+}));
+const mockedExtractChain = vi.mocked(_extractChain);
+describe('providers/solana/index', () => {
+    describe('constants', () => {
+        it('should export NAME as "solana"', () => {
+            expect(NAME).toBe('solana');
+            expect(NAME).toEqual(expect.any(String));
+        });
+        it('should export SUPPORTED_CHAINS with correct chains', () => {
+            expect(SUPPORTED_CHAINS).toEqual([SOL, SOL_DEVNET]);
+            expect(SUPPORTED_CHAINS).toHaveLength(2);
+            expect(SUPPORTED_CHAINS).toContain(SOL);
+            expect(SUPPORTED_CHAINS).toContain(SOL_DEVNET);
+        });
+        it('should have SUPPORTED_CHAINS as readonly array', () => {
+            expect(Array.isArray(SUPPORTED_CHAINS)).toBe(true);
+            // Test that it's a const assertion (readonly in TypeScript)
+            // Note: TypeScript readonly is compile-time only, runtime behavior is still mutable
+            expect(SUPPORTED_CHAINS).toBeInstanceOf(Array);
+            expect(Object.isFrozen(SUPPORTED_CHAINS)).toBe(false); // It's not frozen at runtime
+            // But we can verify it has the expected type structure
+            expect(SUPPORTED_CHAINS).toEqual(expect.arrayContaining([SOL, SOL_DEVNET]));
+        });
+    });
+    describe('Chain type', () => {
+        it('should have Chain type that matches SUPPORTED_CHAINS elements', () => {
+            // Type test - if this compiles, the type is correct
+            const testChain1 = SOL;
+            const testChain2 = SOL_DEVNET;
+            expect(testChain1).toBe(SOL);
+            expect(testChain2).toBe(SOL_DEVNET);
+        });
+    });
+    describe('extractChain function', () => {
+        beforeEach(() => {
+            vi.clearAllMocks();
+        });
+        it('should call _extractChain with correct parameters', () => {
+            const mockResult = SOL;
+            mockedExtractChain.mockReturnValue(mockResult);
+            const result = extractChain({ id: SOL.id });
+            expect(mockedExtractChain).toHaveBeenCalledWith({
+                id: SOL.id,
+                chains: SUPPORTED_CHAINS,
+            });
+            expect(result).toBe(mockResult);
+        });
+        it('should work with SOL chain id', () => {
+            const mockResult = SOL;
+            mockedExtractChain.mockReturnValue(mockResult);
+            const result = extractChain({ id: SOL.id });
+            expect(mockedExtractChain).toHaveBeenCalledWith({
+                id: SOL.id,
+                chains: SUPPORTED_CHAINS,
+            });
+            expect(result).toBe(mockResult);
+        });
+        it('should work with SOL_DEVNET chain id', () => {
+            const mockResult = SOL_DEVNET;
+            mockedExtractChain.mockReturnValue(mockResult);
+            const result = extractChain({ id: SOL_DEVNET.id });
+            expect(mockedExtractChain).toHaveBeenCalledWith({
+                id: SOL_DEVNET.id,
+                chains: SUPPORTED_CHAINS,
+            });
+            expect(result).toBe(mockResult);
+        });
+        it('should preserve type information for chain extraction', () => {
+            const mockResult = SOL;
+            mockedExtractChain.mockReturnValue(mockResult);
+            // Type test - ensure the function maintains proper generic typing
+            const result = extractChain({ id: SOL.id });
+            // This should compile without issues if types are correct
+            expect(result).toBe(mockResult);
+        });
+    });
+    describe('re-exports', () => {
+        it('should re-export actions', () => {
+            // Test that actions are exported (they come from ./actions/index.js)
+            // We can't test all individual actions easily, but we can test that exports exist
+            expect(typeof solanaIndex).toBe('object');
+            // Check for some known action exports that should be available
+            expect('getAccountInfo' in solanaIndex).toBe(true);
+            expect('getBalance' in solanaIndex).toBe(true);
+            expect('getBlock' in solanaIndex).toBe(true);
+            expect('sendTransaction' in solanaIndex).toBe(true);
+        });
+        it('should re-export transports', () => {
+            // Test that transports are exported (they come from ./transports/index.js)
+            expect('http' in solanaIndex).toBe(true);
+            expect('Provider' in solanaIndex).toBe(true);
+        });
+        it('should re-export utils', () => {
+            // Test that utils are exported (they come from ./utils/index.js)
+            expect('toBase64EncodedWireTransaction' in solanaIndex).toBe(true);
+        });
+        it('should have all expected top-level exports', () => {
+            const expectedExports = [
+                'NAME',
+                'SUPPORTED_CHAINS',
+                'extractChain',
+                // From actions
+                'getAccountInfo',
+                'getBalance',
+                'getBlock',
+                'sendTransaction',
+                'actions',
+                // From transports
+                'http',
+                'Provider',
+                // From utils
+                'toBase64EncodedWireTransaction',
+            ];
+            expectedExports.forEach((exportName) => {
+                expect(exportName in solanaIndex).toBe(true);
+            });
+        });
+    });
+    describe('module structure', () => {
+        it('should export the correct number of items', () => {
+            const exports = Object.keys(solanaIndex);
+            // Should have our main exports plus all re-exports
+            expect(exports.length).toBeGreaterThan(50); // Many actions + transports + utils + main exports
+            expect(exports).toContain('NAME');
+            expect(exports).toContain('SUPPORTED_CHAINS');
+            expect(exports).toContain('extractChain');
+        });
+        it('should not export any undefined values', () => {
+            Object.values(solanaIndex).forEach((exportValue) => {
+                expect(exportValue).toBeDefined();
+            });
+        });
+    });
+    describe('integration', () => {
+        it('should work with the actual chain definitions', () => {
+            // Test with real chain objects to ensure integration works
+            expect(SOL.id).toBeDefined();
+            expect(SOL_DEVNET.id).toBeDefined();
+            expect(SOL.name).toBe('Solana Mainnet');
+            expect(SOL_DEVNET.name).toBe('Solana Devnet');
+        });
+        it('should maintain consistency between supported chains and imports', () => {
+            // Ensure SUPPORTED_CHAINS contains the exact same objects as imported
+            expect(SUPPORTED_CHAINS[0]).toBe(SOL);
+            expect(SUPPORTED_CHAINS[1]).toBe(SOL_DEVNET);
+        });
+    });
+});

package/dist/esm/providers/solana/transports/http.d.ts

@@ -0,0 +1,8 @@
+import type { SolanaRpc } from '../index.js';
+export declare function http({ clusters, name, }: {
+    clusters?: {
+        devnet?: SolanaRpc;
+        'mainnet-beta'?: SolanaRpc;
+    };
+    name?: string;
+}): import("viem").CustomTransport;

package/dist/esm/providers/solana/transports/http.js

@@ -0,0 +1,17 @@
+// 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 { custom } from 'viem';
+import { NAME, Provider } from '../index.js';
+export function http({ clusters, name = NAME, }) {
+    const provider = new Provider({ clusters });
+    const config = { name, key: name };
+    return custom(provider, config);
+}

package/dist/esm/providers/solana/transports/http.test.d.ts

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

package/dist/esm/providers/solana/transports/http.test.js

@@ -0,0 +1,86 @@
+// 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 { createSolanaRpc } from '@solana/kit';
+import { custom } from 'viem';
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { Provider } from '../index.js';
+import { http } from './http.js';
+// Mock viem's custom function
+vi.mock('viem', () => ({
+    custom: vi.fn((provider, config) => ({
+        provider,
+        config,
+        type: 'custom',
+    })),
+}));
+// Mock the Provider class
+vi.mock('../index.js', () => ({
+    Provider: vi.fn((config) => ({
+        config,
+        mockProvider: true,
+    })),
+    NAME: 'solana',
+}));
+describe.concurrent('http transport', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    it('should be exported', () => {
+        expect(http).toBeDefined();
+        expect(http).toEqual(expect.any(Function));
+    });
+    it('should create Provider with correct parameters', () => {
+        const clusters = { 'mainnet-beta': createSolanaRpc('https://api.mainnet-beta.solana.com') };
+        http({ clusters });
+        expect(Provider).toHaveBeenCalledWith({ clusters });
+    });
+    it('should create Provider with undefined clusters when not provided', () => {
+        http({});
+        expect(Provider).toHaveBeenCalledWith({ clusters: undefined });
+    });
+    it('should call viem custom function with provider and config', () => {
+        const name = 'custom-solana';
+        http({ name });
+        expect(custom).toHaveBeenCalledWith(expect.any(Object), // The provider instance
+        {
+            name: 'custom-solana',
+            key: 'custom-solana',
+        });
+    });
+    it('should use default name when not provided', () => {
+        http({});
+        expect(custom).toHaveBeenCalledWith(expect.any(Object), {
+            name: 'solana',
+            key: 'solana',
+        });
+    });
+    it('should return the result of viem custom function', () => {
+        const mockResult = vi.fn().mockReturnValue({ provider: {}, config: {}, type: 'custom', request: vi.fn() });
+        vi.mocked(custom).mockReturnValue(mockResult);
+        const result = http({});
+        expect(result).toBe(mockResult);
+    });
+    it('should handle both clusters and name parameters', () => {
+        const clusters = { devnet: createSolanaRpc('https://api.testnet.solana.com') };
+        const name = 'testnet-solana';
+        http({ clusters, name });
+        expect(Provider).toHaveBeenCalledWith({ clusters });
+        expect(custom).toHaveBeenCalledWith(expect.any(Object), {
+            name: 'testnet-solana',
+            key: 'testnet-solana',
+        });
+    });
+    it('should handle multiple clusters', () => {
+        const clusters = { 'mainnet-beta': createSolanaRpc('https://api.devnet.solana.com') };
+        http({ clusters });
+        expect(Provider).toHaveBeenCalledWith({ clusters });
+    });
+});