@ignitionfi/fogo-stake-pool 1.0.2 → 1.1.0

package/dist/index.browser.esm.js

@@ -438,6 +438,139 @@ const USER_STAKE_SEED_PREFIX = Buffer$1.from('user_stake');
 // for merges without a mismatch on credits observed
 const MINIMUM_ACTIVE_STAKE = 1000000;
 
+/**
+ * BN-based layout for data decoding using buffer-layout.
+ * Used for decoding on-chain account data (StakePool, ValidatorList, etc.)
+ */
+class BNDataLayout extends Layout {
+    constructor(span, signed, property) {
+        super(span, property);
+        this.blobLayout = 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);
+    }
+}
+/**
+ * Creates a u64 layout for data decoding (account layouts).
+ * Used in StakePoolLayout, ValidatorListLayout, etc.
+ */
+function u64(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 BufferLayout.Layout {
+    constructor(span, signed, property) {
+        super(span, property);
+        this.blobLayout = BufferLayout.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 Layout {
+    constructor(layout, decoder, encoder, property) {
+        super(layout.span, property);
+        this.layout = layout;
+        this.decoder = decoder;
+        this.encoder = encoder;
+    }
+    decode(b, offset) {
+        return this.decoder(this.layout.decode(b, offset));
+    }
+    encode(src, b, offset) {
+        return this.layout.encode(this.encoder(src), b, offset);
+    }
+    getSpan(b, offset) {
+        return this.layout.getSpan(b, offset);
+    }
+}
+function publicKey(property) {
+    return new WrappedLayout(blob(32), (b) => new PublicKey(b), (key) => key.toBuffer(), property);
+}
+class OptionLayout extends Layout {
+    constructor(layout, property) {
+        super(-1, property);
+        this.layout = layout;
+        this.discriminator = u8();
+    }
+    encode(src, b, offset = 0) {
+        if (src === null || src === undefined) {
+            return this.discriminator.encode(0, b, offset);
+        }
+        this.discriminator.encode(1, b, offset);
+        return this.layout.encode(src, b, offset + 1) + 1;
+    }
+    decode(b, offset = 0) {
+        const discriminator = this.discriminator.decode(b, offset);
+        if (discriminator === 0) {
+            return null;
+        }
+        else if (discriminator === 1) {
+            return this.layout.decode(b, offset + 1);
+        }
+        throw new Error(`Invalid option ${this.property}`);
+    }
+    getSpan(b, offset = 0) {
+        const discriminator = this.discriminator.decode(b, offset);
+        if (discriminator === 0) {
+            return 1;
+        }
+        else if (discriminator === 1) {
+            return this.layout.getSpan(b, offset + 1) + 1;
+        }
+        throw new Error(`Invalid option ${this.property}`);
+    }
+}
+function option(layout, property) {
+    return new OptionLayout(layout, property);
+}
+function vec(elementLayout, property) {
+    const length = u32('length');
+    const layout = struct([
+        length,
+        seq(elementLayout, offset(length, -length.span), 'values'),
+    ]);
+    return new WrappedLayout(layout, ({ values }) => values, values => ({ values }), property);
+}
+
 /**
  * Populate a buffer of instruction data using an InstructionType
  * @internal
@@ -556,95 +689,6 @@ function findUserStakeProgramAddress(programId, userWallet, seed) {
     return publicKey;
 }
 
-class BNLayout extends Layout {
-    constructor(span, signed, property) {
-        super(span, property);
-        this.blob = blob(span);
-        this.signed = signed;
-    }
-    decode(b, offset = 0) {
-        const num = new BN(this.blob.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.blob.encode(src.toArrayLike(Buffer, 'le', this.span), b, offset);
-    }
-}
-function u64(property) {
-    return new BNLayout(8, false, property);
-}
-class WrappedLayout extends Layout {
-    constructor(layout, decoder, encoder, property) {
-        super(layout.span, property);
-        this.layout = layout;
-        this.decoder = decoder;
-        this.encoder = encoder;
-    }
-    decode(b, offset) {
-        return this.decoder(this.layout.decode(b, offset));
-    }
-    encode(src, b, offset) {
-        return this.layout.encode(this.encoder(src), b, offset);
-    }
-    getSpan(b, offset) {
-        return this.layout.getSpan(b, offset);
-    }
-}
-function publicKey(property) {
-    return new WrappedLayout(blob(32), (b) => new PublicKey(b), (key) => key.toBuffer(), property);
-}
-class OptionLayout extends Layout {
-    constructor(layout, property) {
-        super(-1, property);
-        this.layout = layout;
-        this.discriminator = u8();
-    }
-    encode(src, b, offset = 0) {
-        if (src === null || src === undefined) {
-            return this.discriminator.encode(0, b, offset);
-        }
-        this.discriminator.encode(1, b, offset);
-        return this.layout.encode(src, b, offset + 1) + 1;
-    }
-    decode(b, offset = 0) {
-        const discriminator = this.discriminator.decode(b, offset);
-        if (discriminator === 0) {
-            return null;
-        }
-        else if (discriminator === 1) {
-            return this.layout.decode(b, offset + 1);
-        }
-        throw new Error(`Invalid option ${this.property}`);
-    }
-    getSpan(b, offset = 0) {
-        const discriminator = this.discriminator.decode(b, offset);
-        if (discriminator === 0) {
-            return 1;
-        }
-        else if (discriminator === 1) {
-            return this.layout.getSpan(b, offset + 1) + 1;
-        }
-        throw new Error(`Invalid option ${this.property}`);
-    }
-}
-function option(layout, property) {
-    return new OptionLayout(layout, property);
-}
-function vec(elementLayout, property) {
-    const length = u32('length');
-    const layout = struct([
-        length,
-        seq(elementLayout, offset(length, -length.span), 'values'),
-    ]);
-    return new WrappedLayout(layout, ({ values }) => values, values => ({ values }), property);
-}
-
 const feeFields = [u64('denominator'), u64('numerator')];
 var AccountType;
 (function (AccountType) {
@@ -806,80 +850,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 +936,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 +966,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;
 }
@@ -966,11 +1031,50 @@ function arrayChunk(array, size) {
     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 = BufferLayout.struct([
     BufferLayout.u8('instruction'),
-    BufferLayout.ns64('lamports'),
-    BufferLayout.ns64('transientStakeSeed'),
+    u64Instruction('lamports'),
+    u64Instruction('transientStakeSeed'),
 ]);
 const UPDATE_VALIDATOR_LIST_BALANCE_LAYOUT = BufferLayout.struct([
     BufferLayout.u8('instruction'),
@@ -1045,7 +1149,7 @@ const STAKE_POOL_INSTRUCTION_LAYOUTS = Object.freeze({
         index: 10,
         layout: BufferLayout.struct([
             BufferLayout.u8('instruction'),
-            BufferLayout.ns64('poolTokens'),
+            u64Instruction('poolTokens'),
         ]),
     },
     /// Deposit SOL directly into the pool's reserve account. The output is a "pool" token
@@ -1054,7 +1158,7 @@ const STAKE_POOL_INSTRUCTION_LAYOUTS = Object.freeze({
         index: 14,
         layout: BufferLayout.struct([
             BufferLayout.u8('instruction'),
-            BufferLayout.ns64('lamports'),
+            u64Instruction('lamports'),
         ]),
     },
     /// Withdraw SOL directly from the pool's reserve account. Fails if the
@@ -1063,25 +1167,25 @@ const STAKE_POOL_INSTRUCTION_LAYOUTS = Object.freeze({
         index: 16,
         layout: BufferLayout.struct([
             BufferLayout.u8('instruction'),
-            BufferLayout.ns64('poolTokens'),
+            u64Instruction('poolTokens'),
         ]),
     },
     IncreaseAdditionalValidatorStake: {
         index: 19,
         layout: BufferLayout.struct([
             BufferLayout.u8('instruction'),
-            BufferLayout.ns64('lamports'),
-            BufferLayout.ns64('transientStakeSeed'),
-            BufferLayout.ns64('ephemeralStakeSeed'),
+            u64Instruction('lamports'),
+            u64Instruction('transientStakeSeed'),
+            u64Instruction('ephemeralStakeSeed'),
         ]),
     },
     DecreaseAdditionalValidatorStake: {
         index: 20,
         layout: BufferLayout.struct([
             BufferLayout.u8('instruction'),
-            BufferLayout.ns64('lamports'),
-            BufferLayout.ns64('transientStakeSeed'),
-            BufferLayout.ns64('ephemeralStakeSeed'),
+            u64Instruction('lamports'),
+            u64Instruction('transientStakeSeed'),
+            u64Instruction('ephemeralStakeSeed'),
         ]),
     },
     DecreaseValidatorStakeWithReserve: {
@@ -1096,62 +1200,62 @@ const STAKE_POOL_INSTRUCTION_LAYOUTS = Object.freeze({
         index: 23,
         layout: BufferLayout.struct([
             BufferLayout.u8('instruction'),
-            BufferLayout.ns64('lamports'),
+            u64Instruction('lamports'),
         ]),
     },
     WithdrawStakeWithSlippage: {
         index: 24,
         layout: BufferLayout.struct([
             BufferLayout.u8('instruction'),
-            BufferLayout.ns64('poolTokensIn'),
-            BufferLayout.ns64('minimumLamportsOut'),
+            u64Instruction('poolTokensIn'),
+            u64Instruction('minimumLamportsOut'),
         ]),
     },
     DepositSolWithSlippage: {
         index: 25,
         layout: BufferLayout.struct([
             BufferLayout.u8('instruction'),
-            BufferLayout.ns64('lamports'),
+            u64Instruction('lamports'),
         ]),
     },
     WithdrawSolWithSlippage: {
         index: 26,
         layout: BufferLayout.struct([
             BufferLayout.u8('instruction'),
-            BufferLayout.ns64('lamports'),
+            u64Instruction('lamports'),
         ]),
     },
     DepositWsolWithSession: {
         index: 27,
         layout: BufferLayout.struct([
             BufferLayout.u8('instruction'),
-            BufferLayout.ns64('lamportsIn'),
-            BufferLayout.ns64('minimumPoolTokensOut'),
+            u64Instruction('lamportsIn'),
+            u64Instruction('minimumPoolTokensOut'),
         ]),
     },
     WithdrawWsolWithSession: {
         index: 28,
         layout: BufferLayout.struct([
             BufferLayout.u8('instruction'),
-            BufferLayout.ns64('poolTokensIn'),
-            BufferLayout.ns64('minimumLamportsOut'),
+            u64Instruction('poolTokensIn'),
+            u64Instruction('minimumLamportsOut'),
         ]),
     },
     WithdrawStakeWithSession: {
         index: 29,
         layout: BufferLayout.struct([
             BufferLayout.u8('instruction'),
-            BufferLayout.ns64('poolTokensIn'),
-            BufferLayout.ns64('minimumLamportsOut'),
-            BufferLayout.ns64('userStakeSeed'),
+            u64Instruction('poolTokensIn'),
+            u64Instruction('minimumLamportsOut'),
+            u64Instruction('userStakeSeed'),
         ]),
     },
     WithdrawFromStakeAccountWithSession: {
         index: 30,
         layout: BufferLayout.struct([
             BufferLayout.u8('instruction'),
-            BufferLayout.ns64('lamports'),
-            BufferLayout.ns64('userStakeSeed'),
+            u64Instruction('lamports'),
+            u64Instruction('userStakeSeed'),
         ]),
     },
 });
@@ -1283,7 +1387,10 @@ class StakePoolInstruction {
     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 },
@@ -1313,7 +1420,11 @@ class StakePoolInstruction {
     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 },
@@ -1343,7 +1454,10 @@ class StakePoolInstruction {
     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 },
@@ -1369,7 +1483,10 @@ class StakePoolInstruction {
     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 },
@@ -1396,7 +1513,11 @@ class StakePoolInstruction {
     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 },
@@ -1453,7 +1574,7 @@ class StakePoolInstruction {
     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 },
@@ -1486,8 +1607,8 @@ class StakePoolInstruction {
         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 },
@@ -1529,7 +1650,7 @@ class StakePoolInstruction {
     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 },
@@ -1557,7 +1678,7 @@ class StakePoolInstruction {
     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 },
@@ -1592,8 +1713,8 @@ class StakePoolInstruction {
     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 },
@@ -1630,14 +1751,14 @@ 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;
         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 },
@@ -1645,17 +1766,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,
@@ -1670,8 +1793,8 @@ class StakePoolInstruction {
     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 },
@@ -1960,10 +2083,18 @@ skipBalanceCheck = false) {
     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);
@@ -2009,7 +2140,15 @@ skipBalanceCheck = false) {
  */
 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);
@@ -2023,7 +2162,7 @@ async function depositSol(connection, stakePoolAddress, from, lamports, destinat
     instructions.push(SystemProgram.transfer({
         fromPubkey: from,
         toPubkey: userSolTransfer.publicKey,
-        lamports,
+        lamports: lamportsBigInt,
     }));
     // Create token account if not specified
     if (!destinationTokenAccount) {
@@ -2395,37 +2534,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 +2609,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 +2633,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 +2647,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 +2658,7 @@ async function withdrawStakeWithSession(connection, stakePoolAddress, signerOrSe
         instructions,
         stakeAccountPubkeys,
         userStakeSeeds,
+        remainingPoolTokens: partialRemainingAmount ? lamportsToSol(partialRemainingAmount) : 0,
     };
 }
 async function addValidatorToPool(connection, stakePoolAddress, validatorVote, seed) {