@exodus/solana-lib 1.2.13 → 1.2.14

package/src/vendor/stake-program.js

@@ -1,527 +0,0 @@
-// @flow
-
-import * as BufferLayout from '@exodus/buffer-layout'
-
-import { encodeData, decodeData } from './instruction'
-import * as Layout from './utils/layout'
-import { PublicKey } from './publickey'
-import { SystemProgram } from './system-program'
-import { SYSVAR_CLOCK_PUBKEY, SYSVAR_RENT_PUBKEY, SYSVAR_STAKE_HISTORY_PUBKEY } from './sysvar'
-import { Transaction, TransactionInstruction } from './transaction'
-
-export const STAKE_CONFIG_ID = new PublicKey('StakeConfig11111111111111111111111111111111')
-
-export class Authorized {
-  staker: PublicKey
-  withdrawer: PublicKey
-
-  /**
-   * Create a new Authorized object
-   */
-  constructor(staker: PublicKey, withdrawer: PublicKey) {
-    this.staker = staker
-    this.withdrawer = withdrawer
-  }
-}
-
-export class Lockup {
-  unixTimestamp: number
-  epoch: number
-  custodian: PublicKey
-
-  /**
-   * Create a new Lockup object
-   */
-  constructor(unixTimestamp: number, epoch: number, custodian: PublicKey) {
-    this.unixTimestamp = unixTimestamp
-    this.epoch = epoch
-    this.custodian = custodian
-  }
-}
-
-/**
- * Create stake account transaction params
- * @typedef {Object} CreateStakeAccountParams
- * @property {PublicKey} fromPubkey
- * @property {PublicKey} stakePubkey
- * @property {Authorized} authorized
- * @property {Lockup} lockup
- * @property {number} lamports
- */
-export type CreateStakeAccountParams = {|
-  fromPubkey: PublicKey,
-  stakePubkey: PublicKey,
-  authorized: Authorized,
-  lockup: Lockup,
-  lamports: number,
-|}
-
-/**
- * Create stake account with seed transaction params
- * @typedef {Object} CreateStakeAccountWithSeedParams
- * @property {PublicKey} fromPubkey
- * @property {PublicKey} stakePubkey
- * @property {PublicKey} basePubkey
- * @property {string} seed
- * @property {Authorized} authorized
- * @property {Lockup} lockup
- * @property {number} lamports
- */
-export type CreateStakeAccountWithSeedParams = {|
-  fromPubkey: PublicKey,
-  stakePubkey: PublicKey,
-  basePubkey: PublicKey,
-  seed: string,
-  authorized: Authorized,
-  lockup: Lockup,
-  lamports: number,
-|}
-
-/**
- * Initialize stake instruction params
- * @typedef {Object} InitializeStakeParams
- * @property {PublicKey} stakePubkey
- * @property {Authorized} authorized
- * @property {Lockup} lockup
- */
-export type InitializeStakeParams = {|
-  stakePubkey: PublicKey,
-  authorized: Authorized,
-  lockup: Lockup,
-|}
-
-/**
- * Delegate stake instruction params
- * @typedef {Object} DelegateStakeParams
- * @property {PublicKey} stakePubkey
- * @property {PublicKey} authorizedPubkey
- * @property {PublicKey} votePubkey
- */
-export type DelegateStakeParams = {|
-  stakePubkey: PublicKey,
-  authorizedPubkey: PublicKey,
-  votePubkey: PublicKey,
-|}
-
-/**
- * @typedef {Object} StakeAuthorizationType
- * @property (index} The Stake Authorization index (from solana-stake-program)
- */
-export type StakeAuthorizationType = {|
-  index: number,
-|}
-
-/**
- * Authorize stake instruction params
- * @typedef {Object} AuthorizeStakeParams
- * @property {PublicKey} stakePubkey
- * @property {PublicKey} authorizedPubkey
- * @property {PublicKey} newAuthorizedPubkey
- * @property {StakeAuthorizationType} stakeAuthorizationType
- */
-export type AuthorizeStakeParams = {|
-  stakePubkey: PublicKey,
-  authorizedPubkey: PublicKey,
-  newAuthorizedPubkey: PublicKey,
-  stakeAuthorizationType: StakeAuthorizationType,
-|}
-
-/**
- * Authorize stake instruction params using a derived key
- * @typedef {Object} AuthorizeWithSeedStakeParams
- * @property {PublicKey} stakePubkey
- * @property {PublicKey} authorityBase
- * @property {string} authoritySeed
- * @property {PublicKey} authorityOwner
- * @property {PublicKey} newAuthorizedPubkey
- * @property {StakeAuthorizationType} stakeAuthorizationType
- */
-export type AuthorizeWithSeedStakeParams = {|
-  stakePubkey: PublicKey,
-  authorityBase: PublicKey,
-  authoritySeed: string,
-  authorityOwner: PublicKey,
-  newAuthorizedPubkey: PublicKey,
-  stakeAuthorizationType: StakeAuthorizationType,
-|}
-
-/**
- * Split stake instruction params
- * @typedef {Object} SplitStakeParams
- * @property {PublicKey} stakePubkey
- * @property {PublicKey} authorizedPubkey
- * @property {PublicKey} splitStakePubkey
- * @property {number} lamports
- */
-export type SplitStakeParams = {|
-  stakePubkey: PublicKey,
-  authorizedPubkey: PublicKey,
-  splitStakePubkey: PublicKey,
-  lamports: number,
-|}
-
-/**
- * Withdraw stake instruction params
- * @typedef {Object} WithdrawStakeParams
- * @property {PublicKey} stakePubkey
- * @property {PublicKey} authorizedPubkey
- * @property {PublicKey} toPubkey
- * @property {number} lamports
- */
-export type WithdrawStakeParams = {|
-  stakePubkey: PublicKey,
-  authorizedPubkey: PublicKey,
-  toPubkey: PublicKey,
-  lamports: number,
-|}
-
-/**
- * Deactivate stake instruction params
- * @typedef {Object} DeactivateStakeParams
- * @property {PublicKey} stakePubkey
- * @property {PublicKey} authorizedPubkey
- */
-export type DeactivateStakeParams = {|
-  stakePubkey: PublicKey,
-  authorizedPubkey: PublicKey,
-|}
-
-/**
- * An enumeration of valid stake InstructionType's
- */
-export const STAKE_INSTRUCTION_LAYOUTS = Object.freeze({
-  Initialize: {
-    index: 0,
-    layout: BufferLayout.struct([
-      BufferLayout.u32('instruction'),
-      Layout.authorized(),
-      Layout.lockup(),
-    ]),
-  },
-  Authorize: {
-    index: 1,
-    layout: BufferLayout.struct([
-      BufferLayout.u32('instruction'),
-      Layout.publicKey('newAuthorized'),
-      BufferLayout.u32('stakeAuthorizationType'),
-    ]),
-  },
-  Delegate: {
-    index: 2,
-    layout: BufferLayout.struct([BufferLayout.u32('instruction')]),
-  },
-  Split: {
-    index: 3,
-    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports')]),
-  },
-  Withdraw: {
-    index: 4,
-    layout: BufferLayout.struct([BufferLayout.u32('instruction'), BufferLayout.ns64('lamports')]),
-  },
-  Deactivate: {
-    index: 5,
-    layout: BufferLayout.struct([BufferLayout.u32('instruction')]),
-  },
-  AuthorizeWithSeed: {
-    index: 8,
-    layout: BufferLayout.struct([
-      BufferLayout.u32('instruction'),
-      Layout.publicKey('newAuthorized'),
-      BufferLayout.u32('stakeAuthorizationType'),
-      Layout.rustString('authoritySeed'),
-      Layout.publicKey('authorityOwner'),
-    ]),
-  },
-})
-
-/**
- * Stake Instruction class
- */
-export class StakeInstruction {
-  /**
-   * Decode a stake instruction and retrieve the instruction type.
-   */
-  static decodeInstructionType(instruction: TransactionInstruction) {
-    this.checkProgramId(instruction.programId)
-
-    const instructionTypeLayout = BufferLayout.u32('instruction')
-    const typeIndex = instructionTypeLayout.decode(instruction.data)
-
-    let type
-    for (const t of Object.keys(STAKE_INSTRUCTION_LAYOUTS)) {
-      if (STAKE_INSTRUCTION_LAYOUTS[t].index === typeIndex) {
-        type = t
-      }
-    }
-
-    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 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)
-
-    return {
-      stakePubkey: instruction.keys[0].pubkey,
-      toPubkey: instruction.keys[1].pubkey,
-      authorizedPubkey: instruction.keys[4].pubkey,
-      lamports,
-    }
-  }
-
-  /**
-   * 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,
-    }
-  }
-
-  /**
-   * @private
-   */
-  static checkProgramId(programId: PublicKey) {
-    if (!programId.equals(StakeProgram.programId)) {
-      throw new Error('invalid instruction; programId is not StakeProgram')
-    }
-  }
-
-  /**
-   * @private
-   */
-  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 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 {
-  /**
-   * Public key that identifies the Stake program
-   */
-  static get programId(): PublicKey {
-    return new PublicKey('Stake11111111111111111111111111111111111111')
-  }
-
-  /**
-   * Max space of a Stake account
-   *
-   * This is generated from the solana-stake-program StakeState struct as
-   * `std::mem::size_of::<StakeState>()`:
-   * https://docs.rs/solana-stake-program/1.4.4/solana_stake_program/stake_state/enum.StakeState.html
-   */
-  static get space(): number {
-    return 200
-  }
-
-  /**
-   * Generate an Initialize instruction to add to a Stake Create transaction
-   */
-  static initialize(params: InitializeStakeParams): TransactionInstruction {
-    const { stakePubkey, authorized, lockup } = params
-    const type = STAKE_INSTRUCTION_LAYOUTS.Initialize
-    const data = encodeData(type, {
-      authorized: {
-        staker: authorized.staker.toBuffer(),
-        withdrawer: authorized.withdrawer.toBuffer(),
-      },
-      lockup: {
-        unixTimestamp: lockup.unixTimestamp,
-        epoch: lockup.epoch,
-        custodian: 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 withdraws deactivated Stake tokens.
-   */
-  static withdraw(params: WithdrawStakeParams): Transaction {
-    const { stakePubkey, authorizedPubkey, toPubkey, lamports } = params
-    const type = STAKE_INSTRUCTION_LAYOUTS.Withdraw
-    const data = encodeData(type, { lamports })
-
-    return new Transaction().add({
-      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 },
-      ],
-      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,
-    })
-  }
-}