@ignitionfi/spl-stake-pool 1.1.20 → 1.1.22

package/dist/index.browser.cjs.js

@@ -1083,7 +1083,8 @@ const STAKE_POOL_INSTRUCTION_LAYOUTS = Object.freeze({
         index: 24,
         layout: BufferLayout__namespace.struct([
             BufferLayout__namespace.u8('instruction'),
-            BufferLayout__namespace.ns64('lamports'),
+            BufferLayout__namespace.ns64('poolTokensIn'),
+            BufferLayout__namespace.ns64('minimumLamportsOut'),
         ]),
     },
     DepositSolWithSlippage: {
@@ -1116,6 +1117,14 @@ const STAKE_POOL_INSTRUCTION_LAYOUTS = Object.freeze({
             BufferLayout__namespace.ns64('minimumLamportsOut'),
         ]),
     },
+    WithdrawStakeWithSession: {
+        index: 29,
+        layout: BufferLayout__namespace.struct([
+            BufferLayout__namespace.u8('instruction'),
+            BufferLayout__namespace.ns64('poolTokensIn'),
+            BufferLayout__namespace.ns64('minimumLamportsOut'),
+        ]),
+    },
 });
 /**
  * Stake Pool Instruction class
@@ -1591,6 +1600,37 @@ class StakePoolInstruction {
             data,
         });
     }
+    /**
+     * Creates a transaction instruction to withdraw stake from a stake pool using a Fogo session.
+     */
+    static withdrawStakeWithSession(params) {
+        const type = STAKE_POOL_INSTRUCTION_LAYOUTS.WithdrawStakeWithSession;
+        const data = encodeData(type, {
+            poolTokensIn: params.poolTokensIn,
+            minimumLamportsOut: params.minimumLamportsOut,
+        });
+        const keys = [
+            { pubkey: params.stakePool, isSigner: false, isWritable: true },
+            { pubkey: params.validatorList, isSigner: false, isWritable: true },
+            { 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.burnFromPool, isSigner: false, isWritable: true },
+            { pubkey: params.managerFeeAccount, isSigner: false, isWritable: true },
+            { pubkey: params.poolMint, isSigner: false, isWritable: true },
+            { pubkey: web3_js.SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
+            { pubkey: params.tokenProgramId, isSigner: false, isWritable: false },
+            { pubkey: web3_js.StakeProgram.programId, isSigner: false, isWritable: false },
+            { pubkey: params.programSigner, isSigner: false, isWritable: false },
+        ];
+        return new web3_js.TransactionInstruction({
+            programId: params.programId,
+            keys,
+            data,
+        });
+    }
     /**
      * Creates an instruction to create metadata
      * using the mpl token metadata program for the pool token
@@ -2200,6 +2240,111 @@ async function withdrawWsolWithSession(connection, stakePoolAddress, signerOrSes
         signers,
     };
 }
+/**
+ * Creates instructions required to withdraw stake from a stake pool using a Fogo session.
+ * The withdrawn stake account will be authorized to the user's wallet.
+ */
+async function withdrawStakeWithSession(connection, stakePoolAddress, signerOrSession, userPubkey, amount, payer, useReserve = false, voteAccountAddress, minimumLamportsOut = 0, validatorComparator) {
+    const stakePoolAccount = await getStakePoolAccount(connection, stakePoolAddress);
+    const stakePoolProgramId = getStakePoolProgramId(connection.rpcEndpoint);
+    const stakePool = stakePoolAccount.account.data;
+    const poolTokens = solToLamports(amount);
+    const poolAmount = new BN(poolTokens);
+    const poolTokenAccount = splToken.getAssociatedTokenAddressSync(stakePool.poolMint, userPubkey);
+    const tokenAccount = await splToken.getAccount(connection, poolTokenAccount);
+    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] = web3_js.PublicKey.findProgramAddressSync([Buffer.from('fogo_session_program_signer')], stakePoolProgramId);
+    const withdrawAuthority = await findWithdrawAuthorityProgramAddress(stakePoolProgramId, stakePoolAddress);
+    const stakeAccountRentExemption = await connection.getMinimumBalanceForRentExemption(web3_js.StakeProgram.space);
+    // Determine which stake accounts to withdraw from
+    const withdrawAccounts = [];
+    if (useReserve) {
+        withdrawAccounts.push({
+            stakeAddress: stakePool.reserveStake,
+            voteAddress: undefined,
+            poolAmount,
+        });
+    }
+    else if (voteAccountAddress) {
+        const stakeAccountAddress = await findStakeProgramAddress(stakePoolProgramId, voteAccountAddress, stakePoolAddress);
+        const stakeAccount = await connection.getAccountInfo(stakeAccountAddress);
+        if (!stakeAccount) {
+            throw new Error(`Validator stake account not found for vote address ${voteAccountAddress.toBase58()}`);
+        }
+        const availableLamports = new BN(stakeAccount.lamports - MINIMUM_ACTIVE_STAKE - stakeAccountRentExemption);
+        if (availableLamports.lt(new BN(0))) {
+            throw new Error('Invalid Stake Account');
+        }
+        const availableForWithdrawal = calcLamportsWithdrawAmount(stakePool, availableLamports);
+        if (availableForWithdrawal.lt(poolAmount)) {
+            throw new Error(`Not enough lamports available for withdrawal from ${stakeAccountAddress},
+          ${poolAmount} asked, ${availableForWithdrawal} available.`);
+        }
+        withdrawAccounts.push({
+            stakeAddress: stakeAccountAddress,
+            voteAddress: voteAccountAddress,
+            poolAmount,
+        });
+    }
+    else {
+        // Get the list of accounts to withdraw from automatically
+        withdrawAccounts.push(...(await prepareWithdrawAccounts(connection, stakePool, stakePoolAddress, poolAmount, validatorComparator, poolTokenAccount.equals(stakePool.managerFeeAccount))));
+    }
+    const instructions = [];
+    const stakeAccountPubkeys = [];
+    // Max 5 accounts to prevent an error: "Transaction too large"
+    const maxWithdrawAccounts = 5;
+    let i = 0;
+    for (const withdrawAccount of withdrawAccounts) {
+        if (i >= maxWithdrawAccounts) {
+            break;
+        }
+        // Create a deterministic stake account address using a seed
+        // This avoids needing the new account to sign (required for sessions)
+        // We use payer as base so only payer needs to sign (payer = basePubkey)
+        // The seed includes timestamp + random component to ensure uniqueness
+        const uniqueId = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+        const seed = `ws:${uniqueId}:${i}`.slice(0, 32); // Seed max 32 chars
+        const stakeReceiverPubkey = await web3_js.PublicKey.createWithSeed(payer, seed, web3_js.StakeProgram.programId);
+        stakeAccountPubkeys.push(stakeReceiverPubkey);
+        // Create the stake account using createAccountWithSeed
+        // Since basePubkey === fromPubkey (both are payer), only payer needs to sign
+        instructions.push(web3_js.SystemProgram.createAccountWithSeed({
+            fromPubkey: payer,
+            newAccountPubkey: stakeReceiverPubkey,
+            basePubkey: payer,
+            seed,
+            lamports: stakeAccountRentExemption,
+            space: web3_js.StakeProgram.space,
+            programId: web3_js.StakeProgram.programId,
+        }));
+        // Add the withdraw stake with session instruction
+        instructions.push(StakePoolInstruction.withdrawStakeWithSession({
+            programId: stakePoolProgramId,
+            stakePool: stakePoolAddress,
+            validatorList: stakePool.validatorList,
+            withdrawAuthority,
+            stakeToSplit: withdrawAccount.stakeAddress,
+            stakeToReceive: stakeReceiverPubkey,
+            sessionSigner: signerOrSession,
+            burnFromPool: poolTokenAccount,
+            managerFeeAccount: stakePool.managerFeeAccount,
+            poolMint: stakePool.poolMint,
+            tokenProgramId: stakePool.tokenProgramId,
+            programSigner,
+            poolTokensIn: withdrawAccount.poolAmount.toNumber(),
+            minimumLamportsOut,
+        }));
+        i++;
+    }
+    return {
+        instructions,
+        stakeAccountPubkeys,
+    };
+}
 async function addValidatorToPool(connection, stakePoolAddress, validatorVote, seed) {
     const stakePoolAccount = await getStakePoolAccount(connection, stakePoolAddress);
     const stakePoolProgramId = getStakePoolProgramId(connection.rpcEndpoint);
@@ -2587,5 +2732,6 @@ exports.updatePoolTokenMetadata = updatePoolTokenMetadata;
 exports.updateStakePool = updateStakePool;
 exports.withdrawSol = withdrawSol;
 exports.withdrawStake = withdrawStake;
+exports.withdrawStakeWithSession = withdrawStakeWithSession;
 exports.withdrawWsolWithSession = withdrawWsolWithSession;
 //# sourceMappingURL=index.browser.cjs.js.map