@solana/web3.js 2.0.0-experimental.e8095b1 → 2.0.0-experimental.e9c1b10

package/dist/index.native.js

@@ -1,13 +1,22 @@
+import { fetchJsonParsedAccounts, assertAccountsDecoded, assertAccountsExist } from '@solana/accounts';
+export * from '@solana/accounts';
 export * from '@solana/addresses';
+import { getBase58Decoder, getBase64Encoder } from '@solana/codecs';
+export * from '@solana/codecs';
+import { pipe } from '@solana/functional';
+export * from '@solana/functional';
 export * from '@solana/instructions';
 export * from '@solana/keys';
-import { getSignatureFromTransaction, getBase64EncodedWireTransaction } from '@solana/transactions';
+export * from '@solana/programs';
+export * from '@solana/rpc-parsed-types';
+import { commitmentComparator } from '@solana/rpc-types';
+export * from '@solana/rpc-types';
+export * from '@solana/signers';
+import { getCompiledTransactionDecoder, decompileTransaction, getSignatureFromTransaction, getBase64EncodedWireTransaction } from '@solana/transactions';
 export * from '@solana/transactions';
-import { commitmentComparator, createSolanaRpcApi, createSolanaRpcSubscriptionsApi, createSolanaRpcSubscriptionsApi_UNSTABLE } from '@solana/rpc-core';
-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 { base64, base58 } from '@metaplex-foundation/umi-serializers';
 
 // ../build-scripts/env-shim.ts
 var __DEV__ = /* @__PURE__ */ (() => process["env"].NODE_ENV === "development")();
@@ -15,12 +24,14 @@ 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();
+  callerAbortSignal?.throwIfAborted();
   const abortController = new AbortController();
