@solana/web3.js 2.0.0-experimental.3244e3e → 2.0.0-experimental.34c3228

package/dist/index.browser.cjs

@@ -1,52 +1,425 @@
 'use strict';
 
+var accounts = require('@solana/accounts');
+var addresses = require('@solana/addresses');
+var codecs = require('@solana/codecs');
+var functional = require('@solana/functional');
+var instructions = require('@solana/instructions');
 var keys = require('@solana/keys');
+var programs = require('@solana/programs');
+var rpcParsedTypes = require('@solana/rpc-parsed-types');
+var rpcTypes = require('@solana/rpc-types');
+var signers = require('@solana/signers');
+var transactions = require('@solana/transactions');
+var transactionConfirmation = require('@solana/transaction-confirmation');
 var rpcCore = require('@solana/rpc-core');
 var rpcTransport = require('@solana/rpc-transport');
+var fastStableStringify = require('fast-stable-stringify');
+var errors = require('@solana/errors');
 
-// src/index.ts
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
-// 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 = "";
+var fastStableStringify__default = /*#__PURE__*/_interopDefault(fastStableStringify);
+
+// ../build-scripts/env-shim.ts
+var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
+
+// 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: airdropTransactionSignature
+  });
+  return airdropTransactionSignature;
+}
+
+// src/airdrop.ts
+function airdropFactory({ rpc, rpcSubscriptions }) {
+  const getRecentSignatureConfirmationPromise = transactionConfirmation.createRecentSignatureConfirmationPromiseFactory(
+    rpc,
+    rpcSubscriptions
+  );
+  async function confirmSignatureOnlyTransaction(config) {
+    await transactionConfirmation.waitForRecentTransactionConfirmationUntilTimeout({
+      ...config,
+      getRecentSignatureConfirmationPromise,
+      getTimeoutPromise: transactionConfirmation.getTimeoutPromise
+    });
+  }
+  return async function airdrop(config) {
+    return await requestAndConfirmAirdrop_INTERNAL_ONLY_DO_NOT_EXPORT({
+      ...config,
+      confirmSignatureOnlyTransaction,
+      rpc
+    });
+  };
+}
+var compiledTransactionDecoder = void 0;
+async function fetchLookupTables(lookupTableAddresses, rpc, config) {
+  const fetchedLookupTables = await accounts.fetchJsonParsedAccounts(
+    rpc,
+    lookupTableAddresses,
+    config
+  );
+  accounts.assertAccountsDecoded(fetchedLookupTables);
+  accounts.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 = transactions.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 transactions.decompileTransaction(compiledTransaction, {
+    addressesByLookupTableAddress: fetchedLookupTables,
+    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) {
-      ordinal = argPosition + "st";
+      argumentLabel = argPosition + "st";
     } else if (lastDigit == 2 && lastTwoDigits != 12) {
-      ordinal = argPosition + "nd";
+      argumentLabel = argPosition + "nd";
     } else if (lastDigit == 3 && lastTwoDigits != 13) {
-      ordinal = argPosition + "rd";
+      argumentLabel = argPosition + "rd";
     } else {
-      ordinal = argPosition + "th";
+      argumentLabel = 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;
+  } else {
+    argumentLabel = `\`${keyPath[0].toString()}\``;
   }
-  get name() {
-    return "SolanaJsonRpcIntegerOverflowError";
+  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 new SolanaJsonRpcIntegerOverflowError(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: rpcCore.createSolanaRpcApi(DEFAULT_RPC_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) {
@@ -55,23 +428,348 @@ function normalizeHeaders(headers) {
   return out;
 }
 function createDefaultRpcTransport(config) {
-  return 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"
+  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
+    })
+  );
+}
+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`.
+    rpcTypes.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;
+}
+async function sendTransaction_INTERNAL_ONLY_DO_NOT_EXPORT({
+  abortSignal,
+  commitment,
+  rpc,
+  transaction,
+  ...sendTransactionConfig
+}) {
+  const base64EncodedWireTransaction = transactions.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,
+    rpc,
+    transaction
+  });
+  await confirmDurableNonceTransaction({
+    abortSignal,
+    commitment,
+    transaction
+  });
+  return transactionSignature;
+}
+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,
+    rpc,
+    transaction
+  });
+  await confirmRecentTransaction({
+    abortSignal,
+    commitment,
+    transaction
   });
+  return transactionSignature;
 }
 
+// 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.createDefaultRpcSubscriptionsTransport = createDefaultRpcSubscriptionsTransport;
 exports.createDefaultRpcTransport = createDefaultRpcTransport;
 exports.createSolanaRpc = createSolanaRpc;
+exports.createSolanaRpcSubscriptions = createSolanaRpcSubscriptions;
+exports.createSolanaRpcSubscriptions_UNSTABLE = createSolanaRpcSubscriptions_UNSTABLE;
+exports.decodeTransaction = decodeTransaction;
+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,
+    get: function () { return accounts[k]; }
+  });
+});
+Object.keys(addresses).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return addresses[k]; }
+  });
+});
+Object.keys(codecs).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return codecs[k]; }
+  });
+});
+Object.keys(functional).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return functional[k]; }
+  });
+});
+Object.keys(instructions).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return instructions[k]; }
+  });
+});
 Object.keys(keys).forEach(function (k) {
-  if (k !== 'default' && !exports.hasOwnProperty(k)) Object.defineProperty(exports, k, {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,
     get: function () { return keys[k]; }
   });
 });
+Object.keys(programs).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return programs[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(rpcTypes).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return rpcTypes[k]; }
+  });
+});
+Object.keys(signers).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return signers[k]; }
+  });
+});
+Object.keys(transactions).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return transactions[k]; }
+  });
+});
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=index.browser.cjs.map