@solana/web3.js 1.66.4 → 1.67.0

package/lib/index.cjs.js

@@ -454,6 +454,17 @@ class TransactionExpiredTimeoutError extends Error {
 Object.defineProperty(TransactionExpiredTimeoutError.prototype, 'name', {
   value: 'TransactionExpiredTimeoutError'
 });
+class TransactionExpiredNonceInvalidError extends Error {
+  constructor(signature) {
+    super(`Signature ${signature} has expired: the nonce is no longer valid.`);
+    this.signature = void 0;
+    this.signature = signature;
+  }
+
+}
+Object.defineProperty(TransactionExpiredNonceInvalidError.prototype, 'name', {
+  value: 'TransactionExpiredNonceInvalidError'
+});
 
 class MessageAccountKeys {
   constructor(staticAccountKeys, accountKeysFromLookups) {
@@ -1291,6 +1302,7 @@ exports.TransactionStatus = void 0;
   TransactionStatus[TransactionStatus["BLOCKHEIGHT_EXCEEDED"] = 0] = "BLOCKHEIGHT_EXCEEDED";
   TransactionStatus[TransactionStatus["PROCESSED"] = 1] = "PROCESSED";
   TransactionStatus[TransactionStatus["TIMED_OUT"] = 2] = "TIMED_OUT";
+  TransactionStatus[TransactionStatus["NONCE_INVALID"] = 3] = "NONCE_INVALID";
 })(exports.TransactionStatus || (exports.TransactionStatus = {}));
 
 const DEFAULT_SIGNATURE = buffer.Buffer.alloc(SIGNATURE_LENGTH_IN_BYTES).fill(0);
@@ -1385,6 +1397,7 @@ class Transaction {
     this.recentBlockhash = void 0;
     this.lastValidBlockHeight = void 0;
     this.nonceInfo = void 0;
+    this.minNonceContextSlot = void 0;
     this._message = void 0;
     this._json = void 0;
 
@@ -1400,7 +1413,14 @@ class Transaction {
       this.signatures = opts.signatures;
     }
 
-    if (Object.prototype.hasOwnProperty.call(opts, 'lastValidBlockHeight')) {
+    if (Object.prototype.hasOwnProperty.call(opts, 'nonceInfo')) {
+      const {
+        minContextSlot,
+        nonceInfo
+      } = opts;
+      this.minNonceContextSlot = minContextSlot;
+      this.nonceInfo = nonceInfo;
+    } else if (Object.prototype.hasOwnProperty.call(opts, 'lastValidBlockHeight')) {
       const {
         blockhash,
         lastValidBlockHeight
@@ -2217,11 +2237,28 @@ async function sendAndConfirmTransaction(connection, transaction, signers, optio
     minContextSlot: options.minContextSlot
   };
   const signature = await connection.sendTransaction(transaction, signers, sendOptions);
-  const status = transaction.recentBlockhash != null && transaction.lastValidBlockHeight != null ? (await connection.confirmTransaction({
-    signature: signature,
-    blockhash: transaction.recentBlockhash,
-    lastValidBlockHeight: transaction.lastValidBlockHeight
-  }, options && options.commitment)).value : (await connection.confirmTransaction(signature, options && options.commitment)).value;
+  let status;
+
+  if (transaction.recentBlockhash != null && transaction.lastValidBlockHeight != null) {
+    status = (await connection.confirmTransaction({
+      signature: signature,
+      blockhash: transaction.recentBlockhash,
+      lastValidBlockHeight: transaction.lastValidBlockHeight
+    }, options && options.commitment)).value;
+  } else if (transaction.minNonceContextSlot != null && transaction.nonceInfo != null) {
+    const {
+      nonceInstruction
+    } = transaction.nonceInfo;
+    const nonceAccountPubkey = nonceInstruction.keys[0].pubkey;
+    status = (await connection.confirmTransaction({
+      minContextSlot: transaction.minNonceContextSlot,
+      nonceAccountPubkey,
+      nonceValue: transaction.nonceInfo.nonce,
+      signature
+    }, options && options.commitment)).value;
+  } else {
+    status = (await connection.confirmTransaction(signature, options && options.commitment)).value;
+  }
 
   if (status.err) {
     throw new Error(`Transaction ${signature} failed (${JSON.stringify(status)})`);
@@ -2290,6 +2327,9 @@ const FeeCalculatorLayout = BufferLayout__namespace.nu64('lamportsPerSignature')
 
 const NonceAccountLayout = BufferLayout__namespace.struct([BufferLayout__namespace.u32('version'), BufferLayout__namespace.u32('state'), publicKey('authorizedPubkey'), publicKey('nonce'), BufferLayout__namespace.struct([FeeCalculatorLayout], 'feeCalculator')]);
 const NONCE_ACCOUNT_LENGTH = NonceAccountLayout.span;
+/**
+ * A durable nonce is a 32 byte value encoded as a base58 string.
+ */
 
 /**
  * NonceAccount class
@@ -3704,10 +3744,13 @@ function extractCommitmentFromConfig(commitmentOrConfig) {
   };
 }
 /**
- * @internal
+ * A strategy for confirming durable nonce transactions.
  */
 
 
+/**
+ * @internal
+ */
 function createRpcResult(result) {
   return superstruct.union([superstruct.type({
     jsonrpc: superstruct.literal('2.0'),
@@ -5279,25 +5322,45 @@ class Connection {
     }
 
     assert(decodedSignature.length === 64, 'signature has invalid length');
-    const subscriptionCommitment = commitment || this.commitment;
-    let timeoutId;
+
+    if (typeof strategy === 'string') {
+      return await this.confirmTransactionUsingLegacyTimeoutStrategy({
+        commitment: commitment || this.commitment,
+        signature: rawSignature
+      });
+    } else if ('lastValidBlockHeight' in strategy) {
+      return await this.confirmTransactionUsingBlockHeightExceedanceStrategy({
+        commitment: commitment || this.commitment,
+        strategy
+      });
+    } else {
+      return await this.confirmTransactionUsingDurableNonceStrategy({
+        commitment: commitment || this.commitment,
+        strategy
+      });
+    }
+  }
+
+  getTransactionConfirmationPromise({
+    commitment,
+    signature
+  }) {
     let signatureSubscriptionId;
     let disposeSignatureSubscriptionStateChangeObserver;
     let done = false;
     const confirmationPromise = new Promise((resolve, reject) => {
       try {
-        signatureSubscriptionId = this.onSignature(rawSignature, (result, context) => {
+        signatureSubscriptionId = this.onSignature(signature, (result, context) => {
           signatureSubscriptionId = undefined;
           const response = {
             context,
             value: result
           };
-          done = true;
           resolve({
             __type: exports.TransactionStatus.PROCESSED,
             response
           });
-        }, subscriptionCommitment);
+        }, commitment);
         const subscriptionSetupPromise = new Promise(resolveSubscriptionSetup => {
           if (signatureSubscriptionId == null) {
             resolveSubscriptionSetup();
@@ -5313,7 +5376,7 @@ class Connection {
         (async () => {
           await subscriptionSetupPromise;
           if (done) return;
-          const response = await this.getSignatureStatus(rawSignature);
+          const response = await this.getSignatureStatus(signature);
           if (done) return;
 
           if (response == null) {
@@ -5325,11 +5388,41 @@ class Connection {
             value
           } = response;
 
+          if (value == null) {
+            return;
+          }
+
           if (value !== null && value !== void 0 && value.err) {
             reject(value.err);
-          }
+          } else {
+            switch (commitment) {
+              case 'confirmed':
+              case 'single':
+              case 'singleGossip':
+                {
+                  if (value.confirmationStatus === 'processed') {
+                    return;
+                  }
+
+                  break;
+                }
+
+              case 'finalized':
+              case 'max':
+              case 'root':
+                {
+                  if (value.confirmationStatus === 'processed' || value.confirmationStatus === 'confirmed') {
+                    return;
+                  }
+
+                  break;
+                }
+              // exhaust enums to ensure full coverage
+
+              case 'processed':
+              case 'recent':
+            }
 
-          if (value) {
             done = true;
             resolve({
               __type: exports.TransactionStatus.PROCESSED,
@@ -5344,81 +5437,279 @@ class Connection {
         reject(err);
       }
     });
+
+    const abortConfirmation = () => {
+      if (disposeSignatureSubscriptionStateChangeObserver) {
+        disposeSignatureSubscriptionStateChangeObserver();
+        disposeSignatureSubscriptionStateChangeObserver = undefined;
+      }
+
+      if (signatureSubscriptionId) {
+        this.removeSignatureListener(signatureSubscriptionId);
+        signatureSubscriptionId = undefined;
+      }
+    };
+
+    return {
+      abortConfirmation,
+      confirmationPromise
+    };
+  }
+
+  async confirmTransactionUsingBlockHeightExceedanceStrategy({
+    commitment,
+    strategy: {
+      lastValidBlockHeight,
+      signature
+    }
+  }) {
+    let done = false;
     const expiryPromise = new Promise(resolve => {
-      if (typeof strategy === 'string') {
-        let timeoutMs = this._confirmTransactionInitialTimeout || 60 * 1000;
-
-        switch (subscriptionCommitment) {
-          case 'processed':
-          case 'recent':
-          case 'single':
-          case 'confirmed':
-          case 'singleGossip':
-            {
-              timeoutMs = this._confirmTransactionInitialTimeout || 30 * 1000;
-              break;
-            }
+      const checkBlockHeight = async () => {
+        try {
+          const blockHeight = await this.getBlockHeight(commitment);
+          return blockHeight;
+        } catch (_e) {
+          return -1;
         }
+      };
 
-        timeoutId = setTimeout(() => resolve({
-          __type: exports.TransactionStatus.TIMED_OUT,
-          timeoutMs
-        }), timeoutMs);
+      (async () => {
+        let currentBlockHeight = await checkBlockHeight();
+        if (done) return;
+
+        while (currentBlockHeight <= lastValidBlockHeight) {
+          await sleep(1000);
+          if (done) return;
+          currentBlockHeight = await checkBlockHeight();
+          if (done) return;
+        }
+
+        resolve({
+          __type: exports.TransactionStatus.BLOCKHEIGHT_EXCEEDED
+        });
+      })();
+    });
+    const {
+      abortConfirmation,
+      confirmationPromise
+    } = this.getTransactionConfirmationPromise({
+      commitment,
+      signature
+    });
+    let result;
+
+    try {
+      const outcome = await Promise.race([confirmationPromise, expiryPromise]);
+
+      if (outcome.__type === exports.TransactionStatus.PROCESSED) {
+        result = outcome.response;
       } else {
-        let config = strategy;
+        throw new TransactionExpiredBlockheightExceededError(signature);
+      }
+    } finally {
+      done = true;
+      abortConfirmation();
+    }
 
-        const checkBlockHeight = async () => {
-          try {
-            const blockHeight = await this.getBlockHeight(commitment);
-            return blockHeight;
-          } catch (_e) {
-            return -1;
-          }
-        };
+    return result;
+  }
 
-        (async () => {
-          let currentBlockHeight = await checkBlockHeight();
-          if (done) return;
+  async confirmTransactionUsingDurableNonceStrategy({
+    commitment,
+    strategy: {
+      minContextSlot,
+      nonceAccountPubkey,
+      nonceValue,
+      signature
+    }
+  }) {
+    let done = false;
+    const expiryPromise = new Promise(resolve => {
+      let currentNonceValue = nonceValue;
+      let lastCheckedSlot = null;
 
-          while (currentBlockHeight <= config.lastValidBlockHeight) {
-            await sleep(1000);
-            if (done) return;
-            currentBlockHeight = await checkBlockHeight();
-            if (done) return;
+      const getCurrentNonceValue = async () => {
+        try {
+          const {
+            context,
+            value: nonceAccount
+          } = await this.getNonceAndContext(nonceAccountPubkey, {
+            commitment,
+            minContextSlot
+          });
+          lastCheckedSlot = context.slot;
+          return nonceAccount === null || nonceAccount === void 0 ? void 0 : nonceAccount.nonce;
+        } catch (e) {
+          // If for whatever reason we can't reach/read the nonce
+          // account, just keep using the last-known value.
+          return currentNonceValue;
+        }
+      };
+
+      (async () => {
+        currentNonceValue = await getCurrentNonceValue();
+        if (done) return;
+
+        while (true // eslint-disable-line no-constant-condition
+        ) {
+          if (nonceValue !== currentNonceValue) {
+            resolve({
+              __type: exports.TransactionStatus.NONCE_INVALID,
+              slotInWhichNonceDidAdvance: lastCheckedSlot
+            });
+            return;
           }
 
-          resolve({
-            __type: exports.TransactionStatus.BLOCKHEIGHT_EXCEEDED
-          });
-        })();
-      }
+          await sleep(2000);
+          if (done) return;
+          currentNonceValue = await getCurrentNonceValue();
+          if (done) return;
+        }
+      })();
+    });
+    const {
+      abortConfirmation,
+      confirmationPromise
+    } = this.getTransactionConfirmationPromise({
+      commitment,
+      signature
     });
     let result;
 
     try {
       const outcome = await Promise.race([confirmationPromise, expiryPromise]);
 
-      switch (outcome.__type) {
-        case exports.TransactionStatus.BLOCKHEIGHT_EXCEEDED:
-          throw new TransactionExpiredBlockheightExceededError(rawSignature);
+      if (outcome.__type === exports.TransactionStatus.PROCESSED) {
+        result = outcome.response;
+      } else {
+        var _signatureStatus;
+
+        // Double check that the transaction is indeed unconfirmed.
+        let signatureStatus;
 
-        case exports.TransactionStatus.PROCESSED:
-          result = outcome.response;
+        while (true // eslint-disable-line no-constant-condition
+        ) {
+          var _outcome$slotInWhichN;
+
+          const status = await this.getSignatureStatus(signature);
+
+          if (status == null) {
+            break;
+          }
+
+          if (status.context.slot < ((_outcome$slotInWhichN = outcome.slotInWhichNonceDidAdvance) !== null && _outcome$slotInWhichN !== void 0 ? _outcome$slotInWhichN : minContextSlot)) {
+            await sleep(400);
+            continue;
+          }
+
+          signatureStatus = status;
           break;
+        }
+
+        if ((_signatureStatus = signatureStatus) !== null && _signatureStatus !== void 0 && _signatureStatus.value) {
+          const commitmentForStatus = commitment || 'finalized';
+          const {
+            confirmationStatus
+          } = signatureStatus.value;
+
+          switch (commitmentForStatus) {
+            case 'processed':
+            case 'recent':
+              if (confirmationStatus !== 'processed' && confirmationStatus !== 'confirmed' && confirmationStatus !== 'finalized') {
+                throw new TransactionExpiredNonceInvalidError(signature);
+              }
 
-        case exports.TransactionStatus.TIMED_OUT:
-          throw new TransactionExpiredTimeoutError(rawSignature, outcome.timeoutMs / 1000);
+              break;
+
+            case 'confirmed':
+            case 'single':
+            case 'singleGossip':
+              if (confirmationStatus !== 'confirmed' && confirmationStatus !== 'finalized') {
+                throw new TransactionExpiredNonceInvalidError(signature);
+              }
+
+              break;
+
+            case 'finalized':
+            case 'max':
+            case 'root':
+              if (confirmationStatus !== 'finalized') {
+                throw new TransactionExpiredNonceInvalidError(signature);
+              }
+
+              break;
+
+            default:
+              // Exhaustive switch.
+              // eslint-disable-next-line @typescript-eslint/no-unused-vars
+              (_ => {})(commitmentForStatus);
+
+          }
+
+          result = {
+            context: signatureStatus.context,
+            value: {
+              err: signatureStatus.value.err
+            }
+          };
+        } else {
+          throw new TransactionExpiredNonceInvalidError(signature);
+        }
       }
     } finally {
-      clearTimeout(timeoutId);
+      done = true;
+      abortConfirmation();
+    }
 
-      if (disposeSignatureSubscriptionStateChangeObserver) {
-        disposeSignatureSubscriptionStateChangeObserver();
+    return result;
+  }
+
+  async confirmTransactionUsingLegacyTimeoutStrategy({
+    commitment,
+    signature
+  }) {
+    let timeoutId;
+    const expiryPromise = new Promise(resolve => {
+      let timeoutMs = this._confirmTransactionInitialTimeout || 60 * 1000;
+
+      switch (commitment) {
+        case 'processed':
+        case 'recent':
+        case 'single':
+        case 'confirmed':
+        case 'singleGossip':
+          {
+            timeoutMs = this._confirmTransactionInitialTimeout || 30 * 1000;
+            break;
+          }
       }
 
-      if (signatureSubscriptionId) {
-        this.removeSignatureListener(signatureSubscriptionId);
+      timeoutId = setTimeout(() => resolve({
+        __type: exports.TransactionStatus.TIMED_OUT,
+        timeoutMs
+      }), timeoutMs);
+    });
+    const {
+      abortConfirmation,
+      confirmationPromise
+    } = this.getTransactionConfirmationPromise({
+      commitment,
+      signature
+    });
+    let result;
+
+    try {
+      const outcome = await Promise.race([confirmationPromise, expiryPromise]);
+
+      if (outcome.__type === exports.TransactionStatus.PROCESSED) {
+        result = outcome.response;
+      } else {
+        throw new TransactionExpiredTimeoutError(signature, outcome.timeoutMs / 1000);
       }
+    } finally {
+      clearTimeout(timeoutId);
+      abortConfirmation();
     }
 
     return result;
@@ -6474,11 +6765,11 @@ class Connection {
    */
 
 
-  async getNonceAndContext(nonceAccount, commitment) {
+  async getNonceAndContext(nonceAccount, commitmentOrConfig) {
     const {
       context,
       value: accountInfo
-    } = await this.getAccountInfoAndContext(nonceAccount, commitment);
+    } = await this.getAccountInfoAndContext(nonceAccount, commitmentOrConfig);
     let value = null;
 
     if (accountInfo !== null) {
@@ -6495,8 +6786,8 @@ class Connection {
    */
 
 
-  async getNonce(nonceAccount, commitment) {
-    return await this.getNonceAndContext(nonceAccount, commitment).then(x => x.value).catch(e => {
+  async getNonce(nonceAccount, commitmentOrConfig) {
+    return await this.getNonceAndContext(nonceAccount, commitmentOrConfig).then(x => x.value).catch(e => {
       throw new Error('failed to get nonce for account ' + nonceAccount.toBase58() + ': ' + e);
     });
   }
@@ -9911,6 +10202,9 @@ async function sendAndConfirmRawTransaction(connection, rawTransaction, confirma
   if (confirmationStrategyOrConfirmOptions && Object.prototype.hasOwnProperty.call(confirmationStrategyOrConfirmOptions, 'lastValidBlockHeight')) {
     confirmationStrategy = confirmationStrategyOrConfirmOptions;
     options = maybeConfirmOptions;
+  } else if (confirmationStrategyOrConfirmOptions && Object.prototype.hasOwnProperty.call(confirmationStrategyOrConfirmOptions, 'nonceValue')) {
+    confirmationStrategy = confirmationStrategyOrConfirmOptions;
+    options = maybeConfirmOptions;
   } else {
     options = confirmationStrategyOrConfirmOptions;
   }
@@ -9995,6 +10289,7 @@ exports.SystemInstruction = SystemInstruction;
 exports.SystemProgram = SystemProgram;
 exports.Transaction = Transaction;
 exports.TransactionExpiredBlockheightExceededError = TransactionExpiredBlockheightExceededError;
+exports.TransactionExpiredNonceInvalidError = TransactionExpiredNonceInvalidError;
 exports.TransactionExpiredTimeoutError = TransactionExpiredTimeoutError;
 exports.TransactionInstruction = TransactionInstruction;
 exports.TransactionMessage = TransactionMessage;