@ignitionfi/spl-stake-pool 1.1.8

package/src/layouts.ts

@@ -0,0 +1,248 @@
+import { PublicKey } from '@solana/web3.js'
+import BN from 'bn.js'
+import { Layout as LayoutCls, struct, u8, u32 } from 'buffer-layout'
+import {
+  coerce,
+  enums,
+  Infer,
+  instance,
+  nullable,
+  number,
+  optional,
+  string,
+  type,
+} from 'superstruct'
+import { Layout, option, publicKey, u64, vec } from './codecs'
+
+export interface Fee {
+  denominator: BN
+  numerator: BN
+}
+
+const feeFields = [u64('denominator'), u64('numerator')]
+
+export enum AccountType {
+  Uninitialized,
+  StakePool,
+  ValidatorList,
+}
+
+export const BigNumFromString = coerce(instance(BN), string(), (value) => {
+  if (typeof value === 'string') {
+    return new BN(value, 10)
+  }
+  throw new Error('invalid big num')
+})
+
+export const PublicKeyFromString = coerce(
+  instance(PublicKey),
+  string(),
+  value => new PublicKey(value),
+)
+
+export class FutureEpochLayout<T> extends LayoutCls<T | null> {
+  layout: Layout<T>
+  discriminator: Layout<number>
+
+  constructor(layout: Layout<T>, property?: string) {
+    super(-1, property)
+    this.layout = layout
+    this.discriminator = u8()
+  }
+
+  encode(src: T | null, b: Buffer, offset = 0): number {
+    if (src === null || src === undefined) {
+      return this.discriminator.encode(0, b, offset)
+    }
+    // This isn't right, but we don't typically encode outside of tests
+    this.discriminator.encode(2, b, offset)
+    return this.layout.encode(src, b, offset + 1) + 1
+  }
+
+  decode(b: Buffer, offset = 0): T | null {
+    const discriminator = this.discriminator.decode(b, offset)
+    if (discriminator === 0) {
+      return null
+    } else if (discriminator === 1 || discriminator === 2) {
+      return this.layout.decode(b, offset + 1)
+    }
+    throw new Error(`Invalid future epoch ${this.property}`)
+  }
+
+  getSpan(b: Buffer, offset = 0): number {
+    const discriminator = this.discriminator.decode(b, offset)
+    if (discriminator === 0) {
+      return 1
+    } else if (discriminator === 1 || discriminator === 2) {
+      return this.layout.getSpan(b, offset + 1) + 1
+    }
+    throw new Error(`Invalid future epoch ${this.property}`)
+  }
+}
+
+export function futureEpoch<T>(layout: Layout<T>, property?: string): LayoutCls<T | null> {
+  return new FutureEpochLayout<T>(layout, property)
+}
+
+export type StakeAccountType = Infer<typeof StakeAccountType>
+export const StakeAccountType = enums(['uninitialized', 'initialized', 'delegated', 'rewardsPool'])
+
+export type StakeMeta = Infer<typeof StakeMeta>
+export const StakeMeta = type({
+  rentExemptReserve: BigNumFromString,
+  authorized: type({
+    staker: PublicKeyFromString,
+    withdrawer: PublicKeyFromString,
+  }),
+  lockup: type({
+    unixTimestamp: number(),
+    epoch: number(),
+    custodian: PublicKeyFromString,
+  }),
+})
+
+export type StakeAccountInfo = Infer<typeof StakeAccountInfo>
+export const StakeAccountInfo = type({
+  meta: StakeMeta,
+  stake: nullable(
+    type({
+      delegation: type({
+        voter: PublicKeyFromString,
+        stake: BigNumFromString,
+        activationEpoch: BigNumFromString,
+        deactivationEpoch: BigNumFromString,
+        warmupCooldownRate: number(),
+      }),
+      creditsObserved: number(),
+    }),
+  ),
+})
+
+export type StakeAccount = Infer<typeof StakeAccount>
+export const StakeAccount = type({
+  type: StakeAccountType,
+  info: optional(StakeAccountInfo),
+})
+export interface Lockup {
+  unixTimestamp: BN
+  epoch: BN
+  custodian: PublicKey
+}
+
+export interface StakePool {
+  accountType: AccountType
+  manager: PublicKey
+  staker: PublicKey
+  stakeDepositAuthority: PublicKey
+  stakeWithdrawBumpSeed: number
+  validatorList: PublicKey
+  reserveStake: PublicKey
+  poolMint: PublicKey
+  managerFeeAccount: PublicKey
+  tokenProgramId: PublicKey
+  totalLamports: BN
+  poolTokenSupply: BN
+  lastUpdateEpoch: BN
+  lockup: Lockup
+  epochFee: Fee
+  nextEpochFee?: Fee | undefined
+  preferredDepositValidatorVoteAddress?: PublicKey | undefined
+  preferredWithdrawValidatorVoteAddress?: PublicKey | undefined
+  stakeDepositFee: Fee
+  stakeWithdrawalFee: Fee
+  nextStakeWithdrawalFee?: Fee | undefined
+  stakeReferralFee: number
+  solDepositAuthority?: PublicKey | undefined
+  solDepositFee: Fee
+  solReferralFee: number
+  solWithdrawAuthority?: PublicKey | undefined
+  solWithdrawalFee: Fee
+  nextSolWithdrawalFee?: Fee | undefined
+  lastEpochPoolTokenSupply: BN
+  lastEpochTotalLamports: BN
+}
+
+export const StakePoolLayout = struct<StakePool>([
+  u8('accountType'),
+  publicKey('manager'),
+  publicKey('staker'),
+  publicKey('stakeDepositAuthority'),
+  u8('stakeWithdrawBumpSeed'),
+  publicKey('validatorList'),
+  publicKey('reserveStake'),
+  publicKey('poolMint'),
+  publicKey('managerFeeAccount'),
+  publicKey('tokenProgramId'),
+  u64('totalLamports'),
+  u64('poolTokenSupply'),
+  u64('lastUpdateEpoch'),
+  struct([u64('unixTimestamp'), u64('epoch'), publicKey('custodian')], 'lockup'),
+  struct(feeFields, 'epochFee'),
+  futureEpoch(struct(feeFields), 'nextEpochFee'),
+  option(publicKey(), 'preferredDepositValidatorVoteAddress'),
+  option(publicKey(), 'preferredWithdrawValidatorVoteAddress'),
+  struct(feeFields, 'stakeDepositFee'),
+  struct(feeFields, 'stakeWithdrawalFee'),
+  futureEpoch(struct(feeFields), 'nextStakeWithdrawalFee'),
+  u8('stakeReferralFee'),
+  option(publicKey(), 'solDepositAuthority'),
+  struct(feeFields, 'solDepositFee'),
+  u8('solReferralFee'),
+  option(publicKey(), 'solWithdrawAuthority'),
+  struct(feeFields, 'solWithdrawalFee'),
+  futureEpoch(struct(feeFields), 'nextSolWithdrawalFee'),
+  u64('lastEpochPoolTokenSupply'),
+  u64('lastEpochTotalLamports'),
+])
+
+export enum ValidatorStakeInfoStatus {
+  Active,
+  DeactivatingTransient,
+  ReadyForRemoval,
+}
+
+export interface ValidatorStakeInfo {
+  status: ValidatorStakeInfoStatus
+  voteAccountAddress: PublicKey
+  activeStakeLamports: BN
+  transientStakeLamports: BN
+  transientSeedSuffixStart: BN
+  transientSeedSuffixEnd: BN
+  lastUpdateEpoch: BN
+}
+
+export const ValidatorStakeInfoLayout = struct<ValidatorStakeInfo>([
+  /// Amount of active stake delegated to this validator
+  /// Note that if `last_update_epoch` does not match the current epoch then
+  /// this field may not be accurate
+  u64('activeStakeLamports'),
+  /// Amount of transient stake delegated to this validator
+  /// Note that if `last_update_epoch` does not match the current epoch then
+  /// this field may not be accurate
+  u64('transientStakeLamports'),
+  /// Last epoch the active and transient stake lamports fields were updated
+  u64('lastUpdateEpoch'),
+  /// Start of the validator transient account seed suffixes
+  u64('transientSeedSuffixStart'),
+  /// End of the validator transient account seed suffixes
+  u64('transientSeedSuffixEnd'),
+  /// Status of the validator stake account
+  u8('status'),
+  /// Validator vote account address
+  publicKey('voteAccountAddress'),
+])
+
+export interface ValidatorList {
+  /// Account type, must be ValidatorList currently
+  accountType: number
+  /// Maximum allowable number of validators
+  maxValidators: number
+  /// List of stake info for each validator in the pool
+  validators: ValidatorStakeInfo[]
+}
+
+export const ValidatorListLayout = struct<ValidatorList>([
+  u8('accountType'),
+  u32('maxValidators'),
+  vec(ValidatorStakeInfoLayout, 'validators'),
+])

