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

package/src/classes/action.ts

@@ -2,6 +2,7 @@ import {
   AccountRole,
   Address,
   fetchEncodedAccount,
+  generateKeyPairSigner,
   AccountMeta,
   Instruction,
   isNone,
@@ -44,8 +45,10 @@ import {
   RequestElevationGroupAccounts,
   RequestElevationGroupArgs,
   setObligationOrder,
+  unstakeLstCollateralStart,
   withdrawObligationCollateralAndRedeemReserveCollateral,
   withdrawObligationCollateralAndRedeemReserveCollateralV2,
+  withdrawObligationUsol,
   withdrawReferrerFees,
 } from '../@codegen/klend/instructions';
 import {
@@ -62,6 +65,7 @@ import {
   ScopePriceRefreshConfig,
   SOL_PADDING_FOR_INTEREST,
   U64_MAX,
+  unstakingPoolMarketAuthorityPda,
   userMetadataPda,
   WRAPPED_SOL_MINT,
 } from '../utils';
@@ -77,8 +81,14 @@ 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 { getTransferSolInstruction, SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
+import { getCreateAccountInstruction, 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'
@@ -95,12 +105,14 @@ export type ActionType =
   | 'requestElevationGroup'
   | 'withdrawReferrerFees'
   | 'repayAndWithdrawV2'
-  | 'depositAndWithdraw';
+  | 'depositAndWithdraw'
+  | 'unstakeLstCollateralStart';
 
 export type AuxiliaryIx = 'setup' | 'inBetween' | 'cleanup';
 
 export class KaminoAction {
   kaminoMarket: KaminoMarket;
+  unstakingPool: UnstakingPool | undefined;
 
   reserve: KaminoReserve;
 
@@ -163,6 +175,7 @@ export class KaminoAction {
     borrowReserves: Array<Address>,
     reserveState: KaminoReserve,
     currentSlot: Slot,
+    unstakingPool?: UnstakingPool,
     secondaryMint?: Address,
     outflowReserveState?: KaminoReserve,
     outflowAmount?: string | BN,
@@ -197,6 +210,7 @@ export class KaminoAction {
     this.preLoadedDepositReservesSameTx = [];
     this.referrer = referrer;
     this.currentSlot = currentSlot;
+    this.unstakingPool = unstakingPool;
   }
 
   static async initialize(
@@ -208,7 +222,8 @@ export class KaminoAction {
     obligation: KaminoObligation | ObligationType,
     referrer: Option<Address> = none(),
     currentSlot: Slot = 0n,
-    payer: TransactionSigner = owner
+    payer: TransactionSigner = owner,
+    needsUnstakingPool: boolean = false
   ) {
     const reserve = kaminoMarket.getReserveByMint(mint);
     if (reserve === undefined) {
@@ -220,6 +235,15 @@ 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,
@@ -231,6 +255,7 @@ export class KaminoAction {
       borrowReserves,
       reserve,
       currentSlot,
+      unstakingPool,
       undefined,
       undefined,
       undefined,
@@ -938,6 +963,61 @@ 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,
@@ -1004,6 +1084,85 @@ 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
@@ -1136,6 +1295,67 @@ 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,
@@ -1317,6 +1537,128 @@ 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`);
@@ -1536,6 +1878,76 @@ 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();
@@ -2141,6 +2553,39 @@ 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) {
@@ -2270,6 +2715,100 @@ 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,
@@ -2338,6 +2877,7 @@ export class KaminoAction {
         'repayAndWithdrawV2',
         'refreshObligation',
         'depositAndWithdraw',
+        'unstakeLstCollateralStart',
       ].includes(action)
     ) {
       // The support ixs in order are:
@@ -2359,15 +2899,21 @@ export class KaminoAction {
         action === 'liquidate' ||
         action === 'depositAndBorrow' ||
         action === 'repayAndWithdraw' ||
-        action === 'repayAndWithdrawV2'
+        action === 'repayAndWithdrawV2' ||
+        action === 'unstakeLstCollateralStart'
       ) {
         if (!this.outflowReserve) {
           throw new Error('outflowReserve is undefined');
         }
 
-        if (action === 'depositAndBorrow' || action === 'repayAndWithdraw' || action === 'repayAndWithdrawV2') {
+        if (
+          action === 'depositAndBorrow' ||
+          action === 'repayAndWithdraw' ||
+          action === 'repayAndWithdrawV2' ||
+          action === 'unstakeLstCollateralStart'
+        ) {
           currentReserves = [this.reserve, this.outflowReserve];
-          if (action === 'depositAndBorrow') {
+          if (action === 'depositAndBorrow' || action === 'unstakeLstCollateralStart') {
             if (isKaminoObligation(this.obligation)) {
               const deposit = this.obligation.getDepositByReserve(this.reserve.address);
               if (!deposit) {
@@ -2422,6 +2968,11 @@ 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);
@@ -2445,6 +2996,12 @@ 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);
       }
@@ -3353,7 +3910,8 @@ export class KaminoAction {
     obligation: KaminoObligation | ObligationType,
     outflowAmount?: string | BN,
     referrer: Option<Address> = none(),
-    currentSlot: Slot = 0n
+    currentSlot: Slot = 0n,
+    needsUnstakingPool: boolean = false
   ) {
     const inflowReserve = kaminoMarket.getExistingReserveByMint(inflowTokenMint);
     const outflowReserve = kaminoMarket.getExistingReserveByMint(outflowTokenMint);
@@ -3371,15 +3929,24 @@ export class KaminoAction {
 
     let secondaryMint: Address;
     let primaryMint: Address;
+    let unstakingPool: UnstakingPool | undefined = undefined;
 
     if (
       action === 'liquidate' ||
       action === 'depositAndBorrow' ||
       action === 'repayAndWithdraw' ||
-      action === 'repayAndWithdrawV2'
+      action === 'repayAndWithdrawV2' ||
+      action === 'unstakeLstCollateralStart'
     ) {
       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');
     }
@@ -3395,6 +3962,7 @@ export class KaminoAction {
       borrowReserves,
       inflowReserve,
       currentSlot,
+      unstakingPool,
       secondaryMint,
       outflowReserve,
       outflowAmount,
@@ -3436,6 +4004,7 @@ export class KaminoAction {
         undefined,
         undefined,
         undefined,
+        undefined,
         undefined
       ),
       createAtaIxs: [createAtaIx],