@brainai/satp-client 2.0.7 → 2.0.8

package/node_modules/@solana/web3.js/src/programs/system.ts

@@ -1,1048 +0,0 @@
-import * as BufferLayout from '@solana/buffer-layout';
-
-import {
-  encodeData,
-  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 '../utils/to-buffer';
-import {u64} from '../utils/bigint';
-
-/**
- * Create account system transaction params
- */
-export type CreateAccountParams = {
-  /** The account that will transfer lamports to the created account */
-  fromPubkey: PublicKey;
-  /** Public key of the created account */
-  newAccountPubkey: PublicKey;
-  /** Amount of lamports to transfer to the created account */
-  lamports: number;
-  /** Amount of space in bytes to allocate to the created account */
-  space: number;
-  /** Public key of the program to assign as the owner of the created account */
-  programId: PublicKey;
-};
-
-/**
- * Transfer system transaction params
- */
-export type TransferParams = {
-  /** Account that will transfer lamports */
-  fromPubkey: PublicKey;
-  /** Account that will receive transferred lamports */
-  toPubkey: PublicKey;
-  /** Amount of lamports to transfer */
-  lamports: number | bigint;
-};
-
-/**
- * Assign system transaction params
- */
-export type AssignParams = {
-  /** Public key of the account which will be assigned a new owner */
-  accountPubkey: PublicKey;
-  /** Public key of the program to assign as the owner */
-  programId: PublicKey;
-};
-
-/**
- * Create account with seed system transaction params
- */
-export type CreateAccountWithSeedParams = {
-  /** The account that will transfer lamports to the created account */
-  fromPubkey: PublicKey;
-  /** Public key of the created account. Must be pre-calculated with PublicKey.createWithSeed() */
-  newAccountPubkey: PublicKey;
-  /** Base public key to use to derive the address of the created account. Must be the same as the base key used to create `newAccountPubkey` */
-  basePubkey: PublicKey;
-  /** Seed to use to derive the address of the created account. Must be the same as the seed used to create `newAccountPubkey` */
-  seed: string;
-  /** Amount of lamports to transfer to the created account */
-  lamports: number;
-  /** Amount of space in bytes to allocate to the created account */
-  space: number;
-  /** Public key of the program to assign as the owner of the created account */
-  programId: PublicKey;
-};
-
-/**
- * Create nonce account system transaction params
- */
-export type CreateNonceAccountParams = {
-  /** The account that will transfer lamports to the created nonce account */
-  fromPubkey: PublicKey;
-  /** Public key of the created nonce account */
-  noncePubkey: PublicKey;
-  /** Public key to set as authority of the created nonce account */
-  authorizedPubkey: PublicKey;
-  /** Amount of lamports to transfer to the created nonce account */
-  lamports: number;
-};
-
-/**
- * Create nonce account with seed system transaction params
- */
-export type CreateNonceAccountWithSeedParams = {
-  /** The account that will transfer lamports to the created nonce account */
-  fromPubkey: PublicKey;
-  /** Public key of the created nonce account */
-  noncePubkey: PublicKey;
-  /** Public key to set as authority of the created nonce account */
-  authorizedPubkey: PublicKey;
-  /** Amount of lamports to transfer to the created nonce account */
-  lamports: number;
-  /** Base public key to use to derive the address of the nonce account */
-  basePubkey: PublicKey;
-  /** Seed to use to derive the address of the nonce account */
-  seed: string;
-};
-
-/**
- * Initialize nonce account system instruction params
- */
-export type InitializeNonceParams = {
-  /** Nonce account which will be initialized */
-  noncePubkey: PublicKey;
-  /** Public key to set as authority of the initialized nonce account */
-  authorizedPubkey: PublicKey;
-};
-
-/**
- * Advance nonce account system instruction params
- */
-export type AdvanceNonceParams = {
-  /** Nonce account */
-  noncePubkey: PublicKey;
-  /** Public key of the nonce authority */
-  authorizedPubkey: PublicKey;
-};
-
-/**
- * Withdraw nonce account system transaction params
- */
-export type WithdrawNonceParams = {
-  /** Nonce account */
-  noncePubkey: PublicKey;
-  /** Public key of the nonce authority */
-  authorizedPubkey: PublicKey;
-  /** Public key of the account which will receive the withdrawn nonce account balance */
-  toPubkey: PublicKey;
-  /** Amount of lamports to withdraw from the nonce account */
-  lamports: number;
-};
-
-/**
- * Authorize nonce account system transaction params
- */
-export type AuthorizeNonceParams = {
-  /** Nonce account */
-  noncePubkey: PublicKey;
-  /** Public key of the current nonce authority */
-  authorizedPubkey: PublicKey;
-  /** Public key to set as the new nonce authority */
-  newAuthorizedPubkey: PublicKey;
-};
-
-/**
- * Allocate account system transaction params
- */
-export type AllocateParams = {
-  /** Account to allocate */
-  accountPubkey: PublicKey;
-  /** Amount of space in bytes to allocate */
-  space: number;
-};
-
-/**
- * Allocate account with seed system transaction params
- */
-export type AllocateWithSeedParams = {
-  /** Account to allocate */
-  accountPubkey: PublicKey;
-  /** Base public key to use to derive the address of the allocated account */
-  basePubkey: PublicKey;
-  /** Seed to use to derive the address of the allocated account */
-  seed: string;
-  /** Amount of space in bytes to allocate */
-  space: number;
-  /** Public key of the program to assign as the owner of the allocated account */
-  programId: PublicKey;
-};
-
-/**
- * Assign account with seed system transaction params
- */
-export type AssignWithSeedParams = {
-  /** Public key of the account which will be assigned a new owner */
-  accountPubkey: PublicKey;
-  /** Base public key to use to derive the address of the assigned account */
-  basePubkey: PublicKey;
-  /** Seed to use to derive the address of the assigned account */
-  seed: string;
-  /** Public key of the program to assign as the owner */
-  programId: PublicKey;
-};
-
-/**
- * Transfer with seed system transaction params
- */
-export type TransferWithSeedParams = {
-  /** 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: 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 */
-  programId: PublicKey;
-};
-
-/**
- * System Instruction class
- */
-export class SystemInstruction {
-  /**
-   * @internal
-   */
-  constructor() {}
-
-  /**
-   * Decode a system instruction and retrieve the instruction type.
-   */
-  static decodeInstructionType(
-    instruction: TransactionInstruction,
-  ): SystemInstructionType {
-    this.checkProgramId(instruction.programId);
-
-    const instructionTypeLayout = BufferLayout.u32('instruction');
-    const typeIndex = instructionTypeLayout.decode(instruction.data);
-
-    let type: SystemInstructionType | undefined;
-    for (const [ixType, layout] of Object.entries(SYSTEM_INSTRUCTION_LAYOUTS)) {
-      if (layout.index == typeIndex) {
-        type = ixType as SystemInstructionType;
-        break;
-      }
-    }
-
-    if (!type) {
-      throw new Error('Instruction type incorrect; not a SystemInstruction');
-    }
-
-    return type;
-  }
-
-  /**
-   * Decode a create account system instruction and retrieve the instruction params.
-   */
-  static decodeCreateAccount(
-    instruction: TransactionInstruction,
-  ): CreateAccountParams {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 2);
-
-    const {lamports, space, programId} = decodeData(
-      SYSTEM_INSTRUCTION_LAYOUTS.Create,
-      instruction.data,
-    );
-
-    return {
-      fromPubkey: instruction.keys[0].pubkey,
-      newAccountPubkey: instruction.keys[1].pubkey,
-      lamports,
-      space,
-      programId: new PublicKey(programId),
-    };
-  }
-
-  /**
-   * Decode a transfer system instruction and retrieve the instruction params.
-   */
-  static decodeTransfer(
-    instruction: TransactionInstruction,
-  ): DecodedTransferInstruction {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 2);
-
-    const {lamports} = decodeData(
-      SYSTEM_INSTRUCTION_LAYOUTS.Transfer,
-      instruction.data,
-    );
-
-    return {
-      fromPubkey: instruction.keys[0].pubkey,
-      toPubkey: instruction.keys[1].pubkey,
-      lamports,
-    };
-  }
-
-  /**
-   * Decode a transfer with seed system instruction and retrieve the instruction params.
-   */
-  static decodeTransferWithSeed(
-    instruction: TransactionInstruction,
-  ): DecodedTransferWithSeedInstruction {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 3);
-
-    const {lamports, seed, programId} = decodeData(
-      SYSTEM_INSTRUCTION_LAYOUTS.TransferWithSeed,
-      instruction.data,
-    );
-
-    return {
-      fromPubkey: instruction.keys[0].pubkey,
-      basePubkey: instruction.keys[1].pubkey,
-      toPubkey: instruction.keys[2].pubkey,
-      lamports,
-      seed,
-      programId: new PublicKey(programId),
-    };
-  }
-
-  /**
-   * Decode an allocate system instruction and retrieve the instruction params.
-   */
-  static decodeAllocate(instruction: TransactionInstruction): AllocateParams {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 1);
-
-    const {space} = decodeData(
-      SYSTEM_INSTRUCTION_LAYOUTS.Allocate,
-      instruction.data,
-    );
-
-    return {
-      accountPubkey: instruction.keys[0].pubkey,
-      space,
-    };
-  }
-
-  /**
-   * Decode an allocate with seed system instruction and retrieve the instruction params.
-   */
-  static decodeAllocateWithSeed(
-    instruction: TransactionInstruction,
-  ): AllocateWithSeedParams {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 1);
-
-    const {base, seed, space, programId} = decodeData(
-      SYSTEM_INSTRUCTION_LAYOUTS.AllocateWithSeed,
-      instruction.data,
-    );
-
-    return {
-      accountPubkey: instruction.keys[0].pubkey,
-      basePubkey: new PublicKey(base),
-      seed,
-      space,
-      programId: new PublicKey(programId),
-    };
-  }
-
-  /**
-   * Decode an assign system instruction and retrieve the instruction params.
-   */
-  static decodeAssign(instruction: TransactionInstruction): AssignParams {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 1);
-
-    const {programId} = decodeData(
-      SYSTEM_INSTRUCTION_LAYOUTS.Assign,
-      instruction.data,
-    );
-
-    return {
-      accountPubkey: instruction.keys[0].pubkey,
-      programId: new PublicKey(programId),
-    };
-  }
-
-  /**
-   * Decode an assign with seed system instruction and retrieve the instruction params.
-   */
-  static decodeAssignWithSeed(
-    instruction: TransactionInstruction,
-  ): AssignWithSeedParams {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 1);
-
-    const {base, seed, programId} = decodeData(
-      SYSTEM_INSTRUCTION_LAYOUTS.AssignWithSeed,
-      instruction.data,
-    );
-
-    return {
-      accountPubkey: instruction.keys[0].pubkey,
-      basePubkey: new PublicKey(base),
-      seed,
-      programId: new PublicKey(programId),
-    };
-  }
-
-  /**
-   * Decode a create account with seed system instruction and retrieve the instruction params.
-   */
-  static decodeCreateWithSeed(
-    instruction: TransactionInstruction,
-  ): CreateAccountWithSeedParams {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 2);
-
-    const {base, seed, lamports, space, programId} = decodeData(
-      SYSTEM_INSTRUCTION_LAYOUTS.CreateWithSeed,
-      instruction.data,
-    );
-
-    return {
-      fromPubkey: instruction.keys[0].pubkey,
-      newAccountPubkey: instruction.keys[1].pubkey,
-      basePubkey: new PublicKey(base),
-      seed,
-      lamports,
-      space,
-      programId: new PublicKey(programId),
-    };
-  }
-
-  /**
-   * Decode a nonce initialize system instruction and retrieve the instruction params.
-   */
-  static decodeNonceInitialize(
-    instruction: TransactionInstruction,
-  ): InitializeNonceParams {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 3);
-
-    const {authorized} = decodeData(
-      SYSTEM_INSTRUCTION_LAYOUTS.InitializeNonceAccount,
-      instruction.data,
-    );
-
-    return {
-      noncePubkey: instruction.keys[0].pubkey,
-      authorizedPubkey: new PublicKey(authorized),
-    };
-  }
-
-  /**
-   * Decode a nonce advance system instruction and retrieve the instruction params.
-   */
-  static decodeNonceAdvance(
-    instruction: TransactionInstruction,
-  ): AdvanceNonceParams {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 3);
-
-    decodeData(
-      SYSTEM_INSTRUCTION_LAYOUTS.AdvanceNonceAccount,
-      instruction.data,
-    );
-
-    return {
-      noncePubkey: instruction.keys[0].pubkey,
-      authorizedPubkey: instruction.keys[2].pubkey,
-    };
-  }
-
-  /**
-   * Decode a nonce withdraw system instruction and retrieve the instruction params.
-   */
-  static decodeNonceWithdraw(
-    instruction: TransactionInstruction,
-  ): WithdrawNonceParams {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 5);
-
-    const {lamports} = decodeData(
-      SYSTEM_INSTRUCTION_LAYOUTS.WithdrawNonceAccount,
-      instruction.data,
-    );
-
-    return {
-      noncePubkey: instruction.keys[0].pubkey,
-      toPubkey: instruction.keys[1].pubkey,
-      authorizedPubkey: instruction.keys[4].pubkey,
-      lamports,
-    };
-  }
-
-  /**
-   * Decode a nonce authorize system instruction and retrieve the instruction params.
-   */
-  static decodeNonceAuthorize(
-    instruction: TransactionInstruction,
-  ): AuthorizeNonceParams {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 2);
-
-    const {authorized} = decodeData(
-      SYSTEM_INSTRUCTION_LAYOUTS.AuthorizeNonceAccount,
-      instruction.data,
-    );
-
-    return {
-      noncePubkey: instruction.keys[0].pubkey,
-      authorizedPubkey: instruction.keys[1].pubkey,
-      newAuthorizedPubkey: new PublicKey(authorized),
-    };
-  }
-
-  /**
-   * @internal
-   */
-  static checkProgramId(programId: PublicKey) {
-    if (!programId.equals(SystemProgram.programId)) {
-      throw new Error('invalid instruction; programId is not SystemProgram');
-    }
-  }
-
-  /**
-   * @internal
-   */
-  static checkKeyLength(keys: Array<any>, expectedLength: number) {
-    if (keys.length < expectedLength) {
-      throw new Error(
-        `invalid instruction; found ${keys.length} keys, expected at least ${expectedLength}`,
-      );
-    }
-  }
-}
-
-/**
- * An enumeration of valid SystemInstructionType's
- */
-export type SystemInstructionType =
-  // FIXME
-  // It would be preferable for this type to be `keyof SystemInstructionInputData`
-  // but Typedoc does not transpile `keyof` expressions.
-  // See https://github.com/TypeStrong/typedoc/issues/1894
-  | 'AdvanceNonceAccount'
-  | 'Allocate'
-  | 'AllocateWithSeed'
-  | 'Assign'
-  | 'AssignWithSeed'
-  | 'AuthorizeNonceAccount'
-  | 'Create'
-  | 'CreateWithSeed'
-  | 'InitializeNonceAccount'
-  | 'Transfer'
-  | 'TransferWithSeed'
-  | 'WithdrawNonceAccount'
-  | 'UpgradeNonceAccount';
-
-type SystemInstructionInputData = {
-  AdvanceNonceAccount: IInstructionInputData;
-  Allocate: IInstructionInputData & {
-    space: number;
-  };
-  AllocateWithSeed: IInstructionInputData & {
-    base: Uint8Array;
-    programId: Uint8Array;
-    seed: string;
-    space: number;
-  };
-  Assign: IInstructionInputData & {
-    programId: Uint8Array;
-  };
-  AssignWithSeed: IInstructionInputData & {
-    base: Uint8Array;
-    seed: string;
-    programId: Uint8Array;
-  };
-  AuthorizeNonceAccount: IInstructionInputData & {
-    authorized: Uint8Array;
-  };
-  Create: IInstructionInputData & {
-    lamports: number;
-    programId: Uint8Array;
-    space: number;
-  };
-  CreateWithSeed: IInstructionInputData & {
-    base: Uint8Array;
-    lamports: number;
-    programId: Uint8Array;
-    seed: string;
-    space: number;
-  };
-  InitializeNonceAccount: IInstructionInputData & {
-    authorized: Uint8Array;
-  };
-  Transfer: IInstructionInputData & {
-    lamports: bigint;
-  };
-  TransferWithSeed: IInstructionInputData & {
-    lamports: bigint;
-    programId: Uint8Array;
-    seed: string;
-  };
-  WithdrawNonceAccount: IInstructionInputData & {
-    lamports: number;
-  };
-  UpgradeNonceAccount: IInstructionInputData;
-};
-
-/**
- * An enumeration of valid system InstructionType's
- * @internal
- */
-export const SYSTEM_INSTRUCTION_LAYOUTS = Object.freeze<{
-  [Instruction in SystemInstructionType]: InstructionType<
-    SystemInstructionInputData[Instruction]
-  >;
-}>({
-  Create: {
-    index: 0,
-    layout: BufferLayout.struct<SystemInstructionInputData['Create']>([
-      BufferLayout.u32('instruction'),
-      BufferLayout.ns64('lamports'),
-      BufferLayout.ns64('space'),
-      Layout.publicKey('programId'),
-    ]),
-  },
-  Assign: {
-    index: 1,
-    layout: BufferLayout.struct<SystemInstructionInputData['Assign']>([
-      BufferLayout.u32('instruction'),
-      Layout.publicKey('programId'),
-    ]),
-  },
-  Transfer: {
-    index: 2,
-    layout: BufferLayout.struct<SystemInstructionInputData['Transfer']>([
-      BufferLayout.u32('instruction'),
-      u64('lamports'),
-    ]),
-  },
-  CreateWithSeed: {
-    index: 3,
-    layout: BufferLayout.struct<SystemInstructionInputData['CreateWithSeed']>([
-      BufferLayout.u32('instruction'),
-      Layout.publicKey('base'),
-      Layout.rustString('seed'),
-      BufferLayout.ns64('lamports'),
-      BufferLayout.ns64('space'),
-      Layout.publicKey('programId'),
-    ]),
-  },
-  AdvanceNonceAccount: {
-    index: 4,
-    layout: BufferLayout.struct<
-      SystemInstructionInputData['AdvanceNonceAccount']
-    >([BufferLayout.u32('instruction')]),
-  },
-  WithdrawNonceAccount: {
-    index: 5,
-    layout: BufferLayout.struct<
-      SystemInstructionInputData['WithdrawNonceAccount']
-    >([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports')]),
-  },
-  InitializeNonceAccount: {
-    index: 6,
-    layout: BufferLayout.struct<
-      SystemInstructionInputData['InitializeNonceAccount']
-    >([BufferLayout.u32('instruction'), Layout.publicKey('authorized')]),
-  },
-  AuthorizeNonceAccount: {
-    index: 7,
-    layout: BufferLayout.struct<
-      SystemInstructionInputData['AuthorizeNonceAccount']
-    >([BufferLayout.u32('instruction'), Layout.publicKey('authorized')]),
-  },
-  Allocate: {
-    index: 8,
-    layout: BufferLayout.struct<SystemInstructionInputData['Allocate']>([
-      BufferLayout.u32('instruction'),
-      BufferLayout.ns64('space'),
-    ]),
-  },
-  AllocateWithSeed: {
-    index: 9,
-    layout: BufferLayout.struct<SystemInstructionInputData['AllocateWithSeed']>(
-      [
-        BufferLayout.u32('instruction'),
-        Layout.publicKey('base'),
-        Layout.rustString('seed'),
-        BufferLayout.ns64('space'),
-        Layout.publicKey('programId'),
-      ],
-    ),
-  },
-  AssignWithSeed: {
-    index: 10,
-    layout: BufferLayout.struct<SystemInstructionInputData['AssignWithSeed']>([
-      BufferLayout.u32('instruction'),
-      Layout.publicKey('base'),
-      Layout.rustString('seed'),
-      Layout.publicKey('programId'),
-    ]),
-  },
-  TransferWithSeed: {
-    index: 11,
-    layout: BufferLayout.struct<SystemInstructionInputData['TransferWithSeed']>(
-      [
-        BufferLayout.u32('instruction'),
-        u64('lamports'),
-        Layout.rustString('seed'),
-        Layout.publicKey('programId'),
-      ],
-    ),
-  },
-  UpgradeNonceAccount: {
-    index: 12,
-    layout: BufferLayout.struct<
-      SystemInstructionInputData['UpgradeNonceAccount']
-    >([BufferLayout.u32('instruction')]),
-  },
-});
-
-/**
- * Factory class for transactions to interact with the System program
- */
-export class SystemProgram {
-  /**
-   * @internal
-   */
-  constructor() {}
-
-  /**
-   * Public key that identifies the System program
-   */
-  static programId: PublicKey = new PublicKey(
-    '11111111111111111111111111111111',
-  );
-
-  /**
-   * Generate a transaction instruction that creates a new account
-   */
-  static createAccount(params: CreateAccountParams): TransactionInstruction {
-    const type = SYSTEM_INSTRUCTION_LAYOUTS.Create;
-    const data = encodeData(type, {
-      lamports: params.lamports,
-      space: params.space,
-      programId: toBuffer(params.programId.toBuffer()),
-    });
-
-    return new TransactionInstruction({
-      keys: [
-        {pubkey: params.fromPubkey, isSigner: true, isWritable: true},
-        {pubkey: params.newAccountPubkey, isSigner: true, isWritable: true},
-      ],
-      programId: this.programId,
-      data,
-    });
-  }
-
-  /**
-   * Generate a transaction instruction that transfers lamports from one account to another
-   */
-  static transfer(
-    params: TransferParams | TransferWithSeedParams,
-  ): TransactionInstruction {
-    let data;
-    let keys;
-    if ('basePubkey' in params) {
-      const type = SYSTEM_INSTRUCTION_LAYOUTS.TransferWithSeed;
-      data = encodeData(type, {
-        lamports: BigInt(params.lamports),
-        seed: params.seed,
-        programId: toBuffer(params.programId.toBuffer()),
-      });
-      keys = [
-        {pubkey: params.fromPubkey, isSigner: false, isWritable: true},
-        {pubkey: params.basePubkey, isSigner: true, isWritable: false},
-        {pubkey: params.toPubkey, isSigner: false, isWritable: true},
-      ];
-    } else {
-      const type = SYSTEM_INSTRUCTION_LAYOUTS.Transfer;
-      data = encodeData(type, {lamports: BigInt(params.lamports)});
-      keys = [
-        {pubkey: params.fromPubkey, isSigner: true, isWritable: true},
-        {pubkey: params.toPubkey, isSigner: false, isWritable: true},
-      ];
-    }
-
-    return new TransactionInstruction({
-      keys,
-      programId: this.programId,
-      data,
-    });
-  }
-
-  /**
-   * Generate a transaction instruction that assigns an account to a program
-   */
-  static assign(
-    params: AssignParams | AssignWithSeedParams,
-  ): TransactionInstruction {
-    let data;
-    let keys;
-    if ('basePubkey' in params) {
-      const type = SYSTEM_INSTRUCTION_LAYOUTS.AssignWithSeed;
-      data = encodeData(type, {
-        base: toBuffer(params.basePubkey.toBuffer()),
-        seed: params.seed,
-        programId: toBuffer(params.programId.toBuffer()),
-      });
-      keys = [
-        {pubkey: params.accountPubkey, isSigner: false, isWritable: true},
-        {pubkey: params.basePubkey, isSigner: true, isWritable: false},
-      ];
-    } else {
-      const type = SYSTEM_INSTRUCTION_LAYOUTS.Assign;
-      data = encodeData(type, {
-        programId: toBuffer(params.programId.toBuffer()),
-      });
-      keys = [{pubkey: params.accountPubkey, isSigner: true, isWritable: true}];
-    }
-
-    return new TransactionInstruction({
-      keys,
-      programId: this.programId,
-      data,
-    });
-  }
-
-  /**
-   * Generate a transaction instruction that creates a new account at
-   *   an address generated with `from`, a seed, and programId
-   */
-  static createAccountWithSeed(
-    params: CreateAccountWithSeedParams,
-  ): TransactionInstruction {
-    const type = SYSTEM_INSTRUCTION_LAYOUTS.CreateWithSeed;
-    const data = encodeData(type, {
-      base: toBuffer(params.basePubkey.toBuffer()),
-      seed: params.seed,
-      lamports: params.lamports,
-      space: params.space,
-      programId: toBuffer(params.programId.toBuffer()),
-    });
-    let keys = [
-      {pubkey: params.fromPubkey, isSigner: true, isWritable: true},
-      {pubkey: params.newAccountPubkey, isSigner: false, isWritable: true},
-    ];
-    if (!params.basePubkey.equals(params.fromPubkey)) {
-      keys.push({
-        pubkey: params.basePubkey,
-        isSigner: true,
-        isWritable: false,
-      });
-    }
-
-    return new TransactionInstruction({
-      keys,
-      programId: this.programId,
-      data,
-    });
-  }
-
-  /**
-   * Generate a transaction that creates a new Nonce account
-   */
-  static createNonceAccount(
-    params: CreateNonceAccountParams | CreateNonceAccountWithSeedParams,
-  ): Transaction {
-    const transaction = new Transaction();
-    if ('basePubkey' in params && 'seed' in params) {
-      transaction.add(
-        SystemProgram.createAccountWithSeed({
-          fromPubkey: params.fromPubkey,
-          newAccountPubkey: params.noncePubkey,
-          basePubkey: params.basePubkey,
-          seed: params.seed,
-          lamports: params.lamports,
-          space: NONCE_ACCOUNT_LENGTH,
-          programId: this.programId,
-        }),
-      );
-    } else {
-      transaction.add(
-        SystemProgram.createAccount({
-          fromPubkey: params.fromPubkey,
-          newAccountPubkey: params.noncePubkey,
-          lamports: params.lamports,
-          space: NONCE_ACCOUNT_LENGTH,
-          programId: this.programId,
-        }),
-      );
-    }
-
-    const initParams = {
-      noncePubkey: params.noncePubkey,
-      authorizedPubkey: params.authorizedPubkey,
-    };
-
-    transaction.add(this.nonceInitialize(initParams));
-    return transaction;
-  }
-
-  /**
-   * Generate an instruction to initialize a Nonce account
-   */
-  static nonceInitialize(
-    params: InitializeNonceParams,
-  ): TransactionInstruction {
-    const type = SYSTEM_INSTRUCTION_LAYOUTS.InitializeNonceAccount;
-    const data = encodeData(type, {
-      authorized: toBuffer(params.authorizedPubkey.toBuffer()),
-    });
-    const instructionData = {
-      keys: [
-        {pubkey: params.noncePubkey, isSigner: false, isWritable: true},
-        {
-          pubkey: SYSVAR_RECENT_BLOCKHASHES_PUBKEY,
-          isSigner: false,
-          isWritable: false,
-        },
-        {pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
-      ],
-      programId: this.programId,
-      data,
-    };
-    return new TransactionInstruction(instructionData);
-  }
-
-  /**
-   * Generate an instruction to advance the nonce in a Nonce account
-   */
-  static nonceAdvance(params: AdvanceNonceParams): TransactionInstruction {
-    const type = SYSTEM_INSTRUCTION_LAYOUTS.AdvanceNonceAccount;
-    const data = encodeData(type);
-    const instructionData = {
-      keys: [
-        {pubkey: params.noncePubkey, isSigner: false, isWritable: true},
-        {
-          pubkey: SYSVAR_RECENT_BLOCKHASHES_PUBKEY,
-          isSigner: false,
-          isWritable: false,
-        },
-        {pubkey: params.authorizedPubkey, isSigner: true, isWritable: false},
-      ],
-      programId: this.programId,
-      data,
-    };
-    return new TransactionInstruction(instructionData);
-  }
-
-  /**
-   * Generate a transaction instruction that withdraws lamports from a Nonce account
-   */
-  static nonceWithdraw(params: WithdrawNonceParams): TransactionInstruction {
-    const type = SYSTEM_INSTRUCTION_LAYOUTS.WithdrawNonceAccount;
-    const data = encodeData(type, {lamports: params.lamports});
-
-    return new TransactionInstruction({
-      keys: [
-        {pubkey: params.noncePubkey, isSigner: false, isWritable: true},
-        {pubkey: params.toPubkey, isSigner: false, isWritable: true},
-        {
-          pubkey: SYSVAR_RECENT_BLOCKHASHES_PUBKEY,
-          isSigner: false,
-          isWritable: false,
-        },
-        {
-          pubkey: SYSVAR_RENT_PUBKEY,
-          isSigner: false,
-          isWritable: false,
-        },
-        {pubkey: params.authorizedPubkey, isSigner: true, isWritable: false},
-      ],
-      programId: this.programId,
-      data,
-    });
-  }
-
-  /**
-   * Generate a transaction instruction that authorizes a new PublicKey as the authority
-   * on a Nonce account.
-   */
-  static nonceAuthorize(params: AuthorizeNonceParams): TransactionInstruction {
-    const type = SYSTEM_INSTRUCTION_LAYOUTS.AuthorizeNonceAccount;
-    const data = encodeData(type, {
-      authorized: toBuffer(params.newAuthorizedPubkey.toBuffer()),
-    });
-
-    return new TransactionInstruction({
-      keys: [
-        {pubkey: params.noncePubkey, isSigner: false, isWritable: true},
-        {pubkey: params.authorizedPubkey, isSigner: true, isWritable: false},
-      ],
-      programId: this.programId,
-      data,
-    });
-  }
-
-  /**
-   * Generate a transaction instruction that allocates space in an account without funding
-   */
-  static allocate(
-    params: AllocateParams | AllocateWithSeedParams,
-  ): TransactionInstruction {
-    let data;
-    let keys;
-    if ('basePubkey' in params) {
-      const type = SYSTEM_INSTRUCTION_LAYOUTS.AllocateWithSeed;
-      data = encodeData(type, {
-        base: toBuffer(params.basePubkey.toBuffer()),
-        seed: params.seed,
-        space: params.space,
-        programId: toBuffer(params.programId.toBuffer()),
-      });
-      keys = [
-        {pubkey: params.accountPubkey, isSigner: false, isWritable: true},
-        {pubkey: params.basePubkey, isSigner: true, isWritable: false},
-      ];
-    } else {
-      const type = SYSTEM_INSTRUCTION_LAYOUTS.Allocate;
-      data = encodeData(type, {
-        space: params.space,
-      });
-      keys = [{pubkey: params.accountPubkey, isSigner: true, isWritable: true}];
-    }
-
-    return new TransactionInstruction({
-      keys,
-      programId: this.programId,
-      data,
-    });
-  }
-}