@solana/kit 6.3.1 → 6.3.2-canary-20260313143218

package/src/send-transaction-internal.ts

@@ -0,0 +1,134 @@
+import type { Signature } from '@solana/keys';
+import type { Rpc, SendTransactionApi } from '@solana/rpc';
+import { Commitment, commitmentComparator } from '@solana/rpc-types';
+import {
+    TransactionWithLastValidBlockHeight,
+    waitForDurableNonceTransactionConfirmation,
+    waitForRecentTransactionConfirmation,
+} from '@solana/transaction-confirmation';
+import {
+    getBase64EncodedWireTransaction,
+    SendableTransaction,
+    Transaction,
+    TransactionWithDurableNonceLifetime,
+} from '@solana/transactions';
+
+interface SendAndConfirmDurableNonceTransactionConfig
+    extends SendTransactionBaseConfig, SendTransactionConfigWithoutEncoding {
+    confirmDurableNonceTransaction: (
+        config: Omit<
+            Parameters<typeof waitForDurableNonceTransactionConfirmation>[0],
+            'getNonceInvalidationPromise' | 'getRecentSignatureConfirmationPromise'
+        >,
+    ) => Promise<void>;
+    transaction: SendableTransaction & Transaction & TransactionWithDurableNonceLifetime;
+}
+
+interface SendAndConfirmTransactionWithBlockhashLifetimeConfig
+    extends SendTransactionBaseConfig, SendTransactionConfigWithoutEncoding {
+    confirmRecentTransaction: (
+        config: Omit<
+            Parameters<typeof waitForRecentTransactionConfirmation>[0],
+            'getBlockHeightExceedencePromise' | 'getRecentSignatureConfirmationPromise'
+        >,
+    ) => Promise<void>;
+    transaction: SendableTransaction & Transaction & TransactionWithLastValidBlockHeight;
+}
+
+interface SendTransactionBaseConfig extends SendTransactionConfigWithoutEncoding {
+    abortSignal?: AbortSignal;
+    commitment: Commitment;
+    rpc: Rpc<SendTransactionApi>;
+    transaction: SendableTransaction & Transaction;
+}
+
+type SendTransactionConfigWithoutEncoding = Omit<
+    NonNullable<Parameters<SendTransactionApi['sendTransaction']>[1]>,
+    'encoding'
+>;
+
+function getSendTransactionConfigWithAdjustedPreflightCommitment(
+    commitment: Commitment,
+    config?: SendTransactionConfigWithoutEncoding,
+): SendTransactionConfigWithoutEncoding | void {
+    if (
+        // The developer has supplied no value for `preflightCommitment`.
+        !config?.preflightCommitment &&
+        // The value of `commitment` is lower than the server default of `preflightCommitment`.
+        commitmentComparator(commitment, 'finalized' /* default value of `preflightCommitment` */) < 0
+    ) {
+        return {
+            ...config,
+            // In the common case, it is unlikely that you want to simulate a transaction at
+            // `finalized` commitment when your standard of commitment for confirming the
+            // transaction is lower. Cap the simulation commitment level to the level of the
+            // confirmation commitment.
+            preflightCommitment: commitment,
+        };
+    }
+    // The commitment at which the developer wishes to confirm the transaction is at least as
+    // high as the commitment at which they want to simulate it. Honour the config as-is.
+    return config;
+}
+
+export async function sendTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
+    abortSignal,
+    commitment,
+    rpc,
+    transaction,
+    ...sendTransactionConfig
+}: SendTransactionBaseConfig): Promise<Signature> {
+    const base64EncodedWireTransaction = getBase64EncodedWireTransaction(transaction);
+    return await rpc
+        .sendTransaction(base64EncodedWireTransaction, {
+            ...getSendTransactionConfigWithAdjustedPreflightCommitment(commitment, sendTransactionConfig),
+            encoding: 'base64',
+        })
+        .send({ abortSignal });
+}
+
+export async function sendAndConfirmDurableNonceTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
+    abortSignal,
+    commitment,
+    confirmDurableNonceTransaction,
+    rpc,
+    transaction,
+    ...sendTransactionConfig
+}: SendAndConfirmDurableNonceTransactionConfig): Promise<Signature> {
+    const transactionSignature = await sendTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
+        ...sendTransactionConfig,
+        abortSignal,
+        commitment,
+        rpc,
+        transaction,
+    });
+    await confirmDurableNonceTransaction({
+        abortSignal,
+        commitment,
+        transaction,
+    });
+    return transactionSignature;
+}
+
+export async function sendAndConfirmTransactionWithBlockhashLifetime_INTERNAL_ONLY_DO_NOT_EXPORT({
+    abortSignal,
+    commitment,
+    confirmRecentTransaction,
+    rpc,
+    transaction,
+    ...sendTransactionConfig
+}: SendAndConfirmTransactionWithBlockhashLifetimeConfig): Promise<Signature> {
+    const transactionSignature = await sendTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
+        ...sendTransactionConfig,
+        abortSignal,
+        commitment,
+        rpc,
+        transaction,
+    });
+    await confirmRecentTransaction({
+        abortSignal,
+        commitment,
+        transaction,
+    });
+    return transactionSignature;
+}

package/src/send-transaction-without-confirming.ts

@@ -0,0 +1,52 @@
+import type { Rpc, SendTransactionApi } from '@solana/rpc';
+import { SendableTransaction, Transaction } from '@solana/transactions';
+
+import { sendTransaction_INTERNAL_ONLY_DO_NOT_EXPORT } from './send-transaction-internal';
+
+type SendTransactionWithoutConfirmingFunction = (
+    transaction: SendableTransaction & Transaction,
+    config: Omit<Parameters<typeof sendTransaction_INTERNAL_ONLY_DO_NOT_EXPORT>[0], 'rpc' | 'transaction'>,
+) => Promise<void>;
+
+interface SendTransactionWithoutConfirmingFactoryConfig {
+    /** An object that supports the {@link SendTransactionApi} of the Solana RPC API */
+    rpc: Rpc<SendTransactionApi>;
+}
+
+/**
+ * Returns a function that you can call to send a transaction with any kind of lifetime to the
+ * network without waiting for it to be confirmed.
+ *
+ * @param config
+ *
+ * @example
+ * ```ts
+ * import {
+ *     sendTransactionWithoutConfirmingFactory,
+ *     SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE,
+ * } from '@solana/kit';
+ *
+ * const sendTransaction = sendTransactionWithoutConfirmingFactory({ rpc });
+ *
+ * try {
+ *     await sendTransaction(transaction, { commitment: 'confirmed' });
+ * } catch (e) {
+ *     if (isSolanaError(e, SOLANA_ERROR__JSON_RPC__SERVER_ERROR_SEND_TRANSACTION_PREFLIGHT_FAILURE)) {
+ *         console.error('The transaction failed in simulation', e.cause);
+ *     } else {
+ *         throw e;
+ *     }
+ * }
+ * ```
+ */
+export function sendTransactionWithoutConfirmingFactory({
+    rpc,
+}: SendTransactionWithoutConfirmingFactoryConfig): SendTransactionWithoutConfirmingFunction {
+    return async function sendTransactionWithoutConfirming(transaction, config) {
+        await sendTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
+            ...config,
+            rpc,
+            transaction,
+        });
+    };
+}