@solana/web3.js 1.78.0 → 2.0.0-development

package/src/programs/compute-budget.ts

@@ -1,281 +0,0 @@
-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/programs/ed25519.ts

@@ -1,157 +0,0 @@
-import {Buffer} from 'buffer';
-import * as BufferLayout from '@solana/buffer-layout';
-
-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;
-const SIGNATURE_BYTES = 64;
-
-/**
- * Params for creating an ed25519 instruction using a public key
- */
-export type CreateEd25519InstructionWithPublicKeyParams = {
-  publicKey: Uint8Array;
-  message: Uint8Array;
-  signature: Uint8Array;
-  instructionIndex?: number;
-};
-
-/**
- * Params for creating an ed25519 instruction using a private key
- */
-export type CreateEd25519InstructionWithPrivateKeyParams = {
-  privateKey: Uint8Array;
-  message: Uint8Array;
-  instructionIndex?: number;
-};
-
-const ED25519_INSTRUCTION_LAYOUT = BufferLayout.struct<
-  Readonly<{
-    messageDataOffset: number;
-    messageDataSize: number;
-    messageInstructionIndex: number;
-    numSignatures: number;
-    padding: number;
-    publicKeyInstructionIndex: number;
-    publicKeyOffset: number;
-    signatureInstructionIndex: number;
-    signatureOffset: number;
-  }>
->([
-  BufferLayout.u8('numSignatures'),
-  BufferLayout.u8('padding'),
-  BufferLayout.u16('signatureOffset'),
-  BufferLayout.u16('signatureInstructionIndex'),
-  BufferLayout.u16('publicKeyOffset'),
-  BufferLayout.u16('publicKeyInstructionIndex'),
-  BufferLayout.u16('messageDataOffset'),
-  BufferLayout.u16('messageDataSize'),
-  BufferLayout.u16('messageInstructionIndex'),
-]);
-
-export class Ed25519Program {
-  /**
-   * @internal
-   */
-  constructor() {}
-
-  /**
-   * Public key that identifies the ed25519 program
-   */
-  static programId: PublicKey = new PublicKey(
-    'Ed25519SigVerify111111111111111111111111111',
-  );
-
-  /**
-   * Create an ed25519 instruction with a public key and signature. The
-   * public key must be a buffer that is 32 bytes long, and the signature
-   * must be a buffer of 64 bytes.
-   */
-  static createInstructionWithPublicKey(
-    params: CreateEd25519InstructionWithPublicKeyParams,
-  ): TransactionInstruction {
-    const {publicKey, message, signature, instructionIndex} = params;
-
-    assert(
-      publicKey.length === PUBLIC_KEY_BYTES,
-      `Public Key must be ${PUBLIC_KEY_BYTES} bytes but received ${publicKey.length} bytes`,
-    );
-
-    assert(
-      signature.length === SIGNATURE_BYTES,
-      `Signature must be ${SIGNATURE_BYTES} bytes but received ${signature.length} bytes`,
-    );
-
-    const publicKeyOffset = ED25519_INSTRUCTION_LAYOUT.span;
-    const signatureOffset = publicKeyOffset + publicKey.length;
-    const messageDataOffset = signatureOffset + signature.length;
-    const numSignatures = 1;
-
-    const instructionData = Buffer.alloc(messageDataOffset + message.length);
-
-    const index =
-      instructionIndex == null
-        ? 0xffff // An index of `u16::MAX` makes it default to the current instruction.
-        : instructionIndex;
-
-    ED25519_INSTRUCTION_LAYOUT.encode(
-      {
-        numSignatures,
-        padding: 0,
-        signatureOffset,
-        signatureInstructionIndex: index,
-        publicKeyOffset,
-        publicKeyInstructionIndex: index,
-        messageDataOffset,
-        messageDataSize: message.length,
-        messageInstructionIndex: index,
-      },
-      instructionData,
-    );
-
-    instructionData.fill(publicKey, publicKeyOffset);
-    instructionData.fill(signature, signatureOffset);
-    instructionData.fill(message, messageDataOffset);
-
-    return new TransactionInstruction({
-      keys: [],
-      programId: Ed25519Program.programId,
-      data: instructionData,
-    });
-  }
-
-  /**
-   * Create an ed25519 instruction with a private key. The private key
-   * must be a buffer that is 64 bytes long.
-   */
-  static createInstructionWithPrivateKey(
-    params: CreateEd25519InstructionWithPrivateKeyParams,
-  ): TransactionInstruction {
-    const {privateKey, message, instructionIndex} = params;
-
-    assert(
-      privateKey.length === PRIVATE_KEY_BYTES,
-      `Private key must be ${PRIVATE_KEY_BYTES} bytes but received ${privateKey.length} bytes`,
-    );
-
-    try {
-      const keypair = Keypair.fromSecretKey(privateKey);
-      const publicKey = keypair.publicKey.toBytes();
-      const signature = sign(message, keypair.secretKey);
-
-      return this.createInstructionWithPublicKey({
-        publicKey,
-        message,
-        signature,
-        instructionIndex,
-      });
-    } catch (error) {
-      throw new Error(`Error creating instruction; ${error}`);
-    }
-  }
-}

