@circle-fin/usdckit 0.21.1 → 0.22.0

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

@@ -0,0 +1,200 @@
+// 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 { http } from './http.js';
+import { createSolanaRpc } from '@solana/kit';
+import { raise } from '../../../utils/raise.js';
+import { Provider as BaseProvider } from '../../index.js';
+/**
+ * Solana Provider that implements EIP-1193 interface for Solana RPC methods
+ *
+ * {@link https://solana.com/docs/rpc/http | Solana JSON-RPC HTTP API Reference}
+ */
+export class Provider extends BaseProvider {
+    _clusters;
+    constructor({ clusters = {
+        devnet: createSolanaRpc('https://api.devnet.solana.com'),
+        'mainnet-beta': createSolanaRpc('https://api.mainnet-beta.solana.com'),
+    }, }) {
+        super();
+        const clustersEntries = Object.entries(clusters);
+        if (clustersEntries.length === 0) {
+            throw new Error('At least one cluster must be provided');
+        }
+        this._clusters = new Map(clustersEntries);
+        this.sol_switchCluster(clustersEntries[0][0]);
+    }
+    sol_getClusterName() {
+        const currentCluster = this.cluster;
+        for (const [id, cluster] of this._clusters.entries()) {
+            if (id !== undefined && cluster === currentCluster)
+                return id;
+        }
+        throw new Error('Cluster not found');
+    }
+    sol_switchCluster(clusterName) {
+        const cluster = this._clusters.get(clusterName) ?? raise(new Error(`Cluster '${clusterName}' not found`));
+        this._clusters.set(undefined, cluster);
+        return cluster;
+    }
+    get cluster() {
+        return this._clusters.get(undefined);
+    }
+    async sol_getAccountInfo(...params) {
+        return await this.cluster.getAccountInfo(...params).send();
+    }
+    async sol_getBalance(...params) {
+        return await this.cluster.getBalance(...params).send();
+    }
+    async sol_getBlock(...params) {
+        return await this.cluster.getBlock(...params).send();
+    }
+    async sol_getBlockCommitment(...params) {
+        return await this.cluster.getBlockCommitment(...params).send();
+    }
+    async sol_getBlockHeight(...params) {
+        return await this.cluster.getBlockHeight(...params).send();
+    }
+    async sol_getBlockProduction(...params) {
+        return await this.cluster.getBlockProduction(...params).send();
+    }
+    async sol_getBlocks(...params) {
+        return await this.cluster.getBlocks(...params).send();
+    }
+    async sol_getBlocksWithLimit(...params) {
+        return await this.cluster.getBlocksWithLimit(...params).send();
+    }
+    async sol_getBlockTime(...params) {
+        return await this.cluster.getBlockTime(...params).send();
+    }
+    async sol_getClusterNodes(...params) {
+        return await this.cluster.getClusterNodes(...params).send();
+    }
+    async sol_getEpochInfo(...params) {
+        return await this.cluster.getEpochInfo(...params).send();
+    }
+    async sol_getEpochSchedule(...params) {
+        return await this.cluster.getEpochSchedule(...params).send();
+    }
+    async sol_getFeeForMessage(...params) {
+        return await this.cluster.getFeeForMessage(...params).send();
+    }
+    async sol_getFirstAvailableBlock(...params) {
+        return await this.cluster.getFirstAvailableBlock(...params).send();
+    }
+    async sol_getGenesisHash(...params) {
+        return await this.cluster.getGenesisHash(...params).send();
+    }
+    async sol_getHealth(...params) {
+        return await this.cluster.getHealth(...params).send();
+    }
+    async sol_getHighestSnapshotSlot(...params) {
+        return await this.cluster.getHighestSnapshotSlot(...params).send();
+    }
+    async sol_getIdentity(...params) {
+        return await this.cluster.getIdentity(...params).send();
+    }
+    async sol_getInflationGovernor(...params) {
+        return await this.cluster.getInflationGovernor(...params).send();
+    }
+    async sol_getInflationRate(...params) {
+        return await this.cluster.getInflationRate(...params).send();
+    }
+    async sol_getInflationReward(...params) {
+        return await this.cluster.getInflationReward(...params).send();
+    }
+    async sol_getLargestAccounts(...params) {
+        return await this.cluster.getLargestAccounts(...params).send();
+    }
+    async sol_getLatestBlockhash(...params) {
+        return await this.cluster.getLatestBlockhash(...params).send();
+    }
+    async sol_getLeaderSchedule(...params) {
+        return await this.cluster.getLeaderSchedule(...params).send();
+    }
+    async sol_getMaxRetransmitSlot(...params) {
+        return await this.cluster.getMaxRetransmitSlot(...params).send();
+    }
+    async sol_getMaxShredInsertSlot(...params) {
+        return await this.cluster.getMaxShredInsertSlot(...params).send();
+    }
+    async sol_getMinimumBalanceForRentExemption(...params) {
+        return await this.cluster.getMinimumBalanceForRentExemption(...params).send();
+    }
+    async sol_getMultipleAccounts(...params) {
+        return await this.cluster.getMultipleAccounts(...params).send();
+    }
+    async sol_getProgramAccounts(...params) {
+        return await this.cluster.getProgramAccounts(...params).send();
+    }
+    async sol_getRecentPerformanceSamples(...params) {
+        return await this.cluster.getRecentPerformanceSamples(...params).send();
+    }
+    async sol_getRecentPrioritizationFees(...params) {
+        return await this.cluster.getRecentPrioritizationFees(...params).send();
+    }
+    async sol_getSignaturesForAddress(...params) {
+        return await this.cluster.getSignaturesForAddress(...params).send();
+    }
+    async sol_getSignatureStatuses(...params) {
+        return await this.cluster.getSignatureStatuses(...params).send();
+    }
+    async sol_getSlot(...params) {
+        return await this.cluster.getSlot(...params).send();
+    }
+    async sol_getSlotLeader(...params) {
+        return await this.cluster.getSlotLeader(...params).send();
+    }
+    async sol_getSlotLeaders(...params) {
+        return await this.cluster.getSlotLeaders(...params).send();
+    }
+    async sol_getSupply(...params) {
+        return await this.cluster.getSupply(...params).send();
+    }
+    async sol_getTokenAccountBalance(...params) {
+        return await this.cluster.getTokenAccountBalance(...params).send();
+    }
+    async sol_getTokenAccountsByDelegate(...params) {
+        return await this.cluster.getTokenAccountsByDelegate(...params).send();
+    }
+    async sol_getTokenAccountsByOwner(...params) {
+        return await this.cluster.getTokenAccountsByOwner(...params).send();
+    }
+    async sol_getTokenLargestAccounts(...params) {
+        return await this.cluster.getTokenLargestAccounts(...params).send();
+    }
+    async sol_getTokenSupply(...params) {
+        return await this.cluster.getTokenSupply(...params).send();
+    }
+    async sol_getTransaction(...params) {
+        return await this.cluster.getTransaction(...params).send();
+    }
+    async sol_getTransactionCount(...params) {
+        return await this.cluster.getTransactionCount(...params).send();
+    }
+    async sol_getVersion(...params) {
+        return await this.cluster.getVersion(...params).send();
+    }
+    async sol_getVoteAccounts(...params) {
+        return await this.cluster.getVoteAccounts(...params).send();
+    }
+    async sol_isBlockhashValid(...params) {
+        return await this.cluster.isBlockhashValid(...params).send();
+    }
+    async sol_minimumLedgerSlot(...params) {
+        return await this.cluster.minimumLedgerSlot(...params).send();
+    }
+    async sol_sendTransaction(...params) {
+        return await this.cluster.sendTransaction(...params).send();
+    }
+    async sol_simulateTransaction(...params) {
+        return await this.cluster.simulateTransaction(...params).send();
+    }
+}

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

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

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

