@ignitionfi/spl-stake-pool 1.1.20 → 1.1.22

package/dist/index.iife.js

@@ -22264,7 +22264,8 @@ var solanaStakePool = (function (exports, node_buffer) {
 	        index: 24,
 	        layout: LayoutExports$1.struct([
 	            LayoutExports$1.u8('instruction'),
-	            LayoutExports$1.ns64('lamports'),
+	            LayoutExports$1.ns64('poolTokensIn'),
+	            LayoutExports$1.ns64('minimumLamportsOut'),
 	        ]),
 	    },
 	    DepositSolWithSlippage: {
@@ -22297,6 +22298,14 @@ var solanaStakePool = (function (exports, node_buffer) {
 	            LayoutExports$1.ns64('minimumLamportsOut'),
 	        ]),
 	    },
+	    WithdrawStakeWithSession: {
+	        index: 29,
+	        layout: LayoutExports$1.struct([
+	            LayoutExports$1.u8('instruction'),
+	            LayoutExports$1.ns64('poolTokensIn'),
+	            LayoutExports$1.ns64('minimumLamportsOut'),
+	        ]),
+	    },
 	});
 	/**
 	 * Stake Pool Instruction class
@@ -22772,6 +22781,37 @@ var solanaStakePool = (function (exports, node_buffer) {
 	            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: SYSVAR_CLOCK_PUBKEY, isSigner: false, isWritable: false },
+	            { pubkey: params.tokenProgramId, isSigner: false, isWritable: false },
+	            { pubkey: StakeProgram.programId, isSigner: false, isWritable: false },
+	            { pubkey: params.programSigner, isSigner: false, isWritable: false },
+	        ];
+	        return new TransactionInstruction({
+	            programId: params.programId,
+	            keys,
+	            data,
+	        });
+	    }
 	    /**
 	     * Creates an instruction to create metadata
 	     * using the mpl token metadata program for the pool token
@@ -23381,6 +23421,111 @@ var solanaStakePool = (function (exports, node_buffer) {
 	        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 = getAssociatedTokenAddressSync(stakePool.poolMint, userPubkey);
+	    const tokenAccount = await 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] = 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 = [];
+	    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 PublicKey.createWithSeed(payer, seed, StakeProgram.programId);
+	        stakeAccountPubkeys.push(stakeReceiverPubkey);
+	        // Create the stake account using createAccountWithSeed
+	        // Since basePubkey === fromPubkey (both are payer), only payer needs to sign
+	        instructions.push(SystemProgram.createAccountWithSeed({
+	            fromPubkey: payer,
+	            newAccountPubkey: stakeReceiverPubkey,
+	            basePubkey: payer,
+	            seed,
+	            lamports: stakeAccountRentExemption,
+	            space: StakeProgram.space,
+	            programId: 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);
@@ -23768,6 +23913,7 @@ var solanaStakePool = (function (exports, node_buffer) {
 	exports.updateStakePool = updateStakePool;
 	exports.withdrawSol = withdrawSol;
 	exports.withdrawStake = withdrawStake;
+	exports.withdrawStakeWithSession = withdrawStakeWithSession;
 	exports.withdrawWsolWithSession = withdrawWsolWithSession;
 
 	return exports;