@solana/web3.js 2.0.0-experimental.7d44763 → 2.0.0-experimental.7d67615

package/dist/index.native.js

@@ -1,594 +1,184 @@
+import { fetchJsonParsedAccounts, assertAccountsDecoded, assertAccountsExist } from '@solana/accounts';
+export * from '@solana/accounts';
 export * from '@solana/addresses';
+export * from '@solana/codecs';
+export * from '@solana/functional';
 export * from '@solana/instructions';
 export * from '@solana/keys';
-import { getSignatureFromTransaction } from '@solana/transactions';
+export * from '@solana/programs';
+export * from '@solana/rpc';
+export * from '@solana/rpc-parsed-types';
+export * from '@solana/rpc-subscriptions';
+import { commitmentComparator } from '@solana/rpc-types';
+export * from '@solana/rpc-types';
+export * from '@solana/signers';
+import { getCompiledTransactionDecoder, decompileTransaction, getBase64EncodedWireTransaction } from '@solana/transactions';
 export * from '@solana/transactions';
-import { pipe } from '@solana/functional';
-import { createSolanaRpcApi, createSolanaRpcSubscriptionsApi, createSolanaRpcSubscriptionsApi_UNSTABLE, commitmentComparator } from '@solana/rpc-core';
-import { createJsonRpc, createJsonSubscriptionRpc, createHttpTransport, createWebSocketTransport } from '@solana/rpc-transport';
-import fastStableStringify from 'fast-stable-stringify';
-import { base64, base58 } from '@metaplex-foundation/umi-serializers';
+import { createRecentSignatureConfirmationPromiseFactory, createNonceInvalidationPromiseFactory, createBlockHeightExceedencePromiseFactory, waitForRecentTransactionConfirmationUntilTimeout, getTimeoutPromise, waitForDurableNonceTransactionConfirmation, waitForRecentTransactionConfirmation } from '@solana/transaction-confirmation';
 
-// ../build-scripts/env-shim.ts
-var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
+// src/index.ts
 
