@ignitionfi/spl-stake-pool 1.1.24 → 1.1.25

package/dist/index.browser.cjs.js

@@ -844,13 +844,16 @@ async function prepareWithdrawAccounts(connection, stakePool, stakePoolAddress,
             continue;
         }
         const stakeAccountAddress = await findStakeProgramAddress(stakePoolProgramId, validator.voteAccountAddress, stakePoolAddress);
-        if (!validator.activeStakeLamports.isZero()) {
+        // For active stake accounts, subtract the minimum balance that must remain
+        // to allow for merges and maintain rent exemption
+        const availableActiveLamports = validator.activeStakeLamports.sub(minBalance);
+        if (availableActiveLamports.gt(new BN(0))) {
             const isPreferred = (_a = stakePool === null || stakePool === void 0 ? void 0 : stakePool.preferredWithdrawValidatorVoteAddress) === null || _a === void 0 ? void 0 : _a.equals(validator.voteAccountAddress);
             accounts.push({
                 type: isPreferred ? 'preferred' : 'active',
                 voteAddress: validator.voteAccountAddress,
                 stakeAddress: stakeAccountAddress,
-                lamports: validator.activeStakeLamports,
+                lamports: availableActiveLamports,
             });
         }
         const transientStakeLamports = validator.transientStakeLamports.sub(minBalance);
@@ -1141,6 +1144,14 @@ const STAKE_POOL_INSTRUCTION_LAYOUTS = Object.freeze({
             BufferLayout__namespace.ns64('userStakeSeed'),
         ]),
     },
+    WithdrawFromStakeAccountWithSession: {
+        index: 30,
+        layout: BufferLayout__namespace.struct([
+            BufferLayout__namespace.u8('instruction'),
+            BufferLayout__namespace.ns64('lamports'),
+            BufferLayout__namespace.ns64('userStakeSeed'),
+        ]),
+    },
 });
 /**
  * Stake Pool Instruction class
@@ -1617,7 +1628,7 @@ class StakePoolInstruction {
     }
     /**
      * Creates a transaction instruction to withdraw stake from a stake pool using a Fogo session.
-     * The stake account is created as a PDA and rent is paid from the withdrawal amount.
+     * The stake account is created as a PDA and rent is paid by the payer (typically paymaster).
      */
     static withdrawStakeWithSession(params) {
         const type = STAKE_POOL_INSTRUCTION_LAYOUTS.WithdrawStakeWithSession;
@@ -1642,6 +1653,7 @@ class StakePoolInstruction {
             { pubkey: web3_js.StakeProgram.programId, isSigner: false, isWritable: false },
             { pubkey: params.programSigner, isSigner: false, isWritable: false },
             { pubkey: web3_js.SystemProgram.programId, isSigner: false, isWritable: false },
+            { pubkey: params.payer, isSigner: true, isWritable: true },
         ];
         return new web3_js.TransactionInstruction({
             programId: params.programId,
@@ -1649,6 +1661,43 @@ class StakePoolInstruction {
             data,
         });
     }
+    /**
+     * Creates a transaction instruction to withdraw SOL from a deactivated user stake account using a Fogo session.
+     * The stake account must be fully deactivated (inactive).
+     * User receives full stake balance (payer's rent contribution compensates for reduced split).
+     */
+    static withdrawFromStakeAccountWithSession(params) {
+        // For u64::MAX (full withdrawal), we need to manually encode since buffer-layout doesn't handle bigint well
+        const U64_MAX = BigInt('18446744073709551615');
+        const isFullWithdrawal = params.lamports >= U64_MAX;
+        // Manually create the instruction data buffer using Uint8Array for browser compatibility
+        // Layout: u8 instruction (1) + u64 lamports (8) + u64 userStakeSeed (8) = 17 bytes
+        const data = new Uint8Array(17);
+        data[0] = 30; // instruction discriminator (WithdrawFromStakeAccountWithSession = 30)
+        // Write lamports as u64 little-endian (bytes 1-8)
+        const lamportsBigInt = isFullWithdrawal ? U64_MAX : params.lamports;
+        for (let i = 0; i < 8; i++) {
+            data[1 + i] = Number((lamportsBigInt >> BigInt(i * 8)) & BigInt(0xff));
+        }
+        // Write userStakeSeed as u64 little-endian (bytes 9-16)
+        const seedBigInt = BigInt(params.userStakeSeed);
+        for (let i = 0; i < 8; i++) {
+            data[9 + i] = Number((seedBigInt >> BigInt(i * 8)) & BigInt(0xff));
+        }
+        // Account order matches Rust: stake_account, recipient, clock, stake_history, session_signer
+        const keys = [
+            { pubkey: params.userStakeAccount, isSigner: false, isWritable: true },
+            { pubkey: params.userWallet, isSigner: false, isWritable: true },
+            { pubkey: web3_js.SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
+            { pubkey: web3_js.SYSVAR_STAKE_HISTORY_PUBKEY, isSigner: false, isWritable: false },
+            { pubkey: params.sessionSigner, isSigner: true, isWritable: false },
+        ];
+        return new web3_js.TransactionInstruction({
+            programId: params.programId,
+            keys,
+            data: Buffer.from(data),
+        });
+    }
     /**
      * Creates an instruction to create metadata
      * using the mpl token metadata program for the pool token
@@ -1912,14 +1961,21 @@ async function depositStake(connection, stakePoolAddress, authorizedPubkey, vali
 /**
  * Creates instructions required to deposit sol to stake pool.
  */
-async function depositWsolWithSession(connection, stakePoolAddress, signerOrSession, userPubkey, lamports, minimumPoolTokensOut = 0, destinationTokenAccount, referrerTokenAccount, depositAuthority, payer) {
+async function depositWsolWithSession(connection, stakePoolAddress, signerOrSession, userPubkey, lamports, minimumPoolTokensOut = 0, destinationTokenAccount, referrerTokenAccount, depositAuthority, payer, 
+/**
+ * Skip WSOL balance validation. Set to true when adding wrap instructions
+ * in the same transaction that will fund the WSOL account before deposit.
+ */
+skipBalanceCheck = false) {
     const wsolTokenAccount = splToken.getAssociatedTokenAddressSync(splToken.NATIVE_MINT, userPubkey);
-    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.`);
+    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.`);
+        }
     }
     const stakePoolAccount = await getStakePoolAccount(connection, stakePoolAddress);
     const stakePoolProgramId = getStakePoolProgramId(connection.rpcEndpoint);
@@ -2280,16 +2336,83 @@ async function findNextUserStakeSeed(connection, programId, userPubkey, startSee
     }
     throw new Error(`No available user stake seed found between ${startSeed} and ${startSeed + maxSeed - 1}`);
 }