@@ -0,0 +1,272 @@
+// 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, address, signature, blockhash } from '@solana/kit';
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import * as mod from './index.js';
+import { Provider } from './index.js';
+// Mock @solana/kit
+vi.mock('@solana/kit', async (importOriginal) => ({
+    ...(await importOriginal()),
+    createSolanaRpc: vi.fn(() => ({})),
+}));
+describe('solana transports index', () => {
+    beforeEach(() => {
+        vi.resetAllMocks();
+    });
+    it('should export http function', () => {
+        expect(mod.http).toBeDefined();
+        expect(mod.http).toEqual(expect.any(Function));
+    });
+    it('should export Provider class', () => {
+        expect(mod.Provider).toBeDefined();
+        expect(mod.Provider).toEqual(expect.any(Function));
+    });
+    describe('Provider class', () => {
+        it('should be instantiable', () => {
+            const provider = new Provider({});
+            expect(provider).toBeDefined();
+            expect(provider).toBeInstanceOf(Provider);
+        });
+        it('should initialize with default clusters', () => {
+            new Provider({});
+            expect(createSolanaRpc).toHaveBeenCalledWith('https://api.devnet.solana.com');
+            expect(createSolanaRpc).toHaveBeenCalledWith('https://api.mainnet-beta.solana.com');
+            expect(createSolanaRpc).toHaveBeenCalledTimes(2);
+        });
+        it('should initialize with custom clusters', () => {
+            const clusters = {
+                devnet: createSolanaRpc('https://api.devnet.solana.com'),
+                'mainnet-beta': createSolanaRpc('https://api.mainnet-beta.solana.com'),
+            };
+            new Provider({ clusters });
+            expect(createSolanaRpc).toHaveBeenCalledWith('https://api.mainnet-beta.solana.com');
+            expect(createSolanaRpc).toHaveBeenCalledWith('https://api.devnet.solana.com');
+            expect(createSolanaRpc).toHaveBeenCalledTimes(2);
+        });
+        it('should initialize with single cluster', () => {
+            const clusters = {
+                'mainnet-beta': createSolanaRpc('https://api.mainnet-beta.solana.com'),
+            };
+            new Provider({ clusters });
+            expect(createSolanaRpc).toHaveBeenCalledWith('https://api.mainnet-beta.solana.com');
+            expect(createSolanaRpc).toHaveBeenCalledTimes(1);
+        });
+        describe('Cluster switching', () => {
+            it('should switch to devnet cluster', async () => {
+                const devnetRpc = createSolanaRpc('https://api.devnet.solana.com');
+                const mainnetRpc = createSolanaRpc('https://api.mainnet-beta.solana.com');
+                const provider = new Provider({
+                    clusters: {
+                        devnet: devnetRpc,
+                        'mainnet-beta': mainnetRpc,
+                    },
+                });
+                const result = await provider.request({ method: 'sol_switchCluster', params: ['devnet'] });
+                expect(result).toBe(devnetRpc);
+            });
+            it('should switch to mainnet-beta cluster', async () => {
+                const devnetRpc = createSolanaRpc('https://api.devnet.solana.com');
+                const mainnetRpc = createSolanaRpc('https://api.mainnet-beta.solana.com');
+                const provider = new Provider({
+                    clusters: {
+                        devnet: devnetRpc,
+                        'mainnet-beta': mainnetRpc,
+                    },
+                });
+                const result = await provider.request({ method: 'sol_switchCluster', params: ['mainnet-beta'] });
+                expect(result).toBe(mainnetRpc);
+            });
+            it.each([
+                [
+                    {
+                        devnet: createSolanaRpc('https://api.devnet.solana.com'),
+                    },
+                    'mainnet-beta',
+                ],
+                [
+                    {
+                        'mainnet-beta': createSolanaRpc('https://api.mainnet-beta.solana.com'),
+                    },
+                    'devnet',
+                ],
+            ])('should throw error when switching to non-existent cluster (%s)', async (clusters, targetCluster) => {
+                const provider = new Provider({ clusters });
+                await expect(provider.request({ method: 'sol_switchCluster', params: [targetCluster] })).rejects.toThrow(`Cluster '${targetCluster}' not found`);
+            });
+            it('should return current cluster name', async () => {
+                const devnetRpc = createSolanaRpc('https://api.devnet.solana.com');
+                const mainnetRpc = createSolanaRpc('https://api.mainnet-beta.solana.com');
+                const provider = new Provider({
+                    clusters: {
+                        devnet: devnetRpc,
+                        'mainnet-beta': mainnetRpc,
+                    },
+                });
+                // Initially should be the first cluster (devnet)
+                expect(await provider.request({ method: 'sol_getClusterName', params: [] })).toBe('devnet');
+                // Switch to mainnet and verify
+                await provider.request({ method: 'sol_switchCluster', params: ['mainnet-beta'] });
+                expect(await provider.request({ method: 'sol_getClusterName', params: [] })).toBe('mainnet-beta');
+            });
+        });
+        it.each([
+            [
+                'sol_getAccountInfo',
+                'getAccountInfo',
+                [address('SysvarC1ock11111111111111111111111111111111')],
+                { owner: 'test', lamports: 1000 },
+            ],
+            ['sol_getBalance', 'getBalance', [address('SysvarC1ock11111111111111111111111111111111')], { value: 1000000000 }],
+            [
+                'sol_sendTransaction',
+                'sendTransaction',
+                ['encoded-transaction'],
+                'transaction-signature',
+            ],
+            ['sol_getVersion', 'getVersion', [], { 'solana-core': '1.16.0' }],
+            [
+                'sol_simulateTransaction',
+                'simulateTransaction',
+                ['encoded-transaction', {}],
+                { err: null, logs: [], unitsConsumed: 5000 },
+            ],
+            ['sol_getBlockHeight', 'getBlockHeight', [], 54321],
+            ['sol_getBlockProduction', 'getBlockProduction', [], { byIdentity: {} }],
+            ['sol_getClusterNodes', 'getClusterNodes', [], []],
+            ['sol_getEpochInfo', 'getEpochInfo', [], { epoch: 123 }],
+            ['sol_getEpochSchedule', 'getEpochSchedule', [], { slotsPerEpoch: 432000 }],
+            ['sol_getFirstAvailableBlock', 'getFirstAvailableBlock', [], 1],
+            ['sol_getGenesisHash', 'getGenesisHash', [], 'genesis-hash'],
+            ['sol_getHealth', 'getHealth', [], 'ok'],
+            ['sol_getHighestSnapshotSlot', 'getHighestSnapshotSlot', [], { full: 12345 }],
+            ['sol_getIdentity', 'getIdentity', [], { identity: 'node-identity' }],
+            ['sol_getInflationGovernor', 'getInflationGovernor', [], { initial: 0.15 }],
+            ['sol_getInflationRate', 'getInflationRate', [], { total: 0.08 }],
+            ['sol_getLargestAccounts', 'getLargestAccounts', [], { value: [] }],
+            ['sol_getLatestBlockhash', 'getLatestBlockhash', [], { value: { blockhash: 'latest-hash' } }],
+            ['sol_getLeaderSchedule', 'getLeaderSchedule', [], {}],
+            ['sol_getMaxRetransmitSlot', 'getMaxRetransmitSlot', [], 12345],
+            ['sol_getMaxShredInsertSlot', 'getMaxShredInsertSlot', [], 12346],
+            ['sol_getRecentPerformanceSamples', 'getRecentPerformanceSamples', [], []],
+            ['sol_getRecentPrioritizationFees', 'getRecentPrioritizationFees', [], []],
+            ['sol_getSlot', 'getSlot', [], 12345],
+            ['sol_getSlotLeader', 'getSlotLeader', [], 'slot-leader'],
+            ['sol_getSupply', 'getSupply', [], { value: { total: 1000000000 } }],
+            ['sol_getTransactionCount', 'getTransactionCount', [], 54321],
+            ['sol_getVoteAccounts', 'getVoteAccounts', [], { current: [], delinquent: [] }],
+            ['sol_minimumLedgerSlot', 'minimumLedgerSlot', [], 1],
+            ['sol_getBlock', 'getBlock', [12345n], { slot: 12345 }],
+            ['sol_getBlockCommitment', 'getBlockCommitment', [12345n], { commitment: [10, 15, 20] }],
+            ['sol_getBlockTime', 'getBlockTime', [12345n], 1234567890],
+            ['sol_getMinimumBalanceForRentExemption', 'getMinimumBalanceForRentExemption', [128n], { value: 890880 }],
+            ['sol_getBlocks', 'getBlocks', [1n, 100n], [1, 2, 3]],
+            ['sol_getBlocksWithLimit', 'getBlocksWithLimit', [1n, 10], [1, 2, 3]],
+            ['sol_getSlotLeaders', 'getSlotLeaders', [1n, 10], []],
+            [
+                'sol_getTokenAccountBalance',
+                'getTokenAccountBalance',
+                [address('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v')],
+                { value: { amount: '1000' } },
+            ],
+            ['sol_getProgramAccounts', 'getProgramAccounts', [address('SysvarC1ock11111111111111111111111111111111')], []],
+            [
+                'sol_getSignaturesForAddress',
+                'getSignaturesForAddress',
+                [address('EvN4kgKmCmYzdbd5kL8Q8YgkUW5RoqMTpBczrfLExtx7')],
+                [],
+            ],
+            [
+                'sol_getTokenLargestAccounts',
+                'getTokenLargestAccounts',
+                [address('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v')],
+                { value: [] },
+            ],
+            [
+                'sol_getTokenSupply',
+                'getTokenSupply',
+                [address('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v')],
+                { value: { amount: '1000000' } },
+            ],
+            [
+                'sol_getInflationReward',
+                'getInflationReward',
+                [[address('EvN4kgKmCmYzdbd5kL8Q8YgkUW5RoqMTpBczrfLExtx7')]],
+                [{ amount: 1000 }],
+            ],
+            [
+                'sol_getMultipleAccounts',
+                'getMultipleAccounts',
+                [[address('EvN4kgKmCmYzdbd5kL8Q8YgkUW5RoqMTpBczrfLExtx7')]],
+                { value: [] },
+            ],
+            [
+                'sol_getSignatureStatuses',
+                'getSignatureStatuses',
+                [[signature('5uP3hpCqaGKrzJzGgQ9oAhcLmqjrHWLZBZRzNGJCFhJnHJjhDDkVMvFvLPWmKYPL5Yjds1VLwFbCPfz7hKvdLLXu')]],
+                { value: [] },
+            ],
+            [
+                'sol_getFeeForMessage',
+                'getFeeForMessage',
+                ['encoded-message'],
+                { value: 5000 },
+            ],
+            [
+                'sol_getTokenAccountsByDelegate',
+                'getTokenAccountsByDelegate',
+                [
+                    address('EvN4kgKmCmYzdbd5kL8Q8YgkUW5RoqMTpBczrfLExtx7'),
+                    { mint: address('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v') },
+                ],
+                { value: [] },
+            ],
+            [
+                'sol_getTokenAccountsByOwner',
+                'getTokenAccountsByOwner',
+                [
+                    address('EvN4kgKmCmYzdbd5kL8Q8YgkUW5RoqMTpBczrfLExtx7'),
+                    { mint: address('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v') },
+                ],
+                { value: [] },
+            ],
+            [
+                'sol_getTransaction',
+                'getTransaction',
+                [signature('5uP3hpCqaGKrzJzGgQ9oAhcLmqjrHWLZBZRzNGJCFhJnHJjhDDkVMvFvLPWmKYPL5Yjds1VLwFbCPfz7hKvdLLXu')],
+                { slot: 12345 },
+            ],
+            [
+                'sol_isBlockhashValid',
+                'isBlockhashValid',
+                [blockhash('5eykt4UsFv8P8NJdTREpY1vzqKqZKvdpKuc147dw2N9d')],
+                { value: true },
+            ],
+        ])('should implement %s', async (method, solRpcMethodName, params, expected) => {
+            const solRpcMethod = vi.fn(() => ({ send: vi.fn(() => expected) }));
+            vi.mocked(createSolanaRpc).mockReturnValue({ [solRpcMethodName]: solRpcMethod });
+            const testProvider = new Provider({});
+            const result = await testProvider.request({ method, params: [...params] });
+            expect(solRpcMethod).toHaveBeenCalledWith(...params);
+            expect(result).toEqual(expected);
+        });
+        it('should throw error when clusters object is empty', () => {
+            expect(() => new Provider({ clusters: {} })).toThrow();
+        });
+        it.each([
+            ['devnet', 'https://custom-devnet.solana.com'],
+            ['mainnet-beta', 'https://custom-mainnet.solana.com'],
+        ])('should handle clusters with only %s', async (expectedClusterId, url) => {
+            const clusters = { [expectedClusterId]: createSolanaRpc(url) };
+            const provider = new Provider({ clusters });
+            expect(await provider.request({ method: 'sol_getClusterName', params: [] })).toBe(expectedClusterId);
+        });
+    });
+});

