@ignitionfi/fogo-stake-pool 1.0.1 → 1.0.3

package/dist/index.iife.js

@@ -19024,7 +19024,7 @@ var solanaStakePool = (function (exports, node_buffer) {
 	const USER_STAKE_SEED_PREFIX = node_buffer.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
-	const MINIMUM_ACTIVE_STAKE = LAMPORTS_PER_SOL;
+	const MINIMUM_ACTIVE_STAKE = 1000000;
 
 	/**
 	 * Populate a buffer of instruction data using an InstructionType
@@ -22008,80 +22008,84 @@ var solanaStakePool = (function (exports, node_buffer) {
 	        },
 	    };
 	}
-	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);
@@ -22090,23 +22094,24 @@ var solanaStakePool = (function (exports, node_buffer) {
 	        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()) {
@@ -22119,7 +22124,23 @@ var solanaStakePool = (function (exports, node_buffer) {
 	    }
 	    // 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;
 	}
@@ -22832,7 +22853,7 @@ var solanaStakePool = (function (exports, node_buffer) {
 	    }
 	    /**
 	     * 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;
@@ -22847,17 +22868,19 @@ var solanaStakePool = (function (exports, node_buffer) {
 	            { 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,
@@ -23597,37 +23620,51 @@ var solanaStakePool = (function (exports, node_buffer) {
 	 * 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,
@@ -23658,7 +23695,14 @@ var solanaStakePool = (function (exports, node_buffer) {
 	    }
 	    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 = [];
@@ -23675,7 +23719,7 @@ var solanaStakePool = (function (exports, node_buffer) {
 	        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,
@@ -23689,7 +23733,7 @@ var solanaStakePool = (function (exports, node_buffer) {
 	            poolMint: stakePool.poolMint,
 	            tokenProgramId: stakePool.tokenProgramId,
 	            programSigner,
-	            payer,
+	            reserveStake: stakePool.reserveStake,
 	            poolTokensIn: withdrawAccount.poolAmount.toNumber(),
 	            minimumLamportsOut,
 	            userStakeSeed,
@@ -23700,6 +23744,7 @@ var solanaStakePool = (function (exports, node_buffer) {
 	        instructions,
 	        stakeAccountPubkeys,
 	        userStakeSeeds,
+	        remainingPoolTokens: partialRemainingAmount ? lamportsToSol(partialRemainingAmount) : 0,
 	    };
 	}
 	async function addValidatorToPool(connection, stakePoolAddress, validatorVote, seed) {