@solana/kit 6.3.1 → 6.3.2-canary-20260313143218

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana/kit",
-  "version": "6.3.1",
+  "version": "6.3.2-canary-20260313143218",
   "description": "Solana Javascript API",
   "homepage": "https://www.solanakit.com",
   "exports": {
@@ -60,7 +60,8 @@
   "types": "./dist/types/index.d.ts",
   "type": "commonjs",
   "files": [
-    "./dist/"
+    "./dist/",
+    "./src/"
   ],
   "sideEffects": false,
   "keywords": [
@@ -82,30 +83,30 @@
     "maintained node versions"
   ],
   "dependencies": {
-    "@solana/accounts": "6.3.1",
-    "@solana/addresses": "6.3.1",
-    "@solana/codecs": "6.3.1",
-    "@solana/errors": "6.3.1",
-    "@solana/functional": "6.3.1",
-    "@solana/instruction-plans": "6.3.1",
-    "@solana/instructions": "6.3.1",
-    "@solana/keys": "6.3.1",
-    "@solana/offchain-messages": "6.3.1",
-    "@solana/plugin-interfaces": "6.3.1",
-    "@solana/plugin-core": "6.3.1",
-    "@solana/program-client-core": "6.3.1",
-    "@solana/programs": "6.3.1",
-    "@solana/rpc": "6.3.1",
-    "@solana/rpc-parsed-types": "6.3.1",
-    "@solana/rpc-spec-types": "6.3.1",
-    "@solana/rpc-subscriptions": "6.3.1",
-    "@solana/rpc-api": "6.3.1",
-    "@solana/rpc-types": "6.3.1",
-    "@solana/signers": "6.3.1",
-    "@solana/sysvars": "6.3.1",
-    "@solana/transaction-confirmation": "6.3.1",
-    "@solana/transaction-messages": "6.3.1",
-    "@solana/transactions": "6.3.1"
+    "@solana/accounts": "6.3.2-canary-20260313143218",
+    "@solana/addresses": "6.3.2-canary-20260313143218",
+    "@solana/errors": "6.3.2-canary-20260313143218",
+    "@solana/functional": "6.3.2-canary-20260313143218",
+    "@solana/codecs": "6.3.2-canary-20260313143218",
+    "@solana/instructions": "6.3.2-canary-20260313143218",
+    "@solana/instruction-plans": "6.3.2-canary-20260313143218",
+    "@solana/offchain-messages": "6.3.2-canary-20260313143218",
+    "@solana/plugin-core": "6.3.2-canary-20260313143218",
+    "@solana/plugin-interfaces": "6.3.2-canary-20260313143218",
+    "@solana/keys": "6.3.2-canary-20260313143218",
+    "@solana/program-client-core": "6.3.2-canary-20260313143218",
+    "@solana/programs": "6.3.2-canary-20260313143218",
+    "@solana/rpc-api": "6.3.2-canary-20260313143218",
+    "@solana/rpc-parsed-types": "6.3.2-canary-20260313143218",
+    "@solana/rpc-spec-types": "6.3.2-canary-20260313143218",
+    "@solana/rpc-subscriptions": "6.3.2-canary-20260313143218",
+    "@solana/rpc-types": "6.3.2-canary-20260313143218",
+    "@solana/signers": "6.3.2-canary-20260313143218",
+    "@solana/sysvars": "6.3.2-canary-20260313143218",
+    "@solana/rpc": "6.3.2-canary-20260313143218",
+    "@solana/transaction-confirmation": "6.3.2-canary-20260313143218",
+    "@solana/transaction-messages": "6.3.2-canary-20260313143218",
+    "@solana/transactions": "6.3.2-canary-20260313143218"
   },
   "peerDependencies": {
     "typescript": "^5.0.0"

package/src/airdrop-internal.ts

@@ -0,0 +1,38 @@
+import type { Address } from '@solana/addresses';
+import type { Signature } from '@solana/keys';
+import type { RequestAirdropApi, Rpc } from '@solana/rpc';
+import type { Commitment, Lamports } from '@solana/rpc-types';
+import { waitForRecentTransactionConfirmationUntilTimeout } from '@solana/transaction-confirmation';
+
+type RequestAndConfirmAirdropConfig = Readonly<{
+    abortSignal?: AbortSignal;
+    commitment: Commitment;
+    confirmSignatureOnlyTransaction: (
+        config: Omit<
+            Parameters<typeof waitForRecentTransactionConfirmationUntilTimeout>[0],
+            'getRecentSignatureConfirmationPromise' | 'getTimeoutPromise'
+        >,
+    ) => Promise<void>;
+    lamports: Lamports;
+    recipientAddress: Address;
+    rpc: Rpc<RequestAirdropApi>;
+}>;
+
+export async function requestAndConfirmAirdrop_INTERNAL_ONLY_DO_NOT_EXPORT({
+    abortSignal,
+    commitment,
+    confirmSignatureOnlyTransaction,
+    lamports,
+    recipientAddress,
+    rpc,
+}: RequestAndConfirmAirdropConfig): Promise<Signature> {
+    const airdropTransactionSignature = await rpc
+        .requestAirdrop(recipientAddress, lamports, { commitment })
+        .send({ abortSignal });
+    await confirmSignatureOnlyTransaction({
+        abortSignal,
+        commitment,
+        signature: airdropTransactionSignature,
+    });
+    return airdropTransactionSignature;
+}

package/src/airdrop.ts

@@ -0,0 +1,80 @@
+import type { Signature } from '@solana/keys';
+import type { GetSignatureStatusesApi, RequestAirdropApi, Rpc } from '@solana/rpc';
+import type { RpcSubscriptions, SignatureNotificationsApi } from '@solana/rpc-subscriptions';
+import {
+    createRecentSignatureConfirmationPromiseFactory,
+    getTimeoutPromise,
+    waitForRecentTransactionConfirmationUntilTimeout,
+} from '@solana/transaction-confirmation';
+
+import { requestAndConfirmAirdrop_INTERNAL_ONLY_DO_NOT_EXPORT } from './airdrop-internal';
+
+type AirdropFunction = (
+    config: Omit<
+        Parameters<typeof requestAndConfirmAirdrop_INTERNAL_ONLY_DO_NOT_EXPORT>[0],
+        'confirmSignatureOnlyTransaction' | 'rpc'
+    >,
+) => Promise<Signature>;
+
+type AirdropFactoryConfig<TCluster> = {
+    /** An object that supports the {@link GetSignatureStatusesApi} and the {@link RequestAirdropApi} of the Solana RPC API */
+    rpc: Rpc<GetSignatureStatusesApi & RequestAirdropApi> & { '~cluster'?: TCluster };
+    /** An object that supports the {@link SignatureNotificationsApi} of the Solana RPC Subscriptions API */
+    rpcSubscriptions: RpcSubscriptions<SignatureNotificationsApi> & { '~cluster'?: TCluster };
+};
+
+/**
+ * Returns a function that you can call to airdrop a certain amount of {@link Lamports} to a Solana
+ * address.
+ *
+ * > [!NOTE] This only works on test clusters.
+ *
+ * @param config
+ *
+ * @example
+ * ```ts
+ * import { address, airdropFactory, createSolanaRpc, createSolanaRpcSubscriptions, devnet, lamports } from '@solana/kit';
+ *
+ * const rpc = createSolanaRpc(devnet('http://127.0.0.1:8899'));
+ * const rpcSubscriptions = createSolanaRpcSubscriptions(devnet('ws://127.0.0.1:8900'));
+ *
+ * const airdrop = airdropFactory({ rpc, rpcSubscriptions });
+ *
+ * await airdrop({
+ *     commitment: 'confirmed',
+ *     recipientAddress: address('FnHyam9w4NZoWR6mKN1CuGBritdsEWZQa4Z4oawLZGxa'),
+ *     lamports: lamports(10_000_000n),
+ * });
+ * ```
+ */
+export function airdropFactory({ rpc, rpcSubscriptions }: AirdropFactoryConfig<'devnet'>): AirdropFunction;
+export function airdropFactory({ rpc, rpcSubscriptions }: AirdropFactoryConfig<'mainnet'>): AirdropFunction;
+export function airdropFactory({ rpc, rpcSubscriptions }: AirdropFactoryConfig<'testnet'>): AirdropFunction;
+export function airdropFactory<TCluster extends 'devnet' | 'mainnet' | 'testnet' | void = void>({
+    rpc,
+    rpcSubscriptions,
+}: AirdropFactoryConfig<TCluster>): AirdropFunction {
+    const getRecentSignatureConfirmationPromise = createRecentSignatureConfirmationPromiseFactory({
+        rpc,
+        rpcSubscriptions,
+    } as Parameters<typeof createRecentSignatureConfirmationPromiseFactory>[0]);
+    async function confirmSignatureOnlyTransaction(
+        config: Omit<
+            Parameters<typeof waitForRecentTransactionConfirmationUntilTimeout>[0],
+            'getRecentSignatureConfirmationPromise' | 'getTimeoutPromise'
+        >,
+    ) {
+        await waitForRecentTransactionConfirmationUntilTimeout({
+            ...config,
+            getRecentSignatureConfirmationPromise,
+            getTimeoutPromise,
+        });
+    }
+    return async function airdrop(config) {
+        return await requestAndConfirmAirdrop_INTERNAL_ONLY_DO_NOT_EXPORT({
+            ...config,
+            confirmSignatureOnlyTransaction,
+            rpc,
+        });
+    };
+}

package/src/decompile-transaction-message-fetching-lookup-tables.ts

@@ -0,0 +1,50 @@
+import { type FetchAccountsConfig } from '@solana/accounts';
+import type { GetMultipleAccountsApi, Rpc } from '@solana/rpc';
+import {
+    CompiledTransactionMessage,
+    CompiledTransactionMessageWithLifetime,
+    decompileTransactionMessage,
+    TransactionMessage,
+    TransactionMessageWithFeePayer,
+    TransactionMessageWithLifetime,
+} from '@solana/transaction-messages';
+
+import { fetchAddressesForLookupTables } from './fetch-lookup-tables';
+
+type DecompileTransactionMessageFetchingLookupTablesConfig = FetchAccountsConfig & {
+    lastValidBlockHeight?: bigint;
+};
+
+/**
+ * Returns a {@link TransactionMessage} from a {@link CompiledTransactionMessage}. If any of the
+ * accounts in the compiled message require an address lookup table to find their address, this
+ * function will use the supplied RPC instance to fetch the contents of the address lookup table
+ * from the network.
+ *
+ * @param rpc An object that supports the {@link GetMultipleAccountsApi} of the Solana RPC API
+ * @param config
+ */
+export async function decompileTransactionMessageFetchingLookupTables(
+    compiledTransactionMessage: CompiledTransactionMessage & CompiledTransactionMessageWithLifetime,
+    rpc: Rpc<GetMultipleAccountsApi>,
+    config?: DecompileTransactionMessageFetchingLookupTablesConfig,
+): Promise<TransactionMessage & TransactionMessageWithFeePayer & TransactionMessageWithLifetime> {
+    const lookupTables =
+        'addressTableLookups' in compiledTransactionMessage &&
+        compiledTransactionMessage.addressTableLookups !== undefined &&
+        compiledTransactionMessage.addressTableLookups.length > 0
+            ? compiledTransactionMessage.addressTableLookups
+            : [];
+    const lookupTableAddresses = lookupTables.map(l => l.lookupTableAddress);
+
+    const { lastValidBlockHeight, ...fetchAccountsConfig } = config ?? {};
+    const addressesByLookupTableAddress =
+        lookupTableAddresses.length > 0
+            ? await fetchAddressesForLookupTables(lookupTableAddresses, rpc, fetchAccountsConfig)
+            : {};
+
+    return decompileTransactionMessage(compiledTransactionMessage, {
+        addressesByLookupTableAddress,
+        lastValidBlockHeight,
+    });
+}

package/src/fetch-lookup-tables.ts

@@ -0,0 +1,46 @@
+import {
+    assertAccountsDecoded,
+    assertAccountsExist,
+    type FetchAccountsConfig,
+    fetchJsonParsedAccounts,
+} from '@solana/accounts';
+import type { Address } from '@solana/addresses';
+import type { GetMultipleAccountsApi, Rpc } from '@solana/rpc';
+import { type AddressesByLookupTableAddress } from '@solana/transaction-messages';
+
+type FetchedAddressLookup = {
+    addresses: Address[];
+};
+
+/**
+ * Given a list of addresses belonging to address lookup tables, returns a map of lookup table
+ * addresses to an ordered array of the addresses they contain.
+ *
+ * @param rpc An object that supports the {@link GetMultipleAccountsApi} of the Solana RPC API
+ * @param config
+ */
+export async function fetchAddressesForLookupTables(
+    lookupTableAddresses: Address[],
+    rpc: Rpc<GetMultipleAccountsApi>,
+    config?: FetchAccountsConfig,
+): Promise<AddressesByLookupTableAddress> {
+    if (lookupTableAddresses.length === 0) {
+        return {};
+    }
+
+    const fetchedLookupTables = await fetchJsonParsedAccounts<FetchedAddressLookup[]>(
+        rpc,
+        lookupTableAddresses,
+        config,
+    );
+
+    assertAccountsDecoded(fetchedLookupTables);
+    assertAccountsExist(fetchedLookupTables);
+
+    return fetchedLookupTables.reduce<AddressesByLookupTableAddress>((acc, lookup) => {
+        return {
+            ...acc,
+            [lookup.address]: lookup.data.addresses,
+        };
+    }, {});
+}

package/src/get-minimum-balance-for-rent-exemption.ts

@@ -0,0 +1,26 @@
+import type { Lamports } from '@solana/rpc-types';
+
+/**
+ * Calculates the minimum {@link Lamports | lamports} required to make an account rent exempt for a
+ * given data size, without performing an RPC call.
+ *
+ * Values are sourced from the on-chain rent parameters in the Solana runtime:
+ * https://github.com/anza-xyz/solana-sdk/blob/c07f692e41d757057c8700211a9300cdcd6d33b1/rent/src/lib.rs#L93-L97
+ *
+ * Note that this logic may change, or be incorrect depending on the cluster you are connected to.
+ * You can always use the RPC method `getMinimumBalanceForRentExemption` to get the current value.
+ *
+ * @param space The number of bytes of account data.
+ */
+export function getMinimumBalanceForRentExemption(space: bigint): Lamports {
+    const RENT = {
+        ACCOUNT_STORAGE_OVERHEAD: 128n,
+        DEFAULT_EXEMPTION_THRESHOLD: 2n,
+        DEFAULT_LAMPORTS_PER_BYTE_YEAR: 3_480n,
+    } as const;
+    const requiredLamports =
+        (RENT.ACCOUNT_STORAGE_OVERHEAD + space) *
+        RENT.DEFAULT_LAMPORTS_PER_BYTE_YEAR *
+        RENT.DEFAULT_EXEMPTION_THRESHOLD;
+    return requiredLamports as Lamports;
+}

package/src/index.ts

@@ -0,0 +1,43 @@
+/**
+ * This is the JavaScript SDK for building Solana apps for Node, web, and React Native.
+ *
+ * In addition to re-exporting functions from packages in the `@solana/*` namespace, this package
+ * offers additional helpers for building Solana applications, with sensible defaults.
+ *
+ * @packageDocumentation
+ */
+export * from '@solana/accounts';
+export * from '@solana/addresses';
+export * from '@solana/codecs';
+export * from '@solana/errors';
+export * from '@solana/functional';
+export * from '@solana/instructions';
+export * from '@solana/instruction-plans';
+export * from '@solana/keys';
+export * from '@solana/offchain-messages';
+export * from '@solana/plugin-core';
+export type * from '@solana/plugin-interfaces';
+export * from '@solana/programs';
+export * from '@solana/rpc';
+export * from '@solana/rpc-parsed-types';
+export * from '@solana/rpc-subscriptions';
+export * from '@solana/rpc-types';
+export * from '@solana/signers';
+export * from '@solana/transaction-messages';
+export * from '@solana/transactions';
+export * from './airdrop';
+export * from './decompile-transaction-message-fetching-lookup-tables';
+export * from './fetch-lookup-tables';
+export * from './get-minimum-balance-for-rent-exemption';
+export * from './send-and-confirm-durable-nonce-transaction';
+export * from './send-and-confirm-transaction';
+export * from './send-transaction-without-confirming';
+
+export type {
+    RpcRequest,
+    RpcRequestTransformer,
+    RpcResponse,
+    RpcResponseData,
+    RpcResponseTransformer,
+} from '@solana/rpc-spec-types';
+export { createRpcMessage } from '@solana/rpc-spec-types';

package/src/program-client-core.ts

@@ -0,0 +1 @@
+export * from '@solana/program-client-core';

package/src/send-and-confirm-durable-nonce-transaction.ts

@@ -0,0 +1,172 @@
+import { getSolanaErrorFromTransactionError, isSolanaError, SOLANA_ERROR__INVALID_NONCE } from '@solana/errors';
+import { Signature } from '@solana/keys';
+import type { GetAccountInfoApi, GetSignatureStatusesApi, Rpc, SendTransactionApi } from '@solana/rpc';
+import type { AccountNotificationsApi, RpcSubscriptions, SignatureNotificationsApi } from '@solana/rpc-subscriptions';
+import { commitmentComparator } from '@solana/rpc-types';
+import {
+    createNonceInvalidationPromiseFactory,
+    createRecentSignatureConfirmationPromiseFactory,
+    waitForDurableNonceTransactionConfirmation,
+} from '@solana/transaction-confirmation';
+import {
+    getSignatureFromTransaction,
+    SendableTransaction,
+    Transaction,
+    TransactionWithDurableNonceLifetime,
+} from '@solana/transactions';
+
+import { sendAndConfirmDurableNonceTransaction_INTERNAL_ONLY_DO_NOT_EXPORT } from './send-transaction-internal';
+
+type SendAndConfirmDurableNonceTransactionFunction = (
+    transaction: SendableTransaction & Transaction & TransactionWithDurableNonceLifetime,
+    config: Omit<
+        Parameters<typeof sendAndConfirmDurableNonceTransaction_INTERNAL_ONLY_DO_NOT_EXPORT>[0],
+        'confirmDurableNonceTransaction' | 'rpc' | 'transaction'
+    >,
+) => Promise<void>;
+
+type SendAndConfirmDurableNonceTransactionFactoryConfig<TCluster> = {
+    /** An object that supports the {@link GetSignatureStatusesApi} and the {@link SendTransactionApi} of the Solana RPC API */
+    rpc: Rpc<GetAccountInfoApi & GetSignatureStatusesApi & SendTransactionApi> & { '~cluster'?: TCluster };
+    /** An object that supports the {@link AccountNotificationsApi} and the {@link SignatureNotificationsApi} of the Solana RPC Subscriptions API */
+    rpcSubscriptions: RpcSubscriptions<AccountNotificationsApi & SignatureNotificationsApi> & { '~cluster'?: TCluster };
+};
+
+/**
+ * Returns a function that you can call to send a nonce-based transaction to the network and to wait
+ * until it has been confirmed.
+ *
+ * @param config
+ *
+ * @example
+ * ```ts
+ * import {
+ *     isSolanaError,
+ *     sendAndConfirmDurableNonceTransactionFactory,
+ *     SOLANA_ERROR__INVALID_NONCE,
+ *     SOLANA_ERROR__NONCE_ACCOUNT_NOT_FOUND,
+ * } from '@solana/kit';
+ *
+ * const sendAndConfirmNonceTransaction = sendAndConfirmDurableNonceTransactionFactory({ rpc, rpcSubscriptions });
+ *
+ * try {
+ *     await sendAndConfirmNonceTransaction(transaction, { commitment: 'confirmed' });
+ * } catch (e) {
+ *     if (isSolanaError(e, SOLANA_ERROR__NONCE_ACCOUNT_NOT_FOUND)) {
+ *         console.error(
+ *             'The lifetime specified by this transaction refers to a nonce account ' +
+ *                 `\`${e.context.nonceAccountAddress}\` that does not exist`,
+ *         );
+ *     } else if (isSolanaError(e, SOLANA_ERROR__INVALID_NONCE)) {
+ *         console.error('This transaction depends on a nonce that is no longer valid');
+ *     } else {
+ *         throw e;
+ *     }
+ * }
+ * ```
+ */
+export function sendAndConfirmDurableNonceTransactionFactory({
+    rpc,
+    rpcSubscriptions,
+}: SendAndConfirmDurableNonceTransactionFactoryConfig<'devnet'>): SendAndConfirmDurableNonceTransactionFunction;
+export function sendAndConfirmDurableNonceTransactionFactory({
+    rpc,
+    rpcSubscriptions,
+}: SendAndConfirmDurableNonceTransactionFactoryConfig<'testnet'>): SendAndConfirmDurableNonceTransactionFunction;
+export function sendAndConfirmDurableNonceTransactionFactory({
+    rpc,
+    rpcSubscriptions,
+}: SendAndConfirmDurableNonceTransactionFactoryConfig<'mainnet'>): SendAndConfirmDurableNonceTransactionFunction;
+export function sendAndConfirmDurableNonceTransactionFactory<
+    TCluster extends 'devnet' | 'mainnet' | 'testnet' | void = void,
+>({
+    rpc,
+    rpcSubscriptions,
+}: SendAndConfirmDurableNonceTransactionFactoryConfig<TCluster>): SendAndConfirmDurableNonceTransactionFunction {
+    const getNonceInvalidationPromise = createNonceInvalidationPromiseFactory({ rpc, rpcSubscriptions } as Parameters<
+        typeof createNonceInvalidationPromiseFactory
+    >[0]);
+    const getRecentSignatureConfirmationPromise = createRecentSignatureConfirmationPromiseFactory({
+        rpc,
+        rpcSubscriptions,
+    } as Parameters<typeof createRecentSignatureConfirmationPromiseFactory>[0]);
+
+    /**
+     * Creates a wrapped version of getNonceInvalidationPromise that handles the race condition
+     * where the nonce account update notification arrives before the signature confirmation.
+     *
+     * When the nonce changes, we check if our transaction actually landed on-chain.
+     * If it did, we don't throw - letting the signature confirmation promise continue.
+     */
+    function createNonceInvalidationPromiseHandlingRaceCondition(
+        signature: Signature,
+    ): typeof getNonceInvalidationPromise {
+        return async function wrappedGetNonceInvalidationPromise(config) {
+            try {
+                return await getNonceInvalidationPromise(config);
+            } catch (e) {
+                // If nonce became invalid, check if our transaction actually landed
+                if (isSolanaError(e, SOLANA_ERROR__INVALID_NONCE)) {
+                    let status;
+                    try {
+                        const { value: statuses } = await rpc
+                            .getSignatureStatuses([signature])
+                            .send({ abortSignal: config.abortSignal });
+                        status = statuses[0];
+                    } catch {
+                        // RPC failed - propagate the original nonce error
+                        throw e;
+                    }
+
+                    if (status === null || status === undefined) {
+                        // Transaction doesn't exist - nonce was truly invalid
+                        throw e;
+                    }
+
+                    // Check if status meets required commitment
+                    if (
+                        status.confirmationStatus !== null &&
+                        commitmentComparator(status.confirmationStatus, config.commitment) >= 0
+                    ) {
+                        // Transaction failed on-chain, throw the error from the transaction
+                        if (status.err !== null) {
+                            throw getSolanaErrorFromTransactionError(status.err);
+                        }
+                        // Transaction succeeded, resolve the promise successfully
+                        return;
+                    }
+
+                    // Commitment not met yet - return a never-resolving promise
+                    // This lets the signature confirmation promise continue
+                    return await new Promise(() => {});
+                }
+                throw e;
+            }
+        };
+    }
+
+    async function confirmDurableNonceTransaction(
+        config: Omit<
+            Parameters<typeof waitForDurableNonceTransactionConfirmation>[0],
+            'getNonceInvalidationPromise' | 'getRecentSignatureConfirmationPromise'
+        >,
+    ) {
+        const wrappedGetNonceInvalidationPromise = createNonceInvalidationPromiseHandlingRaceCondition(
+            getSignatureFromTransaction(config.transaction),
+        );
+
+        await waitForDurableNonceTransactionConfirmation({
+            ...config,
+            getNonceInvalidationPromise: wrappedGetNonceInvalidationPromise,
+            getRecentSignatureConfirmationPromise,
+        });
+    }
+    return async function sendAndConfirmDurableNonceTransaction(transaction, config) {
+        await sendAndConfirmDurableNonceTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
+            ...config,
+            confirmDurableNonceTransaction,
+            rpc,
+            transaction,
+        });
+    };
+}

