@solana/web3.js 1.41.9 → 1.41.10

package/lib/index.browser.cjs.js

@@ -2376,9 +2376,17 @@ function assert (condition, message) {
   }
 }
 
+exports.TransactionStatus = void 0;
 /**
  * Default (empty) signature
  */
+
+(function (TransactionStatus) {
+  TransactionStatus[TransactionStatus["BLOCKHEIGHT_EXCEEDED"] = 0] = "BLOCKHEIGHT_EXCEEDED";
+  TransactionStatus[TransactionStatus["PROCESSED"] = 1] = "PROCESSED";
+  TransactionStatus[TransactionStatus["TIMED_OUT"] = 2] = "TIMED_OUT";
+})(exports.TransactionStatus || (exports.TransactionStatus = {}));
+
 const DEFAULT_SIGNATURE = buffer.Buffer.alloc(SIGNATURE_LENGTH_IN_BYTES).fill(0);
 /**
  * Account metadata used to define instructions
@@ -2469,10 +2477,23 @@ class Transaction {
     this.feePayer = void 0;
     this.instructions = [];
     this.recentBlockhash = void 0;
+    this.lastValidBlockHeight = void 0;
     this.nonceInfo = void 0;
     this._message = void 0;
     this._json = void 0;
-    opts && Object.assign(this, opts);
+
+    if (!opts) {
+      return;
+    } else if (Object.prototype.hasOwnProperty.call(opts, 'lastValidBlockHeight')) {
+      const newOpts = opts;
+      Object.assign(this, newOpts);
+      this.recentBlockhash = newOpts.blockhash;
+      this.lastValidBlockHeight = newOpts.lastValidBlockHeight;
+    } else {
+      const oldOpts = opts;
+      Object.assign(this, oldOpts);
+      this.recentBlockhash = oldOpts.recentBlockhash;
+    }
   }
   /**
    * @internal
@@ -3082,7 +3103,11 @@ async function sendAndConfirmTransaction(connection, transaction, signers, optio
     maxRetries: options.maxRetries
   };
   const signature = await connection.sendTransaction(transaction, signers, sendOptions);
-  const status = (await connection.confirmTransaction(signature, options && options.commitment)).value;
+  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;
 
   if (status.err) {
     throw new Error(`Transaction ${signature} failed (${JSON.stringify(status)})`);
@@ -4994,16 +5019,28 @@ const NUM_SLOTS_PER_SECOND = NUM_TICKS_PER_SECOND / DEFAULT_TICKS_PER_SLOT;
 
 const MS_PER_SLOT = 1000 / NUM_SLOTS_PER_SECOND;
 
-function promiseTimeout(promise, timeoutMs) {
-  let timeoutId;
-  const timeoutPromise = new Promise(resolve => {
-    timeoutId = setTimeout(() => resolve(null), timeoutMs);
-  });
-  return Promise.race([promise, timeoutPromise]).then(result => {
-    clearTimeout(timeoutId);
-    return result;
-  });
+class TransactionExpiredBlockheightExceededError extends Error {
+  constructor(signature) {
+    super(`Signature ${signature} has expired: block height exceeded.`);
+    this.signature = void 0;
+    this.signature = signature;
+  }
+
 }
+Object.defineProperty(TransactionExpiredBlockheightExceededError.prototype, 'name', {
+  value: 'TransactionExpiredBlockheightExceededError'
+});
+class TransactionExpiredTimeoutError extends Error {
+  constructor(signature, timeoutSeconds) {
+    super(`Transaction was not confirmed in ${timeoutSeconds.toFixed(2)} seconds. It is ` + 'unknown if it succeeded or failed. Check signature ' + `${signature} using the Solana Explorer or CLI tools.`);
+    this.signature = void 0;
+    this.signature = signature;
+  }
+
+}
+Object.defineProperty(TransactionExpiredTimeoutError.prototype, 'name', {
+  value: 'TransactionExpiredTimeoutError'
+});
 
 function makeWebsocketUrl(endpoint) {
   let url = new URL(endpoint);
@@ -6473,67 +6510,124 @@ class Connection {
 
     return res.result;
   }
-  /**
-   * Confirm the transaction identified by the specified signature.
-   */
 
