@ignitionfi/fogo-stake-pool 1.0.2 → 1.1.0

package/dist/index.iife.js

@@ -19026,124 +19026,6 @@ var solanaStakePool = (function (exports, node_buffer) {
 	// for merges without a mismatch on credits observed
 	const MINIMUM_ACTIVE_STAKE = 1000000;
 
-	/**
-	 * Populate a buffer of instruction data using an InstructionType
-	 * @internal
-	 */
-	function encodeData(type, fields) {
-	    const allocLength = type.layout.span;
-	    const data = node_buffer.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
-	 */
-	function decodeData(type, buffer) {
-	    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;
-	}
-
-	function solToLamports(amount) {
-	    if (isNaN(amount)) {
-	        return Number(0);
-	    }
-	    return Number(amount * LAMPORTS_PER_SOL);
-	}
-	function lamportsToSol(lamports) {
-	    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);
-	}
-
-	/**
-	 * Generates the wSOL transient program address for the stake pool
-	 */
-	function findWsolTransientProgramAddress(programId, userPubkey) {
-	    const [publicKey] = PublicKey.findProgramAddressSync([node_buffer.Buffer.from('transient_wsol'), userPubkey.toBuffer()], programId);
-	    return publicKey;
-	}
-	/**
-	 * Generates the withdraw authority program address for the stake pool
-	 */
-	async function findWithdrawAuthorityProgramAddress(programId, stakePoolAddress) {
-	    const [publicKey] = PublicKey.findProgramAddressSync([stakePoolAddress.toBuffer(), node_buffer.Buffer.from('withdraw')], programId);
-	    return publicKey;
-	}
-	/**
-	 * Generates the stake program address for a validator's vote account
-	 */
-	async function findStakeProgramAddress(programId, voteAccountAddress, stakePoolAddress, seed) {
-	    const [publicKey] = PublicKey.findProgramAddressSync([
-	        voteAccountAddress.toBuffer(),
-	        stakePoolAddress.toBuffer(),
-	        seed ? new BN(seed).toArrayLike(node_buffer.Buffer, 'le', 4) : node_buffer.Buffer.alloc(0),
-	    ], programId);
-	    return publicKey;
-	}
-	/**
-	 * Generates the stake program address for a validator's vote account
-	 */
-	async function findTransientStakeProgramAddress(programId, voteAccountAddress, stakePoolAddress, seed) {
-	    const [publicKey] = PublicKey.findProgramAddressSync([
-	        TRANSIENT_STAKE_SEED_PREFIX,
-	        voteAccountAddress.toBuffer(),
-	        stakePoolAddress.toBuffer(),
-	        seed.toArrayLike(node_buffer.Buffer, 'le', 8),
-	    ], programId);
-	    return publicKey;
-	}
-	/**
-	 * Generates the ephemeral program address for stake pool redelegation
-	 */
-	async function findEphemeralStakeProgramAddress(programId, stakePoolAddress, seed) {
-	    const [publicKey] = PublicKey.findProgramAddressSync([EPHEMERAL_STAKE_SEED_PREFIX, stakePoolAddress.toBuffer(), seed.toArrayLike(node_buffer.Buffer, 'le', 8)], programId);
-	    return publicKey;
-	}
-	/**
-	 * Generates the metadata program address for the stake pool
-	 */
-	function findMetadataAddress(stakePoolMintAddress) {
-	    const [publicKey] = PublicKey.findProgramAddressSync([node_buffer.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.
-	 */
-	function findUserStakeProgramAddress(programId, userWallet, seed) {
-	    const seedBN = typeof seed === 'number' ? new BN(seed) : seed;
-	    const [publicKey] = PublicKey.findProgramAddressSync([
-	        USER_STAKE_SEED_PREFIX,
-	        userWallet.toBuffer(),
-	        seedBN.toArrayLike(node_buffer.Buffer, 'le', 8),
-	    ], programId);
-	    return publicKey;
-	}
-
 	var Layout = {};
 
 	/* The MIT License (MIT)
@@ -21758,14 +21640,18 @@ var solanaStakePool = (function (exports, node_buffer) {
 
 	var LayoutExports = /*@__PURE__*/ requireLayout();
 
-	class BNLayout extends LayoutExports.Layout {
+	/**
+	 * BN-based layout for data decoding using buffer-layout.
+	 * Used for decoding on-chain account data (StakePool, ValidatorList, etc.)
+	 */
+	class BNDataLayout extends LayoutExports.Layout {
 	    constructor(span, signed, property) {
 	        super(span, property);
-	        this.blob = LayoutExports.blob(span);
+	        this.blobLayout = LayoutExports.blob(span);
 	        this.signed = signed;
 	    }
 	    decode(b, offset = 0) {
-	        const num = new BN(this.blob.decode(b, offset), 10, 'le');
+	        const num = new BN(this.blobLayout.decode(b, offset), 10, 'le');
 	        if (this.signed) {
 	            return num.fromTwos(this.span * 8).clone();
 	        }
@@ -21775,11 +21661,51 @@ var solanaStakePool = (function (exports, node_buffer) {
 	        if (this.signed) {
 	            src = src.toTwos(this.span * 8);
 	        }
-	        return this.blob.encode(src.toArrayLike(Buffer, 'le', this.span), b, offset);
+	        return this.blobLayout.encode(src.toArrayLike(Buffer, 'le', this.span), b, offset);
 	    }
 	}
+	/**
+	 * Creates a u64 layout for data decoding (account layouts).
+	 * Used in StakePoolLayout, ValidatorListLayout, etc.
+	 */
 	function u64(property) {
-	    return new BNLayout(8, false, property);
+	    return new BNDataLayout(8, false, property);
+	}
+	/**
+	 * BN-based layout for 64-bit unsigned integers using @solana/buffer-layout.
+	 * Used for encoding instruction data with support for values > MAX_SAFE_INTEGER.
+	 */
+	class BNInstructionLayout extends LayoutExports$1.Layout {
+	    constructor(span, signed, property) {
+	        super(span, property);
+	        this.blobLayout = LayoutExports$1.blob(span);
+	        this.signed = signed;
+	    }
+	    decode(b, offset = 0) {
+	        const num = new BN(this.blobLayout.decode(b, offset), 10, 'le');
+	        if (this.signed) {
+	            return num.fromTwos(this.span * 8).clone();
+	        }
+	        return num;
+	    }
+	    encode(src, b, offset = 0) {
+	        if (this.signed) {
+	            src = src.toTwos(this.span * 8);
+	        }
+	        return this.blobLayout.encode(src.toArrayLike(Buffer, 'le', this.span), b, offset);
+	    }
+	    getSpan(_b, _offset) {
+	        return this.span;
+	    }
+	}
+	/**
+	 * Creates a u64 layout for instruction encoding.
+	 * Properly handles BN values larger than Number.MAX_SAFE_INTEGER.
+	 * Compatible with @solana/buffer-layout.struct().
+	 */
+	// eslint-disable-next-line ts/no-explicit-any
+	function u64Instruction(property) {
+	    return new BNInstructionLayout(8, false, property);
 	}
 	class WrappedLayout extends LayoutExports.Layout {
 	    constructor(layout, decoder, encoder, property) {
@@ -21847,6 +21773,124 @@ var solanaStakePool = (function (exports, node_buffer) {
 	    return new WrappedLayout(layout, ({ values }) => values, values => ({ values }), property);
 	}
 
+	/**
+	 * Populate a buffer of instruction data using an InstructionType
+	 * @internal
+	 */
+	function encodeData(type, fields) {
+	    const allocLength = type.layout.span;
+	    const data = node_buffer.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
+	 */
+	function decodeData(type, buffer) {
+	    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;
+	}
+
+	function solToLamports(amount) {
+	    if (isNaN(amount)) {
+	        return Number(0);
+	    }
+	    return Number(amount * LAMPORTS_PER_SOL);
+	}
+	function lamportsToSol(lamports) {
+	    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);
+	}
+
+	/**
+	 * Generates the wSOL transient program address for the stake pool
+	 */
+	function findWsolTransientProgramAddress(programId, userPubkey) {
+	    const [publicKey] = PublicKey.findProgramAddressSync([node_buffer.Buffer.from('transient_wsol'), userPubkey.toBuffer()], programId);
+	    return publicKey;
+	}
+	/**
+	 * Generates the withdraw authority program address for the stake pool
+	 */
+	async function findWithdrawAuthorityProgramAddress(programId, stakePoolAddress) {
+	    const [publicKey] = PublicKey.findProgramAddressSync([stakePoolAddress.toBuffer(), node_buffer.Buffer.from('withdraw')], programId);
+	    return publicKey;
+	}
+	/**
+	 * Generates the stake program address for a validator's vote account
+	 */
+	async function findStakeProgramAddress(programId, voteAccountAddress, stakePoolAddress, seed) {
+	    const [publicKey] = PublicKey.findProgramAddressSync([
+	        voteAccountAddress.toBuffer(),
+	        stakePoolAddress.toBuffer(),
+	        seed ? new BN(seed).toArrayLike(node_buffer.Buffer, 'le', 4) : node_buffer.Buffer.alloc(0),
+	    ], programId);
+	    return publicKey;
+	}
+	/**
+	 * Generates the stake program address for a validator's vote account
+	 */
+	async function findTransientStakeProgramAddress(programId, voteAccountAddress, stakePoolAddress, seed) {
+	    const [publicKey] = PublicKey.findProgramAddressSync([
+	        TRANSIENT_STAKE_SEED_PREFIX,
+	        voteAccountAddress.toBuffer(),
+	        stakePoolAddress.toBuffer(),
+	        seed.toArrayLike(node_buffer.Buffer, 'le', 8),
+	    ], programId);
+	    return publicKey;
+	}
+	/**
+	 * Generates the ephemeral program address for stake pool redelegation
+	 */
+	async function findEphemeralStakeProgramAddress(programId, stakePoolAddress, seed) {
+	    const [publicKey] = PublicKey.findProgramAddressSync([EPHEMERAL_STAKE_SEED_PREFIX, stakePoolAddress.toBuffer(), seed.toArrayLike(node_buffer.Buffer, 'le', 8)], programId);
+	    return publicKey;
+	}
+	/**
+	 * Generates the metadata program address for the stake pool
+	 */
+	function findMetadataAddress(stakePoolMintAddress) {
+	    const [publicKey] = PublicKey.findProgramAddressSync([node_buffer.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.
+	 */
+	function findUserStakeProgramAddress(programId, userWallet, seed) {
+	    const seedBN = typeof seed === 'number' ? new BN(seed) : seed;
+	    const [publicKey] = PublicKey.findProgramAddressSync([
+	        USER_STAKE_SEED_PREFIX,
+	        userWallet.toBuffer(),
+	        seedBN.toArrayLike(node_buffer.Buffer, 'le', 8),
+	    ], programId);
+	    return publicKey;
+	}
+
 	const feeFields = [u64('denominator'), u64('numerator')];
 	var AccountType;
 	(function (AccountType) {
@@ -22008,80 +22052,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 +22138,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 +22168,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;
 	}
@@ -22168,11 +22233,50 @@ var solanaStakePool = (function (exports, node_buffer) {
 	    return result;
 	}
 
+	/**
+	 * Converts various numeric types to BN for safe large number handling.
+	 * @internal
+	 */
+	function toBN(value) {
+	    if (BN.isBN(value)) {
+	        return value;
+	    }
+	    if (typeof value === 'bigint') {
+	        return new BN(value.toString());
+	    }
+	    if (typeof value === 'string') {
+	        // Validate string is a valid non-negative integer
+	        const trimmed = value.trim();
+	        if (!/^\d+$/.test(trimmed)) {
+	            throw new Error(`Invalid amount string: "${value}". Must be a non-negative integer.`);
+	        }
+	        return new BN(trimmed);
+	    }
+	    if (typeof value === 'number') {
+	        if (!Number.isFinite(value)) {
+	            throw new Error('Invalid amount: must be a finite number');
+	        }
+	        if (value < 0) {
+	            throw new Error('Invalid amount: must be non-negative');
+	        }
+	        if (!Number.isInteger(value)) {
+	            throw new Error('Invalid amount: must be an integer (lamports)');
+	        }
+	        // CRITICAL: Numbers > MAX_SAFE_INTEGER have already lost precision
+	        // We throw an error instead of silently corrupting data
+	        if (value > Number.MAX_SAFE_INTEGER) {
+	            throw new Error(`Amount ${value} exceeds Number.MAX_SAFE_INTEGER (9,007,199,254,740,991). ` +
+	                `Use BigInt or BN for large values to avoid precision loss.`);
+	        }
+	        return new BN(value);
+	    }
+	    throw new Error(`Invalid amount type: ${typeof value}`);
+	}
 	// 'UpdateTokenMetadata' and 'CreateTokenMetadata' have dynamic layouts
 	const MOVE_STAKE_LAYOUT = LayoutExports$1.struct([
 	    LayoutExports$1.u8('instruction'),
-	    LayoutExports$1.ns64('lamports'),
-	    LayoutExports$1.ns64('transientStakeSeed'),
+	    u64Instruction('lamports'),
+	    u64Instruction('transientStakeSeed'),
 	]);
 	const UPDATE_VALIDATOR_LIST_BALANCE_LAYOUT = LayoutExports$1.struct([
 	    LayoutExports$1.u8('instruction'),
@@ -22247,7 +22351,7 @@ var solanaStakePool = (function (exports, node_buffer) {
 	        index: 10,
 	        layout: LayoutExports$1.struct([
 	            LayoutExports$1.u8('instruction'),
-	            LayoutExports$1.ns64('poolTokens'),
+	            u64Instruction('poolTokens'),
 	        ]),
 	    },
 	    /// Deposit SOL directly into the pool's reserve account. The output is a "pool" token
@@ -22256,7 +22360,7 @@ var solanaStakePool = (function (exports, node_buffer) {
 	        index: 14,
 	        layout: LayoutExports$1.struct([
 	            LayoutExports$1.u8('instruction'),
-	            LayoutExports$1.ns64('lamports'),
+	            u64Instruction('lamports'),
 	        ]),
 	    },
 	    /// Withdraw SOL directly from the pool's reserve account. Fails if the
@@ -22265,25 +22369,25 @@ var solanaStakePool = (function (exports, node_buffer) {
 	        index: 16,
 	        layout: LayoutExports$1.struct([
 	            LayoutExports$1.u8('instruction'),
-	            LayoutExports$1.ns64('poolTokens'),
+	            u64Instruction('poolTokens'),
 	        ]),
 	    },
 	    IncreaseAdditionalValidatorStake: {
 	        index: 19,
 	        layout: LayoutExports$1.struct([
 	            LayoutExports$1.u8('instruction'),
-	            LayoutExports$1.ns64('lamports'),
-	            LayoutExports$1.ns64('transientStakeSeed'),
-	            LayoutExports$1.ns64('ephemeralStakeSeed'),
+	            u64Instruction('lamports'),
+	            u64Instruction('transientStakeSeed'),
+	            u64Instruction('ephemeralStakeSeed'),
 	        ]),
 	    },
 	    DecreaseAdditionalValidatorStake: {
 	        index: 20,
 	        layout: LayoutExports$1.struct([
 	            LayoutExports$1.u8('instruction'),
-	            LayoutExports$1.ns64('lamports'),
-	            LayoutExports$1.ns64('transientStakeSeed'),
-	            LayoutExports$1.ns64('ephemeralStakeSeed'),
+	            u64Instruction('lamports'),
+	            u64Instruction('transientStakeSeed'),
+	            u64Instruction('ephemeralStakeSeed'),
 	        ]),
 	    },
 	    DecreaseValidatorStakeWithReserve: {
@@ -22298,62 +22402,62 @@ var solanaStakePool = (function (exports, node_buffer) {
 	        index: 23,
 	        layout: LayoutExports$1.struct([
 	            LayoutExports$1.u8('instruction'),
-	            LayoutExports$1.ns64('lamports'),
+	            u64Instruction('lamports'),
 	        ]),
 	    },
 	    WithdrawStakeWithSlippage: {
 	        index: 24,
 	        layout: LayoutExports$1.struct([
 	            LayoutExports$1.u8('instruction'),
-	            LayoutExports$1.ns64('poolTokensIn'),
-	            LayoutExports$1.ns64('minimumLamportsOut'),
+	            u64Instruction('poolTokensIn'),
+	            u64Instruction('minimumLamportsOut'),
 	        ]),
 	    },
 	    DepositSolWithSlippage: {
 	        index: 25,
 	        layout: LayoutExports$1.struct([
 	            LayoutExports$1.u8('instruction'),
-	            LayoutExports$1.ns64('lamports'),
+	            u64Instruction('lamports'),
 	        ]),
 	    },
 	    WithdrawSolWithSlippage: {
 	        index: 26,
 	        layout: LayoutExports$1.struct([
 	            LayoutExports$1.u8('instruction'),
-	            LayoutExports$1.ns64('lamports'),
+	            u64Instruction('lamports'),
 	        ]),
 	    },
 	    DepositWsolWithSession: {
 	        index: 27,
 	        layout: LayoutExports$1.struct([
 	            LayoutExports$1.u8('instruction'),
-	            LayoutExports$1.ns64('lamportsIn'),
-	            LayoutExports$1.ns64('minimumPoolTokensOut'),
+	            u64Instruction('lamportsIn'),
+	            u64Instruction('minimumPoolTokensOut'),
 	        ]),
 	    },
 	    WithdrawWsolWithSession: {
 	        index: 28,
 	        layout: LayoutExports$1.struct([
 	            LayoutExports$1.u8('instruction'),
-	            LayoutExports$1.ns64('poolTokensIn'),
-	            LayoutExports$1.ns64('minimumLamportsOut'),
+	            u64Instruction('poolTokensIn'),
+	            u64Instruction('minimumLamportsOut'),
 	        ]),
 	    },
 	    WithdrawStakeWithSession: {
 	        index: 29,
 	        layout: LayoutExports$1.struct([
 	            LayoutExports$1.u8('instruction'),
-	            LayoutExports$1.ns64('poolTokensIn'),
-	            LayoutExports$1.ns64('minimumLamportsOut'),
-	            LayoutExports$1.ns64('userStakeSeed'),
+	            u64Instruction('poolTokensIn'),
+	            u64Instruction('minimumLamportsOut'),
+	            u64Instruction('userStakeSeed'),
 	        ]),
 	    },
 	    WithdrawFromStakeAccountWithSession: {
 	        index: 30,
 	        layout: LayoutExports$1.struct([
 	            LayoutExports$1.u8('instruction'),
-	            LayoutExports$1.ns64('lamports'),
-	            LayoutExports$1.ns64('userStakeSeed'),
+	            u64Instruction('lamports'),
+	            u64Instruction('userStakeSeed'),
 	        ]),
 	    },
 	});
@@ -22485,7 +22589,10 @@ var solanaStakePool = (function (exports, node_buffer) {
 	    static increaseValidatorStake(params) {
 	        const { programId, stakePool, staker, withdrawAuthority, validatorList, reserveStake, transientStake, validatorStake, validatorVote, lamports, transientStakeSeed, } = params;
 	        const type = STAKE_POOL_INSTRUCTION_LAYOUTS.IncreaseValidatorStake;
-	        const data = encodeData(type, { lamports, transientStakeSeed });
+	        const data = encodeData(type, {
+	            lamports: toBN(lamports),
+	            transientStakeSeed: toBN(transientStakeSeed),
+	        });
 	        const keys = [
 	            { pubkey: stakePool, isSigner: false, isWritable: false },
 	            { pubkey: staker, isSigner: true, isWritable: false },
@@ -22515,7 +22622,11 @@ var solanaStakePool = (function (exports, node_buffer) {
 	    static increaseAdditionalValidatorStake(params) {
 	        const { programId, stakePool, staker, withdrawAuthority, validatorList, reserveStake, transientStake, validatorStake, validatorVote, lamports, transientStakeSeed, ephemeralStake, ephemeralStakeSeed, } = params;
 	        const type = STAKE_POOL_INSTRUCTION_LAYOUTS.IncreaseAdditionalValidatorStake;
-	        const data = encodeData(type, { lamports, transientStakeSeed, ephemeralStakeSeed });
+	        const data = encodeData(type, {
+	            lamports: toBN(lamports),
+	            transientStakeSeed: toBN(transientStakeSeed),
+	            ephemeralStakeSeed: toBN(ephemeralStakeSeed),
+	        });
 	        const keys = [
 	            { pubkey: stakePool, isSigner: false, isWritable: false },
 	            { pubkey: staker, isSigner: true, isWritable: false },
@@ -22545,7 +22656,10 @@ var solanaStakePool = (function (exports, node_buffer) {
 	    static decreaseValidatorStake(params) {
 	        const { programId, stakePool, staker, withdrawAuthority, validatorList, validatorStake, transientStake, lamports, transientStakeSeed, } = params;
 	        const type = STAKE_POOL_INSTRUCTION_LAYOUTS.DecreaseValidatorStake;
-	        const data = encodeData(type, { lamports, transientStakeSeed });
+	        const data = encodeData(type, {
+	            lamports: toBN(lamports),
+	            transientStakeSeed: toBN(transientStakeSeed),
+	        });
 	        const keys = [
 	            { pubkey: stakePool, isSigner: false, isWritable: false },
 	            { pubkey: staker, isSigner: true, isWritable: false },
@@ -22571,7 +22685,10 @@ var solanaStakePool = (function (exports, node_buffer) {
 	    static decreaseValidatorStakeWithReserve(params) {
 	        const { programId, stakePool, staker, withdrawAuthority, validatorList, reserveStake, validatorStake, transientStake, lamports, transientStakeSeed, } = params;
 	        const type = STAKE_POOL_INSTRUCTION_LAYOUTS.DecreaseValidatorStakeWithReserve;
-	        const data = encodeData(type, { lamports, transientStakeSeed });
+	        const data = encodeData(type, {
+	            lamports: toBN(lamports),
+	            transientStakeSeed: toBN(transientStakeSeed),
+	        });
 	        const keys = [
 	            { pubkey: stakePool, isSigner: false, isWritable: false },
 	            { pubkey: staker, isSigner: true, isWritable: false },
@@ -22598,7 +22715,11 @@ var solanaStakePool = (function (exports, node_buffer) {
 	    static decreaseAdditionalValidatorStake(params) {
 	        const { programId, stakePool, staker, withdrawAuthority, validatorList, reserveStake, validatorStake, transientStake, lamports, transientStakeSeed, ephemeralStakeSeed, ephemeralStake, } = params;
 	        const type = STAKE_POOL_INSTRUCTION_LAYOUTS.DecreaseAdditionalValidatorStake;
-	        const data = encodeData(type, { lamports, transientStakeSeed, ephemeralStakeSeed });
+	        const data = encodeData(type, {
+	            lamports: toBN(lamports),
+	            transientStakeSeed: toBN(transientStakeSeed),
+	            ephemeralStakeSeed: toBN(ephemeralStakeSeed),
+	        });
 	        const keys = [
 	            { pubkey: stakePool, isSigner: false, isWritable: false },
 	            { pubkey: staker, isSigner: true, isWritable: false },
@@ -22655,7 +22776,7 @@ var solanaStakePool = (function (exports, node_buffer) {
 	    static depositSol(params) {
 	        const { programId, stakePool, withdrawAuthority, depositAuthority, reserveStake, fundingAccount, destinationPoolAccount, managerFeeAccount, referralPoolAccount, poolMint, lamports, } = params;
 	        const type = STAKE_POOL_INSTRUCTION_LAYOUTS.DepositSol;
-	        const data = encodeData(type, { lamports });
+	        const data = encodeData(type, { lamports: toBN(lamports) });
 	        const keys = [
 	            { pubkey: stakePool, isSigner: false, isWritable: true },
 	            { pubkey: withdrawAuthority, isSigner: false, isWritable: false },
@@ -22688,8 +22809,8 @@ var solanaStakePool = (function (exports, node_buffer) {
 	        var _a;
 	        const type = STAKE_POOL_INSTRUCTION_LAYOUTS.DepositWsolWithSession;
 	        const data = encodeData(type, {
-	            lamportsIn: params.lamportsIn,
-	            minimumPoolTokensOut: params.minimumPoolTokensOut,
+	            lamportsIn: toBN(params.lamportsIn),
+	            minimumPoolTokensOut: toBN(params.minimumPoolTokensOut),
 	        });
 	        const keys = [
 	            { pubkey: params.stakePool, isSigner: false, isWritable: true },
@@ -22731,7 +22852,7 @@ var solanaStakePool = (function (exports, node_buffer) {
 	    static withdrawStake(params) {
 	        const { programId, stakePool, validatorList, withdrawAuthority, validatorStake, destinationStake, destinationStakeAuthority, sourceTransferAuthority, sourcePoolAccount, managerFeeAccount, poolMint, poolTokens, } = params;
 	        const type = STAKE_POOL_INSTRUCTION_LAYOUTS.WithdrawStake;
-	        const data = encodeData(type, { poolTokens });
+	        const data = encodeData(type, { poolTokens: toBN(poolTokens) });
 	        const keys = [
 	            { pubkey: stakePool, isSigner: false, isWritable: true },
 	            { pubkey: validatorList, isSigner: false, isWritable: true },
@@ -22759,7 +22880,7 @@ var solanaStakePool = (function (exports, node_buffer) {
 	    static withdrawSol(params) {
 	        const { programId, stakePool, withdrawAuthority, sourceTransferAuthority, sourcePoolAccount, reserveStake, destinationSystemAccount, managerFeeAccount, solWithdrawAuthority, poolMint, poolTokens, } = params;
 	        const type = STAKE_POOL_INSTRUCTION_LAYOUTS.WithdrawSol;
-	        const data = encodeData(type, { poolTokens });
+	        const data = encodeData(type, { poolTokens: toBN(poolTokens) });
 	        const keys = [
 	            { pubkey: stakePool, isSigner: false, isWritable: true },
 	            { pubkey: withdrawAuthority, isSigner: false, isWritable: false },
@@ -22794,8 +22915,8 @@ var solanaStakePool = (function (exports, node_buffer) {
 	    static withdrawWsolWithSession(params) {
 	        const type = STAKE_POOL_INSTRUCTION_LAYOUTS.WithdrawWsolWithSession;
 	        const data = encodeData(type, {
-	            poolTokensIn: params.poolTokensIn,
-	            minimumLamportsOut: params.minimumLamportsOut,
+	            poolTokensIn: toBN(params.poolTokensIn),
+	            minimumLamportsOut: toBN(params.minimumLamportsOut),
 	        });
 	        const keys = [
 	            { pubkey: params.stakePool, isSigner: false, isWritable: true },
@@ -22832,14 +22953,14 @@ 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;
 	        const data = encodeData(type, {
-	            poolTokensIn: params.poolTokensIn,
-	            minimumLamportsOut: params.minimumLamportsOut,
-	            userStakeSeed: params.userStakeSeed,
+	            poolTokensIn: toBN(params.poolTokensIn),
+	            minimumLamportsOut: toBN(params.minimumLamportsOut),
+	            userStakeSeed: toBN(params.userStakeSeed),
 	        });
 	        const keys = [
 	            { pubkey: params.stakePool, isSigner: false, isWritable: true },
@@ -22847,17 +22968,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,
@@ -22872,8 +22995,8 @@ var solanaStakePool = (function (exports, node_buffer) {
 	    static withdrawFromStakeAccountWithSession(params) {
 	        const type = STAKE_POOL_INSTRUCTION_LAYOUTS.WithdrawFromStakeAccountWithSession;
 	        const data = encodeData(type, {
-	            lamports: params.lamports,
-	            userStakeSeed: params.userStakeSeed,
+	            lamports: toBN(params.lamports),
+	            userStakeSeed: toBN(params.userStakeSeed),
 	        });
 	        const keys = [
 	            { pubkey: params.userStakeAccount, isSigner: false, isWritable: true },
@@ -23162,10 +23285,18 @@ var solanaStakePool = (function (exports, node_buffer) {
 	    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.`);
+	            ? BigInt(tokenAccountInfo.value.amount)
+	            : BigInt(0);
+	        // Convert lamports to BigInt for comparison
+	        const lamportsBigInt = typeof lamports === 'bigint'
+	            ? lamports
+	            : typeof lamports === 'string'
+	                ? BigInt(lamports)
+	                : BN.isBN(lamports)
+	                    ? BigInt(lamports.toString())
+	                    : BigInt(lamports);
+	        if (wsolBalance < lamportsBigInt) {
+	            throw new Error(`Not enough WSOL to deposit into pool. Maximum deposit amount is ${lamportsToSol(Number(wsolBalance))} WSOL.`);
 	        }
 	    }
 	    const stakePoolAccount = await getStakePoolAccount(connection, stakePoolAddress);
@@ -23211,7 +23342,15 @@ var solanaStakePool = (function (exports, node_buffer) {
 	 */
 	async function depositSol(connection, stakePoolAddress, from, lamports, destinationTokenAccount, referrerTokenAccount, depositAuthority) {
 	    const fromBalance = await connection.getBalance(from, 'confirmed');
-	    if (fromBalance < lamports) {
+	    // Convert lamports to BigInt for comparison
+	    const lamportsBigInt = typeof lamports === 'bigint'
+	        ? lamports
+	        : typeof lamports === 'string'
+	            ? BigInt(lamports)
+	            : BN.isBN(lamports)
+	                ? BigInt(lamports.toString())
+	                : BigInt(lamports);
+	    if (BigInt(fromBalance) < lamportsBigInt) {
 	        throw new Error(`Not enough SOL to deposit into pool. Maximum deposit amount is ${lamportsToSol(fromBalance)} SOL.`);
 	    }
 	    const stakePoolAccount = await getStakePoolAccount(connection, stakePoolAddress);
@@ -23225,7 +23364,7 @@ var solanaStakePool = (function (exports, node_buffer) {
 	    instructions.push(SystemProgram.transfer({
 	        fromPubkey: from,
 	        toPubkey: userSolTransfer.publicKey,
-	        lamports,
+	        lamports: lamportsBigInt,
 	    }));
 	    // Create token account if not specified
 	    if (!destinationTokenAccount) {
@@ -23597,37 +23736,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 +23811,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 +23835,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 +23849,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 +23860,7 @@ var solanaStakePool = (function (exports, node_buffer) {
 	        instructions,
 	        stakeAccountPubkeys,
 	        userStakeSeeds,
+	        remainingPoolTokens: partialRemainingAmount ? lamportsToSol(partialRemainingAmount) : 0,
 	    };
 	}
 	async function addValidatorToPool(connection, stakePoolAddress, validatorVote, seed) {