package/dist/esm/providers/solana/utils/codecs.d.ts

@@ -0,0 +1,4 @@
+export declare const bytesToBase58: (bytes: import("@solana/kit").ReadonlyUint8Array | Uint8Array, offset?: import("@solana/kit").Offset) => string;
+export declare const bytesToBase64: (bytes: import("@solana/kit").ReadonlyUint8Array | Uint8Array, offset?: import("@solana/kit").Offset) => string;
+export declare const base58ToBytes: (value: string) => import("@solana/kit").ReadonlyUint8Array;
+export declare const base64ToBytes: (value: string) => import("@solana/kit").ReadonlyUint8Array;

package/dist/esm/providers/solana/utils/codecs.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 { getBase58Codec, getBase64Codec } from '@solana/kit';
+const base58 = getBase58Codec();
+const base64 = getBase64Codec();
+export const bytesToBase58 = base58.decode;
+export const bytesToBase64 = base64.decode;
+export const base58ToBytes = base58.encode;
+export const base64ToBytes = base64.encode;

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

@@ -0,0 +1,2 @@
+export * from './codecs.js';
+export { toBase64EncodedWireTransaction } from './toBase64EncodedWireTransaction.js';

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

@@ -0,0 +1,12 @@
+// 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 * from './codecs.js';
+export { toBase64EncodedWireTransaction } from './toBase64EncodedWireTransaction.js';

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

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

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

