@solana/web3.js 1.78.0 → 2.0.0-development

package/src/programs/stake.ts

@@ -1,935 +0,0 @@
-import * as BufferLayout from '@solana/buffer-layout';
-
-import {
-  encodeData,
-  decodeData,
-  InstructionType,
-  IInstructionInputData,
-} 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 '../utils/to-buffer';
-
-/**
- * Address of the stake config account which configures the rate
- * of stake warmup and cooldown as well as the slashing penalty.
- */
-export const STAKE_CONFIG_ID = new PublicKey(
-  'StakeConfig11111111111111111111111111111111',
-);
-
-/**
- * Stake account authority info
- */
-export class Authorized {
-  /** stake authority */
-  staker: PublicKey;
-  /** withdraw authority */
-  withdrawer: PublicKey;
-
-  /**
-   * Create a new Authorized object
-   * @param staker the stake authority
-   * @param withdrawer the withdraw authority
-   */
-  constructor(staker: PublicKey, withdrawer: PublicKey) {
-    this.staker = staker;
-    this.withdrawer = withdrawer;
-  }
-}
-
-type AuthorizedRaw = Readonly<{
-  staker: Uint8Array;
-  withdrawer: Uint8Array;
-}>;
-
-/**
- * Stake account lockup info
- */
-export class Lockup {
-  /** Unix timestamp of lockup expiration */
-  unixTimestamp: number;
-  /** Epoch of lockup expiration */
-  epoch: number;
-  /** Lockup custodian authority */
-  custodian: PublicKey;
-
-  /**
-   * Create a new Lockup object
-   */
-  constructor(unixTimestamp: number, epoch: number, custodian: PublicKey) {
-    this.unixTimestamp = unixTimestamp;
-    this.epoch = epoch;
-    this.custodian = custodian;
-  }
-
-  /**
-   * Default, inactive Lockup value
-   */
-  static default: Lockup = new Lockup(0, 0, PublicKey.default);
-}
-
-type LockupRaw = Readonly<{
-  custodian: Uint8Array;
-  epoch: number;
-  unixTimestamp: number;
-}>;
-
-/**
- * Create stake account transaction params
- */
-export type CreateStakeAccountParams = {
-  /** Address of the account which will fund creation */
-  fromPubkey: PublicKey;
-  /** Address of the new stake account */
-  stakePubkey: PublicKey;
-  /** Authorities of the new stake account */
-  authorized: Authorized;
-  /** Lockup of the new stake account */
-  lockup?: Lockup;
-  /** Funding amount */
-  lamports: number;
-};
-
-/**
- * Create stake account with seed transaction params
- */
-export type CreateStakeAccountWithSeedParams = {
-  fromPubkey: PublicKey;
-  stakePubkey: PublicKey;
-  basePubkey: PublicKey;
-  seed: string;
-  authorized: Authorized;
-  lockup?: Lockup;
-  lamports: number;
-};
-
-/**
- * Initialize stake instruction params
- */
-export type InitializeStakeParams = {
-  stakePubkey: PublicKey;
-  authorized: Authorized;
-  lockup?: Lockup;
-};
-
-/**
- * Delegate stake instruction params
- */
-export type DelegateStakeParams = {
-  stakePubkey: PublicKey;
-  authorizedPubkey: PublicKey;
-  votePubkey: PublicKey;
-};
-
-/**
- * Authorize stake instruction params
- */
-export type AuthorizeStakeParams = {
-  stakePubkey: PublicKey;
-  authorizedPubkey: PublicKey;
-  newAuthorizedPubkey: PublicKey;
-  stakeAuthorizationType: StakeAuthorizationType;
-  custodianPubkey?: PublicKey;
-};
-
-/**
- * Authorize stake instruction params using a derived key
- */
-export type AuthorizeWithSeedStakeParams = {
-  stakePubkey: PublicKey;
-  authorityBase: PublicKey;
-  authoritySeed: string;
-  authorityOwner: PublicKey;
-  newAuthorizedPubkey: PublicKey;
-  stakeAuthorizationType: StakeAuthorizationType;
-  custodianPubkey?: PublicKey;
-};
-
-/**
- * Split stake instruction params
- */
-export type SplitStakeParams = {
-  stakePubkey: PublicKey;
-  authorizedPubkey: PublicKey;
-  splitStakePubkey: PublicKey;
-  lamports: number;
-};
-
-/**
- * Split with seed transaction params
- */
-export type SplitStakeWithSeedParams = {
-  stakePubkey: PublicKey;
-  authorizedPubkey: PublicKey;
-  splitStakePubkey: PublicKey;
-  basePubkey: PublicKey;
-  seed: string;
-  lamports: number;
-};
-
-/**
- * Withdraw stake instruction params
- */
-export type WithdrawStakeParams = {
-  stakePubkey: PublicKey;
-  authorizedPubkey: PublicKey;
-  toPubkey: PublicKey;
-  lamports: number;
-  custodianPubkey?: PublicKey;
-};
-
-/**
- * Deactivate stake instruction params
- */
-export type DeactivateStakeParams = {
-  stakePubkey: PublicKey;
-  authorizedPubkey: PublicKey;
-};
-
-/**
- * Merge stake instruction params
- */
-export type MergeStakeParams = {
-  stakePubkey: PublicKey;
-  sourceStakePubKey: PublicKey;
-  authorizedPubkey: PublicKey;
-};
-
-/**
- * Stake Instruction class
- */
-export class StakeInstruction {
-  /**
-   * @internal
-   */
-  constructor() {}
-
-  /**
-   * Decode a stake instruction and retrieve the instruction type.
-   */
-  static decodeInstructionType(
-    instruction: TransactionInstruction,
-  ): StakeInstructionType {
-    this.checkProgramId(instruction.programId);
-
-    const instructionTypeLayout = BufferLayout.u32('instruction');
-    const typeIndex = instructionTypeLayout.decode(instruction.data);
-
-    let type: StakeInstructionType | undefined;
-    for (const [ixType, layout] of Object.entries(STAKE_INSTRUCTION_LAYOUTS)) {
-      if (layout.index == typeIndex) {
-        type = ixType as StakeInstructionType;
-        break;
-      }
-    }
-
-    if (!type) {
-      throw new Error('Instruction type incorrect; not a StakeInstruction');
-    }
-
-    return type;
-  }
-
-  /**
-   * Decode a initialize stake instruction and retrieve the instruction params.
-   */
-  static decodeInitialize(
-    instruction: TransactionInstruction,
-  ): InitializeStakeParams {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 2);
-
-    const {authorized, lockup} = decodeData(
-      STAKE_INSTRUCTION_LAYOUTS.Initialize,
-      instruction.data,
-    );
-
-    return {
-      stakePubkey: instruction.keys[0].pubkey,
-      authorized: new Authorized(
-        new PublicKey(authorized.staker),
-        new PublicKey(authorized.withdrawer),
-      ),
-      lockup: new Lockup(
-        lockup.unixTimestamp,
-        lockup.epoch,
-        new PublicKey(lockup.custodian),
-      ),
-    };
-  }
-
-  /**
-   * Decode a delegate stake instruction and retrieve the instruction params.
-   */
-  static decodeDelegate(
-    instruction: TransactionInstruction,
-  ): DelegateStakeParams {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 6);
-    decodeData(STAKE_INSTRUCTION_LAYOUTS.Delegate, instruction.data);
-
-    return {
-      stakePubkey: instruction.keys[0].pubkey,
-      votePubkey: instruction.keys[1].pubkey,
-      authorizedPubkey: instruction.keys[5].pubkey,
-    };
-  }
-
-  /**
-   * Decode an authorize stake instruction and retrieve the instruction params.
-   */
-  static decodeAuthorize(
-    instruction: TransactionInstruction,
-  ): AuthorizeStakeParams {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 3);
-    const {newAuthorized, stakeAuthorizationType} = decodeData(
-      STAKE_INSTRUCTION_LAYOUTS.Authorize,
-      instruction.data,
-    );
-
-    const o: AuthorizeStakeParams = {
-      stakePubkey: instruction.keys[0].pubkey,
-      authorizedPubkey: instruction.keys[2].pubkey,
-      newAuthorizedPubkey: new PublicKey(newAuthorized),
-      stakeAuthorizationType: {
-        index: stakeAuthorizationType,
-      },
-    };
-    if (instruction.keys.length > 3) {
-      o.custodianPubkey = instruction.keys[3].pubkey;
-    }
-    return o;
-  }
-
-  /**
-   * Decode an authorize-with-seed stake instruction and retrieve the instruction params.
-   */
-  static decodeAuthorizeWithSeed(
-    instruction: TransactionInstruction,
-  ): AuthorizeWithSeedStakeParams {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 2);
-
-    const {
-      newAuthorized,
-      stakeAuthorizationType,
-      authoritySeed,
-      authorityOwner,
-    } = decodeData(
-      STAKE_INSTRUCTION_LAYOUTS.AuthorizeWithSeed,
-      instruction.data,
-    );
-
-    const o: AuthorizeWithSeedStakeParams = {
-      stakePubkey: instruction.keys[0].pubkey,
-      authorityBase: instruction.keys[1].pubkey,
-      authoritySeed: authoritySeed,
-      authorityOwner: new PublicKey(authorityOwner),
-      newAuthorizedPubkey: new PublicKey(newAuthorized),
-      stakeAuthorizationType: {
-        index: stakeAuthorizationType,
-      },
-    };
-    if (instruction.keys.length > 3) {
-      o.custodianPubkey = instruction.keys[3].pubkey;
-    }
-    return o;
-  }
-
-  /**
-   * Decode a split stake instruction and retrieve the instruction params.
-   */
-  static decodeSplit(instruction: TransactionInstruction): SplitStakeParams {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 3);
-    const {lamports} = decodeData(
-      STAKE_INSTRUCTION_LAYOUTS.Split,
-      instruction.data,
-    );
-
-    return {
-      stakePubkey: instruction.keys[0].pubkey,
-      splitStakePubkey: instruction.keys[1].pubkey,
-      authorizedPubkey: instruction.keys[2].pubkey,
-      lamports,
-    };
-  }
-
-  /**
-   * Decode a merge stake instruction and retrieve the instruction params.
-   */
-  static decodeMerge(instruction: TransactionInstruction): MergeStakeParams {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 3);
-    decodeData(STAKE_INSTRUCTION_LAYOUTS.Merge, instruction.data);
-
-    return {
-      stakePubkey: instruction.keys[0].pubkey,
-      sourceStakePubKey: instruction.keys[1].pubkey,
-      authorizedPubkey: instruction.keys[4].pubkey,
-    };
-  }
-
-  /**
-   * Decode a withdraw stake instruction and retrieve the instruction params.
-   */
-  static decodeWithdraw(
-    instruction: TransactionInstruction,
-  ): WithdrawStakeParams {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 5);
-    const {lamports} = decodeData(
-      STAKE_INSTRUCTION_LAYOUTS.Withdraw,
-      instruction.data,
-    );
-
-    const o: WithdrawStakeParams = {
-      stakePubkey: instruction.keys[0].pubkey,
-      toPubkey: instruction.keys[1].pubkey,
-      authorizedPubkey: instruction.keys[4].pubkey,
-      lamports,
-    };
-    if (instruction.keys.length > 5) {
-      o.custodianPubkey = instruction.keys[5].pubkey;
-    }
-    return o;
-  }
-
-  /**
-   * Decode a deactivate stake instruction and retrieve the instruction params.
-   */
-  static decodeDeactivate(
-    instruction: TransactionInstruction,
-  ): DeactivateStakeParams {
-    this.checkProgramId(instruction.programId);
-    this.checkKeyLength(instruction.keys, 3);
-    decodeData(STAKE_INSTRUCTION_LAYOUTS.Deactivate, instruction.data);
-
-    return {
-      stakePubkey: instruction.keys[0].pubkey,
-      authorizedPubkey: instruction.keys[2].pubkey,
-    };
-  }
-
-  /**
-   * @internal
-   */
-  static checkProgramId(programId: PublicKey) {
-    if (!programId.equals(StakeProgram.programId)) {
-      throw new Error('invalid instruction; programId is not StakeProgram');
-    }
-  }
-
-  /**
-   * @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 StakeInstructionType's
- */
-export type StakeInstructionType =
-  // FIXME
-  // It would be preferable for this type to be `keyof StakeInstructionInputData`
-  // but Typedoc does not transpile `keyof` expressions.
-  // See https://github.com/TypeStrong/typedoc/issues/1894
-  | 'Authorize'
-  | 'AuthorizeWithSeed'
-  | 'Deactivate'
-  | 'Delegate'
-  | 'Initialize'
-  | 'Merge'
-  | 'Split'
-  | 'Withdraw';
-
-type StakeInstructionInputData = {
-  Authorize: IInstructionInputData &
-    Readonly<{
-      newAuthorized: Uint8Array;
-      stakeAuthorizationType: number;
-    }>;
-  AuthorizeWithSeed: IInstructionInputData &
-    Readonly<{
-      authorityOwner: Uint8Array;
-      authoritySeed: string;
-      instruction: number;
-      newAuthorized: Uint8Array;
-      stakeAuthorizationType: number;
-    }>;
-  Deactivate: IInstructionInputData;
-  Delegate: IInstructionInputData;
-  Initialize: IInstructionInputData &
-    Readonly<{
-      authorized: AuthorizedRaw;
-      lockup: LockupRaw;
-    }>;
-  Merge: IInstructionInputData;
-  Split: IInstructionInputData &
-    Readonly<{
-      lamports: number;
-    }>;
-  Withdraw: IInstructionInputData &
-    Readonly<{
-      lamports: number;
-    }>;
-};
-
-/**
- * An enumeration of valid stake InstructionType's
- * @internal
- */
-export const STAKE_INSTRUCTION_LAYOUTS = Object.freeze<{
-  [Instruction in StakeInstructionType]: InstructionType<
-    StakeInstructionInputData[Instruction]
-  >;
-}>({
-  Initialize: {
-    index: 0,
-    layout: BufferLayout.struct<StakeInstructionInputData['Initialize']>([
-      BufferLayout.u32('instruction'),
-      Layout.authorized(),
-      Layout.lockup(),
-    ]),
-  },
-  Authorize: {
-    index: 1,
-    layout: BufferLayout.struct<StakeInstructionInputData['Authorize']>([
-      BufferLayout.u32('instruction'),
-      Layout.publicKey('newAuthorized'),
-      BufferLayout.u32('stakeAuthorizationType'),
-    ]),
-  },
-  Delegate: {
-    index: 2,
-    layout: BufferLayout.struct<StakeInstructionInputData['Delegate']>([
-      BufferLayout.u32('instruction'),
-    ]),
-  },
-  Split: {
-    index: 3,
-    layout: BufferLayout.struct<StakeInstructionInputData['Split']>([
-      BufferLayout.u32('instruction'),
-      BufferLayout.ns64('lamports'),
-    ]),
-  },
-  Withdraw: {
-    index: 4,
-    layout: BufferLayout.struct<StakeInstructionInputData['Withdraw']>([
-      BufferLayout.u32('instruction'),
-      BufferLayout.ns64('lamports'),
-    ]),
-  },
-  Deactivate: {
-    index: 5,
-    layout: BufferLayout.struct<StakeInstructionInputData['Deactivate']>([
-      BufferLayout.u32('instruction'),
-    ]),
-  },
-  Merge: {
-    index: 7,
-    layout: BufferLayout.struct<StakeInstructionInputData['Merge']>([
-      BufferLayout.u32('instruction'),
-    ]),
-  },
-  AuthorizeWithSeed: {
-    index: 8,
-    layout: BufferLayout.struct<StakeInstructionInputData['AuthorizeWithSeed']>(
-      [
-        BufferLayout.u32('instruction'),
-        Layout.publicKey('newAuthorized'),
-        BufferLayout.u32('stakeAuthorizationType'),
-        Layout.rustString('authoritySeed'),
-        Layout.publicKey('authorityOwner'),
-      ],
-    ),
-  },
-});
-
-/**
- * Stake authorization type
- */
-export type StakeAuthorizationType = {
-  /** The Stake Authorization index (from solana-stake-program) */
-  index: number;
-};
-
-/**
- * An enumeration of valid StakeAuthorizationLayout's
- */
-export const StakeAuthorizationLayout = Object.freeze({
-  Staker: {
-    index: 0,
-  },
-  Withdrawer: {
-    index: 1,
-  },
-});
-
-/**
- * Factory class for transactions to interact with the Stake program
- */
-export class StakeProgram {
-  /**
-   * @internal
-   */
-  constructor() {}
-
-  /**
-   * Public key that identifies the Stake program
-   */
-  static programId: PublicKey = new PublicKey(
-    'Stake11111111111111111111111111111111111111',
-  );
-
-  /**
-   * Max space of a Stake account
-   *
-   * This is generated from the solana-stake-program StakeState struct as
-   * `StakeState::size_of()`:
-   * https://docs.rs/solana-stake-program/latest/solana_stake_program/stake_state/enum.StakeState.html
-   */
-  static space: number = 200;
-
-  /**
-   * Generate an Initialize instruction to add to a Stake Create transaction
-   */
-  static initialize(params: InitializeStakeParams): TransactionInstruction {
-    const {stakePubkey, authorized, lockup: maybeLockup} = params;
-    const lockup: Lockup = maybeLockup || Lockup.default;
-    const type = STAKE_INSTRUCTION_LAYOUTS.Initialize;
-    const data = encodeData(type, {
-      authorized: {
-        staker: toBuffer(authorized.staker.toBuffer()),
-        withdrawer: toBuffer(authorized.withdrawer.toBuffer()),
-      },
-      lockup: {
-        unixTimestamp: lockup.unixTimestamp,
-        epoch: lockup.epoch,
-        custodian: toBuffer(lockup.custodian.toBuffer()),
-      },
-    });
-    const instructionData = {
-      keys: [
-        {pubkey: stakePubkey, isSigner: false, isWritable: true},
-        {pubkey: SYSVAR_RENT_PUBKEY, isSigner: false, isWritable: false},
-      ],
-      programId: this.programId,
-      data,
-    };
-    return new TransactionInstruction(instructionData);
-  }
-
-  /**
-   * Generate a Transaction that creates a new Stake account at
-   *   an address generated with `from`, a seed, and the Stake programId
-   */
-  static createAccountWithSeed(
-    params: CreateStakeAccountWithSeedParams,
-  ): Transaction {
-    const transaction = new Transaction();
-    transaction.add(
-      SystemProgram.createAccountWithSeed({
-        fromPubkey: params.fromPubkey,
-        newAccountPubkey: params.stakePubkey,
-        basePubkey: params.basePubkey,
-        seed: params.seed,
-        lamports: params.lamports,
-        space: this.space,
-        programId: this.programId,
-      }),
-    );
-
-    const {stakePubkey, authorized, lockup} = params;
-    return transaction.add(this.initialize({stakePubkey, authorized, lockup}));
-  }
-
-  /**
-   * Generate a Transaction that creates a new Stake account
-   */
-  static createAccount(params: CreateStakeAccountParams): Transaction {
-    const transaction = new Transaction();
-    transaction.add(
-      SystemProgram.createAccount({
-        fromPubkey: params.fromPubkey,
-        newAccountPubkey: params.stakePubkey,
-        lamports: params.lamports,
-        space: this.space,
-        programId: this.programId,
-      }),
-    );
-
-    const {stakePubkey, authorized, lockup} = params;
-    return transaction.add(this.initialize({stakePubkey, authorized, lockup}));
-  }
-
-  /**
-   * Generate a Transaction that delegates Stake tokens to a validator
-   * Vote PublicKey. This transaction can also be used to redelegate Stake
-   * to a new validator Vote PublicKey.
-   */
-  static delegate(params: DelegateStakeParams): Transaction {
-    const {stakePubkey, authorizedPubkey, votePubkey} = params;
-
-    const type = STAKE_INSTRUCTION_LAYOUTS.Delegate;
-    const data = encodeData(type);
-
-    return new Transaction().add({
-      keys: [
-        {pubkey: stakePubkey, isSigner: false, isWritable: true},
-        {pubkey: votePubkey, isSigner: false, isWritable: false},
-        {pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false},
-        {
-          pubkey: SYSVAR_STAKE_HISTORY_PUBKEY,
-          isSigner: false,
-          isWritable: false,
-        },
-        {pubkey: STAKE_CONFIG_ID, isSigner: false, isWritable: false},
-        {pubkey: authorizedPubkey, isSigner: true, isWritable: false},
-      ],
-      programId: this.programId,
-      data,
-    });
-  }
-
-  /**
-   * Generate a Transaction that authorizes a new PublicKey as Staker
-   * or Withdrawer on the Stake account.
-   */
-  static authorize(params: AuthorizeStakeParams): Transaction {
-    const {
-      stakePubkey,
-      authorizedPubkey,
-      newAuthorizedPubkey,
-      stakeAuthorizationType,
-      custodianPubkey,
-    } = params;
-
-    const type = STAKE_INSTRUCTION_LAYOUTS.Authorize;
-    const data = encodeData(type, {
-      newAuthorized: toBuffer(newAuthorizedPubkey.toBuffer()),
-      stakeAuthorizationType: stakeAuthorizationType.index,
-    });
-
-    const keys = [
-      {pubkey: stakePubkey, isSigner: false, isWritable: true},
-      {pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: true},
-      {pubkey: authorizedPubkey, isSigner: true, isWritable: false},
-    ];
-    if (custodianPubkey) {
-      keys.push({
-        pubkey: custodianPubkey,
-        isSigner: false,
-        isWritable: false,
-      });
-    }
-    return new Transaction().add({
-      keys,
-      programId: this.programId,
-      data,
-    });
-  }
-
-  /**
-   * Generate a Transaction that authorizes a new PublicKey as Staker
-   * or Withdrawer on the Stake account.
-   */
-  static authorizeWithSeed(params: AuthorizeWithSeedStakeParams): Transaction {
-    const {
-      stakePubkey,
-      authorityBase,
-      authoritySeed,
-      authorityOwner,
-      newAuthorizedPubkey,
-      stakeAuthorizationType,
-      custodianPubkey,
-    } = params;
-
-    const type = STAKE_INSTRUCTION_LAYOUTS.AuthorizeWithSeed;
-    const data = encodeData(type, {
-      newAuthorized: toBuffer(newAuthorizedPubkey.toBuffer()),
-      stakeAuthorizationType: stakeAuthorizationType.index,
-      authoritySeed: authoritySeed,
-      authorityOwner: toBuffer(authorityOwner.toBuffer()),
-    });
-
-    const keys = [
-      {pubkey: stakePubkey, isSigner: false, isWritable: true},
-      {pubkey: authorityBase, isSigner: true, isWritable: false},
-      {pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false},
-    ];
-    if (custodianPubkey) {
-      keys.push({
-        pubkey: custodianPubkey,
-        isSigner: false,
-        isWritable: false,
-      });
-    }
-    return new Transaction().add({
-      keys,
-      programId: this.programId,
-      data,
-    });
-  }
-
-  /**
-   * @internal
-   */
-  static splitInstruction(params: SplitStakeParams): TransactionInstruction {
-    const {stakePubkey, authorizedPubkey, splitStakePubkey, lamports} = params;
-    const type = STAKE_INSTRUCTION_LAYOUTS.Split;
-    const data = encodeData(type, {lamports});
-    return new TransactionInstruction({
-      keys: [
-        {pubkey: stakePubkey, isSigner: false, isWritable: true},
-        {pubkey: splitStakePubkey, isSigner: false, isWritable: true},
-        {pubkey: authorizedPubkey, isSigner: true, isWritable: false},
-      ],
-      programId: this.programId,
-      data,
-    });
-  }
-
-  /**
-   * Generate a Transaction that splits Stake tokens into another stake account
-   */
-  static split(params: SplitStakeParams): Transaction {
-    const transaction = new Transaction();
-    transaction.add(
-      SystemProgram.createAccount({
-        fromPubkey: params.authorizedPubkey,
-        newAccountPubkey: params.splitStakePubkey,
-        lamports: 0,
-        space: this.space,
-        programId: this.programId,
-      }),
-    );
-    return transaction.add(this.splitInstruction(params));
-  }
-
-  /**
-   * Generate a Transaction that splits Stake tokens into another account
-   * derived from a base public key and seed
-   */
-  static splitWithSeed(params: SplitStakeWithSeedParams): Transaction {
-    const {
-      stakePubkey,
-      authorizedPubkey,
-      splitStakePubkey,
-      basePubkey,
-      seed,
-      lamports,
-    } = params;
-    const transaction = new Transaction();
-    transaction.add(
-      SystemProgram.allocate({
-        accountPubkey: splitStakePubkey,
-        basePubkey,
-        seed,
-        space: this.space,
-        programId: this.programId,
-      }),
-    );
-    return transaction.add(
-      this.splitInstruction({
-        stakePubkey,
-        authorizedPubkey,
-        splitStakePubkey,
-        lamports,
-      }),
-    );
-  }
-
-  /**
-   * Generate a Transaction that merges Stake accounts.
-   */
-  static merge(params: MergeStakeParams): Transaction {
-    const {stakePubkey, sourceStakePubKey, authorizedPubkey} = params;
-    const type = STAKE_INSTRUCTION_LAYOUTS.Merge;
-    const data = encodeData(type);
-
-    return new Transaction().add({
-      keys: [
-        {pubkey: stakePubkey, isSigner: false, isWritable: true},
-        {pubkey: sourceStakePubKey, isSigner: false, isWritable: true},
-        {pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false},
-        {
-          pubkey: SYSVAR_STAKE_HISTORY_PUBKEY,
-          isSigner: false,
-          isWritable: false,
-        },
-        {pubkey: authorizedPubkey, isSigner: true, isWritable: false},
-      ],
-      programId: this.programId,
-      data,
-    });
-  }
-
-  /**
-   * Generate a Transaction that withdraws deactivated Stake tokens.
-   */
-  static withdraw(params: WithdrawStakeParams): Transaction {
-    const {stakePubkey, authorizedPubkey, toPubkey, lamports, custodianPubkey} =
-      params;
-    const type = STAKE_INSTRUCTION_LAYOUTS.Withdraw;
-    const data = encodeData(type, {lamports});
-
-    const keys = [
-      {pubkey: stakePubkey, isSigner: false, isWritable: true},
-      {pubkey: toPubkey, isSigner: false, isWritable: true},
-      {pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false},
-      {
-        pubkey: SYSVAR_STAKE_HISTORY_PUBKEY,
-        isSigner: false,
-        isWritable: false,
-      },
-      {pubkey: authorizedPubkey, isSigner: true, isWritable: false},
-    ];
-    if (custodianPubkey) {
-      keys.push({
-        pubkey: custodianPubkey,
-        isSigner: false,
-        isWritable: false,
-      });
-    }
-    return new Transaction().add({
-      keys,
-      programId: this.programId,
-      data,
-    });
-  }
-
-  /**
-   * Generate a Transaction that deactivates Stake tokens.
-   */
-  static deactivate(params: DeactivateStakeParams): Transaction {
-    const {stakePubkey, authorizedPubkey} = params;
-    const type = STAKE_INSTRUCTION_LAYOUTS.Deactivate;
-    const data = encodeData(type);
-
-    return new Transaction().add({
-      keys: [
-        {pubkey: stakePubkey, isSigner: false, isWritable: true},
-        {pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false},
-        {pubkey: authorizedPubkey, isSigner: true, isWritable: false},
-      ],
-      programId: this.programId,
-      data,
-    });
-  }
-}