@ignitionfi/spl-stake-pool 1.1.24 → 1.1.25

package/dist/instructions.d.ts

@@ -4,7 +4,7 @@ import { InstructionType } from './utils';
 /**
  * An enumeration of valid StakePoolInstructionType's
  */
-export type StakePoolInstructionType = 'IncreaseValidatorStake' | 'DecreaseValidatorStake' | 'UpdateValidatorListBalance' | 'UpdateStakePoolBalance' | 'CleanupRemovedValidatorEntries' | 'DepositStake' | 'DepositSol' | 'WithdrawStake' | 'WithdrawSol' | 'IncreaseAdditionalValidatorStake' | 'DecreaseAdditionalValidatorStake' | 'DecreaseValidatorStakeWithReserve' | 'Redelegate' | 'AddValidatorToPool' | 'RemoveValidatorFromPool' | 'DepositWsolWithSession' | 'WithdrawWsolWithSession' | 'WithdrawStakeWithSession';
+export type StakePoolInstructionType = 'IncreaseValidatorStake' | 'DecreaseValidatorStake' | 'UpdateValidatorListBalance' | 'UpdateStakePoolBalance' | 'CleanupRemovedValidatorEntries' | 'DepositStake' | 'DepositSol' | 'WithdrawStake' | 'WithdrawSol' | 'IncreaseAdditionalValidatorStake' | 'DecreaseAdditionalValidatorStake' | 'DecreaseValidatorStakeWithReserve' | 'Redelegate' | 'AddValidatorToPool' | 'RemoveValidatorFromPool' | 'DepositWsolWithSession' | 'WithdrawWsolWithSession' | 'WithdrawStakeWithSession' | 'WithdrawFromStakeAccountWithSession';
 export declare function tokenMetadataLayout(instruction: number, nameLength: number, symbolLength: number, uriLength: number): {
     index: number;
     layout: BufferLayout.Structure<any>;
@@ -178,11 +178,26 @@ export type WithdrawStakeWithSessionParams = {
     tokenProgramId: PublicKey;
     /** The program signer PDA derived from PROGRAM_SIGNER_SEED */
     programSigner: PublicKey;
+    /** The payer for stake account rent (typically the paymaster) */
+    payer: PublicKey;
     poolTokensIn: number;
     minimumLamportsOut: number;
     /** Seed used to derive the user stake PDA */
     userStakeSeed: number;
 };
+export type WithdrawFromStakeAccountWithSessionParams = {
+    programId: PublicKey;
+    /** The user stake account PDA to withdraw from */
+    userStakeAccount: PublicKey;
+    /** The user's wallet to receive the withdrawn SOL */
+    userWallet: PublicKey;
+    /** The session signer (user or session) */
+    sessionSigner: PublicKey;
+    /** Seed used to derive the user stake PDA */
+    userStakeSeed: number;
+    /** Lamports to withdraw (use BigInt max for full withdrawal) */
+    lamports: bigint;
+};
 /**
  * Deposit SOL directly into the pool's reserve account. The output is a "pool" token
  * representing ownership into the pool. Inputs are converted to the current ratio.
@@ -329,9 +344,15 @@ export declare class StakePoolInstruction {
     static withdrawWsolWithSession(params: WithdrawWsolWithSessionParams): TransactionInstruction;
     /**
      * Creates a transaction instruction to withdraw stake from a stake pool using a Fogo session.
-     * The stake account is created as a PDA and rent is paid from the withdrawal amount.
+     * The stake account is created as a PDA and rent is paid by the payer (typically paymaster).
      */
     static withdrawStakeWithSession(params: WithdrawStakeWithSessionParams): TransactionInstruction;
+    /**
+     * Creates a transaction instruction to withdraw SOL from a deactivated user stake account using a Fogo session.
+     * The stake account must be fully deactivated (inactive).
+     * User receives full stake balance (payer's rent contribution compensates for reduced split).
+     */
+    static withdrawFromStakeAccountWithSession(params: WithdrawFromStakeAccountWithSessionParams): TransactionInstruction;
     /**
      * Creates an instruction to create metadata
      * using the mpl token metadata program for the pool token

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ignitionfi/spl-stake-pool",
-  "version": "1.1.24",
+  "version": "1.1.25",
   "description": "Ignition Stake Pool SDK for FOGO",
   "contributors": [
     "Anza Maintainers <maintainers@anza.xyz>",

package/src/constants.ts

@@ -11,9 +11,7 @@ export const METADATA_MAX_URI_LENGTH = 200
 export const STAKE_POOL_PROGRAM_ID = new PublicKey('SP1s4uFeTAX9jsXXmwyDs1gxYYf7cdDZ8qHUHVxE1yr')
 
 // Public key that identifies the SPL Stake Pool program deployed to devnet.
-export const DEVNET_STAKE_POOL_PROGRAM_ID = new PublicKey(
-  'DPoo15wWDqpPJJtS2MUZ49aRxqz5ZaaJCJP4z8bLuib',
-)
+export const DEVNET_STAKE_POOL_PROGRAM_ID = new PublicKey('DPoo15wWDqpPJJtS2MUZ49aRxqz5ZaaJCJP4z8bLuib')
 
 // Maximum number of validators to update during UpdateValidatorListBalance.
 export const MAX_VALIDATORS_TO_UPDATE = 4

package/src/index.ts

@@ -309,23 +309,30 @@ export async function depositWsolWithSession(
   referrerTokenAccount?: PublicKey,
   depositAuthority?: PublicKey,
   payer?: PublicKey,
+  /**
+   * Skip WSOL balance validation. Set to true when adding wrap instructions
+   * in the same transaction that will fund the WSOL account before deposit.
+   */
+  skipBalanceCheck: boolean = false,
 ) {
   const wsolTokenAccount = getAssociatedTokenAddressSync(NATIVE_MINT, userPubkey)
 
-  const tokenAccountInfo = await connection.getTokenAccountBalance(
-    wsolTokenAccount,
-    'confirmed',
-  )
-  const wsolBalance = tokenAccountInfo
-    ? parseInt(tokenAccountInfo.value.amount)
-    : 0
-
-  if (wsolBalance < lamports) {
-    throw new Error(
-      `Not enough WSOL to deposit into pool. Maximum deposit amount is ${lamportsToSol(
-        wsolBalance,
-      )} WSOL.`,
+  if (!skipBalanceCheck) {
+    const tokenAccountInfo = await connection.getTokenAccountBalance(
+      wsolTokenAccount,
+      'confirmed',
     )
+    const wsolBalance = tokenAccountInfo
+      ? parseInt(tokenAccountInfo.value.amount)
+      : 0
+
+    if (wsolBalance < lamports) {
+      throw new Error(
+        `Not enough WSOL to deposit into pool. Maximum deposit amount is ${lamportsToSol(
+          wsolBalance,
+        )} WSOL.`,
+      )
+    }
   }
 
   const stakePoolAccount = await getStakePoolAccount(connection, stakePoolAddress)
@@ -927,16 +934,113 @@ export async function findNextUserStakeSeed(
   throw new Error(`No available user stake seed found between ${startSeed} and ${startSeed + maxSeed - 1}`)
 }
 
+/**
+ * Represents a user stake account with its details
+ */
+export interface UserStakeAccount {
+  /** The stake account public key (PDA) */
+  pubkey: PublicKey
+  /** The seed used to derive this PDA */
+  seed: number
+  /** Lamports in the stake account */
+  lamports: number
+  /** Parsed stake state */
+  state: 'inactive' | 'activating' | 'active' | 'deactivating'
+  /** Validator vote account (if delegated) */
+  voter?: PublicKey
+  /** Activation epoch (if active/activating) */
+  activationEpoch?: number
+  /** Deactivation epoch (if deactivating) */
+  deactivationEpoch?: number
+}
+
+/**
+ * Fetches all user stake accounts created via WithdrawStakeWithSession.
+ * These are PDAs derived from [b"user_stake", user_wallet, seed].
+ *
+ * @param connection - Solana connection
+ * @param programId - The stake pool program ID
+ * @param userPubkey - User's wallet address
+ * @param maxSeed - Maximum seed to check (default: 100)
+ * @returns Array of user stake accounts with their details
+ */
+export async function getUserStakeAccounts(
+  connection: Connection,
+  programId: PublicKey,
+  userPubkey: PublicKey,
+  maxSeed: number = 100,
+): Promise<UserStakeAccount[]> {
+  const stakeAccounts: UserStakeAccount[] = []
+  const currentEpoch = (await connection.getEpochInfo()).epoch
+
+  for (let seed = 0; seed < maxSeed; seed++) {
+    const pda = findUserStakeProgramAddress(programId, userPubkey, seed)
+    const accountInfo = await connection.getAccountInfo(pda)
+
+    if (!accountInfo) {
+      continue // Skip empty slots, there might be gaps
+    }
+
+    // Check if owned by stake program
+    if (!accountInfo.owner.equals(StakeProgram.programId)) {
+      continue
+    }
+
+    // Parse stake account data
+    const stakeAccount: UserStakeAccount = {
+      pubkey: pda,
+      seed,
+      lamports: accountInfo.lamports,
+      state: 'inactive',
+    }
+
+    try {
+      // Parse the stake account to get delegation info
+      const parsedAccount = await connection.getParsedAccountInfo(pda)
+      if (parsedAccount.value && 'parsed' in parsedAccount.value.data) {
+        const parsed = parsedAccount.value.data.parsed
+        if (parsed.type === 'delegated' && parsed.info?.stake?.delegation) {
+          const delegation = parsed.info.stake.delegation
+          stakeAccount.voter = new PublicKey(delegation.voter)
+          stakeAccount.activationEpoch = Number(delegation.activationEpoch)
+          stakeAccount.deactivationEpoch = Number(delegation.deactivationEpoch)
+
+          // Determine state based on epochs
+          const activationEpoch = stakeAccount.activationEpoch
+          const deactivationEpoch = stakeAccount.deactivationEpoch
+
+          if (deactivationEpoch !== undefined && deactivationEpoch < Number.MAX_SAFE_INTEGER && deactivationEpoch <= currentEpoch) {
+            stakeAccount.state = 'inactive'
+          } else if (deactivationEpoch !== undefined && deactivationEpoch < Number.MAX_SAFE_INTEGER) {
+            stakeAccount.state = 'deactivating'
+          } else if (activationEpoch !== undefined && activationEpoch <= currentEpoch) {
+            stakeAccount.state = 'active'
+          } else {
+            stakeAccount.state = 'activating'
+          }
+        }
+      }
+    } catch {
+      // If parsing fails, keep default 'inactive' state
+    }
+
+    stakeAccounts.push(stakeAccount)
+  }
+
+  return stakeAccounts
+}
+
 /**
  * Withdraws stake from a stake pool using a Fogo session.
  *
- * The on-chain program creates stake account PDAs, so no pre-creation step is needed.
- * Rent for the stake account PDAs is paid from the withdrawal amount.
+ * The on-chain program creates stake account PDAs. The rent for these accounts
+ * is paid by the payer (typically the paymaster), not deducted from the user's withdrawal.
  *
  * @param connection - Solana connection
  * @param stakePoolAddress - The stake pool to withdraw from
  * @param signerOrSession - The session signer public key
  * @param userPubkey - User's wallet (used for PDA derivation and token ownership)
+ * @param payer - Payer for stake account rent (typically paymaster)
  * @param amount - Amount of pool tokens to withdraw
  * @param userStakeSeedStart - Starting seed for user stake PDA derivation (default: 0)
  * @param useReserve - Whether to withdraw from reserve (default: false)
@@ -949,6 +1053,7 @@ export async function withdrawStakeWithSession(
   stakePoolAddress: PublicKey,
   signerOrSession: PublicKey,
   userPubkey: PublicKey,
+  payer: PublicKey,
   amount: number,
   userStakeSeedStart: number = 0,
   useReserve = false,
@@ -1064,7 +1169,7 @@ export async function withdrawStakeWithSession(
     stakeAccountPubkeys.push(stakeReceiverPubkey)
     userStakeSeeds.push(userStakeSeed)
 
-    // The on-chain program will create the stake account PDA
+    // The on-chain program creates the stake account PDA and rent is paid by payer.
     instructions.push(
       StakePoolInstruction.withdrawStakeWithSession({
         programId: stakePoolProgramId,
@@ -1079,6 +1184,7 @@ export async function withdrawStakeWithSession(
         poolMint: stakePool.poolMint,
         tokenProgramId: stakePool.tokenProgramId,
         programSigner,
+        payer,
         poolTokensIn: withdrawAccount.poolAmount.toNumber(),
         minimumLamportsOut,
         userStakeSeed,

package/src/instructions.ts

@@ -42,6 +42,7 @@ export type StakePoolInstructionType
     | 'DepositWsolWithSession'
     | 'WithdrawWsolWithSession'
     | 'WithdrawStakeWithSession'
+    | 'WithdrawFromStakeAccountWithSession'
 
 // 'UpdateTokenMetadata' and 'CreateTokenMetadata' have dynamic layouts
 
@@ -237,6 +238,14 @@ export const STAKE_POOL_INSTRUCTION_LAYOUTS: {
       BufferLayout.ns64('userStakeSeed'),
     ]),
   },
+  WithdrawFromStakeAccountWithSession: {
+    index: 30,
+    layout: BufferLayout.struct<any>([
+      BufferLayout.u8('instruction'),
+      BufferLayout.ns64('lamports'),
+      BufferLayout.ns64('userStakeSeed'),
+    ]),
+  },
 })
 
 /**
@@ -417,12 +426,28 @@ export type WithdrawStakeWithSessionParams = {
   tokenProgramId: PublicKey
   /** The program signer PDA derived from PROGRAM_SIGNER_SEED */
   programSigner: PublicKey
+  /** The payer for stake account rent (typically the paymaster) */
+  payer: PublicKey
   poolTokensIn: number
   minimumLamportsOut: number
   /** Seed used to derive the user stake PDA */
   userStakeSeed: number
 }
 
+export type WithdrawFromStakeAccountWithSessionParams = {
+  programId: PublicKey
+  /** The user stake account PDA to withdraw from */
+  userStakeAccount: PublicKey
+  /** The user's wallet to receive the withdrawn SOL */
+  userWallet: PublicKey
+  /** The session signer (user or session) */
+  sessionSigner: PublicKey
+  /** Seed used to derive the user stake PDA */
+  userStakeSeed: number
+  /** Lamports to withdraw (use BigInt max for full withdrawal) */
+  lamports: bigint
+}
+
 /**
  * Deposit SOL directly into the pool's reserve account. The output is a "pool" token
  * representing ownership into the pool. Inputs are converted to the current ratio.
@@ -1197,7 +1222,7 @@ export class StakePoolInstruction {
 
   /**
    * Creates a transaction instruction to withdraw stake from a stake pool using a Fogo session.
-   * The stake account is created as a PDA and rent is paid from the withdrawal amount.
+   * The stake account is created as a PDA and rent is paid by the payer (typically paymaster).
    */
   static withdrawStakeWithSession(params: WithdrawStakeWithSessionParams): TransactionInstruction {
     const type = STAKE_POOL_INSTRUCTION_LAYOUTS.WithdrawStakeWithSession
@@ -1223,6 +1248,7 @@ export class StakePoolInstruction {
       { pubkey: StakeProgram.programId, isSigner: false, isWritable: false },
       { pubkey: params.programSigner, isSigner: false, isWritable: false },
       { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+      { pubkey: params.payer, isSigner: true, isWritable: true },
     ]
 
     return new TransactionInstruction({
@@ -1232,6 +1258,49 @@ export class StakePoolInstruction {
     })
   }
 
+  /**
+   * Creates a transaction instruction to withdraw SOL from a deactivated user stake account using a Fogo session.
+   * The stake account must be fully deactivated (inactive).
+   * User receives full stake balance (payer's rent contribution compensates for reduced split).
+   */
+  static withdrawFromStakeAccountWithSession(params: WithdrawFromStakeAccountWithSessionParams): TransactionInstruction {
+    // For u64::MAX (full withdrawal), we need to manually encode since buffer-layout doesn't handle bigint well
+    const U64_MAX = BigInt('18446744073709551615')
+    const isFullWithdrawal = params.lamports >= U64_MAX
+
+    // Manually create the instruction data buffer using Uint8Array for browser compatibility
+    // Layout: u8 instruction (1) + u64 lamports (8) + u64 userStakeSeed (8) = 17 bytes
+    const data = new Uint8Array(17)
+    data[0] = 30 // instruction discriminator (WithdrawFromStakeAccountWithSession = 30)
+
+    // Write lamports as u64 little-endian (bytes 1-8)
+    const lamportsBigInt = isFullWithdrawal ? U64_MAX : params.lamports
+    for (let i = 0; i < 8; i++) {
+      data[1 + i] = Number((lamportsBigInt >> BigInt(i * 8)) & BigInt(0xff))
+    }
+
+    // Write userStakeSeed as u64 little-endian (bytes 9-16)
+    const seedBigInt = BigInt(params.userStakeSeed)
+    for (let i = 0; i < 8; i++) {
+      data[9 + i] = Number((seedBigInt >> BigInt(i * 8)) & BigInt(0xff))
+    }
+
+    // Account order matches Rust: stake_account, recipient, clock, stake_history, session_signer
+    const keys = [
+      { pubkey: params.userStakeAccount, isSigner: false, isWritable: true },
+      { pubkey: params.userWallet, isSigner: false, isWritable: true },
+      { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
+      { pubkey: SYSVAR_STAKE_HISTORY_PUBKEY, isSigner: false, isWritable: false },
+      { pubkey: params.sessionSigner, isSigner: true, isWritable: false },
+    ]
+
+    return new TransactionInstruction({
+      programId: params.programId,
+      keys,
+      data: Buffer.from(data),
+    })
+  }
+
   /**
    * Creates an instruction to create metadata
    * using the mpl token metadata program for the pool token

package/src/utils/stake.ts

@@ -84,7 +84,10 @@ export async function prepareWithdrawAccounts(
       stakePoolAddress,
     )
 
-    if (!validator.activeStakeLamports.isZero()) {
+    // For active stake accounts, subtract the minimum balance that must remain
+    // to allow for merges and maintain rent exemption
+    const availableActiveLamports = validator.activeStakeLamports.sub(minBalance)
+    if (availableActiveLamports.gt(new BN(0))) {
       const isPreferred = stakePool?.preferredWithdrawValidatorVoteAddress?.equals(
         validator.voteAccountAddress,
       )
@@ -92,7 +95,7 @@ export async function prepareWithdrawAccounts(
         type: isPreferred ? 'preferred' : 'active',
         voteAddress: validator.voteAccountAddress,
         stakeAddress: stakeAccountAddress,
-        lamports: validator.activeStakeLamports,
+        lamports: availableActiveLamports,
       })
     }