package/src/types/buffer-layout.d.ts

@@ -0,0 +1,29 @@
+declare module 'buffer-layout' {
+  export class Layout<T = any> {
+    span: number
+    property?: string
+    constructor(span: number, property?: string)
+    decode(b: Buffer | undefined, offset?: number): T
+    encode(src: T, b: Buffer, offset?: number): number
+    getSpan(b: Buffer, offset?: number): number
+    replicate(name: string): this
+  }
+  export function struct<T>(
+    fields: Layout<any>[],
+    property?: string,
+    decodePrefixes?: boolean,
+  ): Layout<T>
+  export function seq<T>(
+    elementLayout: Layout<T>,
+    count: number | Layout<number>,
+    property?: string,
+  ): Layout<T[]>
+  export function offset<T>(layout: Layout<T>, offset?: number, property?: string): Layout<T>
+  export function blob(length: number | Layout<number>, property?: string): Layout<Buffer>
+  export function s32(property?: string): Layout<number>
+  export function u32(property?: string): Layout<number>
+  export function s16(property?: string): Layout<number>
+  export function u16(property?: string): Layout<number>
+  export function s8(property?: string): Layout<number>
+  export function u8(property?: string): Layout<number>
+}

package/src/utils/index.ts

@@ -0,0 +1,12 @@
+export * from './instruction'
+export * from './math'
+export * from './program-address'
+export * from './stake'
+
+export function arrayChunk(array: any[], size: number): any[] {
+  const result = []
+  for (let i = 0; i < array.length; i += size) {
+    result.push(array.slice(i, i + size))
+  }
+  return result
+}

