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

package/src/classes/action.ts

@@ -2,7 +2,6 @@ import {
   AccountRole,
   Address,
   fetchEncodedAccount,
-  generateKeyPairSigner,
   AccountMeta,
   Instruction,
   isNone,
@@ -45,10 +44,8 @@ import {
   RequestElevationGroupAccounts,
   RequestElevationGroupArgs,
   setObligationOrder,
-  unstakeLstCollateralStart,
   withdrawObligationCollateralAndRedeemReserveCollateral,
   withdrawObligationCollateralAndRedeemReserveCollateralV2,
-  withdrawObligationUsol,
   withdrawReferrerFees,
 } from '../@codegen/klend/instructions';
 import {
@@ -65,7 +62,6 @@ import {
   ScopePriceRefreshConfig,
   SOL_PADDING_FOR_INTEREST,
   U64_MAX,
-  unstakingPoolMarketAuthorityPda,
   userMetadataPda,
   WRAPPED_SOL_MINT,
 } from '../utils';
@@ -81,14 +77,8 @@ import { ObligationOrderAtIndex } from './obligationOrder';
 import { ASSOCIATED_TOKEN_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
 import { SYSVAR_INSTRUCTIONS_ADDRESS, SYSVAR_RENT_ADDRESS } from '@solana/sysvars';
 import { getCloseAccountInstruction, getSyncNativeInstruction } from '@solana-program/token-2022';
-import { getCreateAccountInstruction, getTransferSolInstruction, SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
+import { getTransferSolInstruction, SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
 import { noopSigner } from '../utils/signer';
-import { PROGRAM_ID as UNSTAKING_POOL_ID } from '../@codegen/unstaking_pool/programId';
-import { UNSTAKING_POOL_STAGING_ID, UnstakingPool, unstakingPoolBaseAuthorityPda } from './unstakingPool';
-import { PROGRAM_ID } from '../@codegen/klend/programId';
-import { UnstakeTicket } from '../@codegen/unstaking_pool/accounts/UnstakeTicket';
-import { burn } from '../@codegen/unstaking_pool/instructions';
-import { unstakeLstCollateralEnd } from '../@codegen/klend/instructions/unstakeLstCollateralEnd';
 
 export type ActionType =
   | 'deposit'
@@ -105,14 +95,12 @@ export type ActionType =
   | 'requestElevationGroup'
   | 'withdrawReferrerFees'
   | 'repayAndWithdrawV2'
-  | 'depositAndWithdraw'
-  | 'unstakeLstCollateralStart';
+  | 'depositAndWithdraw';
 
 export type AuxiliaryIx = 'setup' | 'inBetween' | 'cleanup';
 
 export class KaminoAction {
   kaminoMarket: KaminoMarket;
-  unstakingPool: UnstakingPool | undefined;
 
   reserve: KaminoReserve;
 
@@ -175,7 +163,6 @@ export class KaminoAction {
     borrowReserves: Array<Address>,
     reserveState: KaminoReserve,
     currentSlot: Slot,
-    unstakingPool?: UnstakingPool,
     secondaryMint?: Address,
     outflowReserveState?: KaminoReserve,
     outflowAmount?: string | BN,
@@ -210,7 +197,6 @@ export class KaminoAction {
     this.preLoadedDepositReservesSameTx = [];
     this.referrer = referrer;
     this.currentSlot = currentSlot;
-    this.unstakingPool = unstakingPool;
   }
 
   static async initialize(
@@ -222,8 +208,7 @@ export class KaminoAction {
     obligation: KaminoObligation | ObligationType,
     referrer: Option<Address> = none(),
     currentSlot: Slot = 0n,
-    payer: TransactionSigner = owner,
-    needsUnstakingPool: boolean = false
+    payer: TransactionSigner = owner
   ) {
     const reserve = kaminoMarket.getReserveByMint(mint);
     if (reserve === undefined) {
@@ -235,15 +220,6 @@ export class KaminoAction {
 
     const referrerKey = await this.getReferrerKey(kaminoMarket, owner.address, kaminoObligation, referrer);
 
-    let unstakingPool = undefined;
-    if (needsUnstakingPool) {
-      const unstakingPoolPk = kaminoMarket.state.unstakingPoolState;
-      const unstakingPoolProgramId =
-        kaminoMarket.programId == PROGRAM_ID ? UNSTAKING_POOL_ID : UNSTAKING_POOL_STAGING_ID;
-      unstakingPool = new UnstakingPool(unstakingPoolPk, undefined, unstakingPoolProgramId);
-      await unstakingPool.reloadState(kaminoMarket.getRpc());
-    }
-
     return new KaminoAction(
       kaminoMarket,
       owner,
@@ -255,7 +231,6 @@ export class KaminoAction {
       borrowReserves,
       reserve,
       currentSlot,
-      unstakingPool,
       undefined,
       undefined,
       undefined,
@@ -963,61 +938,6 @@ export class KaminoAction {
     return axn;
   }
 
-  static async buildUnstakeLstCollateralStartTxns(
-    kaminoMarket: KaminoMarket,
-    lstToConvert: string | BN,
-    usolMint: Address,
-    lstMint: Address,
-    payer: TransactionSigner,
-    currentSlot: Slot,
-    obligation: KaminoObligation | ObligationType,
-    depositStakedSolRemainingAccounts: AccountMeta[],
-    scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
-    extraComputeBudget: number = 1_000_000, // if > 0 then adds the ix
-    includeAtaIxs: boolean = true, // if true it includes create and close wsol and token atas,
-    initUserMetadata: { skipInitialization: boolean; skipLutCreation: boolean } = {
-      skipInitialization: false,
-      skipLutCreation: false,
-    },
-    referrer: Option<Address> = 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: KaminoMarket,
     amount: string | BN,
@@ -1084,85 +1004,6 @@ export class KaminoAction {
     return axn;
   }
 
-  static async buildWithdrawUsolTxns(
-    kaminoMarket: KaminoMarket,
-    amount: string | BN,
-    mint: Address,
-    owner: TransactionSigner,
-    obligation: KaminoObligation | ObligationType,
-    scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
-    extraComputeBudget: number = 1_000_000, // if > 0 then adds the ix
-    includeAtaIxs: boolean = true, // if true it includes create and close wsol and token atas,
-    requestElevationGroup: boolean = false, // to be requested *after* the withdraw
-    initUserMetadata: { skipInitialization: boolean; skipLutCreation: boolean } = {
-      skipInitialization: false,
-      skipLutCreation: false,
-    },
-    referrer: Option<Address> = none(),
-    currentSlot: Slot = 0n,
-    overrideElevationGroupRequest?: number,
-    // Optional customizations which may be needed if the obligation was mutated by some previous ix.
-    obligationCustomizations?: {
-      // Any newly-added deposit reserves.
-      addedDepositReserves?: Address[];
-    },
-    burnUsol: boolean = 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 createAssociatedTokenAccountIdempotentInstruction(
-        axn.owner,
-        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
@@ -1295,67 +1136,6 @@ export class KaminoAction {
     return axn;
   }
 
-  static async buildUnstakeLstCollateralEndTxns(
-    kaminoMarket: KaminoMarket,
-    amount: string | BN,
-    minCollateralReceiveAmount: string | BN,
-    repayTokenMint: Address,
-    withdrawTokenMint: Address,
-    liquidator: TransactionSigner,
-    obligationOwner: Address,
-    obligation: KaminoObligation | ObligationType,
-    scopeRefreshConfig: ScopePriceRefreshConfig | undefined = undefined,
-    extraComputeBudget: number = 1_000_000, // if > 0 then adds the ix
-    includeAtaIxs: boolean = true, // if true it includes create and close wsol and token atas, and creates all other token atas if they don't exist
-    requestElevationGroup: boolean = false,
-    initUserMetadata: { skipInitialization: boolean; skipLutCreation: boolean } = {
-      skipInitialization: false,
-      skipLutCreation: false,
-    },
-    referrer: Option<Address> = none(),
-    maxAllowedLtvOverridePercent: number = 0,
-    currentSlot: Slot = 0n,
-    burnUsol: boolean = false
-  ): Promise<KaminoAction> {
-    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: TransactionSigner,
     tokenMint: Address,
@@ -1537,128 +1317,6 @@ export class KaminoAction {
     );
   }
 
-  async addUnstakeLstCollateralStartIxs(depositStakedSolRemainingAccounts: AccountMeta[]) {
-    // 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: AccountMeta[] = depositReservesList.map((reserve) => {
-      return { address: reserve, role: AccountRole.WRITABLE };
-    });
-    const borrowReserveAccountMetas: AccountMeta[] = this.borrowReserves.map((reserve) => {
-      return { address: reserve, role: 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 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 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 generateKeyPairSigner();
-    const unstakeTicketSize = UnstakeTicket.layout.span + 8;
-    const createUnstakeTicketIx = 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 = 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: none(),
-            collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
-            liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
-            instructionSysvarAccount: 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: none(),
-            collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
-            liquidityTokenProgram: this.outflowReserve.getLiquidityTokenProgram(),
-            instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
-          },
-          depositFarmsAccounts,
-          withdrawFarmsAccounts,
-          farmsProgram: FARMS_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_PROGRAM_ADDRESS,
-          unstakingSolTokenProgram: 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`);
@@ -1878,76 +1536,6 @@ export class KaminoAction {
     );
   }
 
-  async addWithdrawUsolIx(collateralAmount: BN): Promise<Address> {
-    if (!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 generateKeyPairSigner();
-    const unstakeTicketSize = UnstakeTicket.layout.span + 8;
-    const createUnstakeTicketIx = 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 unstakingPoolMarketAuthorityPda(this.kaminoMarket.address, this.kaminoMarket.programId)
-    )[0];
-    this.lendingIxs.push(
-      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: none(),
-              collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
-              liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
-              instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
-            },
-            farmsAccounts: farmsAccounts,
-            farmsProgram: FARMS_PROGRAM_ID,
-          },
-          extraAccounts: {
-            unstakeTicket: this.obligation.state.unstakeTicket,
-            emptyUnstakeTicket: newUnstakeTicket.address,
-            unstakingPoolAuthority: unstakingPoolAuthority,
-            unstakingPoolProgram: this.unstakingPool.programId,
-            systemProgram: SYSTEM_PROGRAM_ADDRESS,
-          },
-        },
-        [],
-        this.kaminoMarket.programId
-      )
-    );
-    return newUnstakeTicket.address;
-  }
-
   /// @deprecated -- use addRepayIxV2 instead
   async addRepayIx() {
     const obligationAddress = await this.getObligationPda();
@@ -2553,39 +2141,6 @@ export class KaminoAction {
     );
   }
 
-  async addBurnAllUsolIx(unstakeTicket: Address): Promise<void> {
-    this.lendingIxsLabels.push(`burnUsolIx`);
-    if (!this.unstakingPool || !this.unstakingPool.state) {
-      throw new Error(`unstaking pool not set`);
-    }
-
-    this.lendingIxs.push(
-      burn(
-        {
-          sharesToBurn: new BN(U64_MAX),
-          minWsolToReceive: new BN(0), // TODO: find a way to compute a reasonable slippage
-        },
-        {
-          user: this.owner,
-          userUnstakingSolToken: await getAssociatedTokenAddress(
-            this.unstakingPool.state.unstakingSolMint,
-            this.owner.address,
-            TOKEN_PROGRAM_ADDRESS
-          ),
-          userWsolToken: await getAssociatedTokenAddress(WRAPPED_SOL_MINT, this.owner.address, TOKEN_PROGRAM_ADDRESS),
-          wsolVault: this.unstakingPool.state.wsolVault,
-          wsolMint: WRAPPED_SOL_MINT,
-          poolState: this.unstakingPool.address,
-          unstakeTicket,
-          unstakingSolMint: this.unstakingPool.state.unstakingSolMint,
-          basePoolAuthority: this.unstakingPool.state.basePoolAuthority,
-          tokenProgram: TOKEN_PROGRAM_ADDRESS,
-        },
-        this.unstakingPool.programId
-      )
-    );
-  }
-
   async addLiquidateIx(maxAllowedLtvOverridePercent: number = 0): Promise<void> {
     this.lendingIxsLabels.push(`liquidateObligationAndRedeemReserveCollateral`);
     if (!this.outflowReserve) {
@@ -2715,100 +2270,6 @@ export class KaminoAction {
     this.lendingIxs.push(liquidateIx);
   }
 
-  async addUnstakeLstCollateralEndIx(maxAllowedLtvOverridePercent: number = 0): Promise<Address> {
-    this.lendingIxsLabels.push(`unstakeLstCollateralEnd`);
-    if (!this.outflowReserve) {
-      throw Error(`Withdraw reserve during liquidation is not defined`);
-    }
-
-    if (!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: AccountMeta[] = depositReservesList.map((reserve) => {
-      return { address: reserve, role: 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 generateKeyPairSigner();
-    const unstakeTicketSize = UnstakeTicket.layout.span + 8;
-    const createUnstakeTicketIx = 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 unstakingPoolMarketAuthorityPda(this.kaminoMarket.address, this.kaminoMarket.programId)
-    )[0];
-    const extraAccounts = this.obligation!.state.elevationGroup > 0 ? depositReserveAccountMetas : [];
-    const liquidateIx = unstakeLstCollateralEnd(
-      {
-        liquidityAmount: this.amount,
-        // TODO: Configure this when updating liquidator with new interface
-        minAcceptableReceivedLiquidityAmount: this.outflowAmount || new BN(0),
-        maxAllowedLtvOverridePercent: new BN(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_PROGRAM_ADDRESS,
-            repayLiquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
-            withdrawLiquidityTokenProgram: this.outflowReserve.getLiquidityTokenProgram(),
-            instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
-          },
-          debtFarmsAccounts,
-          collateralFarmsAccounts,
-          farmsProgram: FARMS_PROGRAM_ID,
-        },
-        extraAccounts: {
-          unstakeTicket: this.obligation.state.unstakeTicket,
-          emptyUnstakeTicket: newUnstakeTicket.address,
-          unstakingPoolAuthority: unstakingPoolAuthority,
-          unstakingPoolProgram: this.unstakingPool.programId,
-          systemProgram: SYSTEM_PROGRAM_ADDRESS,
-        },
-      },
-      extraAccounts,
-      this.kaminoMarket.programId
-    );
-    this.lendingIxs.push(liquidateIx);
-    return newUnstakeTicket.address;
-  }
-
   async addInBetweenIxs(
     action: ActionType,
     includeAtaIxs: boolean,
@@ -2877,7 +2338,6 @@ export class KaminoAction {
         'repayAndWithdrawV2',
         'refreshObligation',
         'depositAndWithdraw',
-        'unstakeLstCollateralStart',
       ].includes(action)
     ) {
       // The support ixs in order are:
@@ -2899,21 +2359,15 @@ export class KaminoAction {
         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 (isKaminoObligation(this.obligation)) {
               const deposit = this.obligation.getDepositByReserve(this.reserve.address);
               if (!deposit) {
@@ -2968,11 +2422,6 @@ export class KaminoAction {
           if (this.outflowReserve) {
             await this.addInitObligationForFarm(this.outflowReserve, ReserveFarmKind.Collateral, addAsSupportIx);
           }
-        } else if (action === 'unstakeLstCollateralStart') {
-          await this.addInitObligationForFarm(this.reserve, ReserveFarmKind.Collateral, addAsSupportIx);
-          if (this.outflowReserve) {
-            await this.addInitObligationForFarm(this.outflowReserve, ReserveFarmKind.Collateral, addAsSupportIx);
-          }
         } else {
           await this.addInitObligationForFarm(this.reserve, ReserveFarmKind.Collateral, addAsSupportIx);
           await this.addInitObligationForFarm(this.reserve, ReserveFarmKind.Debt, addAsSupportIx);
@@ -2996,12 +2445,6 @@ export class KaminoAction {
           ? [repayObligationLiquidity.reserveAddress]
           : [];
         await this.addRefreshObligationIx(addAsSupportIx, repaidBorrowReservesToSkip);
-      } else if (action == 'unstakeLstCollateralStart') {
-        if (!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);
       }
@@ -3910,8 +3353,7 @@ export class KaminoAction {
     obligation: KaminoObligation | ObligationType,
     outflowAmount?: string | BN,
     referrer: Option<Address> = none(),
-    currentSlot: Slot = 0n,
-    needsUnstakingPool: boolean = false
+    currentSlot: Slot = 0n
   ) {
     const inflowReserve = kaminoMarket.getExistingReserveByMint(inflowTokenMint);
     const outflowReserve = kaminoMarket.getExistingReserveByMint(outflowTokenMint);
@@ -3929,24 +3371,15 @@ export class KaminoAction {
 
     let secondaryMint: Address;
     let primaryMint: Address;
-    let unstakingPool: UnstakingPool | undefined = 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 == PROGRAM_ID ? UNSTAKING_POOL_ID : UNSTAKING_POOL_STAGING_ID;
-        unstakingPool = new UnstakingPool(unstakingPoolPk, undefined, unstakingPoolProgramId);
-        await unstakingPool.reloadState(kaminoMarket.getRpc());
-      }
     } else {
       throw new Error('Invalid action');
     }
@@ -3962,7 +3395,6 @@ export class KaminoAction {
       borrowReserves,
       inflowReserve,
       currentSlot,
-      unstakingPool,
       secondaryMint,
       outflowReserve,
       outflowAmount,
@@ -4004,7 +3436,6 @@ export class KaminoAction {
         undefined,
         undefined,
         undefined,
-        undefined,
         undefined
       ),
       createAtaIxs: [createAtaIx],