+  // eslint-disable-next-line no-dupe-class-members
+  async confirmTransaction(strategy, commitment) {
+    let rawSignature;
+
+    if (typeof strategy == 'string') {
+      rawSignature = strategy;
+    } else {
+      const config = strategy;
+      rawSignature = config.signature;
+    }
 
-  async confirmTransaction(signature, commitment) {
     let decodedSignature;
 
     try {
-      decodedSignature = bs58__default["default"].decode(signature);
+      decodedSignature = bs58__default["default"].decode(rawSignature);
     } catch (err) {
-      throw new Error('signature must be base58 encoded: ' + signature);
+      throw new Error('signature must be base58 encoded: ' + rawSignature);
     }
 
     assert(decodedSignature.length === 64, 'signature has invalid length');
-    const start = Date.now();
     const subscriptionCommitment = commitment || this.commitment;
+    let timeoutId;
     let subscriptionId;
-    let response = null;
-    const confirmPromise = new Promise((resolve, reject) => {
+    let done = false;
+    const confirmationPromise = new Promise((resolve, reject) => {
       try {
-        subscriptionId = this.onSignature(signature, (result, context) => {
+        subscriptionId = this.onSignature(rawSignature, (result, context) => {
           subscriptionId = undefined;
-          response = {
+          const response = {
             context,
             value: result
           };
-          resolve(null);
+          done = true;
+          resolve({
+            __type: exports.TransactionStatus.PROCESSED,
+            response
+          });
         }, subscriptionCommitment);
       } catch (err) {
         reject(err);
       }
     });
-    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;
+      }
+    };
+
+    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;
+            }
         }
-    }
+
+        timeoutId = setTimeout(() => resolve({
+          __type: exports.TransactionStatus.TIMED_OUT,
+          timeoutMs
+        }), timeoutMs);
+      } else {
+        let config = strategy;
+
+        (async () => {
+          let currentBlockHeight = await checkBlockHeight();
+          if (done) return;
+
+          while (currentBlockHeight <= config.lastValidBlockHeight) {
+            await sleep(1000);
+            if (done) return;
+            currentBlockHeight = await checkBlockHeight();
+            if (done) return;
+          }
+
+          resolve({
+            __type: exports.TransactionStatus.BLOCKHEIGHT_EXCEEDED
+          });
+        })();
+      }
+    });
+    let result;
 
     try {
-      await promiseTimeout(confirmPromise, timeoutMs);
+      const outcome = await Promise.race([confirmationPromise, expiryPromise]);
+
+      switch (outcome.__type) {
+        case exports.TransactionStatus.BLOCKHEIGHT_EXCEEDED:
+          throw new TransactionExpiredBlockheightExceededError(rawSignature);
+
+        case exports.TransactionStatus.PROCESSED:
+          result = outcome.response;
+          break;
+
+        case exports.TransactionStatus.TIMED_OUT:
+          throw new TransactionExpiredTimeoutError(rawSignature, outcome.timeoutMs / 1000);
+      }
     } finally {
+      clearTimeout(timeoutId);
+
       if (subscriptionId) {
         this.removeSignatureListener(subscriptionId);
       }
     }
 
-    if (response === null) {
-      const duration = (Date.now() - start) / 1000;
-      throw new Error(`Transaction was not confirmed in ${duration.toFixed(2)} seconds. It is unknown if it succeeded or failed. Check signature ${signature} using the Solana Explorer or CLI tools.`);
-    }
-
-    return response;
+    return result;
   }
   /**
    * Return the list of nodes that are currently participating in the cluster