@@ -0,0 +1,18 @@
+// 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 } from 'vitest';
+import { toBase64EncodedWireTransaction } from './toBase64EncodedWireTransaction.js';
+import * as utils from './index.js';
+describe('index', () => {
+    it.each([toBase64EncodedWireTransaction])('should export %s as a function', (fn) => {
+        expect(utils[fn.name]).toBe(fn);
+    });
+});

package/dist/esm/providers/solana/utils/toBase64EncodedWireTransaction.d.ts

@@ -0,0 +1,26 @@
+import type { Base64EncodedWireTransaction } from '@solana/kit';
+/**
+ * Converts various transaction formats to a Base64-encoded wire transaction.
+ *
+ * This utility function handles the conversion of different transaction input types
+ * (Buffer, string, or already encoded Base64EncodedWireTransaction) into a consistent
+ * Base64EncodedWireTransaction format that can be used with Solana RPC methods.
+ *
+ * @param tx - The transaction to convert. Can be:
+ *   - Buffer: Raw transaction bytes that will be converted to base64
+ *   - string: Already base64-encoded transaction string
+ *   - Base64EncodedWireTransaction: Already properly typed, returned as-is
+ * @returns Base64-encoded wire transaction ready for RPC submission
+ *
+ * @example
+ * ```typescript
+ * // Convert Buffer to base64
+ * const txBuffer = Buffer.from([1, 2, 3]);
+ * const base64Tx = toBase64EncodedWireTransaction(txBuffer);
+ *
+ * // Pass through already encoded string
+ * const encodedTx = "SGVsbG8gV29ybGQ=";
+ * const result = toBase64EncodedWireTransaction(encodedTx);
+ * ```
+ */
+export declare function toBase64EncodedWireTransaction(tx: string | Buffer | Base64EncodedWireTransaction): Base64EncodedWireTransaction;

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

