@solana/web3.js 2.0.0-development → 2.0.0-experimental.0099b2a

package/dist/index.native.js

@@ -1,10 +1,173 @@
+export * from '@solana/addresses';
 export * from '@solana/instructions';
 export * from '@solana/keys';
-import { createSolanaRpcApi } from '@solana/rpc-core';
-import { createJsonRpc, createHttpTransport } from '@solana/rpc-transport';
+import { commitmentComparator } from '@solana/rpc-types';
+export * from '@solana/rpc-types';
+import { getSignatureFromTransaction, getBase64EncodedWireTransaction } from '@solana/transactions';
+export * from '@solana/transactions';
+import { pipe } from '@solana/functional';
+import { createSolanaRpcApi, createSolanaRpcSubscriptionsApi, createSolanaRpcSubscriptionsApi_UNSTABLE } from '@solana/rpc-core';
+import { createJsonRpc, createJsonSubscriptionRpc, createHttpTransport, createWebSocketTransport } from '@solana/rpc-transport';
 import fastStableStringify from 'fast-stable-stringify';
+import { getBase58Decoder, getBase64Encoder } from '@solana/codecs-strings';
 
-// src/index.ts
+// ../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,
+    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();
+    }
+  };
+}
+
+// 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)
+    );
+  });
+}
+
+// src/airdrop-confirmer.ts
+function createDefaultSignatureOnlyRecentTransactionConfirmer({
+  rpc,
+  rpcSubscriptions
+}) {
+  const getRecentSignatureConfirmationPromise = createRecentSignatureConfirmationPromiseFactory(
+    rpc,
+    rpcSubscriptions
+  );
+  return async function confirmSignatureOnlyRecentTransaction(config) {
+    await waitForRecentTransactionConfirmationUntilTimeout({
+      ...config,
+      getRecentSignatureConfirmationPromise,
+      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({
+      ...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;
+}
 
 // src/rpc-integer-overflow-error.ts
 var SolanaJsonRpcIntegerOverflowError = class extends Error {
@@ -42,6 +205,193 @@ var DEFAULT_RPC_CONFIG = {
   }
 };
 
+// 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 || (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) {
   return createJsonRpc({
@@ -49,6 +399,24 @@ function createSolanaRpc(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
+    })
+  );
+}
+function createSolanaRpcSubscriptions_UNSTABLE(config) {
+  return createJsonSubscriptionRpc({
+    ...config,
+    api: createSolanaRpcSubscriptionsApi_UNSTABLE(DEFAULT_RPC_CONFIG)
+  });
+}
 
 // src/rpc-request-coalescer.ts
 function getRpcTransportWithRequestCoalescing(transport, getDeduplicationKey) {
@@ -101,13 +469,14 @@ function getRpcTransportWithRequestCoalescing(transport, getDeduplicationKey) {
     }
   };
 }
-function getSolanaRpcPayloadDeduplicationKey(payload) {
+function isJsonRpcPayload(payload) {
   if (payload == null || typeof payload !== "object" || Array.isArray(payload)) {
-    return;
-  }
-  if ("jsonrpc" in payload && payload.jsonrpc === "2.0" && "method" in payload && "params" in payload) {
-    return fastStableStringify([payload.method, payload.params]);
+    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
@@ -119,7 +488,7 @@ function normalizeHeaders(headers) {
   return out;
 }
 function createDefaultRpcTransport(config) {
-  return getRpcTransportWithRequestCoalescing(
+  return pipe(
     createHttpTransport({
       ...config,
       headers: {
@@ -130,10 +499,367 @@ function createDefaultRpcTransport(config) {
         }
       }
     }),
-    getSolanaRpcPayloadDeduplicationKey
+    (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);
+  };
+}
+
+// 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
+    })
+  );
+}
+
+// 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();
+    }
+  };
+}
+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 = getBase58Decoder();
+    const base64Encoder = getBase64Encoder();
+    function getNonceFromAccountData([base64EncodedBytes]) {
+      const data = base64Encoder.encode(base64EncodedBytes);
+      const nonceValueBytes = data.slice(NONCE_VALUE_OFFSET, NONCE_VALUE_OFFSET + 32);
+      return base58Decoder.decode(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();
+    }
+  };
+}
+
+// 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(rpcSubscriptions);
+  const getRecentSignatureConfirmationPromise = createRecentSignatureConfirmationPromiseFactory(
+    rpc,
+    rpcSubscriptions
   );
+  return async function confirmRecentTransaction(config) {
+    await waitForRecentTransactionConfirmation({
+      ...config,
+      getBlockHeightExceedencePromise,
+      getRecentSignatureConfirmationPromise
+    });
+  };
+}
+async function waitForDurableNonceTransactionConfirmation(config) {
+  await raceStrategies(
+    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(
+    getSignatureFromTransaction(config.transaction),
+    config,
+    function getSpecificStrategiesForRace({ abortSignal, getBlockHeightExceedencePromise, transaction }) {
+      return [
+        getBlockHeightExceedencePromise({
+          abortSignal,
+          lastValidBlockHeight: transaction.lifetimeConstraint.lastValidBlockHeight
+        })
+      ];
+    }
+  );
+}
+
+// src/send-transaction.ts
+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;
+}
+async function sendTransaction_INTERNAL({
+  abortSignal,
+  commitment,
+  rpc,
+  transaction,
+  ...sendTransactionConfig
+}) {
+  const base64EncodedWireTransaction = getBase64EncodedWireTransaction(transaction);
+  return await rpc.sendTransaction(base64EncodedWireTransaction, {
+    ...getSendTransactionConfigWithAdjustedPreflightCommitment(commitment, sendTransactionConfig),
+    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({
+  abortSignal,
+  commitment,
+  confirmDurableNonceTransaction,
+  rpc,
+  transaction,
+  ...sendTransactionConfig
+}) {
+  const transactionSignature = await sendTransaction_INTERNAL({
+    ...sendTransactionConfig,
+    abortSignal,
+    commitment,
+    rpc,
+    transaction
+  });
+  await confirmDurableNonceTransaction({
+    abortSignal,
+    commitment,
+    transaction
+  });
+  return transactionSignature;
+}
+async function sendAndConfirmTransaction({
+  abortSignal,
+  commitment,
+  confirmRecentTransaction,
+  rpc,
+  transaction,
+  ...sendTransactionConfig
+}) {
+  const transactionSignature = await sendTransaction_INTERNAL({
+    ...sendTransactionConfig,
+    abortSignal,
+    commitment,
+    rpc,
+    transaction
+  });
+  await confirmRecentTransaction({
+    abortSignal,
+    commitment,
+    transaction
+  });
+  return transactionSignature;
 }
 
-export { createDefaultRpcTransport, createSolanaRpc };
+export { createBlockHeightExceedencePromiseFactory, createDefaultAirdropRequester, createDefaultDurableNonceTransactionConfirmer, createDefaultDurableNonceTransactionSender, createDefaultRecentTransactionConfirmer, createDefaultRpcSubscriptionsTransport, createDefaultRpcTransport, createDefaultTransactionSender, createNonceInvalidationPromiseFactory, createRecentSignatureConfirmationPromiseFactory, createSolanaRpc, createSolanaRpcSubscriptions, createSolanaRpcSubscriptions_UNSTABLE, requestAndConfirmAirdrop, sendAndConfirmDurableNonceTransaction, sendAndConfirmTransaction, waitForDurableNonceTransactionConfirmation, waitForRecentTransactionConfirmation };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.native.js.map