@solana/web3.js 1.41.9 → 1.43.0

package/lib/index.cjs.js

@@ -2388,9 +2388,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
@@ -2481,10 +2489,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
@@ -2819,8 +2840,6 @@ class Transaction {
     const message = this._compile();
 
     this._partialSign(message, ...uniqueSigners);
-
-    this._verifySignatures(message.serialize(), true);
   }
   /**
    * Partially sign a transaction with the specified accounts. All accounts must
@@ -3094,7 +3113,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)})`);
@@ -4174,6 +4197,34 @@ class ComputeBudgetInstruction {
       bytes
     };
   }
+  /**
+   * Decode set compute unit limit compute budget instruction and retrieve the instruction params.
+   */
+
+
+  static decodeSetComputeUnitLimit(instruction) {
+    this.checkProgramId(instruction.programId);
+    const {
+      units
+    } = decodeData(COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitLimit, instruction.data);
+    return {
+      units
+    };
+  }
+  /**
+   * Decode set compute unit price compute budget instruction and retrieve the instruction params.
+   */
+
+
+  static decodeSetComputeUnitPrice(instruction) {
+    this.checkProgramId(instruction.programId);
+    const {
+      microLamports
+    } = decodeData(COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitPrice, instruction.data);
+    return {
+      microLamports
+    };
+  }
   /**
    * @internal
    */
@@ -4202,6 +4253,14 @@ const COMPUTE_BUDGET_INSTRUCTION_LAYOUTS = Object.freeze({
   RequestHeapFrame: {
     index: 1,
     layout: BufferLayout__namespace.struct([BufferLayout__namespace.u8('instruction'), BufferLayout__namespace.u32('bytes')])
+  },
+  SetComputeUnitLimit: {
+    index: 2,
+    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u8('instruction'), BufferLayout__namespace.u32('units')])
+  },
+  SetComputeUnitPrice: {
+    index: 3,
+    layout: BufferLayout__namespace.struct([BufferLayout__namespace.u8('instruction'), bufferLayoutUtils.u64('microLamports')])
   }
 });
 /**
@@ -4238,6 +4297,28 @@ class ComputeBudgetProgram {
     });
   }
 
+  static setComputeUnitLimit(params) {
+    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitLimit;
+    const data = encodeData(type, params);
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data
+    });
+  }
+
+  static setComputeUnitPrice(params) {
+    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitPrice;
+    const data = encodeData(type, {
+      microLamports: BigInt(params.microLamports)
+    });
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data
+    });
+  }
+
 }
 ComputeBudgetProgram.programId = new PublicKey('ComputeBudget111111111111111111111111111111');
 
@@ -4494,16 +4575,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);
@@ -5498,7 +5591,7 @@ class Connection {
     this._disableBlockhashCaching = false;
     this._pollingBlockhash = false;
     this._blockhashInfo = {
-      recentBlockhash: null,
+      latestBlockhash: null,
       lastFetch: 0,
       transactionSignatures: [],
       simulatedSignatures: []
@@ -5979,67 +6072,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
@@ -6404,7 +6554,7 @@ class Connection {
   }
   /**
    * Fetch the latest blockhash from the cluster
-   * @return {Promise<{blockhash: Blockhash, lastValidBlockHeight: number}>}
+   * @return {Promise<BlockhashWithExpiryBlockHeight>}
    */
 
 
@@ -6418,7 +6568,7 @@ class Connection {
   }
   /**
    * Fetch the latest blockhash from the cluster
-   * @return {Promise<{blockhash: Blockhash, lastValidBlockHeight: number}>}
+   * @return {Promise<BlockhashWithExpiryBlockHeight>}
    */
 
 