@@ -0,0 +1,39 @@
+// 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.
+/**
+ * Converts various transaction formats to a Base64-encoded wire transaction.
+ *
+ * This utility function handles the conversion of different transaction input types
+ * (Buffer, string, or already encoded Base64EncodedWireTransaction) into a consistent
+ * Base64EncodedWireTransaction format that can be used with Solana RPC methods.
+ *
+ * @param tx - The transaction to convert. Can be:
+ *   - Buffer: Raw transaction bytes that will be converted to base64
+ *   - string: Already base64-encoded transaction string
+ *   - Base64EncodedWireTransaction: Already properly typed, returned as-is
+ * @returns Base64-encoded wire transaction ready for RPC submission
+ *
+ * @example
+ * ```typescript
+ * // Convert Buffer to base64
+ * const txBuffer = Buffer.from([1, 2, 3]);
+ * const base64Tx = toBase64EncodedWireTransaction(txBuffer);
+ *
+ * // Pass through already encoded string
+ * const encodedTx = "SGVsbG8gV29ybGQ=";
+ * const result = toBase64EncodedWireTransaction(encodedTx);
+ * ```
+ */
+export function toBase64EncodedWireTransaction(tx) {
+    if (tx instanceof Buffer)
+        tx = tx.toString('base64');
+    return tx;
+}

package/dist/esm/providers/solana/utils/toBase64EncodedWireTransaction.test.d.ts

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