package/src/send-and-confirm-transaction.ts

@@ -0,0 +1,95 @@
+import type { GetEpochInfoApi, GetSignatureStatusesApi, Rpc, SendTransactionApi } from '@solana/rpc';
+import type { RpcSubscriptions, SignatureNotificationsApi, SlotNotificationsApi } from '@solana/rpc-subscriptions';
+import {
+    createBlockHeightExceedencePromiseFactory,
+    createRecentSignatureConfirmationPromiseFactory,
+    TransactionWithLastValidBlockHeight,
+    waitForRecentTransactionConfirmation,
+} from '@solana/transaction-confirmation';
+import { SendableTransaction, Transaction } from '@solana/transactions';
+
+import { sendAndConfirmTransactionWithBlockhashLifetime_INTERNAL_ONLY_DO_NOT_EXPORT } from './send-transaction-internal';
+
+type SendAndConfirmTransactionWithBlockhashLifetimeFunction = (
+    transaction: SendableTransaction & Transaction & TransactionWithLastValidBlockHeight,
+    config: Omit<
+        Parameters<typeof sendAndConfirmTransactionWithBlockhashLifetime_INTERNAL_ONLY_DO_NOT_EXPORT>[0],
+        'confirmRecentTransaction' | 'rpc' | 'transaction'
+    >,
+) => Promise<void>;
+
+type SendAndConfirmTransactionWithBlockhashLifetimeFactoryConfig<TCluster> = {
+    /** An object that supports the {@link GetSignatureStatusesApi} and the {@link SendTransactionApi} of the Solana RPC API */
+    rpc: Rpc<GetEpochInfoApi & GetSignatureStatusesApi & SendTransactionApi> & { '~cluster'?: TCluster };
+    /** An object that supports the {@link SignatureNotificationsApi} and the {@link SlotNotificationsApi} of the Solana RPC Subscriptions API */
+    rpcSubscriptions: RpcSubscriptions<SignatureNotificationsApi & SlotNotificationsApi> & { '~cluster'?: TCluster };
+};
+
+/**
+ * Returns a function that you can call to send a blockhash-based transaction to the network and to
+ * wait until it has been confirmed.
+ *
+ * @param config
+ *
+ * @example
+ * ```ts
+ * import { isSolanaError, sendAndConfirmTransactionFactory, SOLANA_ERROR__BLOCK_HEIGHT_EXCEEDED } from '@solana/kit';
+ *
+ * const sendAndConfirmTransaction = sendAndConfirmTransactionFactory({ rpc, rpcSubscriptions });
+ *
+ * try {
+ *     await sendAndConfirmTransaction(transaction, { commitment: 'confirmed' });
+ * } catch (e) {
+ *     if (isSolanaError(e, SOLANA_ERROR__BLOCK_HEIGHT_EXCEEDED)) {
+ *         console.error('This transaction depends on a blockhash that has expired');
+ *     } else {
+ *         throw e;
+ *     }
+ * }
+ * ```
+ */
+export function sendAndConfirmTransactionFactory({
+    rpc,
+    rpcSubscriptions,
+}: SendAndConfirmTransactionWithBlockhashLifetimeFactoryConfig<'devnet'>): SendAndConfirmTransactionWithBlockhashLifetimeFunction;
+export function sendAndConfirmTransactionFactory({
+    rpc,
+    rpcSubscriptions,
+}: SendAndConfirmTransactionWithBlockhashLifetimeFactoryConfig<'testnet'>): SendAndConfirmTransactionWithBlockhashLifetimeFunction;
+export function sendAndConfirmTransactionFactory({
+    rpc,
+    rpcSubscriptions,
+}: SendAndConfirmTransactionWithBlockhashLifetimeFactoryConfig<'mainnet'>): SendAndConfirmTransactionWithBlockhashLifetimeFunction;
+export function sendAndConfirmTransactionFactory<TCluster extends 'devnet' | 'mainnet' | 'testnet' | void = void>({
+    rpc,
+    rpcSubscriptions,
+}: SendAndConfirmTransactionWithBlockhashLifetimeFactoryConfig<TCluster>): SendAndConfirmTransactionWithBlockhashLifetimeFunction {
+    const getBlockHeightExceedencePromise = createBlockHeightExceedencePromiseFactory({
+        rpc,
+        rpcSubscriptions,
+    } as Parameters<typeof createBlockHeightExceedencePromiseFactory>[0]);
+    const getRecentSignatureConfirmationPromise = createRecentSignatureConfirmationPromiseFactory({
+        rpc,
+        rpcSubscriptions,
+    } as Parameters<typeof createRecentSignatureConfirmationPromiseFactory>[0]);
+    async function confirmRecentTransaction(
+        config: Omit<
+            Parameters<typeof waitForRecentTransactionConfirmation>[0],
+            'getBlockHeightExceedencePromise' | 'getRecentSignatureConfirmationPromise'
+        >,
+    ) {
+        await waitForRecentTransactionConfirmation({
+            ...config,
+            getBlockHeightExceedencePromise,
+            getRecentSignatureConfirmationPromise,
+        });
+    }
+    return async function sendAndConfirmTransaction(transaction, config) {
+        await sendAndConfirmTransactionWithBlockhashLifetime_INTERNAL_ONLY_DO_NOT_EXPORT({
+            ...config,
+            confirmRecentTransaction,
+            rpc,
+            transaction,
+        });
+    };
+}