@solana/web3.js 1.40.0 → 1.41.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@solana/web3.js",
-  "version": "1.40.0",
+  "version": "1.41.1",
   "description": "Solana Javascript API",
   "keywords": [
     "api",
@@ -50,8 +50,8 @@
     "pretty": "prettier --check '{,{src,test}/**/}*.{j,t}s'",
     "pretty:fix": "prettier --write '{,{src,test}/**/}*.{j,t}s'",
     "re": "semantic-release --repository-url git@github.com:solana-labs/solana-web3.js.git",
-    "test": "mocha -r ts-node/register './test/**/*.test.ts'",
-    "test:cover": "TS_NODE_COMPILER_OPTIONS='{\"module\": \"commonjs\" }' nyc --reporter=lcov mocha -r ts-node/register './test/**/*.test.ts'",
+    "test": "cross-env TS_NODE_COMPILER_OPTIONS='{ \"module\": \"commonjs\" }' ts-mocha --require esm './test/**/*.test.ts'",
+    "test:cover": "nyc --reporter=lcov npm run test",
     "test:live": "TEST_LIVE=1 npm run test",
     "test:live-with-test-validator": "start-server-and-test 'solana-test-validator --reset --quiet' http://localhost:8899/health test:live"
   },
@@ -117,7 +117,6 @@
     "npm-run-all": "^4.1.5",
     "nyc": "^15.1.0",
     "prettier": "^2.3.0",
-    "puppeteer": "^12.0.0",
     "rimraf": "3.0.2",
     "rollup": "2.60.2",
     "rollup-plugin-dts": "^4.0.0",
@@ -126,6 +125,7 @@
     "semantic-release": "^18.0.0",
     "sinon": "^12.0.0",
     "start-server-and-test": "^1.12.0",
+    "ts-mocha": "^9.0.2",
     "ts-node": "^10.0.0",
     "tslib": "^2.1.0",
     "typedoc": "^0.22.2",

package/src/compute-budget.ts

@@ -0,0 +1,189 @@
+import * as BufferLayout from '@solana/buffer-layout';
+
+import {
+  encodeData,
+  decodeData,
+  InstructionType,
+  IInstructionInputData,
+} from './instruction';
+import {PublicKey} from './publickey';
+import {TransactionInstruction} from './transaction';
+
+/**
+ * Compute Budget Instruction class
+ */
+export class ComputeBudgetInstruction {
+  /**
+   * @internal
+   */
+  constructor() {}
+
+  /**
+   * Decode a compute budget instruction and retrieve the instruction type.
+   */
+  static decodeInstructionType(
+    instruction: TransactionInstruction,
+  ): ComputeBudgetInstructionType {
+    this.checkProgramId(instruction.programId);
+
+    const instructionTypeLayout = BufferLayout.u8('instruction');
+    const typeIndex = instructionTypeLayout.decode(instruction.data);
+
+    let type: ComputeBudgetInstructionType | undefined;
+    for (const [ixType, layout] of Object.entries(
+      COMPUTE_BUDGET_INSTRUCTION_LAYOUTS,
+    )) {
+      if (layout.index == typeIndex) {
+        type = ixType as ComputeBudgetInstructionType;
+        break;
+      }
+    }
+
+    if (!type) {
+      throw new Error(
+        'Instruction type incorrect; not a ComputeBudgetInstruction',
+      );
+    }
+
+    return type;
+  }
+
+  /**
+   * Decode request units compute budget instruction and retrieve the instruction params.
+   */
+  static decodeRequestUnits(
+    instruction: TransactionInstruction,
+  ): RequestUnitsParams {
+    this.checkProgramId(instruction.programId);
+    const {units, additionalFee} = decodeData(
+      COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestUnits,
+      instruction.data,
+    );
+    return {units, additionalFee};
+  }
+
+  /**
+   * Decode request heap frame compute budget instruction and retrieve the instruction params.
+   */
+  static decodeRequestHeapFrame(
+    instruction: TransactionInstruction,
+  ): RequestHeapFrameParams {
+    this.checkProgramId(instruction.programId);
+    const {bytes} = decodeData(
+      COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestHeapFrame,
+      instruction.data,
+    );
+    return {bytes};
+  }
+
+  /**
+   * @internal
+   */
+  static checkProgramId(programId: PublicKey) {
+    if (!programId.equals(ComputeBudgetProgram.programId)) {
+      throw new Error(
+        'invalid instruction; programId is not ComputeBudgetProgram',
+      );
+    }
+  }
+}
+
+/**
+ * An enumeration of valid ComputeBudgetInstructionType's
+ */
+export type ComputeBudgetInstructionType =
+  // FIXME
+  // 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';
+
+type ComputeBudgetInstructionInputData = {
+  RequestUnits: IInstructionInputData & Readonly<RequestUnitsParams>;
+  RequestHeapFrame: IInstructionInputData & Readonly<RequestHeapFrameParams>;
+};
+
+/**
+ * Request units instruction params
+ */
+export interface RequestUnitsParams {
+  /** Units to request for transaction-wide compute */
+  units: number;
+
+  /** Additional fee to pay */
+  additionalFee: number;
+}
+
+/**
+ * Request heap frame instruction params
+ */
+export type RequestHeapFrameParams = {
+  /** Requested transaction-wide program heap size in bytes. Must be multiple of 1024. Applies to each program, including CPIs. */
+  bytes: number;
+};
+
+/**
+ * An enumeration of valid ComputeBudget InstructionType's
+ * @internal
+ */
+export const COMPUTE_BUDGET_INSTRUCTION_LAYOUTS = Object.freeze<{
+  [Instruction in ComputeBudgetInstructionType]: InstructionType<
+    ComputeBudgetInstructionInputData[Instruction]
+  >;
+}>({
+  RequestUnits: {
+    index: 0,
+    layout: BufferLayout.struct<
+      ComputeBudgetInstructionInputData['RequestUnits']
+    >([
+      BufferLayout.u8('instruction'),
+      BufferLayout.u32('units'),
+      BufferLayout.u32('additionalFee'),
+    ]),
+  },
+  RequestHeapFrame: {
+    index: 1,
+    layout: BufferLayout.struct<
+      ComputeBudgetInstructionInputData['RequestHeapFrame']
+    >([BufferLayout.u8('instruction'), BufferLayout.u32('bytes')]),
+  },
+});
+
+/**
+ * Factory class for transaction instructions to interact with the Compute Budget program
+ */
+export class ComputeBudgetProgram {
+  /**
+   * @internal
+   */
+  constructor() {}
+
+  /**
+   * Public key that identifies the Compute Budget program
+   */
+  static programId: PublicKey = new PublicKey(
+    'ComputeBudget111111111111111111111111111111',
+  );
+
+  static requestUnits(params: RequestUnitsParams): TransactionInstruction {
+    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestUnits;
+    const data = encodeData(type, params);
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data,
+    });
+  }
+
+  static requestHeapFrame(
+    params: RequestHeapFrameParams,
+  ): TransactionInstruction {
+    const type = COMPUTE_BUDGET_INSTRUCTION_LAYOUTS.RequestHeapFrame;
+    const data = encodeData(type, params);
+    return new TransactionInstruction({
+      keys: [],
+      programId: this.programId,
+      data,
+    });
+  }
+}