+/**
+ * Fetches all user stake accounts created via WithdrawStakeWithSession.
+ * These are PDAs derived from [b"user_stake", user_wallet, seed].
+ *
+ * @param connection - Solana connection
+ * @param programId - The stake pool program ID
+ * @param userPubkey - User's wallet address
+ * @param maxSeed - Maximum seed to check (default: 100)
+ * @returns Array of user stake accounts with their details
+ */
+async function getUserStakeAccounts(connection, programId, userPubkey, maxSeed = 100) {
+    var _c, _d;
+    const stakeAccounts = [];
+    const currentEpoch = (await connection.getEpochInfo()).epoch;
+    for (let seed = 0; seed < maxSeed; seed++) {
+        const pda = findUserStakeProgramAddress(programId, userPubkey, seed);
+        const accountInfo = await connection.getAccountInfo(pda);
+        if (!accountInfo) {
+            continue; // Skip empty slots, there might be gaps
+        }
+        // Check if owned by stake program
+        if (!accountInfo.owner.equals(web3_js.StakeProgram.programId)) {
+            continue;
+        }
+        // Parse stake account data
+        const stakeAccount = {
+            pubkey: pda,
+            seed,
+            lamports: accountInfo.lamports,
+            state: 'inactive',
+        };
+        try {
+            // Parse the stake account to get delegation info
+            const parsedAccount = await connection.getParsedAccountInfo(pda);
+            if (parsedAccount.value && 'parsed' in parsedAccount.value.data) {
+                const parsed = parsedAccount.value.data.parsed;
+                if (parsed.type === 'delegated' && ((_d = (_c = parsed.info) === null || _c === void 0 ? void 0 : _c.stake) === null || _d === void 0 ? void 0 : _d.delegation)) {
+                    const delegation = parsed.info.stake.delegation;
+                    stakeAccount.voter = new web3_js.PublicKey(delegation.voter);
+                    stakeAccount.activationEpoch = Number(delegation.activationEpoch);
+                    stakeAccount.deactivationEpoch = Number(delegation.deactivationEpoch);
+                    // Determine state based on epochs
+                    const activationEpoch = stakeAccount.activationEpoch;
+                    const deactivationEpoch = stakeAccount.deactivationEpoch;
+                    if (deactivationEpoch !== undefined && deactivationEpoch < Number.MAX_SAFE_INTEGER && deactivationEpoch <= currentEpoch) {
+                        stakeAccount.state = 'inactive';
+                    }
+                    else if (deactivationEpoch !== undefined && deactivationEpoch < Number.MAX_SAFE_INTEGER) {
+                        stakeAccount.state = 'deactivating';
+                    }
+                    else if (activationEpoch !== undefined && activationEpoch <= currentEpoch) {
+                        stakeAccount.state = 'active';
+                    }
+                    else {
+                        stakeAccount.state = 'activating';
+                    }
+                }
+            }
+        }
+        catch {
+            // If parsing fails, keep default 'inactive' state
+        }
+        stakeAccounts.push(stakeAccount);
+    }
+    return stakeAccounts;
+}
 /**
  * Withdraws stake from a stake pool using a Fogo session.
  *
- * The on-chain program creates stake account PDAs, so no pre-creation step is needed.
- * Rent for the stake account PDAs is paid from the withdrawal amount.
+ * 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.
  *
  * @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)
@@ -2297,7 +2420,7 @@ async function findNextUserStakeSeed(connection, programId, userPubkey, startSee
  * @param minimumLamportsOut - Minimum lamports to receive (slippage protection)
  * @param validatorComparator - Optional comparator for validator selection
  */