-  function handleAbort() {
-    abortController.abort();
+  if (callerAbortSignal) {
+    const handleAbort = () => {
+      abortController.abort();
+    };
+    callerAbortSignal.addEventListener("abort", handleAbort, { signal: abortController.signal });
   }
-  callerAbortSignal.addEventListener("abort", handleAbort, { signal: abortController.signal });
   try {
     const specificStrategies = getSpecificStrategiesForRace({
       ...config,
@@ -164,26 +175,63 @@ async function requestAndConfirmAirdrop({
   });
   return airdropTransactionSignature;
 }
+var compiledTransactionDecoder = void 0;
+async function fetchLookupTables(lookupTableAddresses, rpc, config) {
+  const fetchedLookupTables = await fetchJsonParsedAccounts(
+    rpc,
+    lookupTableAddresses,
+    config
+  );
+  assertAccountsDecoded(fetchedLookupTables);
+  assertAccountsExist(fetchedLookupTables);
+  return fetchedLookupTables.reduce((acc, lookup) => {
+    return {
+      ...acc,
+      [lookup.address]: lookup.data.addresses
+    };
+  }, {});
+}
+async function decodeTransaction(encodedTransaction, rpc, config) {
+  const { lastValidBlockHeight, ...fetchAccountsConfig } = config ?? {};
+  if (!compiledTransactionDecoder)
+    compiledTransactionDecoder = getCompiledTransactionDecoder();
+  const compiledTransaction = compiledTransactionDecoder.decode(encodedTransaction);
+  const { compiledMessage } = compiledTransaction;
+  const lookupTables = "addressTableLookups" in compiledMessage && compiledMessage.addressTableLookups !== void 0 && compiledMessage.addressTableLookups.length > 0 ? compiledMessage.addressTableLookups : [];
+  const lookupTableAddresses = lookupTables.map((l) => l.lookupTableAddress);
+  const fetchedLookupTables = lookupTableAddresses.length > 0 ? await fetchLookupTables(lookupTableAddresses, rpc, fetchAccountsConfig) : {};
+  return decompileTransaction(compiledTransaction, {
+    addressesByLookupTableAddress: fetchedLookupTables,
+    lastValidBlockHeight
+  });
+}
 
 // src/rpc-integer-overflow-error.ts
 var SolanaJsonRpcIntegerOverflowError = class extends Error {
+  methodName;
+  keyPath;
+  value;
   constructor(methodName, keyPath, value) {
-    const argPosition = (typeof keyPath[0] === "number" ? keyPath[0] : parseInt(keyPath[0], 10)) + 1;
-    let ordinal = "";
-    const lastDigit = argPosition % 10;
-    const lastTwoDigits = argPosition % 100;
-    if (lastDigit == 1 && lastTwoDigits != 11) {
-      ordinal = argPosition + "st";
-    } else if (lastDigit == 2 && lastTwoDigits != 12) {
-      ordinal = argPosition + "nd";
-    } else if (lastDigit == 3 && lastTwoDigits != 13) {
-      ordinal = argPosition + "rd";
+    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 {
-      ordinal = argPosition + "th";
+      argumentLabel = `\`${keyPath[0].toString()}\``;
     }
     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\`.`
+      `The ${argumentLabel} 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;
@@ -196,6 +244,7 @@ var SolanaJsonRpcIntegerOverflowError = class extends Error {
 
 // src/rpc-default-config.ts
 var DEFAULT_RPC_CONFIG = {
+  defaultCommitment: "confirmed",
   onIntegerOverflow(methodName, keyPath, value) {
     throw new SolanaJsonRpcIntegerOverflowError(methodName, keyPath, value);
   }
@@ -355,11 +404,11 @@ function getRpcSubscriptionsWithSubscriptionCoalescing({
             return {
               ...iterable,
               async *[Symbol.asyncIterator]() {
-                abortPromise || (abortPromise = abortSignal.aborted ? Promise.reject(EXPLICIT_ABORT_TOKEN) : new Promise((_, reject) => {
+                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) {
@@ -431,13 +480,23 @@ function getRpcTransportWithRequestCoalescing(transport, getDeduplicationKey) {
     }
     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: transport({
-          ...config,
-          signal: abortController.signal
-        })
+        responsePromise
       };
     }
     const coalescedRequest = coalescedRequestsByDeduplicationKey[deduplicationKey];
@@ -591,22 +650,52 @@ function createDefaultRpcSubscriptionsTransport(config) {
 }
 
 // src/transaction-confirmation-strategy-blockheight.ts
-function createBlockHeightExceedencePromiseFactory(rpcSubscriptions) {
-  return async function getBlockHeightExceedencePromise({ abortSignal: callerAbortSignal, lastValidBlockHeight }) {
+function createBlockHeightExceedencePromiseFactory({
+  rpc,
+  rpcSubscriptions
+}) {
+  return async function getBlockHeightExceedencePromise({
+    abortSignal: callerAbortSignal,
+    commitment,
+    lastValidBlockHeight
+  }) {
     const abortController = new AbortController();
-    function handleAbort() {
+    const handleAbort = () => {
       abortController.abort();
-    }
+    };
     callerAbortSignal.addEventListener("abort", handleAbort, { signal: abortController.signal });
-    const slotNotifications = await rpcSubscriptions.slotNotifications().subscribe({ abortSignal: abortController.signal });
+    async function getBlockHeightAndDifferenceBetweenSlotHeightAndBlockHeight() {
+      const { absoluteSlot, blockHeight } = await rpc.getEpochInfo({ commitment }).send({ abortSignal: abortController.signal });
+      return {
+        blockHeight,
+        differenceBetweenSlotHeightAndBlockHeight: absoluteSlot - blockHeight
+      };
+    }
     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."
-          );
+      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();
     }
@@ -628,10 +717,12 @@ function createNonceInvalidationPromiseFactory(rpc, rpcSubscriptions) {
     }
     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 = base64.serialize(base64EncodedBytes);
+      const data = base64Encoder.encode(base64EncodedBytes);
       const nonceValueBytes = data.slice(NONCE_VALUE_OFFSET, NONCE_VALUE_OFFSET + 32);
-      return base58.deserialize(nonceValueBytes)[0];
+      return base58Decoder.decode(nonceValueBytes);
     }
     const nonceAccountDidAdvancePromise = (async () => {
       for await (const accountNotification of accountNotifications) {
@@ -696,7 +787,10 @@ function createDefaultRecentTransactionConfirmer({
   rpc,
   rpcSubscriptions
 }) {
-  const getBlockHeightExceedencePromise = createBlockHeightExceedencePromiseFactory(rpcSubscriptions);
+  const getBlockHeightExceedencePromise = createBlockHeightExceedencePromiseFactory({
+    rpc,
+    rpcSubscriptions
+  });
   const getRecentSignatureConfirmationPromise = createRecentSignatureConfirmationPromiseFactory(
     rpc,
     rpcSubscriptions
@@ -729,10 +823,16 @@ async function waitForRecentTransactionConfirmation(config) {
   await raceStrategies(
     getSignatureFromTransaction(config.transaction),
     config,
-    function getSpecificStrategiesForRace({ abortSignal, getBlockHeightExceedencePromise, transaction }) {
+    function getSpecificStrategiesForRace({
+      abortSignal,
+      commitment,
+      getBlockHeightExceedencePromise,
+      transaction
+    }) {
       return [
         getBlockHeightExceedencePromise({
           abortSignal,
+          commitment,
           lastValidBlockHeight: transaction.lifetimeConstraint.lastValidBlockHeight
         })
       ];
@@ -767,7 +867,7 @@ async function sendTransaction_INTERNAL({
   commitment,
   rpc,
   transaction,
-  sendTransactionConfig
+  ...sendTransactionConfig
 }) {
   const base64EncodedWireTransaction = getBase64EncodedWireTransaction(transaction);
   return await rpc.sendTransaction(base64EncodedWireTransaction, {
@@ -792,7 +892,10 @@ function createDefaultDurableNonceTransactionSender({
     });
   };
 }
-function createDefaultTransactionSender({ rpc, rpcSubscriptions }) {
+function createDefaultTransactionSender({
+  rpc,
+  rpcSubscriptions
+}) {
   const confirmRecentTransaction = createDefaultRecentTransactionConfirmer({
     rpc,
     rpcSubscriptions
@@ -815,10 +918,10 @@ async function sendAndConfirmDurableNonceTransaction({
   ...sendTransactionConfig
 }) {
   const transactionSignature = await sendTransaction_INTERNAL({
+    ...sendTransactionConfig,
     abortSignal,
     commitment,
     rpc,
-    sendTransactionConfig,
     transaction
   });
   await confirmDurableNonceTransaction({
@@ -837,10 +940,10 @@ async function sendAndConfirmTransaction({
   ...sendTransactionConfig
 }) {
   const transactionSignature = await sendTransaction_INTERNAL({
+    ...sendTransactionConfig,
     abortSignal,
     commitment,
     rpc,
-    sendTransactionConfig,
     transaction
   });
   await confirmRecentTransaction({
@@ -851,6 +954,6 @@ async function sendAndConfirmTransaction({
   return transactionSignature;
 }
 
-export { createBlockHeightExceedencePromiseFactory, createDefaultAirdropRequester, createDefaultDurableNonceTransactionConfirmer, createDefaultDurableNonceTransactionSender, createDefaultRecentTransactionConfirmer, createDefaultRpcSubscriptionsTransport, createDefaultRpcTransport, createDefaultTransactionSender, createNonceInvalidationPromiseFactory, createRecentSignatureConfirmationPromiseFactory, createSolanaRpc, createSolanaRpcSubscriptions, createSolanaRpcSubscriptions_UNSTABLE, requestAndConfirmAirdrop, sendAndConfirmDurableNonceTransaction, sendAndConfirmTransaction, waitForDurableNonceTransactionConfirmation, waitForRecentTransactionConfirmation };
+export { createBlockHeightExceedencePromiseFactory, createDefaultAirdropRequester, createDefaultDurableNonceTransactionConfirmer, createDefaultDurableNonceTransactionSender, createDefaultRecentTransactionConfirmer, createDefaultRpcSubscriptionsTransport, createDefaultRpcTransport, createDefaultTransactionSender, createNonceInvalidationPromiseFactory, createRecentSignatureConfirmationPromiseFactory, createSolanaRpc, createSolanaRpcSubscriptions, createSolanaRpcSubscriptions_UNSTABLE, decodeTransaction, requestAndConfirmAirdrop, sendAndConfirmDurableNonceTransaction, sendAndConfirmTransaction, waitForDurableNonceTransactionConfirmation, waitForRecentTransactionConfirmation };
 //# sourceMappingURL=out.js.map
 //# sourceMappingURL=index.native.js.map