@solana/web3.js 1.41.10 → 1.42.0

package/lib/index.d.ts

@@ -625,15 +625,17 @@ declare module '@solana/web3.js' {
     /** response value */
     value: T;
   };
+  export type BlockhashWithExpiryBlockHeight = Readonly<{
+    blockhash: Blockhash;
+    lastValidBlockHeight: number;
+  }>;
   /**
    * A strategy for confirming transactions that uses the last valid
    * block height for a given blockhash to check for transaction expiration.
    */
   export type BlockheightBasedTransactionConfimationStrategy = {
     signature: TransactionSignature;
-    blockhash: Blockhash;
-    lastValidBlockHeight: number;
-  };
+  } & BlockhashWithExpiryBlockHeight;
   /**
    * The level of commitment desired when querying state
    * <pre>
@@ -1790,22 +1792,18 @@ declare module '@solana/web3.js' {
     }>;
     /**
      * Fetch the latest blockhash from the cluster
-     * @return {Promise<{blockhash: Blockhash, lastValidBlockHeight: number}>}
+     * @return {Promise<BlockhashWithExpiryBlockHeight>}
      */
-    getLatestBlockhash(commitment?: Commitment): Promise<{
-      blockhash: Blockhash;
-      lastValidBlockHeight: number;
-    }>;
+    getLatestBlockhash(
+      commitment?: Commitment,
+    ): Promise<BlockhashWithExpiryBlockHeight>;
     /**
      * Fetch the latest blockhash from the cluster
-     * @return {Promise<{blockhash: Blockhash, lastValidBlockHeight: number}>}
+     * @return {Promise<BlockhashWithExpiryBlockHeight>}
      */
-    getLatestBlockhashAndContext(commitment?: Commitment): Promise<
-      RpcResponseAndContext<{
-        blockhash: Blockhash;
-        lastValidBlockHeight: number;
-      }>
-    >;
+    getLatestBlockhashAndContext(
+      commitment?: Commitment,
+    ): Promise<RpcResponseAndContext<BlockhashWithExpiryBlockHeight>>;
     /**
      * Fetch the node version
      */
@@ -3354,9 +3352,20 @@ declare module '@solana/web3.js' {
    *
    * @param {Connection} connection
    * @param {Buffer} rawTransaction
+   * @param {BlockheightBasedTransactionConfimationStrategy} confirmationStrategy
    * @param {ConfirmOptions} [options]
    * @returns {Promise<TransactionSignature>}
    */
+  export function sendAndConfirmRawTransaction(
+    connection: Connection,
+    rawTransaction: Buffer,
+    confirmationStrategy: BlockheightBasedTransactionConfimationStrategy,
+    options?: ConfirmOptions,
+  ): Promise<TransactionSignature>;
+  /**
+   * @deprecated Calling `sendAndConfirmRawTransaction()` without a `confirmationStrategy`
+   * is no longer supported and will be removed in a future version.
+   */
   export function sendAndConfirmRawTransaction(
     connection: Connection,
     rawTransaction: Buffer,

package/lib/index.esm.js

@@ -5500,7 +5500,7 @@ class Connection {
     this._disableBlockhashCaching = false;
     this._pollingBlockhash = false;
     this._blockhashInfo = {
-      recentBlockhash: null,
+      latestBlockhash: null,
       lastFetch: 0,
       transactionSignatures: [],
       simulatedSignatures: []
@@ -6463,7 +6463,7 @@ class Connection {
   }
   /**
    * Fetch the latest blockhash from the cluster
-   * @return {Promise<{blockhash: Blockhash, lastValidBlockHeight: number}>}
+   * @return {Promise<BlockhashWithExpiryBlockHeight>}
    */
 
 
@@ -6477,7 +6477,7 @@ class Connection {
   }
   /**
    * Fetch the latest blockhash from the cluster
-   * @return {Promise<{blockhash: Blockhash, lastValidBlockHeight: number}>}
+   * @return {Promise<BlockhashWithExpiryBlockHeight>}
    */
 
 
@@ -7060,7 +7060,7 @@ class Connection {
    */
 
 
-  async _recentBlockhash(disableCache) {
+  async _blockhashWithExpiryBlockHeight(disableCache) {
     if (!disableCache) {
       // Wait for polling to finish
       while (this._pollingBlockhash) {
@@ -7071,8 +7071,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;
       }
     }
 
@@ -7088,20 +7088,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
 
 
@@ -7123,13 +7123,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
 
@@ -7142,7 +7140,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);
 
@@ -7226,7 +7226,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) {
@@ -9667,16 +9669,36 @@ VoteProgram.space = 3731;
  *
  * @param {Connection} connection
  * @param {Buffer} rawTransaction
+ * @param {BlockheightBasedTransactionConfimationStrategy} 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)})`);