@kamino-finance/klend-sdk 7.1.4-beta.0 → 7.1.4

package/dist/classes/action.js

@@ -19,15 +19,8 @@ const sysvars_1 = require("@solana/sysvars");
 const token_2022_1 = require("@solana-program/token-2022");
 const system_1 = require("@solana-program/system");
 const signer_1 = require("../utils/signer");
-const programId_2 = require("../@codegen/unstaking_pool/programId");
-const unstakingPool_1 = require("./unstakingPool");
-const programId_3 = require("../@codegen/klend/programId");
-const UnstakeTicket_1 = require("../@codegen/unstaking_pool/accounts/UnstakeTicket");
-const instructions_2 = require("../@codegen/unstaking_pool/instructions");
-const unstakeLstCollateralEnd_1 = require("../@codegen/klend/instructions/unstakeLstCollateralEnd");
 class KaminoAction {
     kaminoMarket;
-    unstakingPool;
     reserve;
     outflowReserve;
     owner;
@@ -59,7 +52,7 @@ class KaminoAction {
     borrowReserves;
     preLoadedDepositReservesSameTx;
     currentSlot;
-    constructor(kaminoMarket, owner, obligation, mint, positions, amount, depositReserves, borrowReserves, reserveState, currentSlot, unstakingPool, secondaryMint, outflowReserveState, outflowAmount, referrer = (0, kit_1.none)(), payer) {
+    constructor(kaminoMarket, owner, obligation, mint, positions, amount, depositReserves, borrowReserves, reserveState, currentSlot, secondaryMint, outflowReserveState, outflowAmount, referrer = (0, kit_1.none)(), payer) {
         this.kaminoMarket = kaminoMarket;
         this.obligation = obligation;
         this.owner = owner;
@@ -88,23 +81,15 @@ class KaminoAction {
         this.preLoadedDepositReservesSameTx = [];
         this.referrer = referrer;
         this.currentSlot = currentSlot;
-        this.unstakingPool = unstakingPool;
     }
-    static async initialize(action, amount, mint, owner, kaminoMarket, obligation, referrer = (0, kit_1.none)(), currentSlot = 0n, payer = owner, needsUnstakingPool = false) {
+    static async initialize(action, amount, mint, owner, kaminoMarket, obligation, referrer = (0, kit_1.none)(), currentSlot = 0n, payer = owner) {
         const reserve = kaminoMarket.getReserveByMint(mint);
         if (reserve === undefined) {
             throw new Error(`Reserve ${mint} not found in market ${kaminoMarket.getAddress()}`);
         }
         const { kaminoObligation, depositReserves, borrowReserves, distinctReserveCount } = await KaminoAction.loadObligation(action, kaminoMarket, owner.address, reserve.address, obligation);
         const referrerKey = await this.getReferrerKey(kaminoMarket, owner.address, kaminoObligation, referrer);
-        let unstakingPool = undefined;
-        if (needsUnstakingPool) {
-            const unstakingPoolPk = kaminoMarket.state.unstakingPoolState;
-            const unstakingPoolProgramId = kaminoMarket.programId == programId_3.PROGRAM_ID ? programId_2.PROGRAM_ID : unstakingPool_1.UNSTAKING_POOL_STAGING_ID;
-            unstakingPool = new unstakingPool_1.UnstakingPool(unstakingPoolPk, undefined, unstakingPoolProgramId);
-            await unstakingPool.reloadState(kaminoMarket.getRpc());
-        }
-        return new KaminoAction(kaminoMarket, owner, kaminoObligation || obligation, mint, distinctReserveCount, amount, depositReserves, borrowReserves, reserve, currentSlot, unstakingPool, undefined, undefined, undefined, referrerKey, payer);
+        return new KaminoAction(kaminoMarket, owner, kaminoObligation || obligation, mint, distinctReserveCount, amount, depositReserves, borrowReserves, reserve, currentSlot, undefined, undefined, undefined, referrerKey, payer);
     }
     static async getUserAccountAddresses(owner, reserve) {
         const [userTokenAccountAddress, userCollateralAccountAddress] = await Promise.all([
@@ -414,24 +399,6 @@ class KaminoAction {
         }
         return axn;
     }
-    static async buildUnstakeLstCollateralStartTxns(kaminoMarket, lstToConvert, usolMint, lstMint, payer, currentSlot, obligation, depositStakedSolRemainingAccounts, scopeRefreshConfig, extraComputeBudget = 1_000_000, // if > 0 then adds the ix
-    includeAtaIxs = true, // if true it includes create and close wsol and token atas,
-    initUserMetadata = {
-        skipInitialization: false,
-        skipLutCreation: false,
-    }, referrer = (0, kit_1.none)()) {
-        const axn = await KaminoAction.initializeMultiTokenAction(kaminoMarket, 'unstakeLstCollateralStart', lstToConvert, usolMint, lstMint, payer, payer.address, obligation, undefined, referrer, currentSlot, true);
-        const addInitObligationForFarm = true;
-        const twoTokenAction = true;
-        const requestElevationGroup = false;
-        const useV2Ixs = true;
-        if (extraComputeBudget > 0) {
-            axn.addComputeBudgetIx(extraComputeBudget);
-        }
-        await axn.addSupportIxs('unstakeLstCollateralStart', includeAtaIxs, requestElevationGroup, addInitObligationForFarm, useV2Ixs, scopeRefreshConfig, initUserMetadata, twoTokenAction);
-        await axn.addUnstakeLstCollateralStartIxs(depositStakedSolRemainingAccounts);
-        return axn;
-    }
     static async buildWithdrawTxns(kaminoMarket, amount, mint, owner, obligation, useV2Ixs, scopeRefreshConfig, extraComputeBudget = 1_000_000, // if > 0 then adds the ix
     includeAtaIxs = true, // if true it includes create and close wsol and token atas,
     requestElevationGroup = false, // to be requested *after* the withdraw
@@ -458,38 +425,6 @@ class KaminoAction {
         axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
         return axn;
     }
-    static async buildWithdrawUsolTxns(kaminoMarket, amount, mint, owner, obligation, scopeRefreshConfig, extraComputeBudget = 1_000_000, // if > 0 then adds the ix
-    includeAtaIxs = true, // if true it includes create and close wsol and token atas,
-    requestElevationGroup = false, // to be requested *after* the withdraw
-    initUserMetadata = {
-        skipInitialization: false,
-        skipLutCreation: false,
-    }, referrer = (0, kit_1.none)(), currentSlot = 0n, overrideElevationGroupRequest, 
-    // Optional customizations which may be needed if the obligation was mutated by some previous ix.
-    obligationCustomizations, burnUsol = false) {
-        const axn = await KaminoAction.initialize('withdraw', amount, mint, owner, kaminoMarket, obligation, referrer, currentSlot, undefined, true);
-        if (extraComputeBudget > 0) {
-            axn.addComputeBudgetIx(extraComputeBudget);
-        }
-        axn.depositReserves.push(...(obligationCustomizations?.addedDepositReserves || []));
-        const addInitObligationForFarm = true;
-        const useV2Ixs = true;
-        await axn.addSupportIxs('withdraw', includeAtaIxs, requestElevationGroup, addInitObligationForFarm, useV2Ixs, scopeRefreshConfig, initUserMetadata, false, overrideElevationGroupRequest);
-        // We need user SOL ata to be initialized so they can receive the SOL
-        // No need for other support ix (such as refresh reserve) as this burnUsolIx is called from unstaking pool
-        if (burnUsol) {
-            const [userAta, createUserTokenAccountIx] = await (0, utils_1.createAssociatedTokenAccountIdempotentInstruction)(axn.owner, utils_1.WRAPPED_SOL_MINT, axn.owner.address);
-            axn.setupIxs.unshift(createUserTokenAccountIx);
-            axn.setupIxsLabels.unshift(`CreateLiquidityUserAta[${userAta}]`);
-        }
-        const collateralAmount = axn.getWithdrawCollateralAmount(axn.reserve, axn.amount);
-        const unstakeTicket = await axn.addWithdrawUsolIx(collateralAmount);
-        if (burnUsol) {
-            await axn.addBurnAllUsolIx(unstakeTicket);
-        }
-        axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
-        return axn;
-    }
     /**
      *
      * @param kaminoMarket
@@ -547,26 +482,6 @@ class KaminoAction {
         axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
         return axn;
     }
-    static async buildUnstakeLstCollateralEndTxns(kaminoMarket, amount, minCollateralReceiveAmount, repayTokenMint, withdrawTokenMint, liquidator, obligationOwner, obligation, scopeRefreshConfig = undefined, extraComputeBudget = 1_000_000, // if > 0 then adds the ix
-    includeAtaIxs = true, // if true it includes create and close wsol and token atas, and creates all other token atas if they don't exist
-    requestElevationGroup = false, initUserMetadata = {
-        skipInitialization: false,
-        skipLutCreation: false,
-    }, referrer = (0, kit_1.none)(), maxAllowedLtvOverridePercent = 0, currentSlot = 0n, burnUsol = false) {
-        const axn = await KaminoAction.initializeMultiTokenAction(kaminoMarket, 'liquidate', amount, repayTokenMint, withdrawTokenMint, liquidator, obligationOwner, obligation, minCollateralReceiveAmount, referrer, currentSlot, true);
-        const addInitObligationForFarm = true;
-        const useV2Ixs = true;
-        if (extraComputeBudget > 0) {
-            axn.addComputeBudgetIx(extraComputeBudget);
-        }
-        await axn.addSupportIxs('liquidate', includeAtaIxs, requestElevationGroup, addInitObligationForFarm, useV2Ixs, scopeRefreshConfig, initUserMetadata);
-        const unstakeTicket = await axn.addUnstakeLstCollateralEndIx(maxAllowedLtvOverridePercent);
-        if (burnUsol) {
-            await axn.addBurnAllUsolIx(unstakeTicket);
-        }
-        axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
-        return axn;
-    }
     static async buildWithdrawReferrerFeeTxns(owner, tokenMint, kaminoMarket, currentSlot = 0n) {
         const { axn, createAtaIxs } = await KaminoAction.initializeWithdrawReferrerFees(tokenMint, owner, kaminoMarket, currentSlot);
         axn.setupIxs.push(...createAtaIxs);
@@ -684,100 +599,6 @@ class KaminoAction {
             farmsProgram: programId_1.PROGRAM_ID,
         }, undefined, this.kaminoMarket.programId));
     }
-    async addUnstakeLstCollateralStartIxs(depositStakedSolRemainingAccounts) {
-        // Deposit USOL - our custom token issued by unstaking pool program
-        // and withdraw some kind of staked sol
-        this.lendingIxsLabels.push(`unstakeLstCollateral(depositReserve=${this.reserve.address})(withdrawReserve=${this.outflowReserve.address})(obligation=${this.getObligationPda()})`);
-        const depositReservesList = this.getAdditionalDepositReservesList();
-        const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-            return { address: reserve, role: kit_1.AccountRole.WRITABLE };
-        });
-        const borrowReserveAccountMetas = this.borrowReserves.map((reserve) => {
-            return { address: reserve, role: kit_1.AccountRole.WRITABLE };
-        });
-        if (!this.outflowReserve) {
-            throw new Error(`outflowReserve not set`);
-        }
-        if (!this.unstakingPool || !this.unstakingPool.state) {
-            throw new Error(`unstaking pool not set`);
-        }
-        const basePoolAuthority = (await (0, unstakingPool_1.unstakingPoolBaseAuthorityPda)(this.unstakingPool.address, this.unstakingPool.programId))[0];
-        const ownerUsolToken = await this.getUserTokenAccountAddress(this.reserve);
-        const ownerLstToken = await this.getUserTokenAccountAddress(this.outflowReserve);
-        const unstakingPoolAuthority = (await (0, utils_1.unstakingPoolMarketAuthorityPda)(this.kaminoMarket.address, this.kaminoMarket.programId))[0];
-        const obligationPda = await this.getObligationPda();
-        const { collateralFarmAccounts: depositFarmsAccounts } = await KaminoAction.getFarmAccountsForReserve(obligationPda, this.reserve);
-        const { collateralFarmAccounts: withdrawFarmsAccounts } = await KaminoAction.getFarmAccountsForReserve(obligationPda, this.outflowReserve);
-        // Create unstake ticket
-        const unstakeTicket = await (0, kit_1.generateKeyPairSigner)();
-        const unstakeTicketSize = UnstakeTicket_1.UnstakeTicket.layout.span + 8;
-        const createUnstakeTicketIx = (0, system_1.getCreateAccountInstruction)({
-            payer: this.owner,
-            newAccount: unstakeTicket,
-            lamports: await this.kaminoMarket.getRpc().getMinimumBalanceForRentExemption(BigInt(unstakeTicketSize)).send(),
-            space: unstakeTicketSize,
-            programAddress: this.unstakingPool.programId,
-        });
-        this.lendingIxs.push(createUnstakeTicketIx);
-        const unstakeLstCollateralStartIx = (0, instructions_1.unstakeLstCollateralStart)({
-            lstToConvert: this.amount,
-        }, {
-            depositAndWithdrawAccounts: {
-                depositAccounts: {
-                    owner: this.owner,
-                    obligation: obligationPda,
-                    lendingMarket: this.kaminoMarket.getAddress(),
-                    lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
-                    reserve: this.reserve.address,
-                    reserveLiquidityMint: this.reserve.getLiquidityMint(),
-                    reserveLiquiditySupply: this.reserve.state.liquidity.supplyVault,
-                    reserveCollateralMint: this.reserve.getCTokenMint(),
-                    reserveDestinationDepositCollateral: this.reserve.state.collateral.supplyVault, // destinationCollateral
-                    userSourceLiquidity: ownerUsolToken,
-                    placeholderUserDestinationCollateral: (0, kit_1.none)(),
-                    collateralTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
-                    liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
-                    instructionSysvarAccount: sysvars_1.SYSVAR_INSTRUCTIONS_ADDRESS,
-                },
-                withdrawAccounts: {
-                    owner: this.owner,
-                    obligation: obligationPda,
-                    lendingMarket: this.kaminoMarket.getAddress(),
-                    lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
-                    withdrawReserve: this.outflowReserve.address,
-                    reserveLiquidityMint: this.outflowReserve.getLiquidityMint(),
-                    reserveCollateralMint: this.outflowReserve.getCTokenMint(),
-                    reserveLiquiditySupply: this.outflowReserve.state.liquidity.supplyVault,
-                    reserveSourceCollateral: this.outflowReserve.state.collateral.supplyVault,
-                    userDestinationLiquidity: ownerLstToken,
-                    placeholderUserDestinationCollateral: (0, kit_1.none)(),
-                    collateralTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
-                    liquidityTokenProgram: this.outflowReserve.getLiquidityTokenProgram(),
-                    instructionSysvarAccount: sysvars_1.SYSVAR_INSTRUCTIONS_ADDRESS,
-                },
-                depositFarmsAccounts,
-                withdrawFarmsAccounts,
-                farmsProgram: programId_1.PROGRAM_ID,
-            },
-            depositStakedSolAccounts: {
-                owner: this.owner,
-                unstakingPoolAuthority,
-                ownerStakedSolToken: ownerLstToken,
-                ownerUnstakingSolToken: ownerUsolToken,
-                stakedSolMint: this.outflowReserve.getLiquidityMint(),
-                poolState: this.unstakingPool.address,
-                unstakingSolMint: this.reserve.getLiquidityMint(),
-                basePoolAuthority,
-                systemProgram: system_1.SYSTEM_PROGRAM_ADDRESS,
-                unstakingSolTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
-                stakedSolTokenProgram: this.outflowReserve.getLiquidityTokenProgram(),
-                unstakeTicket: unstakeTicket.address,
-                unstakingTicketBurnAuthority: unstakingPoolAuthority,
-            },
-            unstakingPoolProgram: this.unstakingPool.programId,
-        }, [...depositStakedSolRemainingAccounts, ...depositReserveAccountMetas, ...borrowReserveAccountMetas], this.kaminoMarket.programId);
-        this.lendingIxs.push(unstakeLstCollateralStartIx);
-    }
     /// @deprecated -- use addDepositObligationCollateralIxV2 instead
     async addDepositObligationCollateralIx() {
         this.lendingIxsLabels.push(`depositObligationCollateral`);
@@ -934,60 +755,6 @@ class KaminoAction {
             farmsProgram: programId_1.PROGRAM_ID,
         }, undefined, this.kaminoMarket.programId));
     }
-    async addWithdrawUsolIx(collateralAmount) {
-        if (!(0, obligation_1.isKaminoObligation)(this.obligation)) {
-            throw new Error(`obligation is not a KaminoObligation`);
-        }
-        if (!this.unstakingPool || !this.unstakingPool.state) {
-            throw new Error(`unstaking pool not set`);
-        }
-        const obligationAddress = await this.getObligationPda();
-        const { collateralFarmAccounts: farmsAccounts } = await KaminoAction.getFarmAccountsForReserve(obligationAddress, this.reserve);
-        this.lendingIxsLabels.push(`withdrawUsol`);
-        const newUnstakeTicket = await (0, kit_1.generateKeyPairSigner)();
-        const unstakeTicketSize = UnstakeTicket_1.UnstakeTicket.layout.span + 8;
-        const createUnstakeTicketIx = (0, system_1.getCreateAccountInstruction)({
-            payer: this.owner,
-            newAccount: newUnstakeTicket,
-            lamports: await this.kaminoMarket.getRpc().getMinimumBalanceForRentExemption(BigInt(unstakeTicketSize)).send(),
-            space: unstakeTicketSize,
-            programAddress: this.unstakingPool.programId,
-        });
-        this.lendingIxs.push(createUnstakeTicketIx);
-        const unstakingPoolAuthority = (await (0, utils_1.unstakingPoolMarketAuthorityPda)(this.kaminoMarket.address, this.kaminoMarket.programId))[0];
-        this.lendingIxs.push((0, instructions_1.withdrawObligationUsol)({
-            collateralAmount,
-        }, {
-            withdrawAccounts: {
-                withdrawAccounts: {
-                    owner: this.owner,
-                    obligation: obligationAddress,
-                    lendingMarket: this.kaminoMarket.getAddress(),
-                    lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
-                    withdrawReserve: this.reserve.address,
-                    reserveLiquidityMint: this.reserve.getLiquidityMint(),
-                    reserveCollateralMint: this.reserve.getCTokenMint(),
-                    reserveLiquiditySupply: this.reserve.state.liquidity.supplyVault,
-                    reserveSourceCollateral: this.reserve.state.collateral.supplyVault,
-                    userDestinationLiquidity: await this.getUserTokenAccountAddress(this.reserve),
-                    placeholderUserDestinationCollateral: (0, kit_1.none)(),
-                    collateralTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
-                    liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
-                    instructionSysvarAccount: sysvars_1.SYSVAR_INSTRUCTIONS_ADDRESS,
-                },
-                farmsAccounts: farmsAccounts,
-                farmsProgram: programId_1.PROGRAM_ID,
-            },
-            extraAccounts: {
-                unstakeTicket: this.obligation.state.unstakeTicket,
-                emptyUnstakeTicket: newUnstakeTicket.address,
-                unstakingPoolAuthority: unstakingPoolAuthority,
-                unstakingPoolProgram: this.unstakingPool.programId,
-                systemProgram: system_1.SYSTEM_PROGRAM_ADDRESS,
-            },
-        }, [], this.kaminoMarket.programId));
-        return newUnstakeTicket.address;
-    }
     /// @deprecated -- use addRepayIxV2 instead
     async addRepayIx() {
         const obligationAddress = await this.getObligationPda();
@@ -1417,27 +1184,6 @@ class KaminoAction {
             farmsProgram: programId_1.PROGRAM_ID,
         }, undefined, this.kaminoMarket.programId));
     }
-    async addBurnAllUsolIx(unstakeTicket) {
-        this.lendingIxsLabels.push(`burnUsolIx`);
-        if (!this.unstakingPool || !this.unstakingPool.state) {
-            throw new Error(`unstaking pool not set`);
-        }
-        this.lendingIxs.push((0, instructions_2.burn)({
-            sharesToBurn: new bn_js_1.default(utils_1.U64_MAX),
-            minWsolToReceive: new bn_js_1.default(0), // TODO: find a way to compute a reasonable slippage
-        }, {
-            user: this.owner,
-            userUnstakingSolToken: await (0, utils_1.getAssociatedTokenAddress)(this.unstakingPool.state.unstakingSolMint, this.owner.address, token_1.TOKEN_PROGRAM_ADDRESS),
-            userWsolToken: await (0, utils_1.getAssociatedTokenAddress)(utils_1.WRAPPED_SOL_MINT, this.owner.address, token_1.TOKEN_PROGRAM_ADDRESS),
-            wsolVault: this.unstakingPool.state.wsolVault,
-            wsolMint: utils_1.WRAPPED_SOL_MINT,
-            poolState: this.unstakingPool.address,
-            unstakeTicket,
-            unstakingSolMint: this.unstakingPool.state.unstakingSolMint,
-            basePoolAuthority: this.unstakingPool.state.basePoolAuthority,
-            tokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
-        }, this.unstakingPool.programId));
-    }
     async addLiquidateIx(maxAllowedLtvOverridePercent = 0) {
         this.lendingIxsLabels.push(`liquidateObligationAndRedeemReserveCollateral`);
         if (!this.outflowReserve) {
@@ -1540,80 +1286,6 @@ class KaminoAction {
         };
         this.lendingIxs.push(liquidateIx);
     }
-    async addUnstakeLstCollateralEndIx(maxAllowedLtvOverridePercent = 0) {
-        this.lendingIxsLabels.push(`unstakeLstCollateralEnd`);
-        if (!this.outflowReserve) {
-            throw Error(`Withdraw reserve during liquidation is not defined`);
-        }
-        if (!(0, obligation_1.isKaminoObligation)(this.obligation)) {
-            throw new Error(`obligation is not a KaminoObligation`);
-        }
-        if (!this.unstakingPool || !this.unstakingPool.state) {
-            throw new Error(`unstaking pool not set`);
-        }
-        const depositReservesList = this.getAdditionalDepositReservesList();
-        const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-            return { address: reserve, role: kit_1.AccountRole.WRITABLE };
-        });
-        const obligationAddress = await this.getObligationPda();
-        const { collateralFarmAccounts: collateralFarmsAccounts } = await KaminoAction.getFarmAccountsForReserve(obligationAddress, this.outflowReserve);
-        const { debtFarmAccounts: debtFarmsAccounts } = await KaminoAction.getFarmAccountsForReserve(await this.getObligationPda(), this.reserve);
-        const newUnstakeTicket = await (0, kit_1.generateKeyPairSigner)();
-        const unstakeTicketSize = UnstakeTicket_1.UnstakeTicket.layout.span + 8;
-        const createUnstakeTicketIx = (0, system_1.getCreateAccountInstruction)({
-            payer: this.owner,
-            newAccount: newUnstakeTicket,
-            lamports: await this.kaminoMarket.getRpc().getMinimumBalanceForRentExemption(BigInt(unstakeTicketSize)).send(),
-            space: unstakeTicketSize,
-            programAddress: this.unstakingPool.programId,
-        });
-        this.lendingIxs.push(createUnstakeTicketIx);
-        const unstakingPoolAuthority = (await (0, utils_1.unstakingPoolMarketAuthorityPda)(this.kaminoMarket.address, this.kaminoMarket.programId))[0];
-        const extraAccounts = this.obligation.state.elevationGroup > 0 ? depositReserveAccountMetas : [];
-        const liquidateIx = (0, unstakeLstCollateralEnd_1.unstakeLstCollateralEnd)({
-            liquidityAmount: this.amount,
-            // TODO: Configure this when updating liquidator with new interface
-            minAcceptableReceivedLiquidityAmount: this.outflowAmount || new bn_js_1.default(0),
-            maxAllowedLtvOverridePercent: new bn_js_1.default(maxAllowedLtvOverridePercent),
-        }, {
-            liquidationAccounts: {
-                liquidationAccounts: {
-                    liquidator: this.owner,
-                    obligation: obligationAddress,
-                    lendingMarket: this.kaminoMarket.getAddress(),
-                    lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
-                    repayReserve: this.reserve.address,
-                    repayReserveLiquidityMint: this.reserve.getLiquidityMint(),
-                    repayReserveLiquiditySupply: this.reserve.state.liquidity.supplyVault,
-                    withdrawReserve: this.outflowReserve.address,
-                    withdrawReserveLiquidityMint: this.outflowReserve.getLiquidityMint(),
-                    withdrawReserveCollateralMint: this.outflowReserve.getCTokenMint(),
-                    withdrawReserveCollateralSupply: this.outflowReserve.state.collateral.supplyVault,
-                    withdrawReserveLiquiditySupply: this.outflowReserve.state.liquidity.supplyVault,
-                    userSourceLiquidity: await this.getUserTokenAccountAddress(this.reserve),
-                    userDestinationCollateral: await this.getUserCollateralAccountAddress(this.outflowReserve),
-                    userDestinationLiquidity: await this.getUserTokenAccountAddress(this.outflowReserve),
-                    withdrawReserveLiquidityFeeReceiver: this.outflowReserve.state.liquidity.feeVault,
-                    collateralTokenProgram: token_1.TOKEN_PROGRAM_ADDRESS,
-                    repayLiquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
-                    withdrawLiquidityTokenProgram: this.outflowReserve.getLiquidityTokenProgram(),
-                    instructionSysvarAccount: sysvars_1.SYSVAR_INSTRUCTIONS_ADDRESS,
-                },
-                debtFarmsAccounts,
-                collateralFarmsAccounts,
-                farmsProgram: programId_1.PROGRAM_ID,
-            },
-            extraAccounts: {
-                unstakeTicket: this.obligation.state.unstakeTicket,
-                emptyUnstakeTicket: newUnstakeTicket.address,
-                unstakingPoolAuthority: unstakingPoolAuthority,
-                unstakingPoolProgram: this.unstakingPool.programId,
-                systemProgram: system_1.SYSTEM_PROGRAM_ADDRESS,
-            },
-        }, extraAccounts, this.kaminoMarket.programId);
-        this.lendingIxs.push(liquidateIx);
-        return newUnstakeTicket.address;
-    }
     async addInBetweenIxs(action, includeAtaIxs, requestElevationGroup, addInitObligationForFarm, useV2Ixs) {
         await this.addSupportIxsWithoutInitObligation(action, includeAtaIxs, useV2Ixs, 'inBetween', requestElevationGroup, addInitObligationForFarm);
     }
@@ -1644,7 +1316,6 @@ class KaminoAction {
             'repayAndWithdrawV2',
             'refreshObligation',
             'depositAndWithdraw',
-            'unstakeLstCollateralStart',
         ].includes(action)) {
             // The support ixs in order are:
             // 0. Init obligation ix
@@ -1662,17 +1333,13 @@ class KaminoAction {
             if (action === 'liquidate' ||
                 action === 'depositAndBorrow' ||
                 action === 'repayAndWithdraw' ||
-                action === 'repayAndWithdrawV2' ||
-                action === 'unstakeLstCollateralStart') {
+                action === 'repayAndWithdrawV2') {
                 if (!this.outflowReserve) {
                     throw new Error('outflowReserve is undefined');
                 }
-                if (action === 'depositAndBorrow' ||
-                    action === 'repayAndWithdraw' ||
-                    action === 'repayAndWithdrawV2' ||
-                    action === 'unstakeLstCollateralStart') {
+                if (action === 'depositAndBorrow' || action === 'repayAndWithdraw' || action === 'repayAndWithdrawV2') {
                     currentReserves = [this.reserve, this.outflowReserve];
-                    if (action === 'depositAndBorrow' || action === 'unstakeLstCollateralStart') {
+                    if (action === 'depositAndBorrow') {
                         if ((0, obligation_1.isKaminoObligation)(this.obligation)) {
                             const deposit = this.obligation.getDepositByReserve(this.reserve.address);
                             if (!deposit) {
@@ -1725,12 +1392,6 @@ class KaminoAction {
                         await this.addInitObligationForFarm(this.outflowReserve, types_1.ReserveFarmKind.Collateral, addAsSupportIx);
                     }
                 }
-                else if (action === 'unstakeLstCollateralStart') {
-                    await this.addInitObligationForFarm(this.reserve, types_1.ReserveFarmKind.Collateral, addAsSupportIx);
-                    if (this.outflowReserve) {
-                        await this.addInitObligationForFarm(this.outflowReserve, types_1.ReserveFarmKind.Collateral, addAsSupportIx);
-                    }
-                }
                 else {
                     await this.addInitObligationForFarm(this.reserve, types_1.ReserveFarmKind.Collateral, addAsSupportIx);
                     await this.addInitObligationForFarm(this.reserve, types_1.ReserveFarmKind.Debt, addAsSupportIx);
@@ -1754,13 +1415,6 @@ class KaminoAction {
                     : [];
                 await this.addRefreshObligationIx(addAsSupportIx, repaidBorrowReservesToSkip);
             }
-            else if (action == 'unstakeLstCollateralStart') {
-                if (!(0, obligation_1.isKaminoObligation)(this.obligation)) {
-                    throw new Error(`obligation is not a KaminoObligation`);
-                }
-                // Usol reserve doesn't exist yet
-                await this.addRefreshObligationIx(addAsSupportIx, [this.reserve.address]);
-            }
             else {
                 await this.addRefreshObligationIx(addAsSupportIx);
             }
@@ -2387,32 +2041,24 @@ class KaminoAction {
         this.cleanupIxs.push(...postIxs);
         this.cleanupIxsLabels.push(...postIxsLabels);
     }
-    static async initializeMultiTokenAction(kaminoMarket, action, inflowAmount, inflowTokenMint, outflowTokenMint, signer, obligationOwner, obligation, outflowAmount, referrer = (0, kit_1.none)(), currentSlot = 0n, needsUnstakingPool = false) {
+    static async initializeMultiTokenAction(kaminoMarket, action, inflowAmount, inflowTokenMint, outflowTokenMint, signer, obligationOwner, obligation, outflowAmount, referrer = (0, kit_1.none)(), currentSlot = 0n) {
         const inflowReserve = kaminoMarket.getExistingReserveByMint(inflowTokenMint);
         const outflowReserve = kaminoMarket.getExistingReserveByMint(outflowTokenMint);
         const { kaminoObligation, depositReserves, borrowReserves, distinctReserveCount } = await KaminoAction.loadObligation(action, kaminoMarket, obligationOwner, inflowReserve.address, obligation, outflowReserve.address);
         const referrerKey = await this.getReferrerKey(kaminoMarket, signer.address, kaminoObligation, referrer);
         let secondaryMint;
         let primaryMint;
-        let unstakingPool = undefined;
         if (action === 'liquidate' ||
             action === 'depositAndBorrow' ||
             action === 'repayAndWithdraw' ||
-            action === 'repayAndWithdrawV2' ||
-            action === 'unstakeLstCollateralStart') {
+            action === 'repayAndWithdrawV2') {
             primaryMint = inflowTokenMint;
             secondaryMint = outflowTokenMint;
-            if (needsUnstakingPool) {
-                const unstakingPoolPk = kaminoMarket.state.unstakingPoolState;
-                const unstakingPoolProgramId = kaminoMarket.programId == programId_3.PROGRAM_ID ? programId_2.PROGRAM_ID : unstakingPool_1.UNSTAKING_POOL_STAGING_ID;
-                unstakingPool = new unstakingPool_1.UnstakingPool(unstakingPoolPk, undefined, unstakingPoolProgramId);
-                await unstakingPool.reloadState(kaminoMarket.getRpc());
-            }
         }
         else {
             throw new Error('Invalid action');
         }
-        return new KaminoAction(kaminoMarket, signer, kaminoObligation || obligation, primaryMint, distinctReserveCount, inflowAmount, depositReserves, borrowReserves, inflowReserve, currentSlot, unstakingPool, secondaryMint, outflowReserve, outflowAmount, referrerKey);
+        return new KaminoAction(kaminoMarket, signer, kaminoObligation || obligation, primaryMint, distinctReserveCount, inflowAmount, depositReserves, borrowReserves, inflowReserve, currentSlot, secondaryMint, outflowReserve, outflowAmount, referrerKey);
     }
     static async initializeWithdrawReferrerFees(mint, owner, kaminoMarket, currentSlot = 0n) {
         const reserve = kaminoMarket.getReserveByMint(mint);
@@ -2426,7 +2072,7 @@ class KaminoAction {
             },
         ]);
         return {
-            axn: new KaminoAction(kaminoMarket, owner, new ObligationType_1.VanillaObligation(kaminoMarket.programId), mint, 0, new bn_js_1.default(0), [], [], reserve, currentSlot, undefined, undefined, undefined, undefined, undefined, undefined),
+            axn: new KaminoAction(kaminoMarket, owner, new ObligationType_1.VanillaObligation(kaminoMarket.programId), mint, 0, new bn_js_1.default(0), [], [], reserve, currentSlot, undefined, undefined, undefined, undefined, undefined),
             createAtaIxs: [createAtaIx],
         };
     }