@solana/web3.js 2.0.0-experimental.ba46ce1 → 2.0.0-experimental.ba9b4c7

package/dist/index.node.cjs

@@ -4,10 +4,11 @@ var addresses = require('@solana/addresses');
 var instructions = require('@solana/instructions');
 var keys = require('@solana/keys');
 var transactions = require('@solana/transactions');
-var functional = require('@solana/functional');
 var rpcCore = require('@solana/rpc-core');
+var functional = require('@solana/functional');
 var rpcTransport = require('@solana/rpc-transport');
 var fastStableStringify = require('fast-stable-stringify');
+var umiSerializers = require('@metaplex-foundation/umi-serializers');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -16,6 +17,159 @@ var fastStableStringify__default = /*#__PURE__*/_interopDefault(fastStableString
 // ../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();
+  function 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 && rpcCore.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 {
   constructor(methodName, keyPath, value) {
@@ -258,6 +412,12 @@ function createSolanaRpcSubscriptions(config) {
     })
   );
 }
+function createSolanaRpcSubscriptions_UNSTABLE(config) {
+  return rpcTransport.createJsonSubscriptionRpc({
+    ...config,
+    api: rpcCore.createSolanaRpcSubscriptionsApi_UNSTABLE(DEFAULT_RPC_CONFIG)
+  });
+}
 
 // src/rpc-request-coalescer.ts
 function getRpcTransportWithRequestCoalescing(transport, getDeduplicationKey) {
@@ -435,10 +595,285 @@ function createDefaultRpcSubscriptionsTransport(config) {
   );
 }
 
+// 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 });
+    function getNonceFromAccountData([base64EncodedBytes]) {
+      const data = umiSerializers.base64.serialize(base64EncodedBytes);
+      const nonceValueBytes = data.slice(NONCE_VALUE_OFFSET, NONCE_VALUE_OFFSET + 32);
+      return umiSerializers.base58.deserialize(nonceValueBytes)[0];
+    }
+    const nonceAccountDidAdvancePromise = (async () => {
+      for await (const accountNotification of accountNotifications) {
+        const nonceValue = getNonceFromAccountData(accountNotification.value.data);
+        if (nonceValue !== currentNonceValue) {
+          throw new Error(
+            `The nonce \`${currentNonceValue}\` is no longer valid. It has advanced to \`${nonceValue}\`.`
+          );
+        }
+      }
+    })();
+    const nonceIsAlreadyInvalidPromise = (async () => {
+      const { value: nonceAccount } = await rpc.getAccountInfo(nonceAccountAddress, {
+        commitment,
+        dataSlice: { length: 32, offset: NONCE_VALUE_OFFSET },
+        encoding: "base58"
+      }).send({ abortSignal: abortController.signal });
+      if (!nonceAccount) {
+        throw new Error(`No nonce account could be found at address \`${nonceAccountAddress}\`.`);
+      }
+      const nonceValue = (
+        // This works because we asked for the exact slice of data representing the nonce
+        // value, and furthermore asked for it in `base58` encoding.
+        nonceAccount.data[0]
+      );
+      if (nonceValue !== currentNonceValue) {
+        throw new Error(
+          `The nonce \`${currentNonceValue}\` is no longer valid. It has advanced to \`${nonceValue}\`.`
+        );
+      } else {
+        await new Promise(() => {
+        });
+      }
+    })();
+    try {
+      return await Promise.race([nonceAccountDidAdvancePromise, nonceIsAlreadyInvalidPromise]);
+    } finally {
+      abortController.abort();
+    }
+  };
+}
+
+// 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(
+    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, 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`.
+    rpcCore.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 = transactions.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({
+    abortSignal,
+    commitment,
+    rpc,
+    sendTransactionConfig,
+    transaction
+  });
+  await confirmDurableNonceTransaction({
+    abortSignal,
+    commitment,
+    transaction
+  });
+  return transactionSignature;
+}
+async function sendAndConfirmTransaction({
+  abortSignal,
+  commitment,
+  confirmRecentTransaction,
+  rpc,
+  transaction,
+  ...sendTransactionConfig
+}) {
+  const transactionSignature = await sendTransaction_INTERNAL({
+    abortSignal,
+    commitment,
+    rpc,
+    sendTransactionConfig,
+    transaction
+  });
+  await confirmRecentTransaction({
+    abortSignal,
+    commitment,
+    transaction
+  });
+  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;
+exports.requestAndConfirmAirdrop = requestAndConfirmAirdrop;
+exports.sendAndConfirmDurableNonceTransaction = sendAndConfirmDurableNonceTransaction;
+exports.sendAndConfirmTransaction = sendAndConfirmTransaction;
+exports.waitForDurableNonceTransactionConfirmation = waitForDurableNonceTransactionConfirmation;
+exports.waitForRecentTransactionConfirmation = waitForRecentTransactionConfirmation;
 Object.keys(addresses).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,