@@ -7001,7 +7151,7 @@ class Connection {
    */
 
 
-  async _recentBlockhash(disableCache) {
+  async _blockhashWithExpiryBlockHeight(disableCache) {
     if (!disableCache) {
       // Wait for polling to finish
       while (this._pollingBlockhash) {
@@ -7012,8 +7162,8 @@ class Connection {
 
       const expired = timeSinceFetch >= BLOCKHASH_CACHE_TIMEOUT_MS;
 
-      if (this._blockhashInfo.recentBlockhash !== null && !expired) {
-        return this._blockhashInfo.recentBlockhash;
+      if (this._blockhashInfo.latestBlockhash !== null && !expired) {
+        return this._blockhashInfo.latestBlockhash;
       }
     }
 
@@ -7029,20 +7179,20 @@ class Connection {
 
     try {
       const startTime = Date.now();
+      const cachedLatestBlockhash = this._blockhashInfo.latestBlockhash;
+      const cachedBlockhash = cachedLatestBlockhash ? cachedLatestBlockhash.blockhash : null;
 
       for (let i = 0; i < 50; i++) {
-        const {
-          blockhash
-        } = await this.getRecentBlockhash('finalized');
+        const latestBlockhash = await this.getLatestBlockhash('finalized');
 
-        if (this._blockhashInfo.recentBlockhash != blockhash) {
+        if (cachedBlockhash !== latestBlockhash.blockhash) {
           this._blockhashInfo = {
-            recentBlockhash: blockhash,
+            latestBlockhash,
             lastFetch: Date.now(),
             transactionSignatures: [],
             simulatedSignatures: []
           };
-          return blockhash;
+          return latestBlockhash;
         } // Sleep for approximately half a slot
 
 
@@ -7064,13 +7214,11 @@ class Connection {
 
     if (transactionOrMessage instanceof Transaction) {
       let originalTx = transactionOrMessage;
-      transaction = new Transaction({
-        recentBlockhash: originalTx.recentBlockhash,
-        nonceInfo: originalTx.nonceInfo,
-        feePayer: originalTx.feePayer,
-        signatures: [...originalTx.signatures]
-      });
+      transaction = new Transaction();
+      transaction.feePayer = originalTx.feePayer;
       transaction.instructions = transactionOrMessage.instructions;
+      transaction.nonceInfo = originalTx.nonceInfo;
+      transaction.signatures = originalTx.signatures;
     } else {
       transaction = Transaction.populate(transactionOrMessage); // HACK: this function relies on mutating the populated transaction
 
@@ -7083,7 +7231,9 @@ class Connection {
       let disableCache = this._disableBlockhashCaching;
 
       for (;;) {
-        transaction.recentBlockhash = await this._recentBlockhash(disableCache);
+        const latestBlockhash = await this._blockhashWithExpiryBlockHeight(disableCache);
+        transaction.lastValidBlockHeight = latestBlockhash.lastValidBlockHeight;
+        transaction.recentBlockhash = latestBlockhash.blockhash;
         if (!signers) break;
         transaction.sign(...signers);
 
@@ -7167,7 +7317,9 @@ class Connection {
       let disableCache = this._disableBlockhashCaching;
 
       for (;;) {
-        transaction.recentBlockhash = await this._recentBlockhash(disableCache);
+        const latestBlockhash = await this._blockhashWithExpiryBlockHeight(disableCache);
+        transaction.lastValidBlockHeight = latestBlockhash.lastValidBlockHeight;
+        transaction.recentBlockhash = latestBlockhash.blockhash;
         transaction.sign(...signers);
 
         if (!transaction.signature) {
@@ -9608,16 +9760,36 @@ VoteProgram.space = 3731;
  *
  * @param {Connection} connection
  * @param {Buffer} rawTransaction
+ * @param {BlockheightBasedTransactionConfirmationStrategy} confirmationStrategy
  * @param {ConfirmOptions} [options]
  * @returns {Promise<TransactionSignature>}
  */
-async function sendAndConfirmRawTransaction(connection, rawTransaction, options) {
+
+/**
+ * @deprecated Calling `sendAndConfirmRawTransaction()` without a `confirmationStrategy`
+ * is no longer supported and will be removed in a future version.
+ */
+// eslint-disable-next-line no-redeclare
+// eslint-disable-next-line no-redeclare
+async function sendAndConfirmRawTransaction(connection, rawTransaction, confirmationStrategyOrConfirmOptions, maybeConfirmOptions) {
+  let confirmationStrategy;
+  let options;
+
+  if (confirmationStrategyOrConfirmOptions && Object.prototype.hasOwnProperty.call(confirmationStrategyOrConfirmOptions, 'lastValidBlockHeight')) {
+    confirmationStrategy = confirmationStrategyOrConfirmOptions;
+    options = maybeConfirmOptions;
+  } else {
+    options = confirmationStrategyOrConfirmOptions;
+  }
+
   const sendOptions = options && {
     skipPreflight: options.skipPreflight,
     preflightCommitment: options.preflightCommitment || options.commitment
   };
   const signature = await connection.sendRawTransaction(rawTransaction, sendOptions);
-  const status = (await connection.confirmTransaction(signature, options && options.commitment)).value;
+  const commitment = options && options.commitment;
+  const confirmationPromise = confirmationStrategy ? connection.confirmTransaction(confirmationStrategy, commitment) : connection.confirmTransaction(signature, commitment);
+  const status = (await confirmationPromise).value;
 
   if (status.err) {
     throw new Error(`Raw transaction ${signature} failed (${JSON.stringify(status)})`);