-async function withdrawStakeWithSession(connection, stakePoolAddress, signerOrSession, userPubkey, amount, userStakeSeedStart = 0, useReserve = false, voteAccountAddress, minimumLamportsOut = 0, validatorComparator) {
+async function withdrawStakeWithSession(connection, stakePoolAddress, signerOrSession, userPubkey, payer, amount, userStakeSeedStart = 0, useReserve = false, voteAccountAddress, minimumLamportsOut = 0, validatorComparator) {
     const stakePoolAccount = await getStakePoolAccount(connection, stakePoolAddress);
     const stakePoolProgramId = getStakePoolProgramId(connection.rpcEndpoint);
     const stakePool = stakePoolAccount.account.data;
@@ -2361,7 +2484,7 @@ async function withdrawStakeWithSession(connection, stakePoolAddress, signerOrSe
         const stakeReceiverPubkey = findUserStakeProgramAddress(stakePoolProgramId, userPubkey, userStakeSeed);
         stakeAccountPubkeys.push(stakeReceiverPubkey);
         userStakeSeeds.push(userStakeSeed);
-        // The on-chain program will create the stake account PDA
+        // The on-chain program creates the stake account PDA and rent is paid by payer.
         instructions.push(StakePoolInstruction.withdrawStakeWithSession({
             programId: stakePoolProgramId,
             stakePool: stakePoolAddress,
@@ -2375,6 +2498,7 @@ async function withdrawStakeWithSession(connection, stakePoolAddress, signerOrSe
             poolMint: stakePool.poolMint,
             tokenProgramId: stakePool.tokenProgramId,
             programSigner,
+            payer,
             poolTokensIn: withdrawAccount.poolAmount.toNumber(),
             minimumLamportsOut,
             userStakeSeed,
@@ -2773,6 +2897,7 @@ exports.getStakeAccount = getStakeAccount;
 exports.getStakePoolAccount = getStakePoolAccount;
 exports.getStakePoolAccounts = getStakePoolAccounts;
 exports.getStakePoolProgramId = getStakePoolProgramId;
+exports.getUserStakeAccounts = getUserStakeAccounts;
 exports.increaseValidatorStake = increaseValidatorStake;
 exports.removeValidatorFromPool = removeValidatorFromPool;
 exports.stakePoolInfo = stakePoolInfo;