package/src/utils/instruction.ts

@@ -0,0 +1,46 @@
+import { Buffer } from 'node:buffer'
+import * as BufferLayout from '@solana/buffer-layout'
+
+/**
+ * @internal
+ */
+export type InstructionType = {
+  /** The Instruction index (from solana upstream program) */
+  index: number
+  /** The BufferLayout to use to build data */
+  layout: BufferLayout.Layout<any>
+}
+
+/**
+ * Populate a buffer of instruction data using an InstructionType
+ * @internal
+ */
+export function encodeData(type: InstructionType, fields?: any): Buffer {
+  const allocLength = type.layout.span
+  const data = Buffer.alloc(allocLength)
+  const layoutFields = Object.assign({ instruction: type.index }, fields)
+  type.layout.encode(layoutFields, data)
+
+  return data
+}
+
+/**
+ * Decode instruction data buffer using an InstructionType
+ * @internal
+ */
+export function decodeData(type: InstructionType, buffer: Buffer): any {
+  let data
+  try {
+    data = type.layout.decode(buffer)
+  } catch (err) {
+    throw new Error(`invalid instruction; ${err}`)
+  }
+
+  if (data.instruction !== type.index) {
+    throw new Error(
+      `invalid instruction; instruction index mismatch ${data.instruction} != ${type.index}`,
+    )
+  }
+
+  return data
+}

package/src/utils/math.ts