package/src/index.ts

@@ -2,6 +2,7 @@ export * from './account';
 export * from './blockhash';
 export * from './bpf-loader-deprecated';
 export * from './bpf-loader';
+export * from './compute-budget';
 export * from './connection';
 export * from './epoch-schedule';
 export * from './ed25519-program';

package/src/loader.ts

@@ -2,7 +2,7 @@ import {Buffer} from 'buffer';
 import * as BufferLayout from '@solana/buffer-layout';
 
 import {PublicKey} from './publickey';
-import {Transaction, PACKET_DATA_SIZE} from './transaction';
+import {Transaction} from './transaction';
 import {SYSVAR_RENT_PUBKEY} from './sysvar';
 import {sendAndConfirmTransaction} from './util/send-and-confirm-transaction';
 import {sleep} from './util/sleep';
@@ -10,6 +10,7 @@ import type {Connection} from './connection';
 import type {Signer} from './keypair';
 import {SystemProgram} from './system-program';
 import {IInstructionInputData} from './instruction';
+import {PACKET_DATA_SIZE} from './transaction-constants';
 
 // Keep program chunks under PACKET_DATA_SIZE, leaving enough room for the
 // rest of the Transaction fields

package/src/message.ts

@@ -5,7 +5,7 @@ import * as BufferLayout from '@solana/buffer-layout';
 import {PublicKey} from './publickey';
 import type {Blockhash} from './blockhash';
 import * as Layout from './layout';
-import {PACKET_DATA_SIZE} from './transaction';
+import {PACKET_DATA_SIZE} from './transaction-constants';
 import * as shortvec from './util/shortvec-encoding';
 import {toBuffer} from './util/to-buffer';
 

package/src/transaction-constants.ts

@@ -0,0 +1,10 @@
+/**
+ * Maximum over-the-wire size of a Transaction
+ *
+ * 1280 is IPv6 minimum MTU
+ * 40 bytes is the size of the IPv6 header
+ * 8 bytes is the size of the fragment header
+ */
+export const PACKET_DATA_SIZE = 1280 - 40 - 8;
+
+export const SIGNATURE_LENGTH_IN_BYTES = 64;

package/src/transaction.ts

@@ -2,6 +2,10 @@ import nacl from 'tweetnacl';
 import bs58 from 'bs58';
 import {Buffer} from 'buffer';
 
+import {
+  PACKET_DATA_SIZE,
+  SIGNATURE_LENGTH_IN_BYTES,
+} from './transaction-constants';
 import {Connection} from './connection';
 import {Message} from './message';
 import {PublicKey} from './publickey';
@@ -19,21 +23,8 @@ export type TransactionSignature = string;
 
 /**
  * Default (empty) signature
- *
- * Signatures are 64 bytes in length
- */
-const DEFAULT_SIGNATURE = Buffer.alloc(64).fill(0);
-
-/**
- * Maximum over-the-wire size of a Transaction
- *
- * 1280 is IPv6 minimum MTU
- * 40 bytes is the size of the IPv6 header
- * 8 bytes is the size of the fragment header
  */
-export const PACKET_DATA_SIZE = 1280 - 40 - 8;
-
-const SIGNATURE_LENGTH = 64;
+const DEFAULT_SIGNATURE = Buffer.alloc(SIGNATURE_LENGTH_IN_BYTES).fill(0);
 
 /**
  * Account metadata used to define instructions
@@ -747,8 +738,8 @@ export class Transaction {
     const signatureCount = shortvec.decodeLength(byteArray);
     let signatures = [];
     for (let i = 0; i < signatureCount; i++) {
-      const signature = byteArray.slice(0, SIGNATURE_LENGTH);
-      byteArray = byteArray.slice(SIGNATURE_LENGTH);
+      const signature = byteArray.slice(0, SIGNATURE_LENGTH_IN_BYTES);
+      byteArray = byteArray.slice(SIGNATURE_LENGTH_IN_BYTES);
       signatures.push(bs58.encode(Buffer.from(signature)));
     }