@solana/web3.js 1.42.0 → 1.43.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana/web3.js",
-  "version": "1.42.0",
+  "version": "1.43.0",
   "description": "Solana Javascript API",
   "keywords": [
     "api",

package/src/compute-budget.ts

@@ -1,4 +1,5 @@
 import * as BufferLayout from '@solana/buffer-layout';
+import {u64} from '@solana/buffer-layout-utils';
 
 import {
   encodeData,
@@ -76,6 +77,34 @@ export class ComputeBudgetInstruction {
     return {bytes};
   }
 
+  /**
+   * Decode set compute unit limit compute budget instruction and retrieve the instruction params.
+   */
+  static decodeSetComputeUnitLimit(
+    instruction: TransactionInstruction,
+  ): SetComputeUnitLimitParams {
+    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: TransactionInstruction,
+  ): SetComputeUnitPriceParams {
+    this.checkProgramId(instruction.programId);
+    const {microLamports} = decodeData(
+      COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitPrice,
+      instruction.data,
+    );
+    return {microLamports};
+  }
+
   /**
    * @internal
    */
@@ -96,11 +125,18 @@ export type ComputeBudgetInstructionType =
   // It would be preferable for this type to be `keyof ComputeBudgetInstructionInputData`
   // but Typedoc does not transpile `keyof` expressions.
   // See https://github.com/TypeStrong/typedoc/issues/1894
-  'RequestUnits' | 'RequestHeapFrame';
+  | 'RequestUnits'
+  | 'RequestHeapFrame'
+  | 'SetComputeUnitLimit'
+  | 'SetComputeUnitPrice';
 
 type ComputeBudgetInstructionInputData = {
   RequestUnits: IInstructionInputData & Readonly<RequestUnitsParams>;
   RequestHeapFrame: IInstructionInputData & Readonly<RequestHeapFrameParams>;
+  SetComputeUnitLimit: IInstructionInputData &
+    Readonly<SetComputeUnitLimitParams>;
+  SetComputeUnitPrice: IInstructionInputData &
+    Readonly<SetComputeUnitPriceParams>;
 };
 
 /**
@@ -109,8 +145,7 @@ type ComputeBudgetInstructionInputData = {
 export interface RequestUnitsParams {
   /** Units to request for transaction-wide compute */
   units: number;
-
-  /** Additional fee to pay */
+  /** Prioritization fee lamports */
   additionalFee: number;
 }
 
@@ -122,6 +157,22 @@ export type RequestHeapFrameParams = {
   bytes: number;
 };
 
+/**
+ * Set compute unit limit instruction params
+ */
+export interface SetComputeUnitLimitParams {
+  /** Transaction-wide compute unit limit */
+  units: number;
+}
+
+/**
+ * Set compute unit price instruction params
+ */
+export interface SetComputeUnitPriceParams {
+  /** Transaction compute unit price used for prioritization fees */
+  microLamports: number | bigint;
+}
+
 /**
  * An enumeration of valid ComputeBudget InstructionType's
  * @internal
@@ -147,6 +198,18 @@ export const COMPUTE_BUDGET_INSTRUCTION_LAYOUTS = Object.freeze<{
       ComputeBudgetInstructionInputData['RequestHeapFrame']
     >([BufferLayout.u8('instruction'), BufferLayout.u32('bytes')]),
   },
+  SetComputeUnitLimit: {
+    index: 2,
+    layout: BufferLayout.struct<
+      ComputeBudgetInstructionInputData['SetComputeUnitLimit']
+    >([BufferLayout.u8('instruction'), BufferLayout.u32('units')]),
+  },
+  SetComputeUnitPrice: {
+    index: 3,
+    layout: BufferLayout.struct<
+      ComputeBudgetInstructionInputData['SetComputeUnitPrice']
+    >([BufferLayout.u8('instruction'), u64('microLamports')]),
+  },
 });
 
 /**
@@ -186,4 +249,30 @@ export class ComputeBudgetProgram {
       data,
     });
   }
+
+  static setComputeUnitLimit(
+    params: SetComputeUnitLimitParams,
+  ): TransactionInstruction {
+    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitLimit;
+    const data = encodeData(type, params);
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data,
+    });
+  }
+
+  static setComputeUnitPrice(
+    params: SetComputeUnitPriceParams,
+  ): TransactionInstruction {
+    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.SetComputeUnitPrice;
+    const data = encodeData(type, {
+      microLamports: BigInt(params.microLamports),
+    });
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data,
+    });
+  }
 }

package/src/connection.ts

@@ -293,7 +293,7 @@ export type BlockhashWithExpiryBlockHeight = Readonly<{
  * 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;
 } & BlockhashWithExpiryBlockHeight;
 
@@ -2842,7 +2842,7 @@ export class Connection {
   }
 
   confirmTransaction(
-    strategy: BlockheightBasedTransactionConfimationStrategy,
+    strategy: BlockheightBasedTransactionConfirmationStrategy,
     commitment?: Commitment,
   ): Promise<RpcResponseAndContext<SignatureResult>>;
 
@@ -2856,7 +2856,7 @@ export class Connection {
   // eslint-disable-next-line no-dupe-class-members
   async confirmTransaction(
     strategy:
-      | BlockheightBasedTransactionConfimationStrategy
+      | BlockheightBasedTransactionConfirmationStrategy
       | TransactionSignature,
     commitment?: Commitment,
   ): Promise<RpcResponseAndContext<SignatureResult>> {
@@ -2865,7 +2865,8 @@ export class Connection {
     if (typeof strategy == 'string') {
       rawSignature = strategy;
     } else {
-      const config = strategy as BlockheightBasedTransactionConfimationStrategy;
+      const config =
+        strategy as BlockheightBasedTransactionConfirmationStrategy;
       rawSignature = config.signature;
     }
 
@@ -2942,7 +2943,8 @@ export class Connection {
           timeoutMs,
         );
       } else {
-        let config = strategy as BlockheightBasedTransactionConfimationStrategy;
+        let config =
+          strategy as BlockheightBasedTransactionConfirmationStrategy;
         (async () => {
           let currentBlockHeight = await checkBlockHeight();
           if (done) return;

package/src/transaction.ts

@@ -599,7 +599,6 @@ export class Transaction {
 
     const message = this._compile();
     this._partialSign(message, ...uniqueSigners);
-    this._verifySignatures(message.serialize(), true);
   }
 
   /**

package/src/util/send-and-confirm-raw-transaction.ts

@@ -1,7 +1,7 @@
 import type {Buffer} from 'buffer';
 
 import {
-  BlockheightBasedTransactionConfimationStrategy,
+  BlockheightBasedTransactionConfirmationStrategy,
   Connection,
 } from '../connection';
 import type {TransactionSignature} from '../transaction';
@@ -14,14 +14,14 @@ import type {ConfirmOptions} from '../connection';
  *
  * @param {Connection} connection
  * @param {Buffer} rawTransaction
- * @param {BlockheightBasedTransactionConfimationStrategy} confirmationStrategy
+ * @param {BlockheightBasedTransactionConfirmationStrategy} confirmationStrategy
  * @param {ConfirmOptions} [options]
  * @returns {Promise<TransactionSignature>}
  */
 export async function sendAndConfirmRawTransaction(
   connection: Connection,
   rawTransaction: Buffer,
-  confirmationStrategy: BlockheightBasedTransactionConfimationStrategy,
+  confirmationStrategy: BlockheightBasedTransactionConfirmationStrategy,
   options?: ConfirmOptions,
 ): Promise<TransactionSignature>;
 
@@ -41,13 +41,13 @@ export async function sendAndConfirmRawTransaction(
   connection: Connection,
   rawTransaction: Buffer,
   confirmationStrategyOrConfirmOptions:
-    | BlockheightBasedTransactionConfimationStrategy
+    | BlockheightBasedTransactionConfirmationStrategy
     | ConfirmOptions
     | undefined,
   maybeConfirmOptions?: ConfirmOptions,
 ): Promise<TransactionSignature> {
   let confirmationStrategy:
-    | BlockheightBasedTransactionConfimationStrategy
+    | BlockheightBasedTransactionConfirmationStrategy
     | undefined;
   let options: ConfirmOptions | undefined;
   if (
@@ -58,7 +58,7 @@ export async function sendAndConfirmRawTransaction(
     )
   ) {
     confirmationStrategy =
-      confirmationStrategyOrConfirmOptions as BlockheightBasedTransactionConfimationStrategy;
+      confirmationStrategyOrConfirmOptions as BlockheightBasedTransactionConfirmationStrategy;
     options = maybeConfirmOptions;
   } else {
     options = confirmationStrategyOrConfirmOptions as