@solana/web3.js 0.0.0-next → 0.0.0-pr-29130

package/src/programs/compute-budget.ts

@@ -0,0 +1,281 @@
+import * as BufferLayout from '@solana/buffer-layout';
+
+import {
+  encodeData,
+  decodeData,
+  InstructionType,
+  IInstructionInputData,
+} from '../instruction';
+import {PublicKey} from '../publickey';
+import {TransactionInstruction} from '../transaction';
+import {u64} from '../utils/bigint';
+
+/**
+ * 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};
+  }
+
+  /**
+   * 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
+   */
+  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'
+  | 'SetComputeUnitLimit'
+  | 'SetComputeUnitPrice';
+
+type ComputeBudgetInstructionInputData = {
+  RequestUnits: IInstructionInputData & Readonly<RequestUnitsParams>;
+  RequestHeapFrame: IInstructionInputData & Readonly<RequestHeapFrameParams>;
+  SetComputeUnitLimit: IInstructionInputData &
+    Readonly<SetComputeUnitLimitParams>;
+  SetComputeUnitPrice: IInstructionInputData &
+    Readonly<SetComputeUnitPriceParams>;
+};
+
+/**
+ * Request units instruction params
+ */
+export interface RequestUnitsParams {
+  /** Units to request for transaction-wide compute */
+  units: number;
+  /** Prioritization fee lamports */
+  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;
+};
+
+/**
+ * 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
+ */
+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')]),
+  },
+  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')]),
+  },
+});
+
+/**
+ * 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',
+  );
+
+  /**
+   * @deprecated Instead, call {@link setComputeUnitLimit} and/or {@link setComputeUnitPrice}
+   */
+  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,
+    });
+  }
+
+  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/{ed25519-program.ts → programs/ed25519.ts}

@@ -1,11 +1,11 @@
 import {Buffer} from 'buffer';
 import * as BufferLayout from '@solana/buffer-layout';
-import nacl from 'tweetnacl';
 
-import {Keypair} from './keypair';
-import {PublicKey} from './publickey';
-import {TransactionInstruction} from './transaction';
-import assert from './util/assert';
+import {Keypair} from '../keypair';
+import {PublicKey} from '../publickey';
+import {TransactionInstruction} from '../transaction';
+import assert from '../utils/assert';
+import {sign} from '../utils/ed25519';
 
 const PRIVATE_KEY_BYTES = 64;
 const PUBLIC_KEY_BYTES = 32;
