@ignitionfi/fogo-stake-pool 1.0.0

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,125 @@
+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,
+  USER_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
+}
+
+/**
+ * Generates the user stake account PDA for session-based withdrawals.
+ * The PDA is derived from the user's wallet and a unique seed.
+ */
+export function findUserStakeProgramAddress(
+  programId: PublicKey,
+  userWallet: PublicKey,
+  seed: BN | number,
+) {
+  const seedBN = typeof seed === 'number' ? new BN(seed) : seed
+  const [publicKey] = PublicKey.findProgramAddressSync(
+    [
+      USER_STAKE_SEED_PREFIX,
+      userWallet.toBuffer(),
+      seedBN.toArrayLike(Buffer, 'le', 8),
+    ],
+    programId,
+  )
+  return publicKey
+}