@solana/web3.js 1.41.10 → 1.43.1

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 = {
+  export type BlockheightBasedTransactionConfirmationStrategy = {
     signature: TransactionSignature;
-    blockhash: Blockhash;
-    lastValidBlockHeight: number;
-  };
+  } & BlockhashWithExpiryBlockHeight;
   /**
    * The level of commitment desired when querying state
    * <pre>
@@ -1657,7 +1659,7 @@ declare module '@solana/web3.js' {
       }>
     >;
     confirmTransaction(
-      strategy: BlockheightBasedTransactionConfimationStrategy,
+      strategy: BlockheightBasedTransactionConfirmationStrategy,
       commitment?: Commitment,
     ): Promise<RpcResponseAndContext<SignatureResult>>;
     /** @deprecated Instead, call `confirmTransaction` using a `TransactionConfirmationConfig` */
@@ -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
      */
@@ -2228,20 +2226,34 @@ declare module '@solana/web3.js' {
     static decodeRequestHeapFrame(
       instruction: TransactionInstruction,
     ): RequestHeapFrameParams;
+    /**
+     * Decode set compute unit limit compute budget instruction and retrieve the instruction params.
+     */
+    static decodeSetComputeUnitLimit(
+      instruction: TransactionInstruction,
+    ): SetComputeUnitLimitParams;
+    /**
+     * Decode set compute unit price compute budget instruction and retrieve the instruction params.
+     */
+    static decodeSetComputeUnitPrice(
+      instruction: TransactionInstruction,
+    ): SetComputeUnitPriceParams;
   }
   /**
    * An enumeration of valid ComputeBudgetInstructionType's
    */
   export type ComputeBudgetInstructionType =
     | 'RequestUnits'
-    | 'RequestHeapFrame';
+    | 'RequestHeapFrame'
+    | 'SetComputeUnitLimit'
+    | 'SetComputeUnitPrice';
   /**
    * Request units instruction params
    */
   interface RequestUnitsParams {
     /** Units to request for transaction-wide compute */
     units: number;
-    /** Additional fee to pay */
+    /** Prioritization fee lamports */
     additionalFee: number;
   }
   /**
@@ -2251,6 +2263,20 @@ declare module '@solana/web3.js' {
     /** Requested transaction-wide program heap size in bytes. Must be multiple of 1024. Applies to each program, including CPIs. */
     bytes: number;
   };
+  /**
+   * Set compute unit limit instruction params
+   */
+  interface SetComputeUnitLimitParams {
+    /** Transaction-wide compute unit limit */
+    units: number;
+  }
+  /**
+   * Set compute unit price instruction params
+   */
+  interface SetComputeUnitPriceParams {
+    /** Transaction compute unit price used for prioritization fees */
+    microLamports: number | bigint;
+  }
   /**
    * Factory class for transaction instructions to interact with the Compute Budget program
    */
@@ -2263,6 +2289,12 @@ declare module '@solana/web3.js' {
     static requestHeapFrame(
       params: RequestHeapFrameParams,
     ): TransactionInstruction;
+    static setComputeUnitLimit(
+      params: SetComputeUnitLimitParams,
+    ): TransactionInstruction;
+    static setComputeUnitPrice(
+      params: SetComputeUnitPriceParams,
+    ): TransactionInstruction;
   }
 
   /**
@@ -3354,9 +3386,20 @@ declare module '@solana/web3.js' {
    *
    * @param {Connection} connection
    * @param {Buffer} rawTransaction
+   * @param {BlockheightBasedTransactionConfirmationStrategy} confirmationStrategy
    * @param {ConfirmOptions} [options]
    * @returns {Promise<TransactionSignature>}
    */
+  export function sendAndConfirmRawTransaction(
+    connection: Connection,
+    rawTransaction: Buffer,
+    confirmationStrategy: BlockheightBasedTransactionConfirmationStrategy,
+    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

@@ -4,7 +4,8 @@ import BN from 'bn.js';
 import bs58 from 'bs58';
 import { serialize, deserialize, deserializeUnchecked } from 'borsh';
 import * as BufferLayout from '@solana/buffer-layout';
-import { u64 } from '@solana/buffer-layout-utils';
+import { blob } from '@solana/buffer-layout';
+import { toBigIntLE, toBufferLE } from 'bigint-buffer';
 import crossFetch from 'cross-fetch';
 import { coerce, instance, string, tuple, literal, unknown, union, type, optional, any, number, array, nullable, create, boolean, record, assert as assert$7 } from 'superstruct';
 import { Client } from 'rpc-websockets';
@@ -2805,8 +2806,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
@@ -3186,6 +3185,38 @@ class NonceAccount {
 
 }
 
+const encodeDecode = layout => {
+  const decode = layout.decode.bind(layout);
+  const encode = layout.encode.bind(layout);
+  return {
+    decode,
+    encode
+  };
+};
+
+const bigInt = length => property => {
+  const layout = blob(length, property);
+  const {
+    encode,
+    decode
+  } = encodeDecode(layout);
+  const bigIntLayout = layout;
+
+  bigIntLayout.decode = (buffer, offset) => {
+    const src = decode(buffer, offset);
+    return toBigIntLE(Buffer.from(src));
+  };
+
+  bigIntLayout.encode = (bigInt, buffer, offset) => {
+    const src = toBufferLE(bigInt, length);
+    return encode(src, buffer, offset);
+  };
+
+  return bigIntLayout;
+};
+
+const u64 = bigInt(8);
+
 /**
  * Create account system transaction params
  */
@@ -4164,6 +4195,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
    */
@@ -4192,6 +4251,14 @@ const COMPUTE_BUDGET_INSTRUCTION_LAYOUTS = Object.freeze({
   RequestHeapFrame: {
     index: 1,
     layout: BufferLayout.struct([BufferLayout.u8('instruction'), BufferLayout.u32('bytes')])
+  },
+  SetComputeUnitLimit: {
+    index: 2,
+    layout: BufferLayout.struct([BufferLayout.u8('instruction'), BufferLayout.u32('units')])
+  },
+  SetComputeUnitPrice: {
+    index: 3,
+    layout: BufferLayout.struct([BufferLayout.u8('instruction'), u64('microLamports')])
   }
 });
 /**
@@ -4228,6 +4295,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');
 
@@ -5500,7 +5589,7 @@ class Connection {
     this._disableBlockhashCaching = false;
     this._pollingBlockhash = false;
     this._blockhashInfo = {
-      recentBlockhash: null,
+      latestBlockhash: null,
       lastFetch: 0,
       transactionSignatures: [],
       simulatedSignatures: []
@@ -6463,7 +6552,7 @@ class Connection {
   }
   /**
    * Fetch the latest blockhash from the cluster
-   * @return {Promise<{blockhash: Blockhash, lastValidBlockHeight: number}>}
+   * @return {Promise<BlockhashWithExpiryBlockHeight>}
    */
 
 
@@ -6477,7 +6566,7 @@ class Connection {
   }
   /**
    * Fetch the latest blockhash from the cluster
-   * @return {Promise<{blockhash: Blockhash, lastValidBlockHeight: number}>}
+   * @return {Promise<BlockhashWithExpiryBlockHeight>}
    */
 
 
@@ -7060,7 +7149,7 @@ class Connection {
    */
 
 
-  async _recentBlockhash(disableCache) {
+  async _blockhashWithExpiryBlockHeight(disableCache) {
     if (!disableCache) {
       // Wait for polling to finish
       while (this._pollingBlockhash) {
@@ -7071,8 +7160,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 +7177,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 +7212,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 +7229,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 +7315,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 +9758,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)})`);