@ignitionfi/fogo-stake-pool 1.0.1 → 1.0.3

package/dist/index.d.ts

@@ -144,24 +144,25 @@ export declare function getUserStakeAccounts(connection: Connection, programId:
  * Withdraws stake from a stake pool using a Fogo session.
  *
  * 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.
+ * is funded from the reserve stake.
  *
  * @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)
  * @param voteAccountAddress - Optional specific validator to withdraw from
  * @param minimumLamportsOut - Minimum lamports to receive (slippage protection)
  * @param validatorComparator - Optional comparator for validator selection
+ * @param allowPartial - If true, returns partial results instead of throwing when not enough stake available
  */
-export declare function withdrawStakeWithSession(connection: Connection, stakePoolAddress: PublicKey, signerOrSession: PublicKey, userPubkey: PublicKey, payer: PublicKey, amount: number, userStakeSeedStart?: number, useReserve?: boolean, voteAccountAddress?: PublicKey, minimumLamportsOut?: number, validatorComparator?: (_a: ValidatorAccount, _b: ValidatorAccount) => number): Promise<{
+export declare function withdrawStakeWithSession(connection: Connection, stakePoolAddress: PublicKey, signerOrSession: PublicKey, userPubkey: PublicKey, amount: number, userStakeSeedStart?: number, useReserve?: boolean, voteAccountAddress?: PublicKey, minimumLamportsOut?: number, validatorComparator?: (_a: ValidatorAccount, _b: ValidatorAccount) => number, allowPartial?: boolean): Promise<{
     instructions: TransactionInstruction[];
     stakeAccountPubkeys: PublicKey[];
     userStakeSeeds: number[];
+    remainingPoolTokens: number;
 }>;
 export declare function addValidatorToPool(connection: Connection, stakePoolAddress: PublicKey, validatorVote: PublicKey, seed?: number): Promise<{
     instructions: TransactionInstruction[];

package/dist/index.esm.js

@@ -436,7 +436,7 @@ const TRANSIENT_STAKE_SEED_PREFIX = Buffer$1.from('transient');
 const USER_STAKE_SEED_PREFIX = Buffer$1.from('user_stake');
 // Minimum amount of staked SOL required in a validator stake account to allow
 // for merges without a mismatch on credits observed
-const MINIMUM_ACTIVE_STAKE = LAMPORTS_PER_SOL;
+const MINIMUM_ACTIVE_STAKE = 1000000;
 
 /**
  * Populate a buffer of instruction data using an InstructionType
@@ -806,80 +806,84 @@ async function getValidatorListAccount(connection, pubkey) {
         },
     };
 }
-async function prepareWithdrawAccounts(connection, stakePool, stakePoolAddress, amount, compareFn, skipFee) {
+async function prepareWithdrawAccounts(connection, stakePool, stakePoolAddress, amount, compareFn, skipFee, allowPartial, prefetchedData) {
     var _a, _b;
     const stakePoolProgramId = getStakePoolProgramId(connection.rpcEndpoint);
-    const validatorListAcc = await connection.getAccountInfo(stakePool.validatorList);
-    const validatorList = ValidatorListLayout.decode(validatorListAcc === null || validatorListAcc === void 0 ? void 0 : validatorListAcc.data);
-    if (!(validatorList === null || validatorList === void 0 ? void 0 : validatorList.validators) || (validatorList === null || validatorList === void 0 ? void 0 : validatorList.validators.length) === 0) {
-        throw new Error('No accounts found');
+    // Use prefetched data if available, otherwise fetch from RPC
+    let validatorListData;
+    let minBalanceForRentExemption;
+    let stakeMinimumDelegation;
+    if (prefetchedData) {
+        validatorListData = prefetchedData.validatorListData;
+        minBalanceForRentExemption = prefetchedData.minBalanceForRentExemption;
+        stakeMinimumDelegation = prefetchedData.stakeMinimumDelegation;
     }
-    const minBalanceForRentExemption = await connection.getMinimumBalanceForRentExemption(StakeProgram.space);
-    const minBalance = new BN(minBalanceForRentExemption + MINIMUM_ACTIVE_STAKE);
-    // First, collect all stake account addresses we need to check
-    const accountsToFetch = [];
+    else {
+        const [validatorListAcc, rentExemption, stakeMinimumDelegationResponse] = await Promise.all([
+            connection.getAccountInfo(stakePool.validatorList),
+            connection.getMinimumBalanceForRentExemption(StakeProgram.space),
+            connection.getStakeMinimumDelegation(),
+        ]);
+        validatorListData = (_a = validatorListAcc === null || validatorListAcc === void 0 ? void 0 : validatorListAcc.data) !== null && _a !== void 0 ? _a : null;
+        minBalanceForRentExemption = rentExemption;
+        stakeMinimumDelegation = Number(stakeMinimumDelegationResponse.value);
+    }
+    if (!validatorListData) {
+        throw new Error('No staked funds available for delayed unstake. Use instant unstake instead.');
+    }
+    const validatorList = ValidatorListLayout.decode(validatorListData);
+    if (!(validatorList === null || validatorList === void 0 ? void 0 : validatorList.validators) || (validatorList === null || validatorList === void 0 ? void 0 : validatorList.validators.length) === 0) {
+        throw new Error('No staked funds available for delayed unstake. Use instant unstake instead.');
+    }
+    // minBalance = rent + max(stake_minimum_delegation, MINIMUM_ACTIVE_STAKE)
+    const minimumDelegation = Math.max(stakeMinimumDelegation, MINIMUM_ACTIVE_STAKE);
+    const minBalance = new BN(minBalanceForRentExemption + minimumDelegation);
+    // Threshold for has_active_stake check (ceiling division for lamports_per_pool_token)
+    const lamportsPerPoolToken = stakePool.totalLamports
+        .add(stakePool.poolTokenSupply)
+        .sub(new BN(1))
+        .div(stakePool.poolTokenSupply);
+    const minimumLamportsWithTolerance = minBalance.add(lamportsPerPoolToken);
+    const hasActiveStake = validatorList.validators.some(v => v.status === ValidatorStakeInfoStatus.Active
+        && v.activeStakeLamports.gt(minimumLamportsWithTolerance));
+    const hasTransientStake = validatorList.validators.some(v => v.status === ValidatorStakeInfoStatus.Active
+        && v.transientStakeLamports.gt(minimumLamportsWithTolerance));
+    // ValidatorRemoval mode: no validator above threshold
+    const isValidatorRemovalMode = !hasActiveStake && !hasTransientStake;
+    let accounts = [];
     for (const validator of validatorList.validators) {
         if (validator.status !== ValidatorStakeInfoStatus.Active) {
             continue;
         }
         const stakeAccountAddress = await findStakeProgramAddress(stakePoolProgramId, validator.voteAccountAddress, stakePoolAddress);
-        const isPreferred = (_a = stakePool === null || stakePool === void 0 ? void 0 : stakePool.preferredWithdrawValidatorVoteAddress) === null || _a === void 0 ? void 0 : _a.equals(validator.voteAccountAddress);
-        // Add active stake account if validator list indicates it has stake
-        if (validator.activeStakeLamports.gt(new BN(0))) {
-            accountsToFetch.push({
+        // ValidatorRemoval: full balance available; Normal: leave minBalance
+        const availableActiveLamports = isValidatorRemovalMode
+            ? validator.activeStakeLamports
+            : validator.activeStakeLamports.sub(minBalance);
+        if (availableActiveLamports.gt(new BN(0))) {
+            const isPreferred = (_b = stakePool === null || stakePool === void 0 ? void 0 : stakePool.preferredWithdrawValidatorVoteAddress) === null || _b === void 0 ? void 0 : _b.equals(validator.voteAccountAddress);
+            accounts.push({
                 type: isPreferred ? 'preferred' : 'active',
                 voteAddress: validator.voteAccountAddress,
                 stakeAddress: stakeAccountAddress,
+                lamports: availableActiveLamports,
             });
         }
-        // Add transient stake account if validator list indicates it has stake
-        if (validator.transientStakeLamports.gt(new BN(0))) {
+        const availableTransientLamports = isValidatorRemovalMode
+            ? validator.transientStakeLamports
+            : validator.transientStakeLamports.sub(minBalance);
+        if (availableTransientLamports.gt(new BN(0))) {
             const transientStakeAccountAddress = await findTransientStakeProgramAddress(stakePoolProgramId, validator.voteAccountAddress, stakePoolAddress, validator.transientSeedSuffixStart);
-            accountsToFetch.push({
+            accounts.push({
                 type: 'transient',
                 voteAddress: validator.voteAccountAddress,
                 stakeAddress: transientStakeAccountAddress,
-            });
-        }
-    }
-    // Fetch all stake accounts + reserve in one batch call
-    const addressesToFetch = [
-        ...accountsToFetch.map(a => a.stakeAddress),
-        stakePool.reserveStake,
-    ];
-    const accountInfos = await connection.getMultipleAccountsInfo(addressesToFetch);
-    // Build accounts list using actual on-chain balances
-    let accounts = [];
-    for (let i = 0; i < accountsToFetch.length; i++) {
-        const { type, voteAddress, stakeAddress } = accountsToFetch[i];
-        const accountInfo = accountInfos[i];
-        if (!accountInfo) {
-            continue;
-        }
-        // Use actual on-chain balance instead of validator list value
-        const actualLamports = new BN(accountInfo.lamports);
-        const availableLamports = actualLamports.sub(minBalance);
-        if (availableLamports.gt(new BN(0))) {
-            accounts.push({
-                type,
-                voteAddress,
-                stakeAddress,
-                lamports: availableLamports,
+                lamports: availableTransientLamports,
             });
         }
     }
     // Sort from highest to lowest balance
     accounts = accounts.sort(compareFn || ((a, b) => b.lamports.sub(a.lamports).toNumber()));
-    // Add reserve stake using actual balance (last item in batch fetch)
-    const reserveAccountInfo = accountInfos[accountInfos.length - 1];
-    const reserveStakeBalance = new BN(((_b = reserveAccountInfo === null || reserveAccountInfo === void 0 ? void 0 : reserveAccountInfo.lamports) !== null && _b !== void 0 ? _b : 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 = [];
     let remainingAmount = new BN(amount);
@@ -888,23 +892,24 @@ async function prepareWithdrawAccounts(connection, stakePool, stakePoolAddress,
         numerator: fee.denominator.sub(fee.numerator),
         denominator: fee.denominator,
     };
-    for (const type of ['preferred', 'active', 'transient', 'reserve']) {
+    for (const type of ['preferred', 'active', 'transient']) {
         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);
             }
+            // In ValidatorRemoval mode, must withdraw full validator balance (no partial)
+            // Skip if remaining amount is less than full validator balance
+            if (isValidatorRemovalMode && remainingAmount.lt(availableForWithdrawal)) {
+                continue;
+            }
             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()) {
@@ -917,7 +922,23 @@ async function prepareWithdrawAccounts(connection, stakePool, stakePoolAddress,
     }
     // 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.`);
+        if (allowPartial) {
+            const delayedAmount = amount.sub(remainingAmount);
+            return {
+                withdrawAccounts: withdrawFrom,
+                delayedAmount,
+                remainingAmount,
+            };
+        }
+        const availableAmount = amount.sub(remainingAmount);
+        throw new Error(`Not enough staked funds for delayed unstake. Requested ${lamportsToSol(amount)} iFOGO, but only ${lamportsToSol(availableAmount)} available. Use instant unstake for the remaining amount.`);
+    }
+    if (allowPartial) {
+        return {
+            withdrawAccounts: withdrawFrom,
+            delayedAmount: amount,
+            remainingAmount: new BN(0),
+        };
     }
     return withdrawFrom;
 }
@@ -1630,7 +1651,7 @@ 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 by the payer (typically paymaster).
+     * The stake account is created as a PDA and rent is funded from the reserve.
      */
     static withdrawStakeWithSession(params) {
         const type = STAKE_POOL_INSTRUCTION_LAYOUTS.WithdrawStakeWithSession;
@@ -1645,17 +1666,19 @@ class StakePoolInstruction {
             { pubkey: params.withdrawAuthority, isSigner: false, isWritable: false },
             { pubkey: params.stakeToSplit, isSigner: false, isWritable: true },
             { pubkey: params.stakeToReceive, isSigner: false, isWritable: true },
-            { pubkey: params.sessionSigner, isSigner: true, isWritable: false }, // user_stake_authority_info (signer_or_session)
-            { pubkey: params.sessionSigner, isSigner: false, isWritable: false }, // user_transfer_authority_info (not used in session path)
+            { pubkey: params.sessionSigner, isSigner: true, isWritable: false }, // user_stake_authority_info
+            { pubkey: params.sessionSigner, isSigner: false, isWritable: false }, // user_transfer_authority_info (unused in session path)
             { pubkey: params.burnFromPool, isSigner: false, isWritable: true },
             { pubkey: params.managerFeeAccount, isSigner: false, isWritable: true },
             { pubkey: params.poolMint, isSigner: false, isWritable: true },
             { pubkey: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
             { pubkey: params.tokenProgramId, isSigner: false, isWritable: false },
             { pubkey: StakeProgram.programId, isSigner: false, isWritable: false },
+            // Session-specific accounts
             { pubkey: params.programSigner, isSigner: false, isWritable: false },
             { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
-            { pubkey: params.payer, isSigner: true, isWritable: true },
+            { pubkey: params.reserveStake, isSigner: false, isWritable: true },
+            { pubkey: SYSVAR_STAKE_HISTORY_PUBKEY, isSigner: false, isWritable: false },
         ];
         return new TransactionInstruction({
             programId: params.programId,
@@ -2395,37 +2418,51 @@ async function getUserStakeAccounts(connection, programId, userPubkey, maxSeed =
  * Withdraws stake from a stake pool using a Fogo session.
  *
  * 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.
+ * is funded from the reserve stake.
  *
  * @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)
  * @param voteAccountAddress - Optional specific validator to withdraw from
  * @param minimumLamportsOut - Minimum lamports to receive (slippage protection)
  * @param validatorComparator - Optional comparator for validator selection
+ * @param allowPartial - If true, returns partial results instead of throwing when not enough stake available
  */
-async function withdrawStakeWithSession(connection, stakePoolAddress, signerOrSession, userPubkey, payer, amount, userStakeSeedStart = 0, useReserve = false, voteAccountAddress, minimumLamportsOut = 0, validatorComparator) {
-    const stakePoolAccount = await getStakePoolAccount(connection, stakePoolAddress);
+async function withdrawStakeWithSession(connection, stakePoolAddress, signerOrSession, userPubkey, amount, userStakeSeedStart = 0, useReserve = false, voteAccountAddress, minimumLamportsOut = 0, validatorComparator, allowPartial = false) {
+    var _c;
     const stakePoolProgramId = getStakePoolProgramId(connection.rpcEndpoint);
+    // First fetch: get stake pool to know other account addresses
+    const stakePoolAccount = await getStakePoolAccount(connection, stakePoolAddress);
     const stakePool = stakePoolAccount.account.data;
     const poolTokens = solToLamports(amount);
     const poolAmount = new BN(poolTokens);
     const poolTokenAccount = getAssociatedTokenAddressSync(stakePool.poolMint, userPubkey);
-    const tokenAccount = await getAccount(connection, poolTokenAccount);
+    // Second fetch: get ALL remaining data in parallel
+    const [tokenAccount, stakeAccountRentExemption, validatorListAcc, stakeMinimumDelegationResponse] = await Promise.all([
+        getAccount(connection, poolTokenAccount),
+        connection.getMinimumBalanceForRentExemption(StakeProgram.space),
+        connection.getAccountInfo(stakePool.validatorList),
+        connection.getStakeMinimumDelegation(),
+    ]);
+    // Pre-fetch data to avoid duplicate RPC calls in prepareWithdrawAccounts
+    const prefetchedData = {
+        validatorListData: (_c = validatorListAcc === null || validatorListAcc === void 0 ? void 0 : validatorListAcc.data) !== null && _c !== void 0 ? _c : null,
+        minBalanceForRentExemption: stakeAccountRentExemption,
+        stakeMinimumDelegation: Number(stakeMinimumDelegationResponse.value),
+    };
     if (tokenAccount.amount < poolTokens) {
         throw new Error(`Not enough token balance to withdraw ${amount} pool tokens.
           Maximum withdraw amount is ${lamportsToSol(tokenAccount.amount)} pool tokens.`);
     }
     const [programSigner] = PublicKey.findProgramAddressSync([Buffer.from('fogo_session_program_signer')], stakePoolProgramId);
     const withdrawAuthority = await findWithdrawAuthorityProgramAddress(stakePoolProgramId, stakePoolAddress);
-    const stakeAccountRentExemption = await connection.getMinimumBalanceForRentExemption(StakeProgram.space);
     // Determine which stake accounts to withdraw from
     const withdrawAccounts = [];
+    let partialRemainingAmount;
     if (useReserve) {
         withdrawAccounts.push({
             stakeAddress: stakePool.reserveStake,
@@ -2456,7 +2493,14 @@ async function withdrawStakeWithSession(connection, stakePoolAddress, signerOrSe
     }
     else {
         // Get the list of accounts to withdraw from automatically
-        withdrawAccounts.push(...(await prepareWithdrawAccounts(connection, stakePool, stakePoolAddress, poolAmount, validatorComparator, poolTokenAccount.equals(stakePool.managerFeeAccount))));
+        if (allowPartial) {
+            const result = await prepareWithdrawAccounts(connection, stakePool, stakePoolAddress, poolAmount, validatorComparator, poolTokenAccount.equals(stakePool.managerFeeAccount), true, prefetchedData);
+            withdrawAccounts.push(...result.withdrawAccounts);
+            partialRemainingAmount = result.remainingAmount;
+        }
+        else {
+            withdrawAccounts.push(...(await prepareWithdrawAccounts(connection, stakePool, stakePoolAddress, poolAmount, validatorComparator, poolTokenAccount.equals(stakePool.managerFeeAccount), undefined, prefetchedData)));
+        }
     }
     const instructions = [];
     const stakeAccountPubkeys = [];
@@ -2473,7 +2517,7 @@ async function withdrawStakeWithSession(connection, stakePoolAddress, signerOrSe
         const stakeReceiverPubkey = findUserStakeProgramAddress(stakePoolProgramId, userPubkey, userStakeSeed);
         stakeAccountPubkeys.push(stakeReceiverPubkey);
         userStakeSeeds.push(userStakeSeed);
-        // The on-chain program creates the stake account PDA and rent is paid by payer.
+        // The on-chain program creates the stake account PDA and rent is funded from reserve.
         instructions.push(StakePoolInstruction.withdrawStakeWithSession({
             programId: stakePoolProgramId,
             stakePool: stakePoolAddress,
@@ -2487,7 +2531,7 @@ async function withdrawStakeWithSession(connection, stakePoolAddress, signerOrSe
             poolMint: stakePool.poolMint,
             tokenProgramId: stakePool.tokenProgramId,
             programSigner,
-            payer,
+            reserveStake: stakePool.reserveStake,
             poolTokensIn: withdrawAccount.poolAmount.toNumber(),
             minimumLamportsOut,
             userStakeSeed,
@@ -2498,6 +2542,7 @@ async function withdrawStakeWithSession(connection, stakePoolAddress, signerOrSe
         instructions,
         stakeAccountPubkeys,
         userStakeSeeds,
+        remainingPoolTokens: partialRemainingAmount ? lamportsToSol(partialRemainingAmount) : 0,
     };
 }
 async function addValidatorToPool(connection, stakePoolAddress, validatorVote, seed) {