@solana/web3.js 2.0.0-experimental.606040b → 2.0.0-experimental.61e27a2

package/dist/index.browser.cjs

@@ -7,176 +7,55 @@ var functional = require('@solana/functional');
 var instructions = require('@solana/instructions');
 var keys = require('@solana/keys');
 var programs = require('@solana/programs');
+var rpc = require('@solana/rpc');
 var rpcParsedTypes = require('@solana/rpc-parsed-types');
+var rpcSubscriptions = require('@solana/rpc-subscriptions');
 var rpcTypes = require('@solana/rpc-types');
 var signers = require('@solana/signers');
 var transactions = require('@solana/transactions');
-var rpcCore = require('@solana/rpc-core');
-var rpcTransport = require('@solana/rpc-transport');
-var fastStableStringify = require('fast-stable-stringify');
-var errors = require('@solana/errors');
+var transactionConfirmation = require('@solana/transaction-confirmation');
 
-function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+// src/index.ts
 
-var fastStableStringify__default = /*#__PURE__*/_interopDefault(fastStableStringify);
-
-// ../build-scripts/env-shim.ts
-var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
-
-// src/transaction-confirmation-strategy-racer.ts
-async function raceStrategies(signature, config, getSpecificStrategiesForRace) {
-  const { abortSignal: callerAbortSignal, commitment, getRecentSignatureConfirmationPromise } = config;
-  callerAbortSignal?.throwIfAborted();
-  const abortController = new AbortController();
-  if (callerAbortSignal) {
-    const handleAbort = () => {
-      abortController.abort();
-    };
-    callerAbortSignal.addEventListener("abort", handleAbort, { signal: abortController.signal });
-  }
-  try {
-    const specificStrategies = getSpecificStrategiesForRace({
-      ...config,
-      abortSignal: abortController.signal
-    });
-    return await Promise.race([
-      getRecentSignatureConfirmationPromise({
-        abortSignal: abortController.signal,
-        commitment,
-        signature
-      }),
-      ...specificStrategies
-    ]);
-  } finally {
-    abortController.abort();
-  }
-}
-function createRecentSignatureConfirmationPromiseFactory(rpc, rpcSubscriptions) {
-  return async function getRecentSignatureConfirmationPromise({
-    abortSignal: callerAbortSignal,
+// src/airdrop-internal.ts
+async function requestAndConfirmAirdrop_INTERNAL_ONLY_DO_NOT_EXPORT({
+  abortSignal,
+  commitment,
+  confirmSignatureOnlyTransaction,
+  lamports,
+  recipientAddress,
+  rpc
+}) {
+  const airdropTransactionSignature = await rpc.requestAirdrop(recipientAddress, lamports, { commitment }).send({ abortSignal });
+  await confirmSignatureOnlyTransaction({
+    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 && rpcTypes.commitmentComparator(signatureStatus.confirmationStatus, commitment) >= 0) {
-        return;
-      } else {
-        await new Promise(() => {
-        });
-      }
-    })();
-    try {
-      return await Promise.race([signatureDidCommitPromise, signatureStatusLookupPromise]);
-    } finally {
-      abortController.abort();
-    }
-  };
-}
-
-// src/transaction-confirmation-strategy-timeout.ts
-async function getTimeoutPromise({ abortSignal: callerAbortSignal, commitment }) {
-  return await new Promise((_, reject) => {
-    const handleAbort = (e) => {
-      clearTimeout(timeoutId);
-      const abortError = new DOMException(e.target.reason, "AbortError");
-      reject(abortError);
-    };
-    callerAbortSignal.addEventListener("abort", handleAbort);
-    const timeoutMs = commitment === "processed" ? 3e4 : 6e4;
-    const startMs = performance.now();
-    const timeoutId = (
-      // We use `setTimeout` instead of `AbortSignal.timeout()` because we want to measure
-      // elapsed time instead of active time.
-      // See https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal/timeout_static
-      setTimeout(() => {
-        const elapsedMs = performance.now() - startMs;
-        reject(new DOMException(`Timeout elapsed after ${elapsedMs} ms`, "TimeoutError"));
-      }, timeoutMs)
-    );
+    signature: airdropTransactionSignature
   });
+  return airdropTransactionSignature;
 }
 
-// src/airdrop-confirmer.ts
-function createDefaultSignatureOnlyRecentTransactionConfirmer({
-  rpc,
-  rpcSubscriptions
-}) {
-  const getRecentSignatureConfirmationPromise = createRecentSignatureConfirmationPromiseFactory(
+// src/airdrop.ts
+function airdropFactory({ rpc, rpcSubscriptions }) {
+  const getRecentSignatureConfirmationPromise = transactionConfirmation.createRecentSignatureConfirmationPromiseFactory(
     rpc,
     rpcSubscriptions
   );
-  return async function confirmSignatureOnlyRecentTransaction(config) {
-    await waitForRecentTransactionConfirmationUntilTimeout({
+  async function confirmSignatureOnlyTransaction(config) {
+    await transactionConfirmation.waitForRecentTransactionConfirmationUntilTimeout({
       ...config,
       getRecentSignatureConfirmationPromise,
-      getTimeoutPromise
+      getTimeoutPromise: transactionConfirmation.getTimeoutPromise
     });
-  };
-}
-async function waitForRecentTransactionConfirmationUntilTimeout(config) {
-  await raceStrategies(
-    config.signature,
-    config,
-    function getSpecificStrategiesForRace({ abortSignal, commitment, getTimeoutPromise: getTimeoutPromise2 }) {
-      return [
-        getTimeoutPromise2({
-          abortSignal,
-          commitment
-        })
-      ];
-    }
-  );
-}
-
-// src/airdrop.ts
-function createDefaultAirdropRequester({ rpc, rpcSubscriptions }) {
-  const confirmSignatureOnlyTransaction = createDefaultSignatureOnlyRecentTransactionConfirmer({
-    rpc,
-    rpcSubscriptions
-  });
-  return async function requestAirdrop(config) {
-    return await requestAndConfirmAirdrop({
+  }
+  return async function airdrop(config) {
+    return await requestAndConfirmAirdrop_INTERNAL_ONLY_DO_NOT_EXPORT({
       ...config,
       confirmSignatureOnlyTransaction,
       rpc
     });
   };
 }
-async function requestAndConfirmAirdrop({
-  abortSignal,
-  commitment,
-  confirmSignatureOnlyTransaction,
-  lamports,
-  recipientAddress,
-  rpc
-}) {
-  const airdropTransactionSignature = await rpc.requestAirdrop(recipientAddress, lamports, { commitment }).send({ abortSignal });
-  await confirmSignatureOnlyTransaction({
-    abortSignal,
-    commitment,
-    signature: airdropTransactionSignature
-  });
-  return airdropTransactionSignature;
-}
 var compiledTransactionDecoder = void 0;
 async function fetchLookupTables(lookupTableAddresses, rpc, config) {
   const fetchedLookupTables = await accounts.fetchJsonParsedAccounts(
@@ -207,656 +86,6 @@ async function decodeTransaction(encodedTransaction, rpc, config) {
     lastValidBlockHeight
   });
 }
-function createSolanaJsonRpcIntegerOverflowError(methodName, keyPath, value) {
-  let argumentLabel = "";
-  if (typeof keyPath[0] === "number") {
-    const argPosition = keyPath[0] + 1;
-    const lastDigit = argPosition % 10;
-    const lastTwoDigits = argPosition % 100;
-    if (lastDigit == 1 && lastTwoDigits != 11) {
-      argumentLabel = argPosition + "st";
-    } else if (lastDigit == 2 && lastTwoDigits != 12) {
-      argumentLabel = argPosition + "nd";
-    } else if (lastDigit == 3 && lastTwoDigits != 13) {
-      argumentLabel = argPosition + "rd";
-    } else {
-      argumentLabel = argPosition + "th";
-    }
-  } else {
-    argumentLabel = `\`${keyPath[0].toString()}\``;
-  }
-  const path = keyPath.length > 1 ? keyPath.slice(1).map((pathPart) => typeof pathPart === "number" ? `[${pathPart}]` : pathPart).join(".") : void 0;
-  const error = new errors.SolanaError(errors.SOLANA_ERROR__RPC_INTEGER_OVERFLOW, {
-    argumentLabel,
-    keyPath,
-    methodName,
-    optionalPathLabel: path ? ` at path \`${path}\`` : "",
-    value,
-    ...path !== void 0 ? { path } : void 0
-  });
-  if ("captureStackTrace" in Error && typeof Error.captureStackTrace === "function") {
-    Error.captureStackTrace(error, createSolanaJsonRpcIntegerOverflowError);
-  }
-  return error;
-}
-
-// src/rpc-default-config.ts
-var DEFAULT_RPC_CONFIG = {
-  defaultCommitment: "confirmed",
-  onIntegerOverflow(methodName, keyPath, value) {
-    throw createSolanaJsonRpcIntegerOverflowError(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
-}) {
-  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 ||= 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;
-      };
-    }
-  });
-}
-
-// src/rpc.ts
-function createSolanaRpc(config) {
-  const api = rpcCore.createSolanaRpcApi(DEFAULT_RPC_CONFIG);
-  return rpcTransport.createJsonRpc({
-    ...config,
-    api
-  });
-}
-function createSolanaRpcSubscriptions(config) {
-  return functional.pipe(
-    rpcTransport.createJsonSubscriptionRpc({
-      ...config,
-      api: rpcCore.createSolanaRpcSubscriptionsApi(DEFAULT_RPC_CONFIG)
-    }),
-    (rpcSubscriptions) => getRpcSubscriptionsWithSubscriptionCoalescing({
-      getDeduplicationKey: (...args) => fastStableStringify__default.default(args),
-      rpcSubscriptions
-    })
-  );
-}
-function createSolanaRpcSubscriptions_UNSTABLE(config) {
-  return rpcTransport.createJsonSubscriptionRpc({
-    ...config,
-    api: rpcCore.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();
-      const responsePromise = (async () => {
-        try {
-          return await transport({
-            ...config,
-            signal: abortController.signal
-          });
-        } catch (e) {
-          if (e && typeof e === "object" && "name" in e && e.name === "AbortError") {
-            return;
-          }
-          throw e;
-        }
-      })();
-      coalescedRequestsByDeduplicationKey[deduplicationKey] = {
-        abortController,
-        numConsumers: 0,
-        responsePromise
-      };
-    }
-    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__default.default([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];
-  }
-  return out;
-}
-function createDefaultRpcTransport(config) {
-  return functional.pipe(
-    rpcTransport.createHttpTransport({
-      ...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);
-          }
-        }
-      })();
-      if (globalThis.navigator.onLine) {
-        restartPingTimer();
-      }
-      let handleOffline;
-      let handleOnline;
-      {
-        handleOffline = () => {
-          clearInterval(intervalId);
-        };
-        handleOnline = () => {
-          sendPing();
-          restartPingTimer();
-        };
-        globalThis.window.addEventListener("offline", handleOffline);
-        globalThis.window.addEventListener("online", handleOnline);
-      }
-    }
-    return pingableConnections.get(connection);
-  };
-}
-
-// 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 functional.pipe(
-    rpcTransport.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
-    })
-  );
-}
-
-// src/transaction-confirmation-strategy-blockheight.ts
-function createBlockHeightExceedencePromiseFactory({
-  rpc,
-  rpcSubscriptions
-}) {
-  return async function getBlockHeightExceedencePromise({
-    abortSignal: callerAbortSignal,
-    commitment,
-    lastValidBlockHeight
-  }) {
-    const abortController = new AbortController();
-    const handleAbort = () => {
-      abortController.abort();
-    };
-    callerAbortSignal.addEventListener("abort", handleAbort, { signal: abortController.signal });
-    async function getBlockHeightAndDifferenceBetweenSlotHeightAndBlockHeight() {
-      const { absoluteSlot, blockHeight } = await rpc.getEpochInfo({ commitment }).send({ abortSignal: abortController.signal });
-      return {
-        blockHeight,
-        differenceBetweenSlotHeightAndBlockHeight: absoluteSlot - blockHeight
-      };
-    }
-    try {
-      const [slotNotifications, { blockHeight, differenceBetweenSlotHeightAndBlockHeight }] = await Promise.all([
-        rpcSubscriptions.slotNotifications().subscribe({ abortSignal: abortController.signal }),
-        getBlockHeightAndDifferenceBetweenSlotHeightAndBlockHeight()
-      ]);
-      if (blockHeight <= lastValidBlockHeight) {
-        let lastKnownDifferenceBetweenSlotHeightAndBlockHeight = differenceBetweenSlotHeightAndBlockHeight;
-        for await (const slotNotification of slotNotifications) {
-          const { slot } = slotNotification;
-          if (slot - lastKnownDifferenceBetweenSlotHeightAndBlockHeight > lastValidBlockHeight) {
-            const {
-              blockHeight: currentBlockHeight,
-              differenceBetweenSlotHeightAndBlockHeight: currentDifferenceBetweenSlotHeightAndBlockHeight
-            } = await getBlockHeightAndDifferenceBetweenSlotHeightAndBlockHeight();
-            if (currentBlockHeight > lastValidBlockHeight) {
-              break;
-            } else {
-              lastKnownDifferenceBetweenSlotHeightAndBlockHeight = currentDifferenceBetweenSlotHeightAndBlockHeight;
-            }
-          }
-        }
-      }
-      throw new Error(
-        "The network has progressed past the last block for which this transaction could have been committed."
-      );
-    } finally {
-      abortController.abort();
-    }
-  };
-}
-var NONCE_VALUE_OFFSET = 4 + // version(u32)
-4 + // state(u32)
-32;
-function createNonceInvalidationPromiseFactory(rpc, rpcSubscriptions) {
-  return async function getNonceInvalidationPromise({
-    abortSignal: callerAbortSignal,
-    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 });
-    const base58Decoder = codecs.getBase58Decoder();
-    const base64Encoder = codecs.getBase64Encoder();
-    function getNonceFromAccountData([base64EncodedBytes]) {
-      const data = base64Encoder.encode(base64EncodedBytes);
-      const nonceValueBytes = data.slice(NONCE_VALUE_OFFSET, NONCE_VALUE_OFFSET + 32);
-      return base58Decoder.decode(nonceValueBytes);
-    }
-    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();
-    }
-  };
-}
-
-// src/transaction-confirmation.ts
-function createDefaultDurableNonceTransactionConfirmer({
-  rpc,
-  rpcSubscriptions
-}) {
-  const getNonceInvalidationPromise = createNonceInvalidationPromiseFactory(rpc, rpcSubscriptions);
-  const getRecentSignatureConfirmationPromise = createRecentSignatureConfirmationPromiseFactory(
-    rpc,
-    rpcSubscriptions
-  );
-  return async function confirmDurableNonceTransaction(config) {
-    await waitForDurableNonceTransactionConfirmation({
-      ...config,
-      getNonceInvalidationPromise,
-      getRecentSignatureConfirmationPromise
-    });
-  };
-}
-function createDefaultRecentTransactionConfirmer({
-  rpc,
-  rpcSubscriptions
-}) {
-  const getBlockHeightExceedencePromise = createBlockHeightExceedencePromiseFactory({
-    rpc,
-    rpcSubscriptions
-  });
-  const getRecentSignatureConfirmationPromise = createRecentSignatureConfirmationPromiseFactory(
-    rpc,
-    rpcSubscriptions
-  );
-  return async function confirmRecentTransaction(config) {
-    await waitForRecentTransactionConfirmation({
-      ...config,
-      getBlockHeightExceedencePromise,
-      getRecentSignatureConfirmationPromise
-    });
-  };
-}
-async function waitForDurableNonceTransactionConfirmation(config) {
-  await raceStrategies(
-    transactions.getSignatureFromTransaction(config.transaction),
-    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(
-    transactions.getSignatureFromTransaction(config.transaction),
-    config,
-    function getSpecificStrategiesForRace({
-      abortSignal,
-      commitment,
-      getBlockHeightExceedencePromise,
-      transaction
-    }) {
-      return [
-        getBlockHeightExceedencePromise({
-          abortSignal,
-          commitment,
-          lastValidBlockHeight: transaction.lifetimeConstraint.lastValidBlockHeight
-        })
-      ];
-    }
-  );
-}
-
-// src/send-transaction.ts
 function getSendTransactionConfigWithAdjustedPreflightCommitment(commitment, config) {
   if (
     // The developer has supplied no value for `preflightCommitment`.
@@ -878,7 +107,7 @@ function getSendTransactionConfigWithAdjustedPreflightCommitment(commitment, con
   }
   return config;
 }
-async function sendTransaction_INTERNAL({
+async function sendTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
   abortSignal,
   commitment,
   rpc,
@@ -891,41 +120,7 @@ async function sendTransaction_INTERNAL({
     encoding: "base64"
   }).send({ abortSignal });
 }
-function createDefaultDurableNonceTransactionSender({
-  rpc,
-  rpcSubscriptions
-}) {
-  const confirmDurableNonceTransaction = createDefaultDurableNonceTransactionConfirmer({
-    rpc,
-    rpcSubscriptions
-  });
-  return async function sendDurableNonceTransaction(transaction, config) {
-    await sendAndConfirmDurableNonceTransaction({
-      ...config,
-      confirmDurableNonceTransaction,
-      rpc,
-      transaction
-    });
-  };
-}
-function createDefaultTransactionSender({
-  rpc,
-  rpcSubscriptions
-}) {
-  const confirmRecentTransaction = createDefaultRecentTransactionConfirmer({
-    rpc,
-    rpcSubscriptions
-  });
-  return async function sendTransaction(transaction, config) {
-    await sendAndConfirmTransaction({
-      ...config,
-      confirmRecentTransaction,
-      rpc,
-      transaction
-    });
-  };
-}
-async function sendAndConfirmDurableNonceTransaction({
+async function sendAndConfirmDurableNonceTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
   abortSignal,
   commitment,
   confirmDurableNonceTransaction,
@@ -933,7 +128,7 @@ async function sendAndConfirmDurableNonceTransaction({
   transaction,
   ...sendTransactionConfig
 }) {
-  const transactionSignature = await sendTransaction_INTERNAL({
+  const transactionSignature = await sendTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
     ...sendTransactionConfig,
     abortSignal,
     commitment,
@@ -947,7 +142,7 @@ async function sendAndConfirmDurableNonceTransaction({
   });
   return transactionSignature;
 }
-async function sendAndConfirmTransaction({
+async function sendAndConfirmTransactionWithBlockhashLifetime_INTERNAL_ONLY_DO_NOT_EXPORT({
   abortSignal,
   commitment,
   confirmRecentTransaction,
@@ -955,7 +150,7 @@ async function sendAndConfirmTransaction({
   transaction,
   ...sendTransactionConfig
 }) {
-  const transactionSignature = await sendTransaction_INTERNAL({
+  const transactionSignature = await sendTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
     ...sendTransactionConfig,
     abortSignal,
     commitment,
@@ -970,25 +165,77 @@ async function sendAndConfirmTransaction({
   return transactionSignature;
 }
 
-exports.createBlockHeightExceedencePromiseFactory = createBlockHeightExceedencePromiseFactory;
-exports.createDefaultAirdropRequester = createDefaultAirdropRequester;
-exports.createDefaultDurableNonceTransactionConfirmer = createDefaultDurableNonceTransactionConfirmer;
-exports.createDefaultDurableNonceTransactionSender = createDefaultDurableNonceTransactionSender;
-exports.createDefaultRecentTransactionConfirmer = createDefaultRecentTransactionConfirmer;
-exports.createDefaultRpcSubscriptionsTransport = createDefaultRpcSubscriptionsTransport;
-exports.createDefaultRpcTransport = createDefaultRpcTransport;
-exports.createDefaultTransactionSender = createDefaultTransactionSender;
-exports.createNonceInvalidationPromiseFactory = createNonceInvalidationPromiseFactory;
-exports.createRecentSignatureConfirmationPromiseFactory = createRecentSignatureConfirmationPromiseFactory;
-exports.createSolanaRpc = createSolanaRpc;
-exports.createSolanaRpcSubscriptions = createSolanaRpcSubscriptions;
-exports.createSolanaRpcSubscriptions_UNSTABLE = createSolanaRpcSubscriptions_UNSTABLE;
+// src/send-transaction.ts
+function sendTransactionWithoutConfirmingFactory({
+  rpc
+}) {
+  return async function sendTransactionWithoutConfirming(transaction, config) {
+    await sendTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
+      ...config,
+      rpc,
+      transaction
+    });
+  };
+}
+function sendAndConfirmDurableNonceTransactionFactory({
+  rpc,
+  rpcSubscriptions
+}) {
+  const getNonceInvalidationPromise = transactionConfirmation.createNonceInvalidationPromiseFactory(rpc, rpcSubscriptions);
+  const getRecentSignatureConfirmationPromise = transactionConfirmation.createRecentSignatureConfirmationPromiseFactory(
+    rpc,
+    rpcSubscriptions
+  );
+  async function confirmDurableNonceTransaction(config) {
+    await transactionConfirmation.waitForDurableNonceTransactionConfirmation({
+      ...config,
+      getNonceInvalidationPromise,
+      getRecentSignatureConfirmationPromise
+    });
+  }
+  return async function sendAndConfirmDurableNonceTransaction(transaction, config) {
+    await sendAndConfirmDurableNonceTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
+      ...config,
+      confirmDurableNonceTransaction,
+      rpc,
+      transaction
+    });
+  };
+}
+function sendAndConfirmTransactionFactory({
+  rpc,
+  rpcSubscriptions
+}) {
+  const getBlockHeightExceedencePromise = transactionConfirmation.createBlockHeightExceedencePromiseFactory({
+    rpc,
+    rpcSubscriptions
+  });
+  const getRecentSignatureConfirmationPromise = transactionConfirmation.createRecentSignatureConfirmationPromiseFactory(
+    rpc,
+    rpcSubscriptions
+  );
+  async function confirmRecentTransaction(config) {
+    await transactionConfirmation.waitForRecentTransactionConfirmation({
+      ...config,
+      getBlockHeightExceedencePromise,
+      getRecentSignatureConfirmationPromise
+    });
+  }
+  return async function sendAndConfirmTransaction(transaction, config) {
+    await sendAndConfirmTransactionWithBlockhashLifetime_INTERNAL_ONLY_DO_NOT_EXPORT({
+      ...config,
+      confirmRecentTransaction,
+      rpc,
+      transaction
+    });
+  };
+}
+
+exports.airdropFactory = airdropFactory;
 exports.decodeTransaction = decodeTransaction;
-exports.requestAndConfirmAirdrop = requestAndConfirmAirdrop;
-exports.sendAndConfirmDurableNonceTransaction = sendAndConfirmDurableNonceTransaction;
-exports.sendAndConfirmTransaction = sendAndConfirmTransaction;
-exports.waitForDurableNonceTransactionConfirmation = waitForDurableNonceTransactionConfirmation;
-exports.waitForRecentTransactionConfirmation = waitForRecentTransactionConfirmation;
+exports.sendAndConfirmDurableNonceTransactionFactory = sendAndConfirmDurableNonceTransactionFactory;
+exports.sendAndConfirmTransactionFactory = sendAndConfirmTransactionFactory;
+exports.sendTransactionWithoutConfirmingFactory = sendTransactionWithoutConfirmingFactory;
 Object.keys(accounts).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,
@@ -1031,12 +278,24 @@ Object.keys(programs).forEach(function (k) {
     get: function () { return programs[k]; }
   });
 });
+Object.keys(rpc).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return rpc[k]; }
+  });
+});
 Object.keys(rpcParsedTypes).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,
     get: function () { return rpcParsedTypes[k]; }
   });
 });
+Object.keys(rpcSubscriptions).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return rpcSubscriptions[k]; }
+  });
+});
 Object.keys(rpcTypes).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,