@solana/web3.js 1.66.5 → 1.67.0

package/lib/index.esm.js

@@ -421,6 +421,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) {
@@ -1258,6 +1269,7 @@ let TransactionStatus;
   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";
 })(TransactionStatus || (TransactionStatus = {}));
 
 const DEFAULT_SIGNATURE = Buffer.alloc(SIGNATURE_LENGTH_IN_BYTES).fill(0);
@@ -1352,6 +1364,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;
 
@@ -1367,7 +1380,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
@@ -2184,11 +2204,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)})`);
@@ -2257,6 +2294,9 @@ const FeeCalculatorLayout = BufferLayout.nu64('lamportsPerSignature');
 
 const NonceAccountLayout = BufferLayout.struct([BufferLayout.u32('version'), BufferLayout.u32('state'), publicKey('authorizedPubkey'), publicKey('nonce'), BufferLayout.struct([FeeCalculatorLayout], 'feeCalculator')]);
 const NONCE_ACCOUNT_LENGTH = NonceAccountLayout.span;
+/**
+ * A durable nonce is a 32 byte value encoded as a base58 string.
+ */
 
 /**
  * NonceAccount class
@@ -3671,10 +3711,13 @@ function extractCommitmentFromConfig(commitmentOrConfig) {
   };
 }
 /**
- * @internal
+ * A strategy for confirming durable nonce transactions.
  */
 
 
+/**
+ * @internal
+ */
 function createRpcResult(result) {
   return union([type({
     jsonrpc: literal('2.0'),
@@ -5246,25 +5289,45 @@ class Connection {
     }
 
     assert(decodedSignature.length === 64, 'signature has invalid length');
-    const confirmationCommitment = 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: TransactionStatus.PROCESSED,
             response
           });
-        }, confirmationCommitment);
+        }, commitment);
         const subscriptionSetupPromise = new Promise(resolveSubscriptionSetup => {
           if (signatureSubscriptionId == null) {
             resolveSubscriptionSetup();
@@ -5280,7 +5343,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) {
@@ -5299,7 +5362,7 @@ class Connection {
           if (value !== null && value !== void 0 && value.err) {
             reject(value.err);
           } else {
-            switch (confirmationCommitment) {
+            switch (commitment) {
               case 'confirmed':
               case 'single':
               case 'singleGossip':
@@ -5341,81 +5404,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 (confirmationCommitment) {
-          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: 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: TransactionStatus.BLOCKHEIGHT_EXCEEDED
+        });
+      })();
+    });
+    const {
+      abortConfirmation,
+      confirmationPromise
+    } = this.getTransactionConfirmationPromise({
+      commitment,
+      signature
+    });
+    let result;
+
+    try {
+      const outcome = await Promise.race([confirmationPromise, expiryPromise]);
+
+      if (outcome.__type === 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: TransactionStatus.NONCE_INVALID,
+              slotInWhichNonceDidAdvance: lastCheckedSlot
+            });
+            return;
           }
 
-          resolve({
-            __type: 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 TransactionStatus.BLOCKHEIGHT_EXCEEDED:
-          throw new TransactionExpiredBlockheightExceededError(rawSignature);
+      if (outcome.__type === TransactionStatus.PROCESSED) {
+        result = outcome.response;
+      } else {
+        var _signatureStatus;
+
+        // Double check that the transaction is indeed unconfirmed.
+        let signatureStatus;
+
+        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;
+          }
 
-        case TransactionStatus.PROCESSED:
-          result = outcome.response;
+          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);
+              }
+
+              break;
+
+            case 'confirmed':
+            case 'single':
+            case 'singleGossip':
+              if (confirmationStatus !== 'confirmed' && confirmationStatus !== 'finalized') {
+                throw new TransactionExpiredNonceInvalidError(signature);
+              }
 
-        case TransactionStatus.TIMED_OUT:
-          throw new TransactionExpiredTimeoutError(rawSignature, outcome.timeoutMs / 1000);
+              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: 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 === TransactionStatus.PROCESSED) {
+        result = outcome.response;
+      } else {
+        throw new TransactionExpiredTimeoutError(signature, outcome.timeoutMs / 1000);
       }
+    } finally {
+      clearTimeout(timeoutId);
+      abortConfirmation();
     }
 
     return result;
@@ -6471,11 +6732,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) {
@@ -6492,8 +6753,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);
     });
   }
@@ -9908,6 +10169,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;
   }
@@ -9935,5 +10199,5 @@ async function sendAndConfirmRawTransaction(connection, rawTransaction, confirma
 
 const LAMPORTS_PER_SOL = 1000000000;
 
-export { Account, AddressLookupTableAccount, AddressLookupTableInstruction, AddressLookupTableProgram, Authorized, BLOCKHASH_CACHE_TIMEOUT_MS, BPF_LOADER_DEPRECATED_PROGRAM_ID, BPF_LOADER_PROGRAM_ID, BpfLoader, COMPUTE_BUDGET_INSTRUCTION_LAYOUTS, ComputeBudgetInstruction, ComputeBudgetProgram, Connection, Ed25519Program, Enum, EpochSchedule, FeeCalculatorLayout, Keypair, LAMPORTS_PER_SOL, LOOKUP_TABLE_INSTRUCTION_LAYOUTS, Loader, Lockup, MAX_SEED_LENGTH, Message, MessageAccountKeys, MessageV0, NONCE_ACCOUNT_LENGTH, NonceAccount, PACKET_DATA_SIZE, PUBLIC_KEY_LENGTH, PublicKey, SIGNATURE_LENGTH_IN_BYTES, SOLANA_SCHEMA, STAKE_CONFIG_ID, STAKE_INSTRUCTION_LAYOUTS, SYSTEM_INSTRUCTION_LAYOUTS, SYSVAR_CLOCK_PUBKEY, SYSVAR_EPOCH_SCHEDULE_PUBKEY, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_RECENT_BLOCKHASHES_PUBKEY, SYSVAR_RENT_PUBKEY, SYSVAR_REWARDS_PUBKEY, SYSVAR_SLOT_HASHES_PUBKEY, SYSVAR_SLOT_HISTORY_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY, Secp256k1Program, SendTransactionError, SolanaJSONRPCError, SolanaJSONRPCErrorCode, StakeAuthorizationLayout, StakeInstruction, StakeProgram, Struct, SystemInstruction, SystemProgram, Transaction, TransactionExpiredBlockheightExceededError, TransactionExpiredTimeoutError, TransactionInstruction, TransactionMessage, TransactionStatus, VALIDATOR_INFO_KEY, VERSION_PREFIX_MASK, VOTE_PROGRAM_ID, ValidatorInfo, VersionedMessage, VersionedTransaction, VoteAccount, VoteAuthorizationLayout, VoteInit, VoteInstruction, VoteProgram, clusterApiUrl, sendAndConfirmRawTransaction, sendAndConfirmTransaction };
+export { Account, AddressLookupTableAccount, AddressLookupTableInstruction, AddressLookupTableProgram, Authorized, BLOCKHASH_CACHE_TIMEOUT_MS, BPF_LOADER_DEPRECATED_PROGRAM_ID, BPF_LOADER_PROGRAM_ID, BpfLoader, COMPUTE_BUDGET_INSTRUCTION_LAYOUTS, ComputeBudgetInstruction, ComputeBudgetProgram, Connection, Ed25519Program, Enum, EpochSchedule, FeeCalculatorLayout, Keypair, LAMPORTS_PER_SOL, LOOKUP_TABLE_INSTRUCTION_LAYOUTS, Loader, Lockup, MAX_SEED_LENGTH, Message, MessageAccountKeys, MessageV0, NONCE_ACCOUNT_LENGTH, NonceAccount, PACKET_DATA_SIZE, PUBLIC_KEY_LENGTH, PublicKey, SIGNATURE_LENGTH_IN_BYTES, SOLANA_SCHEMA, STAKE_CONFIG_ID, STAKE_INSTRUCTION_LAYOUTS, SYSTEM_INSTRUCTION_LAYOUTS, SYSVAR_CLOCK_PUBKEY, SYSVAR_EPOCH_SCHEDULE_PUBKEY, SYSVAR_INSTRUCTIONS_PUBKEY, SYSVAR_RECENT_BLOCKHASHES_PUBKEY, SYSVAR_RENT_PUBKEY, SYSVAR_REWARDS_PUBKEY, SYSVAR_SLOT_HASHES_PUBKEY, SYSVAR_SLOT_HISTORY_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY, Secp256k1Program, SendTransactionError, SolanaJSONRPCError, SolanaJSONRPCErrorCode, StakeAuthorizationLayout, StakeInstruction, StakeProgram, Struct, SystemInstruction, SystemProgram, Transaction, TransactionExpiredBlockheightExceededError, TransactionExpiredNonceInvalidError, TransactionExpiredTimeoutError, TransactionInstruction, TransactionMessage, TransactionStatus, VALIDATOR_INFO_KEY, VERSION_PREFIX_MASK, VOTE_PROGRAM_ID, ValidatorInfo, VersionedMessage, VersionedTransaction, VoteAccount, VoteAuthorizationLayout, VoteInit, VoteInstruction, VoteProgram, clusterApiUrl, sendAndConfirmRawTransaction, sendAndConfirmTransaction };
 //# sourceMappingURL=index.esm.js.map