@@ -142,7 +142,7 @@ export class Ed25519Program {
     try {
       const keypair = Keypair.fromSecretKey(privateKey);
       const publicKey = keypair.publicKey.toBytes();
-      const signature = nacl.sign.detached(message, keypair.secretKey);
+      const signature = sign(message, keypair.secretKey);
 
       return this.createInstructionWithPublicKey({
         publicKey,

package/src/programs/index.ts

@@ -0,0 +1,7 @@
+export * from './address-lookup-table';
+export * from './compute-budget';
+export * from './ed25519';
+export * from './secp256k1';
+export * from './stake';
+export * from './system';
+export * from './vote';

package/src/{secp256k1-program.ts → programs/secp256k1.ts}

@@ -1,14 +1,12 @@
 import {Buffer} from 'buffer';
 import * as BufferLayout from '@solana/buffer-layout';
-import secp256k1 from 'secp256k1';
-import sha3 from 'js-sha3';
+import {keccak_256} from '@noble/hashes/sha3';
 
-import {PublicKey} from './publickey';
-import {TransactionInstruction} from './transaction';
-import assert from './util/assert';
-import {toBuffer} from './util/to-buffer';
-
-const {publicKeyCreate, ecdsaSign} = secp256k1;
+import {PublicKey} from '../publickey';
+import {TransactionInstruction} from '../transaction';
+import assert from '../utils/assert';
+import {publicKeyCreate, ecdsaSign} from '../utils/secp256k1';
+import {toBuffer} from '../utils/to-buffer';
 
 const PRIVATE_KEY_BYTES = 32;
 const ETHEREUM_ADDRESS_BYTES = 20;
@@ -100,9 +98,9 @@ export class Secp256k1Program {
     );
 
     try {
-      return Buffer.from(
-        sha3.keccak_256.update(toBuffer(publicKey)).digest(),
-      ).slice(-ETHEREUM_ADDRESS_BYTES);
+      return Buffer.from(keccak_256(toBuffer(publicKey))).slice(
+        -ETHEREUM_ADDRESS_BYTES,
+      );
     } catch (error) {
       throw new Error(`Error constructing Ethereum address: ${error}`);
     }
@@ -209,11 +207,12 @@ export class Secp256k1Program {
 
     try {
       const privateKey = toBuffer(pkey);
-      const publicKey = publicKeyCreate(privateKey, false).slice(1); // throw away leading byte
-      const messageHash = Buffer.from(
-        sha3.keccak_256.update(toBuffer(message)).digest(),
-      );
-      const {signature, recid: recoveryId} = ecdsaSign(messageHash, privateKey);
+      const publicKey = publicKeyCreate(
+        privateKey,
+        false /* isCompressed */,
+      ).slice(1); // throw away leading byte
+      const messageHash = Buffer.from(keccak_256(toBuffer(message)));
+      const [signature, recoveryId] = ecdsaSign(messageHash, privateKey);
 
       return this.createInstructionWithPublicKey({
         publicKey,

package/src/{stake-program.ts → programs/stake.ts}

@@ -5,17 +5,17 @@ import {
   decodeData,
   InstructionType,
   IInstructionInputData,
-} from './instruction';
-import * as Layout from './layout';
-import {PublicKey} from './publickey';
-import {SystemProgram} from './system-program';
+} from '../instruction';
+import * as Layout from '../layout';
+import {PublicKey} from '../publickey';
+import {SystemProgram} from './system';
 import {
   SYSVAR_CLOCK_PUBKEY,
   SYSVAR_RENT_PUBKEY,
   SYSVAR_STAKE_HISTORY_PUBKEY,
-} from './sysvar';
-import {Transaction, TransactionInstruction} from './transaction';
-import {toBuffer} from './util/to-buffer';
+} from '../sysvar';
+import {Transaction, TransactionInstruction} from '../transaction';
+import {toBuffer} from '../utils/to-buffer';
 
 /**
  * Address of the stake config account which configures the rate

package/src/{system-program.ts → programs/system.ts}

@@ -5,13 +5,14 @@ import {
   decodeData,
   InstructionType,
   IInstructionInputData,
-} from './instruction';
-import * as Layout from './layout';
-import {NONCE_ACCOUNT_LENGTH} from './nonce-account';
-import {PublicKey} from './publickey';
-import {SYSVAR_RECENT_BLOCKHASHES_PUBKEY, SYSVAR_RENT_PUBKEY} from './sysvar';
-import {Transaction, TransactionInstruction} from './transaction';
-import {toBuffer} from './util/to-buffer';
+} from '../instruction';
+import * as Layout from '../layout';
+import {NONCE_ACCOUNT_LENGTH} from '../nonce-account';
+import {PublicKey} from '../publickey';
+import {SYSVAR_RECENT_BLOCKHASHES_PUBKEY, SYSVAR_RENT_PUBKEY} from '../sysvar';
+import {Transaction, TransactionInstruction} from '../transaction';
+import {toBuffer} from '../utils/to-buffer';
+import {u64} from '../utils/bigint';
 
 /**
  * Create account system transaction params
@@ -38,7 +39,7 @@ export type TransferParams = {
   /** Account that will receive transferred lamports */
   toPubkey: PublicKey;
   /** Amount of lamports to transfer */
-  lamports: number;
+  lamports: number | bigint;
 };
 
 /**
@@ -200,7 +201,33 @@ export type TransferWithSeedParams = {
   /** Account that will receive transferred lamports */
   toPubkey: PublicKey;
   /** Amount of lamports to transfer */
-  lamports: number;
+  lamports: number | bigint;
+  /** Seed to use to derive the funding account address */
+  seed: string;
+  /** Program id to use to derive the funding account address */
+  programId: PublicKey;
+};
+
+/** Decoded transfer system transaction instruction */
+export type DecodedTransferInstruction = {
+  /** Account that will transfer lamports */
+  fromPubkey: PublicKey;
+  /** Account that will receive transferred lamports */
+  toPubkey: PublicKey;
+  /** Amount of lamports to transfer */
+  lamports: bigint;
+};
+
+/** Decoded transferWithSeed system transaction instruction */
+export type DecodedTransferWithSeedInstruction = {
+  /** Account that will transfer lamports */
+  fromPubkey: PublicKey;
+  /** Base public key to use to derive the funding account address */
+  basePubkey: PublicKey;
+  /** Account that will receive transferred lamports */
+  toPubkey: PublicKey;
+  /** Amount of lamports to transfer */
+  lamports: bigint;
   /** Seed to use to derive the funding account address */
   seed: string;
   /** Program id to use to derive the funding account address */
@@ -268,7 +295,9 @@ export class SystemInstruction {
   /**
    * Decode a transfer system instruction and retrieve the instruction params.
    */
-  static decodeTransfer(instruction: TransactionInstruction): TransferParams {
+  static decodeTransfer(
+    instruction: TransactionInstruction,
+  ): DecodedTransferInstruction {
     this.checkProgramId(instruction.programId);
     this.checkKeyLength(instruction.keys, 2);
 
@@ -289,7 +318,7 @@ export class SystemInstruction {
    */
   static decodeTransferWithSeed(
     instruction: TransactionInstruction,
-  ): TransferWithSeedParams {
+  ): DecodedTransferWithSeedInstruction {
     this.checkProgramId(instruction.programId);
     this.checkKeyLength(instruction.keys, 3);
 
@@ -537,7 +566,8 @@ export type SystemInstructionType =
   | 'InitializeNonceAccount'
   | 'Transfer'
   | 'TransferWithSeed'
-  | 'WithdrawNonceAccount';
+  | 'WithdrawNonceAccount'
+  | 'UpgradeNonceAccount';
 
 type SystemInstructionInputData = {
   AdvanceNonceAccount: IInstructionInputData;
@@ -577,16 +607,17 @@ type SystemInstructionInputData = {
     authorized: Uint8Array;
   };
   Transfer: IInstructionInputData & {
-    lamports: number;
+    lamports: bigint;
   };
   TransferWithSeed: IInstructionInputData & {
-    lamports: number;
+    lamports: bigint;
     programId: Uint8Array;
     seed: string;
   };
   WithdrawNonceAccount: IInstructionInputData & {
     lamports: number;
   };
+  UpgradeNonceAccount: IInstructionInputData;
 };
 
 /**
@@ -618,7 +649,7 @@ export const SYSTEM_INSTRUCTION_LAYOUTS = Object.freeze<{
     index: 2,
     layout: BufferLayout.struct<SystemInstructionInputData['Transfer']>([
       BufferLayout.u32('instruction'),
-      BufferLayout.ns64('lamports'),
+      u64('lamports'),
     ]),
   },
   CreateWithSeed: {
@@ -689,12 +720,18 @@ export const SYSTEM_INSTRUCTION_LAYOUTS = Object.freeze<{
     layout: BufferLayout.struct<SystemInstructionInputData['TransferWithSeed']>(
       [
         BufferLayout.u32('instruction'),
-        BufferLayout.ns64('lamports'),
+        u64('lamports'),
         Layout.rustString('seed'),
         Layout.publicKey('programId'),
       ],
     ),
   },
+  UpgradeNonceAccount: {
+    index: 12,
+    layout: BufferLayout.struct<
+      SystemInstructionInputData['UpgradeNonceAccount']
+    >([BufferLayout.u32('instruction')]),
+  },
 });
 
 /**
@@ -745,7 +782,7 @@ export class SystemProgram {
     if ('basePubkey' in params) {
       const type = SYSTEM_INSTRUCTION_LAYOUTS.TransferWithSeed;
       data = encodeData(type, {
-        lamports: params.lamports,
+        lamports: BigInt(params.lamports),
         seed: params.seed,
         programId: toBuffer(params.programId.toBuffer()),
       });
@@ -756,7 +793,7 @@ export class SystemProgram {
       ];
     } else {
       const type = SYSTEM_INSTRUCTION_LAYOUTS.Transfer;
-      data = encodeData(type, {lamports: params.lamports});
+      data = encodeData(type, {lamports: BigInt(params.lamports)});
       keys = [
         {pubkey: params.fromPubkey, isSigner: true, isWritable: true},
         {pubkey: params.toPubkey, isSigner: false, isWritable: true},