@@ -0,0 +1,29 @@
+import { LAMPORTS_PER_SOL } from '@solana/web3.js'
+import BN from 'bn.js'
+
+export function solToLamports(amount: number): number {
+  if (isNaN(amount)) {
+    return Number(0)
+  }
+  return Number(amount * LAMPORTS_PER_SOL)
+}
+
+export function lamportsToSol(lamports: number | BN | bigint): number {
+  if (typeof lamports === 'number') {
+    return Math.abs(lamports) / LAMPORTS_PER_SOL
+  }
+  if (typeof lamports === 'bigint') {
+    return Math.abs(Number(lamports)) / LAMPORTS_PER_SOL
+  }
+
+  let signMultiplier = 1
+  if (lamports.isNeg()) {
+    signMultiplier = -1
+  }
+
+  const absLamports = lamports.abs()
+  const lamportsString = absLamports.toString(10).padStart(10, '0')
+  const splitIndex = lamportsString.length - 9
+  const solString = `${lamportsString.slice(0, splitIndex)}.${lamportsString.slice(splitIndex)}`
+  return signMultiplier * Number.parseFloat(solString)
+}

package/src/utils/program-address.ts

@@ -0,0 +1,103 @@
+import { Buffer } from 'node:buffer'
+import { PublicKey } from '@solana/web3.js'
+import BN from 'bn.js'
+import {
+  EPHEMERAL_STAKE_SEED_PREFIX,
+  METADATA_PROGRAM_ID,
+  TRANSIENT_STAKE_SEED_PREFIX,
+} from '../constants'
+
+/**
+ * Generates the wSOL transient program address for the stake pool
+ */
+export function findWsolTransientProgramAddress(
+  programId: PublicKey,
+  userPubkey: PublicKey,
+) {
+  const [publicKey] = PublicKey.findProgramAddressSync(
+    [Buffer.from('transient_wsol'), userPubkey.toBuffer()],
+    programId,
+  )
+  return publicKey
+}
+
+/**
+ * Generates the withdraw authority program address for the stake pool
+ */
+export async function findWithdrawAuthorityProgramAddress(
+  programId: PublicKey,
+  stakePoolAddress: PublicKey,
+) {
+  const [publicKey] = PublicKey.findProgramAddressSync(
+    [stakePoolAddress.toBuffer(), Buffer.from('withdraw')],
+    programId,
+  )
+  return publicKey
+}
+
+/**
+ * Generates the stake program address for a validator's vote account
+ */
+export async function findStakeProgramAddress(
+  programId: PublicKey,
+  voteAccountAddress: PublicKey,
+  stakePoolAddress: PublicKey,
+  seed?: number,
+) {
+  const [publicKey] = PublicKey.findProgramAddressSync(
+    [
+      voteAccountAddress.toBuffer(),
+      stakePoolAddress.toBuffer(),
+      seed ? new BN(seed).toArrayLike(Buffer, 'le', 4) : Buffer.alloc(0),
+    ],
+    programId,
+  )
+  return publicKey
+}
+
+/**
+ * Generates the stake program address for a validator's vote account
+ */
+export async function findTransientStakeProgramAddress(
+  programId: PublicKey,
+  voteAccountAddress: PublicKey,
+  stakePoolAddress: PublicKey,
+  seed: BN,
+) {
+  const [publicKey] = PublicKey.findProgramAddressSync(
+    [
+      TRANSIENT_STAKE_SEED_PREFIX,
+      voteAccountAddress.toBuffer(),
+      stakePoolAddress.toBuffer(),
+      seed.toArrayLike(Buffer, 'le', 8),
+    ],
+    programId,
+  )
+  return publicKey
+}
+
+/**
+ * Generates the ephemeral program address for stake pool redelegation
+ */
+export async function findEphemeralStakeProgramAddress(
+  programId: PublicKey,
+  stakePoolAddress: PublicKey,
+  seed: BN,
+) {
+  const [publicKey] = PublicKey.findProgramAddressSync(
+    [EPHEMERAL_STAKE_SEED_PREFIX, stakePoolAddress.toBuffer(), seed.toArrayLike(Buffer, 'le', 8)],
+    programId,
+  )
+  return publicKey
+}
+
+/**
+ * Generates the metadata program address for the stake pool
+ */
+export function findMetadataAddress(stakePoolMintAddress: PublicKey) {
+  const [publicKey] = PublicKey.findProgramAddressSync(
+    [Buffer.from('metadata'), METADATA_PROGRAM_ID.toBuffer(), stakePoolMintAddress.toBuffer()],
+    METADATA_PROGRAM_ID,
+  )
+  return publicKey
+}

