@ignitionfi/spl-stake-pool 1.1.21 → 1.1.23

package/dist/instructions.d.ts

@@ -169,6 +169,7 @@ export type WithdrawStakeWithSessionParams = {
     validatorList: PublicKey;
     withdrawAuthority: PublicKey;
     stakeToSplit: PublicKey;
+    /** The stake account PDA that will receive the withdrawn stake (derived from user wallet + seed) */
     stakeToReceive: PublicKey;
     /** The session signer (user or session) - used as both stake authority and transfer authority */
     sessionSigner: PublicKey;
@@ -178,8 +179,12 @@ export type WithdrawStakeWithSessionParams = {
     tokenProgramId: PublicKey;
     /** The program signer PDA derived from PROGRAM_SIGNER_SEED */
     programSigner: PublicKey;
+    /** Payer for the stake account rent (paymaster payer) */
+    payer: PublicKey;
     poolTokensIn: number;
     minimumLamportsOut: number;
+    /** Seed used to derive the user stake PDA */
+    userStakeSeed: number;
 };
 /**
  * Deposit SOL directly into the pool's reserve account. The output is a "pool" token

package/dist/utils/program-address.d.ts

@@ -24,3 +24,8 @@ export declare function findEphemeralStakeProgramAddress(programId: PublicKey, s
  * Generates the metadata program address for the stake pool
  */
 export declare function findMetadataAddress(stakePoolMintAddress: PublicKey): 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 declare function findUserStakeProgramAddress(programId: PublicKey, userWallet: PublicKey, seed: BN | number): PublicKey;

package/package.json

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

package/src/constants.ts

@@ -24,6 +24,9 @@ export const EPHEMERAL_STAKE_SEED_PREFIX = Buffer.from('ephemeral')
 // Seed used to derive transient stake accounts.
 export const TRANSIENT_STAKE_SEED_PREFIX = Buffer.from('transient')
 
+// Seed for user stake account created during session withdrawal
+export const USER_STAKE_SEED_PREFIX = Buffer.from('user_stake')
+
 // Minimum amount of staked SOL required in a validator stake account to allow
 // for merges without a mismatch on credits observed
 export const MINIMUM_ACTIVE_STAKE = LAMPORTS_PER_SOL

package/src/index.ts

@@ -40,6 +40,7 @@ import {
   findMetadataAddress,
   findStakeProgramAddress,
   findTransientStakeProgramAddress,
+  findUserStakeProgramAddress,
   findWithdrawAuthorityProgramAddress,
   findWsolTransientProgramAddress,
   getValidatorListAccount,
@@ -66,6 +67,14 @@ export {
   ValidatorListLayout,
   ValidatorStakeInfoLayout,
 } from './layouts'
+export {
+  findUserStakeProgramAddress,
+  findWithdrawAuthorityProgramAddress,
+  findStakeProgramAddress,
+  findTransientStakeProgramAddress,
+  findEphemeralStakeProgramAddress,
+  findWsolTransientProgramAddress,
+} from './utils'
 
 export interface ValidatorListAccount {
   pubkey: PublicKey
@@ -891,19 +900,63 @@ export async function withdrawWsolWithSession(
 }
 
 /**
- * Creates instructions required to withdraw stake from a stake pool using a Fogo session.
- * The withdrawn stake account will be authorized to the user's wallet.
+ * Finds the next available seed for creating a user stake PDA.
+ * Scans from startSeed until an unused PDA is found.
+ *
+ * @param connection - Solana connection
+ * @param programId - The stake pool program ID
+ * @param userPubkey - User's wallet (used for PDA derivation)
+ * @param startSeed - Starting seed to search from (default: 0)
+ * @param maxSeed - Maximum seed to check before giving up (default: 1000)
+ * @returns The next available seed
+ * @throws Error if no available seed found within maxSeed
+ */
+export async function findNextUserStakeSeed(
+  connection: Connection,
+  programId: PublicKey,
+  userPubkey: PublicKey,
+  startSeed: number = 0,
+  maxSeed: number = 1000,
+): Promise<number> {
+  for (let seed = startSeed; seed < startSeed + maxSeed; seed++) {
+    const pda = findUserStakeProgramAddress(programId, userPubkey, seed)
+    const account = await connection.getAccountInfo(pda)
+    if (!account) {
+      return seed
+    }
+  }
+  throw new Error(`No available user stake seed found between ${startSeed} and ${startSeed + maxSeed - 1}`)
+}
+
+/**
+ * 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.
+ * The paymaster payer provides rent for the stake account PDAs.
+ *
+ * @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 (paymaster payer in session context)
+ * @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)
+ * @param voteAccountAddress - Optional specific validator to withdraw from
+ * @param minimumLamportsOut - Minimum lamports to receive (slippage protection)
+ * @param validatorComparator - Optional comparator for validator selection
  */
 export async function withdrawStakeWithSession(
   connection: Connection,
   stakePoolAddress: PublicKey,
   signerOrSession: PublicKey,
   userPubkey: PublicKey,
+  payer: PublicKey,
   amount: number,
+  userStakeSeedStart: number = 0,
   useReserve = false,
   voteAccountAddress?: PublicKey,
   minimumLamportsOut: number = 0,
-  payer?: PublicKey,
   validatorComparator?: (_a: ValidatorAccount, _b: ValidatorAccount) => number,
 ) {
   const stakePoolAccount = await getStakePoolAccount(connection, stakePoolAddress)
@@ -991,8 +1044,8 @@ export async function withdrawStakeWithSession(
   }
 
   const instructions: TransactionInstruction[] = []
-  const signers: Signer[] = []
   const stakeAccountPubkeys: PublicKey[] = []
+  const userStakeSeeds: number[] = []
 
   // Max 5 accounts to prevent an error: "Transaction too large"
   const maxWithdrawAccounts = 5
@@ -1003,23 +1056,18 @@ export async function withdrawStakeWithSession(
       break
     }
 
-    // Create a new stake account to receive the withdrawal
-    const stakeReceiver = Keypair.generate()
-    signers.push(stakeReceiver)
-    stakeAccountPubkeys.push(stakeReceiver.publicKey)
-
-    // Create the stake account that will receive the split stake
-    instructions.push(
-      SystemProgram.createAccount({
-        fromPubkey: payer ?? userPubkey,
-        newAccountPubkey: stakeReceiver.publicKey,
-        lamports: stakeAccountRentExemption,
-        space: StakeProgram.space,
-        programId: StakeProgram.programId,
-      }),
+    // Derive the stake account PDA for this withdrawal
+    const userStakeSeed = userStakeSeedStart + i
+    const stakeReceiverPubkey = findUserStakeProgramAddress(
+      stakePoolProgramId,
+      userPubkey,
+      userStakeSeed,
     )
 
-    // Add the withdraw stake with session instruction
+    stakeAccountPubkeys.push(stakeReceiverPubkey)
+    userStakeSeeds.push(userStakeSeed)
+
+    // The on-chain program will create the stake account PDA
     instructions.push(
       StakePoolInstruction.withdrawStakeWithSession({
         programId: stakePoolProgramId,
@@ -1027,15 +1075,17 @@ export async function withdrawStakeWithSession(
         validatorList: stakePool.validatorList,
         withdrawAuthority,
         stakeToSplit: withdrawAccount.stakeAddress,
-        stakeToReceive: stakeReceiver.publicKey,
+        stakeToReceive: stakeReceiverPubkey,
         sessionSigner: signerOrSession,
         burnFromPool: poolTokenAccount,
         managerFeeAccount: stakePool.managerFeeAccount,
         poolMint: stakePool.poolMint,
         tokenProgramId: stakePool.tokenProgramId,
         programSigner,
+        payer,
         poolTokensIn: withdrawAccount.poolAmount.toNumber(),
-        minimumLamportsOut: solToLamports(minimumLamportsOut),
+        minimumLamportsOut,
+        userStakeSeed,
       }),
     )
     i++
@@ -1043,8 +1093,8 @@ export async function withdrawStakeWithSession(
 
   return {
     instructions,
-    signers,
     stakeAccountPubkeys,
+    userStakeSeeds,
   }
 }
 

package/src/instructions.ts

@@ -234,6 +234,7 @@ export const STAKE_POOL_INSTRUCTION_LAYOUTS: {
       BufferLayout.u8('instruction'),
       BufferLayout.ns64('poolTokensIn'),
       BufferLayout.ns64('minimumLamportsOut'),
+      BufferLayout.ns64('userStakeSeed'),
     ]),
   },
 })
@@ -407,6 +408,7 @@ export type WithdrawStakeWithSessionParams = {
   validatorList: PublicKey
   withdrawAuthority: PublicKey
   stakeToSplit: PublicKey
+  /** The stake account PDA that will receive the withdrawn stake (derived from user wallet + seed) */
   stakeToReceive: PublicKey
   /** The session signer (user or session) - used as both stake authority and transfer authority */
   sessionSigner: PublicKey
@@ -416,8 +418,12 @@ export type WithdrawStakeWithSessionParams = {
   tokenProgramId: PublicKey
   /** The program signer PDA derived from PROGRAM_SIGNER_SEED */
   programSigner: PublicKey
+  /** Payer for the stake account rent (paymaster payer) */
+  payer: PublicKey
   poolTokensIn: number
   minimumLamportsOut: number
+  /** Seed used to derive the user stake PDA */
+  userStakeSeed: number
 }
 
 /**
@@ -1200,6 +1206,7 @@ export class StakePoolInstruction {
     const data = encodeData(type, {
       poolTokensIn: params.poolTokensIn,
       minimumLamportsOut: params.minimumLamportsOut,
+      userStakeSeed: params.userStakeSeed,
     })
 
     const keys = [
@@ -1217,6 +1224,8 @@ export class StakePoolInstruction {
       { pubkey: params.tokenProgramId, isSigner: false, isWritable: false },
       { pubkey: StakeProgram.programId, isSigner: false, isWritable: false },
       { pubkey: params.programSigner, isSigner: false, isWritable: false },
+      { pubkey: params.payer, isSigner: true, isWritable: true },
+      { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
     ]
 
     return new TransactionInstruction({

package/src/utils/program-address.ts

@@ -5,6 +5,7 @@ import {
   EPHEMERAL_STAKE_SEED_PREFIX,
   METADATA_PROGRAM_ID,
   TRANSIENT_STAKE_SEED_PREFIX,
+  USER_STAKE_SEED_PREFIX,
 } from '../constants'
 
 /**
@@ -101,3 +102,24 @@ export function findMetadataAddress(stakePoolMintAddress: PublicKey) {
   )
   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
+}