package/src/programs/index.ts

@@ -1,7 +0,0 @@
-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/programs/secp256k1.ts

@@ -1,228 +0,0 @@
-import {Buffer} from 'buffer';
-import * as BufferLayout from '@solana/buffer-layout';
-import {keccak_256} from '@noble/hashes/sha3';
-
-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;
-const PUBLIC_KEY_BYTES = 64;
-const SIGNATURE_OFFSETS_SERIALIZED_SIZE = 11;
-
-/**
- * Params for creating an secp256k1 instruction using a public key
- */
-export type CreateSecp256k1InstructionWithPublicKeyParams = {
-  publicKey: Buffer | Uint8Array | Array<number>;
-  message: Buffer | Uint8Array | Array<number>;
-  signature: Buffer | Uint8Array | Array<number>;
-  recoveryId: number;
-  instructionIndex?: number;
-};
-
-/**
- * Params for creating an secp256k1 instruction using an Ethereum address
- */
-export type CreateSecp256k1InstructionWithEthAddressParams = {
-  ethAddress: Buffer | Uint8Array | Array<number> | string;
-  message: Buffer | Uint8Array | Array<number>;
-  signature: Buffer | Uint8Array | Array<number>;
-  recoveryId: number;
-  instructionIndex?: number;
-};
-
-/**
- * Params for creating an secp256k1 instruction using a private key
- */
-export type CreateSecp256k1InstructionWithPrivateKeyParams = {
-  privateKey: Buffer | Uint8Array | Array<number>;
-  message: Buffer | Uint8Array | Array<number>;
-  instructionIndex?: number;
-};
-
-const SECP256K1_INSTRUCTION_LAYOUT = BufferLayout.struct<
-  Readonly<{
-    ethAddress: Uint8Array;
-    ethAddressInstructionIndex: number;
-    ethAddressOffset: number;
-    messageDataOffset: number;
-    messageDataSize: number;
-    messageInstructionIndex: number;
-    numSignatures: number;
-    recoveryId: number;
-    signature: Uint8Array;
-    signatureInstructionIndex: number;
-    signatureOffset: number;
-  }>
->([
-  BufferLayout.u8('numSignatures'),
-  BufferLayout.u16('signatureOffset'),
-  BufferLayout.u8('signatureInstructionIndex'),
-  BufferLayout.u16('ethAddressOffset'),
-  BufferLayout.u8('ethAddressInstructionIndex'),
-  BufferLayout.u16('messageDataOffset'),
-  BufferLayout.u16('messageDataSize'),
-  BufferLayout.u8('messageInstructionIndex'),
-  BufferLayout.blob(20, 'ethAddress'),
-  BufferLayout.blob(64, 'signature'),
-  BufferLayout.u8('recoveryId'),
-]);
-
-export class Secp256k1Program {
-  /**
-   * @internal
-   */
-  constructor() {}
-
-  /**
-   * Public key that identifies the secp256k1 program
-   */
-  static programId: PublicKey = new PublicKey(
-    'KeccakSecp256k11111111111111111111111111111',
-  );
-
-  /**
-   * Construct an Ethereum address from a secp256k1 public key buffer.
-   * @param {Buffer} publicKey a 64 byte secp256k1 public key buffer
-   */
-  static publicKeyToEthAddress(
-    publicKey: Buffer | Uint8Array | Array<number>,
-  ): Buffer {
-    assert(
-      publicKey.length === PUBLIC_KEY_BYTES,
-      `Public key must be ${PUBLIC_KEY_BYTES} bytes but received ${publicKey.length} bytes`,
-    );
-
-    try {
-      return Buffer.from(keccak_256(toBuffer(publicKey))).slice(
-        -ETHEREUM_ADDRESS_BYTES,
-      );
-    } catch (error) {
-      throw new Error(`Error constructing Ethereum address: ${error}`);
-    }
-  }
-
-  /**
-   * Create an secp256k1 instruction with a public key. The public key
-   * must be a buffer that is 64 bytes long.
-   */
-  static createInstructionWithPublicKey(
-    params: CreateSecp256k1InstructionWithPublicKeyParams,
-  ): TransactionInstruction {
-    const {publicKey, message, signature, recoveryId, instructionIndex} =
-      params;
-    return Secp256k1Program.createInstructionWithEthAddress({
-      ethAddress: Secp256k1Program.publicKeyToEthAddress(publicKey),
-      message,
-      signature,
-      recoveryId,
-      instructionIndex,
-    });
-  }
-
-  /**
-   * Create an secp256k1 instruction with an Ethereum address. The address
-   * must be a hex string or a buffer that is 20 bytes long.
-   */
-  static createInstructionWithEthAddress(
-    params: CreateSecp256k1InstructionWithEthAddressParams,
-  ): TransactionInstruction {
-    const {
-      ethAddress: rawAddress,
-      message,
-      signature,
-      recoveryId,
-      instructionIndex = 0,
-    } = params;
-
-    let ethAddress;
-    if (typeof rawAddress === 'string') {
-      if (rawAddress.startsWith('0x')) {
-        ethAddress = Buffer.from(rawAddress.substr(2), 'hex');
-      } else {
-        ethAddress = Buffer.from(rawAddress, 'hex');
-      }
-    } else {
-      ethAddress = rawAddress;
-    }
-
-    assert(
-      ethAddress.length === ETHEREUM_ADDRESS_BYTES,
-      `Address must be ${ETHEREUM_ADDRESS_BYTES} bytes but received ${ethAddress.length} bytes`,
-    );
-
-    const dataStart = 1 + SIGNATURE_OFFSETS_SERIALIZED_SIZE;
-    const ethAddressOffset = dataStart;
-    const signatureOffset = dataStart + ethAddress.length;
-    const messageDataOffset = signatureOffset + signature.length + 1;
-    const numSignatures = 1;
-
-    const instructionData = Buffer.alloc(
-      SECP256K1_INSTRUCTION_LAYOUT.span + message.length,
-    );
-
-    SECP256K1_INSTRUCTION_LAYOUT.encode(
-      {
-        numSignatures,
-        signatureOffset,
-        signatureInstructionIndex: instructionIndex,
-        ethAddressOffset,
-        ethAddressInstructionIndex: instructionIndex,
-        messageDataOffset,
-        messageDataSize: message.length,
-        messageInstructionIndex: instructionIndex,
-        signature: toBuffer(signature),
-        ethAddress: toBuffer(ethAddress),
-        recoveryId,
-      },
-      instructionData,
-    );
-
-    instructionData.fill(toBuffer(message), SECP256K1_INSTRUCTION_LAYOUT.span);
-
-    return new TransactionInstruction({
-      keys: [],
-      programId: Secp256k1Program.programId,
-      data: instructionData,
-    });
-  }
-
-  /**
-   * Create an secp256k1 instruction with a private key. The private key
-   * must be a buffer that is 32 bytes long.
-   */
-  static createInstructionWithPrivateKey(
-    params: CreateSecp256k1InstructionWithPrivateKeyParams,
-  ): TransactionInstruction {
-    const {privateKey: pkey, message, instructionIndex} = params;
-
-    assert(
-      pkey.length === PRIVATE_KEY_BYTES,
-      `Private key must be ${PRIVATE_KEY_BYTES} bytes but received ${pkey.length} bytes`,
-    );
-
-    try {
-      const privateKey = toBuffer(pkey);
-      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,
-        message,
-        signature,
-        recoveryId,
-        instructionIndex,
-      });
-    } catch (error) {
-      throw new Error(`Error creating instruction; ${error}`);
-    }
-  }
-}