package/src/utils/stake.ts

@@ -0,0 +1,230 @@
+import {
+  Connection,
+  Keypair,
+  PublicKey,
+  StakeProgram,
+  SystemProgram,
+  TransactionInstruction,
+} from '@solana/web3.js'
+import BN from 'bn.js'
+import { MINIMUM_ACTIVE_STAKE } from '../constants'
+
+import { getStakePoolProgramId, WithdrawAccount } from '../index'
+import {
+  Fee,
+  StakePool,
+  ValidatorList,
+  ValidatorListLayout,
+  ValidatorStakeInfoStatus,
+} from '../layouts'
+import { lamportsToSol } from './math'
+import { findStakeProgramAddress, findTransientStakeProgramAddress } from './program-address'
+
+export async function getValidatorListAccount(connection: Connection, pubkey: PublicKey) {
+  const account = await connection.getAccountInfo(pubkey)
+  if (!account) {
+    throw new Error('Invalid validator list account')
+  }
+
+  return {
+    pubkey,
+    account: {
+      data: ValidatorListLayout.decode(account?.data) as ValidatorList,
+      executable: account.executable,
+      lamports: account.lamports,
+      owner: account.owner,
+    },
+  }
+}
+
+export interface ValidatorAccount {
+  type: 'preferred' | 'active' | 'transient' | 'reserve'
+  voteAddress?: PublicKey | undefined
+  stakeAddress: PublicKey
+  lamports: BN
+}
+
+export async function prepareWithdrawAccounts(
+  connection: Connection,
+  stakePool: StakePool,
+  stakePoolAddress: PublicKey,
+  amount: BN,
+  compareFn?: (a: ValidatorAccount, b: ValidatorAccount) => number,
+  skipFee?: boolean,
+): Promise<WithdrawAccount[]> {
+  const stakePoolProgramId = getStakePoolProgramId(connection.rpcEndpoint)
+  const validatorListAcc = await connection.getAccountInfo(stakePool.validatorList)
+  const validatorList = ValidatorListLayout.decode(validatorListAcc?.data) as ValidatorList
+
+  if (!validatorList?.validators || validatorList?.validators.length == 0) {
+    throw new Error('No accounts found')
+  }
+
+  const minBalanceForRentExemption = await connection.getMinimumBalanceForRentExemption(
+    StakeProgram.space,
+  )
+  const minBalance = new BN(minBalanceForRentExemption + MINIMUM_ACTIVE_STAKE)
+
+  let accounts = [] as Array<{
+    type: 'preferred' | 'active' | 'transient' | 'reserve'
+    voteAddress?: PublicKey | undefined
+    stakeAddress: PublicKey
+    lamports: BN
+  }>
+
+  // Prepare accounts
+  for (const validator of validatorList.validators) {
+    if (validator.status !== ValidatorStakeInfoStatus.Active) {
+      continue
+    }
+
+    const stakeAccountAddress = await findStakeProgramAddress(
+      stakePoolProgramId,
+      validator.voteAccountAddress,
+      stakePoolAddress,
+    )
+
+    if (!validator.activeStakeLamports.isZero()) {
+      const isPreferred = stakePool?.preferredWithdrawValidatorVoteAddress?.equals(
+        validator.voteAccountAddress,
+      )
+      accounts.push({
+        type: isPreferred ? 'preferred' : 'active',
+        voteAddress: validator.voteAccountAddress,
+        stakeAddress: stakeAccountAddress,
+        lamports: validator.activeStakeLamports,
+      })
+    }
+
+    const transientStakeLamports = validator.transientStakeLamports.sub(minBalance)
+    if (transientStakeLamports.gt(new BN(0))) {
+      const transientStakeAccountAddress = await findTransientStakeProgramAddress(
+        stakePoolProgramId,
+        validator.voteAccountAddress,
+        stakePoolAddress,
+        validator.transientSeedSuffixStart,
+      )
+      accounts.push({
+        type: 'transient',
+        voteAddress: validator.voteAccountAddress,
+        stakeAddress: transientStakeAccountAddress,
+        lamports: transientStakeLamports,
+      })
+    }
+  }
+
+  // Sort from highest to lowest balance
+  accounts = accounts.sort(compareFn || ((a, b) => b.lamports.sub(a.lamports).toNumber()))
+
+  const reserveStake = await connection.getAccountInfo(stakePool.reserveStake)
+  const reserveStakeBalance = new BN((reserveStake?.lamports ?? 0) - minBalanceForRentExemption)
+  if (reserveStakeBalance.gt(new BN(0))) {
+    accounts.push({
+      type: 'reserve',
+      stakeAddress: stakePool.reserveStake,
+      lamports: reserveStakeBalance,
+    })
+  }
+
+  // Prepare the list of accounts to withdraw from
+  const withdrawFrom: WithdrawAccount[] = []
+  let remainingAmount = new BN(amount)
+
+  const fee = stakePool.stakeWithdrawalFee
+  const inverseFee: Fee = {
+    numerator: fee.denominator.sub(fee.numerator),
+    denominator: fee.denominator,
+  }
+
+  for (const type of ['preferred', 'active', 'transient', 'reserve']) {
+    const filteredAccounts = accounts.filter(a => a.type == type)
+
+    for (const { stakeAddress, voteAddress, lamports } of filteredAccounts) {
+      if (lamports.lte(minBalance) && type == 'transient') {
+        continue
+      }
+
+      let availableForWithdrawal = calcPoolTokensForDeposit(stakePool, lamports)
+
+      if (!skipFee && !inverseFee.numerator.isZero()) {
+        availableForWithdrawal = availableForWithdrawal
+          .mul(inverseFee.denominator)
+          .div(inverseFee.numerator)
+      }
+
+      const poolAmount = BN.min(availableForWithdrawal, remainingAmount)
+      if (poolAmount.lte(new BN(0))) {
+        continue
+      }
+
+      // Those accounts will be withdrawn completely with `claim` instruction
+      withdrawFrom.push({ stakeAddress, voteAddress, poolAmount })
+      remainingAmount = remainingAmount.sub(poolAmount)
+
+      if (remainingAmount.isZero()) {
+        break
+      }
+    }
+
+    if (remainingAmount.isZero()) {
+      break
+    }
+  }
+
+  // Not enough stake to withdraw the specified amount
+  if (remainingAmount.gt(new BN(0))) {
+    throw new Error(
+      `No stake accounts found in this pool with enough balance to withdraw ${lamportsToSol(
+        amount,
+      )} pool tokens.`,
+    )
+  }
+
+  return withdrawFrom
+}
+
+/**
+ * Calculate the pool tokens that should be minted for a deposit of `stakeLamports`
+ */
+export function calcPoolTokensForDeposit(stakePool: StakePool, stakeLamports: BN): BN {
+  if (stakePool.poolTokenSupply.isZero() || stakePool.totalLamports.isZero()) {
+    return stakeLamports
+  }
+  const numerator = stakeLamports.mul(stakePool.poolTokenSupply)
+  return numerator.div(stakePool.totalLamports)
+}
+
+/**
+ * Calculate lamports amount on withdrawal
+ */
+export function calcLamportsWithdrawAmount(stakePool: StakePool, poolTokens: BN): BN {
+  const numerator = poolTokens.mul(stakePool.totalLamports)
+  const denominator = stakePool.poolTokenSupply
+  if (numerator.lt(denominator)) {
+    return new BN(0)
+  }
+  return numerator.div(denominator)
+}
+
+export function newStakeAccount(
+  feePayer: PublicKey,
+  instructions: TransactionInstruction[],
+  lamports: number,
+): Keypair {
+  // Account for tokens not specified, creating one
+  const stakeReceiverKeypair = Keypair.generate()
+  console.log(`Creating account to receive stake ${stakeReceiverKeypair.publicKey}`)
+
+  instructions.push(
+    // Creating new account
+    SystemProgram.createAccount({
+      fromPubkey: feePayer,
+      newAccountPubkey: stakeReceiverKeypair.publicKey,
+      lamports,
+      space: StakeProgram.space,
+      programId: StakeProgram.programId,
+    }),
+  )
+
+  return stakeReceiverKeypair
+}