-// src/rpc-integer-overflow-error.ts
-var SolanaJsonRpcIntegerOverflowError = class extends Error {
-  constructor(methodName, keyPath, value) {
-    const argPosition = (typeof keyPath[0] === "number" ? keyPath[0] : parseInt(keyPath[0], 10)) + 1;
-    let ordinal = "";
-    const lastDigit = argPosition % 10;
-    const lastTwoDigits = argPosition % 100;
-    if (lastDigit == 1 && lastTwoDigits != 11) {
-      ordinal = argPosition + "st";
-    } else if (lastDigit == 2 && lastTwoDigits != 12) {
-      ordinal = argPosition + "nd";
-    } else if (lastDigit == 3 && lastTwoDigits != 13) {
-      ordinal = argPosition + "rd";
-    } else {
-      ordinal = argPosition + "th";
-    }
-    const path = keyPath.length > 1 ? keyPath.slice(1).map((pathPart) => typeof pathPart === "number" ? `[${pathPart}]` : pathPart).join(".") : null;
-    super(
-      `The ${ordinal} argument to the \`${methodName}\` RPC method${path ? ` at path \`${path}\`` : ""} was \`${value}\`. This number is unsafe for use with the Solana JSON-RPC because it exceeds \`Number.MAX_SAFE_INTEGER\`.`
-    );
-    this.keyPath = keyPath;
-    this.methodName = methodName;
-    this.value = value;
-  }
-  get name() {
-    return "SolanaJsonRpcIntegerOverflowError";
-  }
-};
-
-// src/rpc-default-config.ts
-var DEFAULT_RPC_CONFIG = {
-  onIntegerOverflow(methodName, keyPath, value) {
-    throw new SolanaJsonRpcIntegerOverflowError(methodName, keyPath, value);
-  }
-};
-
-// src/cached-abortable-iterable.ts
-function registerIterableCleanup(iterable, cleanupFn) {
-  (async () => {
-    try {
-      for await (const _ of iterable)
-        ;
-    } catch {
-    } finally {
-      cleanupFn();
-    }
-  })();
-}
-function getCachedAbortableIterableFactory({
-  getAbortSignalFromInputArgs,
-  getCacheEntryMissingError,
-  getCacheKeyFromInputArgs,
-  onCacheHit,
-  onCreateIterable
-}) {
-  const cache = /* @__PURE__ */ new Map();
-  function getCacheEntryOrThrow(cacheKey) {
-    const currentCacheEntry = cache.get(cacheKey);
-    if (!currentCacheEntry) {
-      throw getCacheEntryMissingError(cacheKey);
-    }
-    return currentCacheEntry;
-  }
-  return async (...args) => {
-    const cacheKey = getCacheKeyFromInputArgs(...args);
-    const signal = getAbortSignalFromInputArgs(...args);
-    if (cacheKey === void 0) {
-      return await onCreateIterable(signal, ...args);
-    }
-    const cleanup = () => {
-      cache.delete(cacheKey);
-      signal.removeEventListener("abort", handleAbort);
-    };
-    const handleAbort = () => {
-      const cacheEntry = getCacheEntryOrThrow(cacheKey);
-      if (cacheEntry.purgeScheduled !== true) {
-        cacheEntry.purgeScheduled = true;
-        globalThis.queueMicrotask(() => {
-          cacheEntry.purgeScheduled = false;
-          if (cacheEntry.referenceCount === 0) {
-            cacheEntry.abortController.abort();
-            cleanup();
-          }
-        });
-      }
-      cacheEntry.referenceCount--;
-    };
-    signal.addEventListener("abort", handleAbort);
-    try {
-      const cacheEntry = cache.get(cacheKey);
-      if (!cacheEntry) {
-        const singletonAbortController = new AbortController();
-        const newIterablePromise = onCreateIterable(singletonAbortController.signal, ...args);
-        const newCacheEntry = {
-          abortController: singletonAbortController,
-          iterable: newIterablePromise,
-          purgeScheduled: false,
-          referenceCount: 1
-        };
-        cache.set(cacheKey, newCacheEntry);
-        const newIterable = await newIterablePromise;
-        registerIterableCleanup(newIterable, cleanup);
-        newCacheEntry.iterable = newIterable;
-        return newIterable;
-      } else {
-        cacheEntry.referenceCount++;
-        const iterableOrIterablePromise = cacheEntry.iterable;
-        const cachedIterable = "then" in iterableOrIterablePromise ? await iterableOrIterablePromise : iterableOrIterablePromise;
-        await onCacheHit(cachedIterable, ...args);
-        return cachedIterable;
-      }
-    } catch (e) {
-      cleanup();
-      throw e;
-    }
-  };
-}
-
-// src/rpc-subscription-coalescer.ts
-var EXPLICIT_ABORT_TOKEN = Symbol(
-  __DEV__ ? "This symbol is thrown from a subscription's iterator when the subscription is explicitly aborted by the user" : void 0
-);
-function registerIterableCleanup2(iterable, cleanupFn) {
-  (async () => {
-    try {
-      for await (const _ of iterable)
-        ;
-    } catch {
-    } finally {
-      cleanupFn();
-    }
-  })();
-}
-function getRpcSubscriptionsWithSubscriptionCoalescing({
-  getDeduplicationKey,
-  rpcSubscriptions
+// src/airdrop-internal.ts
+async function requestAndConfirmAirdrop_INTERNAL_ONLY_DO_NOT_EXPORT({
+  abortSignal,
+  commitment,
+  confirmSignatureOnlyTransaction,
+  lamports,
+  recipientAddress,
+  rpc
 }) {
-  const cache = /* @__PURE__ */ new Map();
-  return new Proxy(rpcSubscriptions, {
-    defineProperty() {
-      return false;
-    },
-    deleteProperty() {
-      return false;
-    },
-    get(target, p, receiver) {
-      const subscriptionMethod = Reflect.get(target, p, receiver);
-      if (typeof subscriptionMethod !== "function") {
-        return subscriptionMethod;
-      }
-      return function(...rawParams) {
-        const deduplicationKey = getDeduplicationKey(p, rawParams);
-        if (deduplicationKey === void 0) {
-          return subscriptionMethod(...rawParams);
-        }
-        if (cache.has(deduplicationKey)) {
-          return cache.get(deduplicationKey);
-        }
-        const iterableFactory = getCachedAbortableIterableFactory({
-          getAbortSignalFromInputArgs: ({ abortSignal }) => abortSignal,
-          getCacheEntryMissingError(deduplicationKey2) {
-            return new Error(
-              `Found no cache entry for subscription with deduplication key \`${deduplicationKey2?.toString()}\``
-            );
-          },
-          getCacheKeyFromInputArgs: () => deduplicationKey,
-          async onCacheHit(_iterable, _config) {
-          },
-          async onCreateIterable(abortSignal, config) {
-            const pendingSubscription2 = subscriptionMethod(
-              ...rawParams
-            );
-            const iterable = await pendingSubscription2.subscribe({
-              ...config,
-              abortSignal
-            });
-            registerIterableCleanup2(iterable, () => {
-              cache.delete(deduplicationKey);
-            });
-            return iterable;
-          }
-        });
-        const pendingSubscription = {
-          async subscribe(...args) {
-            const iterable = await iterableFactory(...args);
-            const { abortSignal } = args[0];
-            let abortPromise;
-            return {
-              ...iterable,
-              async *[Symbol.asyncIterator]() {
-                abortPromise || (abortPromise = abortSignal.aborted ? Promise.reject(EXPLICIT_ABORT_TOKEN) : new Promise((_, reject) => {
-                  abortSignal.addEventListener("abort", () => {
-                    reject(EXPLICIT_ABORT_TOKEN);
-                  });
-                }));
-                try {
-                  const iterator = iterable[Symbol.asyncIterator]();
-                  while (true) {
-                    const iteratorResult = await Promise.race([iterator.next(), abortPromise]);
-                    if (iteratorResult.done) {
-                      return;
-                    } else {
-                      yield iteratorResult.value;
-                    }
-                  }
-                } catch (e) {
-                  if (e === EXPLICIT_ABORT_TOKEN) {
-                    return;
-                  }
-                  cache.delete(deduplicationKey);
-                  throw e;
-                }
-              }
-            };
-          }
-        };
-        cache.set(deduplicationKey, pendingSubscription);
-        return pendingSubscription;
-      };
-    }
+  const airdropTransactionSignature = await rpc.requestAirdrop(recipientAddress, lamports, { commitment }).send({ abortSignal });
+  await confirmSignatureOnlyTransaction({
+    abortSignal,
+    commitment,
+    signature: airdropTransactionSignature
   });
+  return airdropTransactionSignature;
 }
 
-// src/rpc.ts
-function createSolanaRpc(config) {
-  return createJsonRpc({
-    ...config,
-    api: createSolanaRpcApi(DEFAULT_RPC_CONFIG)
-  });
-}
-function createSolanaRpcSubscriptions(config) {
-  return pipe(
-    createJsonSubscriptionRpc({
-      ...config,
-      api: createSolanaRpcSubscriptionsApi(DEFAULT_RPC_CONFIG)
-    }),
-    (rpcSubscriptions) => getRpcSubscriptionsWithSubscriptionCoalescing({
-      getDeduplicationKey: (...args) => fastStableStringify(args),
-      rpcSubscriptions
-    })
+// src/airdrop.ts
+function airdropFactory({ rpc, rpcSubscriptions }) {
+  const getRecentSignatureConfirmationPromise = createRecentSignatureConfirmationPromiseFactory(
+    rpc,
+    rpcSubscriptions
   );
-}
-function createSolanaRpcSubscriptions_UNSTABLE(config) {
-  return createJsonSubscriptionRpc({
-    ...config,
-    api: createSolanaRpcSubscriptionsApi_UNSTABLE(DEFAULT_RPC_CONFIG)
-  });
-}
-
-// src/rpc-request-coalescer.ts
-function getRpcTransportWithRequestCoalescing(transport, getDeduplicationKey) {
-  let coalescedRequestsByDeduplicationKey;
-  return async function makeCoalescedHttpRequest(config) {
-    const { payload, signal } = config;
-    const deduplicationKey = getDeduplicationKey(payload);
-    if (deduplicationKey === void 0) {
-      return await transport(config);
-    }
-    if (!coalescedRequestsByDeduplicationKey) {
-      Promise.resolve().then(() => {
-        coalescedRequestsByDeduplicationKey = void 0;
-      });
-      coalescedRequestsByDeduplicationKey = {};
-    }
-    if (coalescedRequestsByDeduplicationKey[deduplicationKey] == null) {
-      const abortController = new AbortController();
-      coalescedRequestsByDeduplicationKey[deduplicationKey] = {
-        abortController,
-        numConsumers: 0,
-        responsePromise: transport({
-          ...config,
-          signal: abortController.signal
-        })
-      };
-    }
-    const coalescedRequest = coalescedRequestsByDeduplicationKey[deduplicationKey];
-    coalescedRequest.numConsumers++;
-    if (signal) {
-      const responsePromise = coalescedRequest.responsePromise;
-      return await new Promise((resolve, reject) => {
-        const handleAbort = (e) => {
-          signal.removeEventListener("abort", handleAbort);
-          coalescedRequest.numConsumers -= 1;
-          if (coalescedRequest.numConsumers === 0) {
-            const abortController = coalescedRequest.abortController;
-            abortController.abort();
-          }
-          const abortError = new DOMException(e.target.reason, "AbortError");
-          reject(abortError);
-        };
-        signal.addEventListener("abort", handleAbort);
-        responsePromise.then(resolve).finally(() => {
-          signal.removeEventListener("abort", handleAbort);
-        });
-      });
-    } else {
-      return await coalescedRequest.responsePromise;
-    }
-  };
-}
-function isJsonRpcPayload(payload) {
-  if (payload == null || typeof payload !== "object" || Array.isArray(payload)) {
-    return false;
-  }
-  return "jsonrpc" in payload && payload.jsonrpc === "2.0" && "method" in payload && typeof payload.method === "string" && "params" in payload;
-}
-function getSolanaRpcPayloadDeduplicationKey(payload) {
-  return isJsonRpcPayload(payload) ? fastStableStringify([payload.method, payload.params]) : void 0;
-}
-
-// src/rpc-transport.ts
-function normalizeHeaders(headers) {
-  const out = {};
-  for (const headerName in headers) {
-    out[headerName.toLowerCase()] = headers[headerName];
+  async function confirmSignatureOnlyTransaction(config) {
+    await waitForRecentTransactionConfirmationUntilTimeout({
+      ...config,
+      getRecentSignatureConfirmationPromise,
+      getTimeoutPromise
+    });
   }
-  return out;
-}
-function createDefaultRpcTransport(config) {
-  return pipe(
-    createHttpTransport({
+  return async function airdrop(config) {
+    return await requestAndConfirmAirdrop_INTERNAL_ONLY_DO_NOT_EXPORT({
       ...config,
-      headers: {
-        ...config.headers ? normalizeHeaders(config.headers) : void 0,
-        ...{
-          // Keep these headers lowercase so they will override any user-supplied headers above.
-          "solana-client": `js/${"2.0.0-development"}` ?? "UNKNOWN"
-        }
-      }
-    }),
-    (transport) => getRpcTransportWithRequestCoalescing(transport, getSolanaRpcPayloadDeduplicationKey)
-  );
-}
-
-// src/rpc-websocket-autopinger.ts
-var PING_PAYLOAD = {
-  jsonrpc: "2.0",
-  method: "ping"
-};
-function getWebSocketTransportWithAutoping({ intervalMs, transport }) {
-  const pingableConnections = /* @__PURE__ */ new Map();
-  return async (...args) => {
-    const connection = await transport(...args);
-    let intervalId;
-    function sendPing() {
-      connection.send_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(PING_PAYLOAD);
-    }
-    function restartPingTimer() {
-      clearInterval(intervalId);
-      intervalId = setInterval(sendPing, intervalMs);
-    }
-    if (pingableConnections.has(connection) === false) {
-      pingableConnections.set(connection, {
-        [Symbol.asyncIterator]: connection[Symbol.asyncIterator].bind(connection),
-        send_DO_NOT_USE_OR_YOU_WILL_BE_FIRED: (...args2) => {
-          restartPingTimer();
-          return connection.send_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(...args2);
-        }
-      });
-      (async () => {
-        try {
-          for await (const _ of connection) {
-            restartPingTimer();
-          }
-        } catch {
-        } finally {
-          pingableConnections.delete(connection);
-          clearInterval(intervalId);
-          if (handleOffline) {
-            globalThis.window.removeEventListener("offline", handleOffline);
-          }
-          if (handleOnline) {
-            globalThis.window.removeEventListener("online", handleOnline);
-          }
-        }
-      })();
-      {
-        restartPingTimer();
-      }
-      let handleOffline;
-      let handleOnline;
-    }
-    return pingableConnections.get(connection);
+      confirmSignatureOnlyTransaction,
+      rpc
+    });
   };
 }
-
-// src/rpc-websocket-connection-sharding.ts
-var NULL_SHARD_CACHE_KEY = Symbol(
-  __DEV__ ? "Cache key to use when there is no connection sharding strategy" : void 0
-);
-function getWebSocketTransportWithConnectionSharding({ getShard, transport }) {
-  return getCachedAbortableIterableFactory({
-    getAbortSignalFromInputArgs: ({ signal }) => signal,
-    getCacheEntryMissingError(shardKey) {
-      return new Error(`Found no cache entry for connection with shard key \`${shardKey?.toString()}\``);
-    },
-    getCacheKeyFromInputArgs: ({ payload }) => getShard ? getShard(payload) : NULL_SHARD_CACHE_KEY,
-    onCacheHit: (connection, { payload }) => connection.send_DO_NOT_USE_OR_YOU_WILL_BE_FIRED(payload),
-    onCreateIterable: (abortSignal, config) => transport({
-      ...config,
-      signal: abortSignal
-    })
-  });
-}
-
-// src/rpc-websocket-transport.ts
-function createDefaultRpcSubscriptionsTransport(config) {
-  const { getShard, intervalMs, ...rest } = config;
-  return pipe(
-    createWebSocketTransport({
-      ...rest,
-      sendBufferHighWatermark: config.sendBufferHighWatermark ?? // Let 128KB of data into the WebSocket buffer before buffering it in the app.
-      131072
-    }),
-    (transport) => getWebSocketTransportWithAutoping({
-      intervalMs: intervalMs ?? 5e3,
-      transport
-    }),
-    (transport) => getWebSocketTransportWithConnectionSharding({
-      getShard,
-      transport
-    })
+var compiledTransactionDecoder = void 0;
+async function fetchLookupTables(lookupTableAddresses, rpc, config) {
+  const fetchedLookupTables = await fetchJsonParsedAccounts(
+    rpc,
+    lookupTableAddresses,
+    config
   );
+  assertAccountsDecoded(fetchedLookupTables);
+  assertAccountsExist(fetchedLookupTables);
+  return fetchedLookupTables.reduce((acc, lookup) => {
+    return {
+      ...acc,
+      [lookup.address]: lookup.data.addresses
+    };
+  }, {});
+}
+async function decodeTransaction(encodedTransaction, rpc, config) {
+  const { lastValidBlockHeight, ...fetchAccountsConfig } = config ?? {};
+  if (!compiledTransactionDecoder)
+    compiledTransactionDecoder = getCompiledTransactionDecoder();
+  const compiledTransaction = compiledTransactionDecoder.decode(encodedTransaction);
+  const { compiledMessage } = compiledTransaction;
+  const lookupTables = "addressTableLookups" in compiledMessage && compiledMessage.addressTableLookups !== void 0 && compiledMessage.addressTableLookups.length > 0 ? compiledMessage.addressTableLookups : [];
+  const lookupTableAddresses = lookupTables.map((l) => l.lookupTableAddress);
+  const fetchedLookupTables = lookupTableAddresses.length > 0 ? await fetchLookupTables(lookupTableAddresses, rpc, fetchAccountsConfig) : {};
+  return decompileTransaction(compiledTransaction, {
+    addressesByLookupTableAddress: fetchedLookupTables,
+    lastValidBlockHeight
+  });
 }
-
-// src/transaction-confirmation-strategy-blockheight.ts
-function createBlockHeightExceedencePromiseFactory(rpcSubscriptions) {
-  return async function getBlockHeightExceedencePromise({ abortSignal: callerAbortSignal, lastValidBlockHeight }) {
-    const abortController = new AbortController();
-    function handleAbort() {
-      abortController.abort();
-    }
-    callerAbortSignal.addEventListener("abort", handleAbort, { signal: abortController.signal });
-    const slotNotifications = await rpcSubscriptions.slotNotifications().subscribe({ abortSignal: abortController.signal });
-    try {
-      for await (const slotNotification of slotNotifications) {
-        if (slotNotification.slot > lastValidBlockHeight) {
-          throw new Error(
-            "The network has progressed past the last block for which this transaction could have committed."
-          );
-        }
-      }
-    } finally {
-      abortController.abort();
-    }
-  };
+function getSendTransactionConfigWithAdjustedPreflightCommitment(commitment, config) {
+  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
+    };
+  }
+  return config;
 }
-var NONCE_VALUE_OFFSET = 4 + // version(u32)
-4 + // state(u32)
-32;
-function createNonceInvalidationPromiseFactory(rpc, rpcSubscriptions) {
-  return async function getNonceInvalidationPromise({
-    abortSignal: callerAbortSignal,
+async function sendTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
+  abortSignal,
+  commitment,
+  rpc,
+  transaction,
+  ...sendTransactionConfig
+}) {
+  const base64EncodedWireTransaction = getBase64EncodedWireTransaction(transaction);
+  return await rpc.sendTransaction(base64EncodedWireTransaction, {
+    ...getSendTransactionConfigWithAdjustedPreflightCommitment(commitment, sendTransactionConfig),
+    encoding: "base64"
+  }).send({ abortSignal });
+}
+async function sendAndConfirmDurableNonceTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
+  abortSignal,
+  commitment,
+  confirmDurableNonceTransaction,
+  rpc,
+  transaction,
+  ...sendTransactionConfig
+}) {
+  const transactionSignature = await sendTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
+    ...sendTransactionConfig,
+    abortSignal,
     commitment,
-    currentNonceValue,
-    nonceAccountAddress
-  }) {
-    const abortController = new AbortController();
-    function handleAbort() {
-      abortController.abort();
-    }
-    callerAbortSignal.addEventListener("abort", handleAbort, { signal: abortController.signal });
-    const accountNotifications = await rpcSubscriptions.accountNotifications(nonceAccountAddress, { commitment, encoding: "base64" }).subscribe({ abortSignal: abortController.signal });
-    function getNonceFromAccountData([base64EncodedBytes]) {
-      const data = base64.serialize(base64EncodedBytes);
-      const nonceValueBytes = data.slice(NONCE_VALUE_OFFSET, NONCE_VALUE_OFFSET + 32);
-      return base58.deserialize(nonceValueBytes)[0];
-    }
-    const nonceAccountDidAdvancePromise = (async () => {
-      for await (const accountNotification of accountNotifications) {
-        const nonceValue = getNonceFromAccountData(accountNotification.value.data);
-        if (nonceValue !== currentNonceValue) {
-          throw new Error(
-            `The nonce \`${currentNonceValue}\` is no longer valid. It has advanced to \`${nonceValue}\`.`
-          );
-        }
-      }
-    })();
-    const nonceIsAlreadyInvalidPromise = (async () => {
-      const { value: nonceAccount } = await rpc.getAccountInfo(nonceAccountAddress, {
-        commitment,
-        dataSlice: { length: 32, offset: NONCE_VALUE_OFFSET },
-        encoding: "base58"
-      }).send({ abortSignal: abortController.signal });
-      if (!nonceAccount) {
-        throw new Error(`No nonce account could be found at address \`${nonceAccountAddress}\`.`);
-      }
-      const nonceValue = (
-        // This works because we asked for the exact slice of data representing the nonce
-        // value, and furthermore asked for it in `base58` encoding.
-        nonceAccount.data[0]
-      );
-      if (nonceValue !== currentNonceValue) {
-        throw new Error(
-          `The nonce \`${currentNonceValue}\` is no longer valid. It has advanced to \`${nonceValue}\`.`
-        );
-      } else {
-        await new Promise(() => {
-        });
-      }
-    })();
-    try {
-      return await Promise.race([nonceAccountDidAdvancePromise, nonceIsAlreadyInvalidPromise]);
-    } finally {
-      abortController.abort();
-    }
-  };
+    rpc,
+    transaction
+  });
+  await confirmDurableNonceTransaction({
+    abortSignal,
+    commitment,
+    transaction
+  });
+  return transactionSignature;
 }
-function createRecentSignatureConfirmationPromiseFactory(rpc, rpcSubscriptions) {
-  return async function getRecentSignatureConfirmationPromise({
-    abortSignal: callerAbortSignal,
+async function sendAndConfirmTransactionWithBlockhashLifetime_INTERNAL_ONLY_DO_NOT_EXPORT({
+  abortSignal,
+  commitment,
+  confirmRecentTransaction,
+  rpc,
+  transaction,
+  ...sendTransactionConfig
+}) {
+  const transactionSignature = await sendTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
+    ...sendTransactionConfig,
+    abortSignal,
     commitment,
-    signature
-  }) {
-    const abortController = new AbortController();
-    function handleAbort() {
-      abortController.abort();
-    }
-    callerAbortSignal.addEventListener("abort", handleAbort, { signal: abortController.signal });
-    const signatureStatusNotifications = await rpcSubscriptions.signatureNotifications(signature, { commitment }).subscribe({ abortSignal: abortController.signal });
-    const signatureDidCommitPromise = (async () => {
-      for await (const signatureStatusNotification of signatureStatusNotifications) {
-        if (signatureStatusNotification.value.err) {
-          throw new Error(`The transaction with signature \`${signature}\` failed.`, {
-            cause: signatureStatusNotification.value.err
-          });
-        } else {
-          return;
-        }
-      }
-    })();
-    const signatureStatusLookupPromise = (async () => {
-      const { value: signatureStatusResults } = await rpc.getSignatureStatuses([signature]).send({ abortSignal: abortController.signal });
-      const signatureStatus = signatureStatusResults[0];
-      if (signatureStatus && signatureStatus.confirmationStatus && commitmentComparator(signatureStatus.confirmationStatus, commitment) >= 0) {
-        return;
-      } else {
-        await new Promise(() => {
-        });
-      }
-    })();
-    try {
-      return await Promise.race([signatureDidCommitPromise, signatureStatusLookupPromise]);
-    } finally {
-      abortController.abort();
-    }
-  };
+    rpc,
+    transaction
+  });
+  await confirmRecentTransaction({
+    abortSignal,
+    commitment,
+    transaction
+  });
+  return transactionSignature;
 }
 
-// src/transaction-confirmation.ts
-async function raceStrategies(config, getSpecificStrategiesForRace) {
-  const { abortSignal: callerAbortSignal, commitment, getRecentSignatureConfirmationPromise, transaction } = config;
-  callerAbortSignal.throwIfAborted();
-  const signature = getSignatureFromTransaction(transaction);
-  const abortController = new AbortController();
-  function handleAbort() {
-    abortController.abort();
-  }
-  callerAbortSignal.addEventListener("abort", handleAbort, { signal: abortController.signal });
-  try {
-    const specificStrategies = getSpecificStrategiesForRace({
+// src/send-transaction.ts
+function sendTransactionWithoutConfirmingFactory({
+  rpc
+}) {
+  return async function sendTransactionWithoutConfirming(transaction, config) {
+    await sendTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
       ...config,
-      abortSignal: abortController.signal
+      rpc,
+      transaction
     });
-    return await Promise.race([
-      getRecentSignatureConfirmationPromise({
-        abortSignal: abortController.signal,
-        commitment,
-        signature
-      }),
-      ...specificStrategies
-    ]);
-  } finally {
-    abortController.abort();
-  }
+  };
 }
-function createDefaultDurableNonceTransactionConfirmer({
+function sendAndConfirmDurableNonceTransactionFactory({
   rpc,
   rpcSubscriptions
 }) {
@@ -597,60 +187,51 @@ function createDefaultDurableNonceTransactionConfirmer({
     rpc,
     rpcSubscriptions
   );
-  return async function confirmDurableNonceTransaction(config) {
+  async function confirmDurableNonceTransaction(config) {
     await waitForDurableNonceTransactionConfirmation({
       ...config,
       getNonceInvalidationPromise,
       getRecentSignatureConfirmationPromise
     });
+  }
+  return async function sendAndConfirmDurableNonceTransaction(transaction, config) {
+    await sendAndConfirmDurableNonceTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
+      ...config,
+      confirmDurableNonceTransaction,
+      rpc,
+      transaction
+    });
   };
 }
-function createDefaultRecentTransactionConfirmer({
+function sendAndConfirmTransactionFactory({
   rpc,
   rpcSubscriptions
 }) {
-  const getBlockHeightExceedencePromise = createBlockHeightExceedencePromiseFactory(rpcSubscriptions);
+  const getBlockHeightExceedencePromise = createBlockHeightExceedencePromiseFactory({
+    rpc,
+    rpcSubscriptions
+  });
   const getRecentSignatureConfirmationPromise = createRecentSignatureConfirmationPromiseFactory(
     rpc,
     rpcSubscriptions
   );
-  return async function confirmRecentTransaction(config) {
+  async function confirmRecentTransaction(config) {
     await waitForRecentTransactionConfirmation({
       ...config,
       getBlockHeightExceedencePromise,
       getRecentSignatureConfirmationPromise
     });
+  }
+  return async function sendAndConfirmTransaction(transaction, config) {
+    await sendAndConfirmTransactionWithBlockhashLifetime_INTERNAL_ONLY_DO_NOT_EXPORT({
+      ...config,
+      confirmRecentTransaction,
+      rpc,
+      transaction
+    });
   };
 }
-async function waitForDurableNonceTransactionConfirmation(config) {
-  await raceStrategies(
-    config,
-    function getSpecificStrategiesForRace({ abortSignal, commitment, getNonceInvalidationPromise, transaction }) {
-      return [
-        getNonceInvalidationPromise({
-          abortSignal,
-          commitment,
-          currentNonceValue: transaction.lifetimeConstraint.nonce,
-          nonceAccountAddress: transaction.instructions[0].accounts[0].address
-        })
-      ];
-    }
-  );
-}
-async function waitForRecentTransactionConfirmation(config) {
-  await raceStrategies(
-    config,
-    function getSpecificStrategiesForRace({ abortSignal, getBlockHeightExceedencePromise, transaction }) {
-      return [
-        getBlockHeightExceedencePromise({
-          abortSignal,
-          lastValidBlockHeight: transaction.lifetimeConstraint.lastValidBlockHeight
-        })
-      ];
-    }
-  );
-}
 
-export { createBlockHeightExceedencePromiseFactory, createDefaultDurableNonceTransactionConfirmer, createDefaultRecentTransactionConfirmer, createDefaultRpcSubscriptionsTransport, createDefaultRpcTransport, createNonceInvalidationPromiseFactory, createRecentSignatureConfirmationPromiseFactory, createSolanaRpc, createSolanaRpcSubscriptions, createSolanaRpcSubscriptions_UNSTABLE, waitForDurableNonceTransactionConfirmation, waitForRecentTransactionConfirmation };
+export { airdropFactory, decodeTransaction, sendAndConfirmDurableNonceTransactionFactory, sendAndConfirmTransactionFactory, sendTransactionWithoutConfirmingFactory };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.native.js.map