@kamino-finance/klend-sdk 5.10.35-beta.0 → 5.10.35-beta.1

package/src/classes/action.ts

@@ -21,12 +21,10 @@ import BN from 'bn.js';
 import Decimal from 'decimal.js';
 import {
   borrowObligationLiquidity,
-  borrowObligationLiquidityV2,
+  depositAndWithdraw,
   depositObligationCollateral,
-  depositObligationCollateralV2,
   depositReserveLiquidity,
   depositReserveLiquidityAndObligationCollateral,
-  depositReserveLiquidityAndObligationCollateralV2,
   initObligation,
   initObligationFarmsForReserve,
   InitObligationFarmsForReserveAccounts,
@@ -34,20 +32,18 @@ import {
   initReferrerTokenState,
   initUserMetadata,
   liquidateObligationAndRedeemReserveCollateral,
-  liquidateObligationAndRedeemReserveCollateralV2,
   redeemReserveCollateral,
   refreshObligation,
   refreshObligationFarmsForReserve,
   RefreshObligationFarmsForReserveAccounts,
   RefreshObligationFarmsForReserveArgs,
   refreshReserve,
+  repayAndWithdrawAndRedeem,
   repayObligationLiquidity,
-  repayObligationLiquidityV2,
   requestElevationGroup,
   RequestElevationGroupAccounts,
   RequestElevationGroupArgs,
   withdrawObligationCollateralAndRedeemReserveCollateral,
-  withdrawObligationCollateralAndRedeemReserveCollateralV2,
   withdrawReferrerFees,
 } from '../idl_codegen/instructions';
 import {
@@ -90,7 +86,9 @@ export type ActionType =
   | 'repayAndWithdraw'
   | 'refreshObligation'
   | 'requestElevationGroup'
-  | 'withdrawReferrerFees';
+  | 'withdrawReferrerFees'
+  | 'repayAndWithdrawV2'
+  | 'depositAndWithdraw';
 
 export type AuxiliaryIx = 'setup' | 'inBetween' | 'cleanup';
 
@@ -410,7 +408,6 @@ export class KaminoAction {
     mint: PublicKey,
     owner: PublicKey,
     obligation: KaminoObligation | ObligationType,
-    useV2Ixs: boolean,
     extraComputeBudget: number = 1_000_000, // if > 0 then adds the ixn
     includeAtaIxns: boolean = true, // if true it includes create and close wsol and token atas,
     requestElevationGroup: boolean = false, // to be requested *before* the deposit
@@ -453,16 +450,12 @@ export class KaminoAction {
       requestElevationGroup,
       includeUserMetadata,
       addInitObligationForFarm,
-      useV2Ixs,
+      false,
       createLookupTable,
       undefined,
       overrideElevationGroupRequest
     );
-    if (useV2Ixs) {
-      axn.addDepositIxV2();
-    } else {
-      axn.addDepositIx();
-    }
+    axn.addDepositIx();
     axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
 
     return axn;
@@ -512,7 +505,6 @@ export class KaminoAction {
     mint: PublicKey,
     owner: PublicKey,
     obligation: KaminoObligation | ObligationType,
-    useV2Ixs: boolean,
     extraComputeBudget: number = 1_000_000, // if > 0 then adds the ixn
     includeAtaIxns: boolean = true, // if true it includes create and close wsol and token atas,
     requestElevationGroup: boolean = false,
@@ -555,16 +547,12 @@ export class KaminoAction {
       requestElevationGroup,
       includeUserMetadata,
       addInitObligationForFarm,
-      useV2Ixs,
+      false,
       createLookupTable,
       undefined,
       overrideElevationGroupRequest
     );
-    if (useV2Ixs) {
-      axn.addBorrowIxV2();
-    } else {
-      axn.addBorrowIx();
-    }
+    axn.addBorrowIx();
     axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
 
     return axn;
@@ -684,7 +672,6 @@ export class KaminoAction {
     mint: PublicKey,
     owner: PublicKey,
     obligation: KaminoObligation | ObligationType,
-    useV2Ixs: boolean,
     extraComputeBudget: number = 1_000_000, // if > 0 then adds the ixn
     includeAtaIxns: boolean = true, // if true it includes create and close wsol and token atas
     requestElevationGroup: boolean = false,
@@ -727,14 +714,10 @@ export class KaminoAction {
       requestElevationGroup,
       includeUserMetadata,
       addInitObligationForFarm,
-      useV2Ixs,
+      false,
       createLookupTable
     );
-    if (useV2Ixs) {
-      axn.addDepositObligationCollateralIxV2();
-    } else {
-      axn.addDepositObligationCollateralIx();
-    }
+    axn.addDepositObligationCollateralIx();
     axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
     return axn;
   }
@@ -747,7 +730,6 @@ export class KaminoAction {
     borrowMint: PublicKey,
     payer: PublicKey,
     obligation: KaminoObligation | ObligationType,
-    useV2Ixs: boolean,
     extraComputeBudget: number = 1_000_000, // if > 0 then adds the ixn
     includeAtaIxns: boolean = true, // if true it includes create and close wsol and token atas,
     requestElevationGroup: boolean = false,
@@ -796,27 +778,147 @@ export class KaminoAction {
       requestElevationGroup,
       includeUserMetadata,
       addInitObligationForFarmForDeposit,
-      useV2Ixs,
+      false,
       createLookupTable,
       twoTokenAction
     );
-
-    if (useV2Ixs) {
-      await axn.addDepositAndBorrowIxV2();
-    } else {
-      await axn.addDepositAndBorrowIx();
-    }
+    axn.addDepositAndBorrowIx();
     await axn.addInBetweenIxs(
       'depositAndBorrow',
       includeAtaIxns,
       requestElevationGroup,
-      addInitObligationForFarmForBorrow,
-      useV2Ixs
+      addInitObligationForFarmForBorrow
     );
     axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
     return axn;
   }
 
+  static async buildDepositAndWithdrawV2Txns(
+    kaminoMarket: KaminoMarket,
+    depositAmount: string | BN,
+    depositMint: PublicKey,
+    withdrawAmount: string | BN,
+    withdrawMint: PublicKey,
+    payer: PublicKey,
+    currentSlot: number,
+    obligation: KaminoObligation | ObligationType,
+    extraComputeBudget: number = 1_000_000, // if > 0 then adds the ixn
+    includeAtaIxns: boolean = true, // if true it includes create and close wsol and token atas,
+    requestElevationGroup: boolean = false,
+    includeUserMetadata: boolean = true, // if true it includes user metadata,
+    referrer: PublicKey = PublicKey.default,
+    scopeRefresh: ScopeRefresh = { includeScopeRefresh: false, scopeFeed: 'hubble' }
+  ) {
+    const axn = await KaminoAction.initializeMultiTokenAction(
+      kaminoMarket,
+      'depositAndWithdraw',
+      depositAmount,
+      depositMint,
+      withdrawMint,
+      payer,
+      payer,
+      obligation,
+      withdrawAmount,
+      referrer,
+      currentSlot
+    );
+    const addInitObligationForFarm = true;
+    const twoTokenAction = true;
+    if (extraComputeBudget > 0) {
+      axn.addComputeBudgetIxn(extraComputeBudget);
+    }
+
+    const allReserves = new PublicKeySet<PublicKey>([
+      ...axn.depositReserves,
+      ...axn.borrowReserves,
+      axn.reserve.address,
+      axn.outflowReserve!.address,
+    ]).toArray();
+    const tokenIds = axn.getTokenIdsForScopeRefresh(kaminoMarket, allReserves);
+
+    if (tokenIds.length > 0 && scopeRefresh.includeScopeRefresh) {
+      await axn.addScopeRefreshIxs(tokenIds, scopeRefresh.scopeFeed);
+    }
+
+    await axn.addSupportIxs(
+      'depositAndWithdraw',
+      includeAtaIxns,
+      requestElevationGroup,
+      includeUserMetadata,
+      addInitObligationForFarm,
+      true,
+      twoTokenAction
+    );
+    const withdrawCollateralAmount = axn.getWithdrawCollateralAmount(axn.outflowReserve!, axn.outflowAmount!);
+    axn.addDepositAndWithdrawV2Ixs(withdrawCollateralAmount);
+
+    return axn;
+  }
+
+  static async buildRepayAndWithdrawV2Txns(
+    kaminoMarket: KaminoMarket,
+    repayAmount: string | BN,
+    repayMint: PublicKey,
+    withdrawAmount: string | BN,
+    withdrawMint: PublicKey,
+    payer: PublicKey,
+    currentSlot: number,
+    obligation: KaminoObligation | ObligationType,
+    extraComputeBudget: number = 1_000_000, // if > 0 then adds the ixn
+    includeAtaIxns: boolean = true, // if true it includes create and close wsol and token atas,
+    requestElevationGroup: boolean = false,
+    includeUserMetadata: boolean = true, // if true it includes user metadata,
+    createLookupTable: boolean = true,
+    referrer: PublicKey = PublicKey.default,
+    scopeRefresh: ScopeRefresh = { includeScopeRefresh: false, scopeFeed: 'hubble' }
+  ) {
+    const axn = await KaminoAction.initializeMultiTokenAction(
+      kaminoMarket,
+      'repayAndWithdrawV2',
+      repayAmount,
+      repayMint,
+      withdrawMint,
+      payer,
+      payer,
+      obligation,
+      withdrawAmount,
+      referrer,
+      currentSlot
+    );
+    const addInitObligationForFarm = true;
+    const twoTokenAction = true;
+    if (extraComputeBudget > 0) {
+      axn.addComputeBudgetIxn(extraComputeBudget);
+    }
+
+    const allReserves = new PublicKeySet<PublicKey>([
+      ...axn.depositReserves,
+      ...axn.borrowReserves,
+      axn.reserve.address,
+      axn.outflowReserve!.address,
+    ]).toArray();
+    const tokenIds = axn.getTokenIdsForScopeRefresh(kaminoMarket, allReserves);
+
+    if (tokenIds.length > 0 && scopeRefresh.includeScopeRefresh) {
+      await axn.addScopeRefreshIxs(tokenIds, scopeRefresh.scopeFeed);
+    }
+
+    await axn.addSupportIxs(
+      'repayAndWithdrawV2',
+      includeAtaIxns,
+      requestElevationGroup,
+      includeUserMetadata,
+      addInitObligationForFarm,
+      true,
+      createLookupTable,
+      twoTokenAction
+    );
+    const withdrawCollateralAmount = axn.getWithdrawCollateralAmount(axn.outflowReserve!, axn.outflowAmount!);
+    axn.addRepayAndWithdrawV2Ixs(withdrawCollateralAmount);
+
+    return axn;
+  }
+
   static async buildRepayAndWithdrawTxns(
     kaminoMarket: KaminoMarket,
     repayAmount: string | BN,
@@ -826,7 +928,6 @@ export class KaminoAction {
     payer: PublicKey,
     currentSlot: number,
     obligation: KaminoObligation | ObligationType,
-    useV2Ixs: boolean,
     extraComputeBudget: number = 1_000_000, // if > 0 then adds the ixn
     includeAtaIxns: boolean = true, // if true it includes create and close wsol and token atas,
     requestElevationGroup: boolean = false,
@@ -873,24 +974,19 @@ export class KaminoAction {
       requestElevationGroup,
       includeUserMetadata,
       addInitObligationForFarmForRepay,
-      useV2Ixs,
+      false,
       createLookupTable,
       twoTokenAction
     );
 
     const withdrawCollateralAmount = axn.getWithdrawCollateralAmount(axn.outflowReserve!, axn.outflowAmount!);
-    if (useV2Ixs) {
-      await axn.addRepayAndWithdrawIxsV2(withdrawCollateralAmount);
-    } else {
-      await axn.addRepayAndWithdrawIxs(withdrawCollateralAmount);
-    }
 
+    await axn.addRepayAndWithdrawIxs(withdrawCollateralAmount);
     await axn.addInBetweenIxs(
       'repayAndWithdraw',
       includeAtaIxns,
       requestElevationGroup,
-      addInitObligationForFarmForWithdraw,
-      useV2Ixs
+      addInitObligationForFarmForWithdraw
     );
     axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
     return axn;
@@ -902,7 +998,6 @@ export class KaminoAction {
     mint: PublicKey,
     owner: PublicKey,
     obligation: KaminoObligation | ObligationType,
-    useV2Ixs: boolean,
     extraComputeBudget: number = 1_000_000, // if > 0 then adds the ixn
     includeAtaIxns: boolean = true, // if true it includes create and close wsol and token atas,
     requestElevationGroup: boolean = false, // to be requested *after* the withdraw
@@ -953,19 +1048,15 @@ export class KaminoAction {
       requestElevationGroup,
       includeUserMetadata,
       addInitObligationForFarm,
-      useV2Ixs,
+      false,
       createLookupTable,
       false,
       overrideElevationGroupRequest
     );
 
     const collateralAmount = axn.getWithdrawCollateralAmount(axn.reserve, axn.amount);
-    if (useV2Ixs) {
-      await axn.addWithdrawIxV2(collateralAmount);
-    } else {
-      await axn.addWithdrawIx(collateralAmount);
-    }
 
+    axn.addWithdrawIx(collateralAmount);
     axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
 
     return axn;
@@ -992,7 +1083,6 @@ export class KaminoAction {
     mint: PublicKey,
     owner: PublicKey,
     obligation: KaminoObligation | ObligationType,
-    useV2Ixs: boolean,
     currentSlot: number,
     payer: PublicKey | undefined = undefined,
     extraComputeBudget: number = 1_000_000,
@@ -1037,14 +1127,10 @@ export class KaminoAction {
       requestElevationGroup,
       includeUserMetadata,
       addInitObligationForFarm,
-      useV2Ixs,
+      false,
       createLookupTable
     );
-    if (useV2Ixs) {
-      await axn.addRepayIxV2();
-    } else {
-      await axn.addRepayIx();
-    }
+    axn.addRepayIx();
     axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
 
     return axn;
@@ -1059,7 +1145,6 @@ export class KaminoAction {
     liquidator: PublicKey,
     obligationOwner: PublicKey,
     obligation: KaminoObligation | ObligationType,
-    useV2Ixs: boolean,
     extraComputeBudget: number = 1_000_000, // if > 0 then adds the ixn
     includeAtaIxns: 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,
@@ -1107,14 +1192,10 @@ export class KaminoAction {
       requestElevationGroup,
       includeUserMetadata,
       addInitObligationForFarm,
-      useV2Ixs,
+      false,
       createLookupTable
     );
-    if (useV2Ixs) {
-      await axn.addLiquidateIxV2(maxAllowedLtvOverridePercent);
-    } else {
-      await axn.addLiquidateIx(maxAllowedLtvOverridePercent);
-    }
+    axn.addLiquidateIx(maxAllowedLtvOverridePercent);
     axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
 
     return axn;
@@ -1240,23 +1321,25 @@ export class KaminoAction {
     return await sendTransaction(txn, this.kaminoMarket.getConnection());
   }
 
-  addDepositReserveLiquidityIx() {
-    this.lendingIxsLabels.push(`depositReserveLiquidity`);
+  addDepositIx() {
+    this.lendingIxsLabels.push(`depositReserveLiquidityAndObligationCollateral`);
     this.lendingIxs.push(
-      depositReserveLiquidity(
+      depositReserveLiquidityAndObligationCollateral(
         {
           liquidityAmount: this.amount,
         },
         {
           owner: this.owner,
+          obligation: this.getObligationPda(),
           lendingMarket: this.kaminoMarket.getAddress(),
           lendingMarketAuthority: 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: this.userTokenAccountAddress,
-          userDestinationCollateral: this.userCollateralAccountAddress,
+          placeholderUserDestinationCollateral: this.kaminoMarket.programId,
           collateralTokenProgram: TOKEN_PROGRAM_ID,
           liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
           instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
@@ -1266,12 +1349,12 @@ export class KaminoAction {
     );
   }
 
-  addRedeemReserveCollateralIx() {
-    this.lendingIxsLabels.push(`redeemReserveCollateral`);
+  addDepositReserveLiquidityIx() {
+    this.lendingIxsLabels.push(`depositReserveLiquidity`);
     this.lendingIxs.push(
-      redeemReserveCollateral(
+      depositReserveLiquidity(
         {
-          collateralAmount: this.amount,
+          liquidityAmount: this.amount,
         },
         {
           owner: this.owner,
@@ -1281,8 +1364,8 @@ export class KaminoAction {
           reserveLiquidityMint: this.reserve.getLiquidityMint(),
           reserveLiquiditySupply: this.reserve.state.liquidity.supplyVault,
           reserveCollateralMint: this.reserve.getCTokenMint(),
-          userSourceCollateral: this.userCollateralAccountAddress,
-          userDestinationLiquidity: this.userTokenAccountAddress,
+          userSourceLiquidity: this.userTokenAccountAddress,
+          userDestinationCollateral: this.userCollateralAccountAddress,
           collateralTokenProgram: TOKEN_PROGRAM_ID,
           liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
           instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
@@ -1292,26 +1375,23 @@ export class KaminoAction {
     );
   }
 
-  // @deprecated -- use addDepositIxV2 instead
-  addDepositIx() {
-    this.lendingIxsLabels.push(`depositReserveLiquidityAndObligationCollateral`);
+  addRedeemReserveCollateralIx() {
+    this.lendingIxsLabels.push(`redeemReserveCollateral`);
     this.lendingIxs.push(
-      depositReserveLiquidityAndObligationCollateral(
+      redeemReserveCollateral(
         {
-          liquidityAmount: this.amount,
+          collateralAmount: this.amount,
         },
         {
           owner: this.owner,
-          obligation: this.getObligationPda(),
           lendingMarket: this.kaminoMarket.getAddress(),
           lendingMarketAuthority: 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: this.userTokenAccountAddress,
-          placeholderUserDestinationCollateral: this.kaminoMarket.programId,
+          userSourceCollateral: this.userCollateralAccountAddress,
+          userDestinationLiquidity: this.userTokenAccountAddress,
           collateralTokenProgram: TOKEN_PROGRAM_ID,
           liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
           instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
@@ -1321,52 +1401,6 @@ export class KaminoAction {
     );
   }
 
-  addDepositIxV2() {
-    const farmsAccounts = this.reserve.state.farmCollateral.equals(PublicKey.default)
-      ? {
-          obligationFarmUserState: PROGRAM_ID,
-          reserveFarmState: PROGRAM_ID,
-        }
-      : {
-          obligationFarmUserState: obligationFarmStatePda(
-            this.getObligationPda(),
-            this.reserve.state.farmCollateral
-          )[0],
-          reserveFarmState: this.reserve.state.farmCollateral,
-        };
-
-    this.lendingIxsLabels.push(`depositReserveLiquidityAndObligationCollateralV2`);
-    this.lendingIxs.push(
-      depositReserveLiquidityAndObligationCollateralV2(
-        {
-          liquidityAmount: this.amount,
-        },
-        {
-          depositAccounts: {
-            owner: this.owner,
-            obligation: this.getObligationPda(),
-            lendingMarket: this.kaminoMarket.getAddress(),
-            lendingMarketAuthority: 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: this.userTokenAccountAddress,
-            placeholderUserDestinationCollateral: this.kaminoMarket.programId,
-            collateralTokenProgram: TOKEN_PROGRAM_ID,
-            liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
-            instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
-          },
-          farmsAccounts,
-          farmsProgram: farmsId,
-        },
-        this.kaminoMarket.programId
-      )
-    );
-  }
-
-  /// @deprecated -- use addDepositObligationCollateralIxV2 instead
   addDepositObligationCollateralIx() {
     this.lendingIxsLabels.push(`depositObligationCollateral`);
     this.lendingIxs.push(
@@ -1389,47 +1423,6 @@ export class KaminoAction {
     );
   }
 
-  addDepositObligationCollateralIxV2() {
-    const farmsAccounts = this.reserve.state.farmCollateral.equals(PublicKey.default)
-      ? {
-          obligationFarmUserState: PROGRAM_ID,
-          reserveFarmState: PROGRAM_ID,
-        }
-      : {
-          obligationFarmUserState: obligationFarmStatePda(
-            this.getObligationPda(),
-            this.reserve.state.farmCollateral
-          )[0],
-          reserveFarmState: this.reserve.state.farmCollateral,
-        };
-
-    this.lendingIxsLabels.push(`depositObligationCollateralV2`);
-    this.lendingIxs.push(
-      depositObligationCollateralV2(
-        {
-          collateralAmount: this.amount,
-        },
-        {
-          depositAccounts: {
-            owner: this.owner,
-            obligation: this.getObligationPda(),
-            lendingMarket: this.kaminoMarket.getAddress(),
-            depositReserve: this.reserve.address,
-            reserveDestinationCollateral: this.reserve.state.collateral.supplyVault,
-            userSourceCollateral: this.userCollateralAccountAddress,
-            tokenProgram: TOKEN_PROGRAM_ID,
-            instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
-          },
-          lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
-          farmsAccounts,
-          farmsProgram: farmsId,
-        },
-        this.kaminoMarket.programId
-      )
-    );
-  }
-
-  /// @deprecated -- use addDepositObligationCollateralIxV2 instead
   addBorrowIx() {
     this.lendingIxsLabels.push(`borrowObligationLiquidity`);
 
@@ -1466,220 +1459,7 @@ export class KaminoAction {
     this.lendingIxs.push(borrowIx);
   }
 
-  addBorrowIxV2() {
-    this.lendingIxsLabels.push(`borrowObligationLiquidityV2`);
-
-    const depositReservesList = this.getAdditionalDepositReservesList();
-
-    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
-    });
-
-    const farmsAccounts = this.reserve.state.farmDebt.equals(PublicKey.default)
-      ? {
-          obligationFarmUserState: PROGRAM_ID,
-          reserveFarmState: PROGRAM_ID,
-        }
-      : {
-          obligationFarmUserState: obligationFarmStatePda(this.getObligationPda(), this.reserve.state.farmDebt)[0],
-          reserveFarmState: this.reserve.state.farmDebt,
-        };
-
-    const borrowIx = borrowObligationLiquidityV2(
-      {
-        liquidityAmount: this.amount,
-      },
-      {
-        borrowAccounts: {
-          owner: this.owner,
-          obligation: this.getObligationPda(),
-          lendingMarket: this.kaminoMarket.getAddress(),
-          lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
-          borrowReserve: this.reserve.address,
-          borrowReserveLiquidityMint: this.reserve.getLiquidityMint(),
-          reserveSourceLiquidity: this.reserve.state.liquidity.supplyVault,
-          userDestinationLiquidity: this.userTokenAccountAddress,
-          borrowReserveLiquidityFeeReceiver: this.reserve.state.liquidity.feeVault,
-          referrerTokenState: referrerTokenStatePda(
-            this.referrer,
-            this.reserve.address,
-            this.kaminoMarket.programId
-          )[0],
-          tokenProgram: this.reserve.getLiquidityTokenProgram(),
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
-        },
-        farmsAccounts,
-        farmsProgram: farmsId,
-      },
-      this.kaminoMarket.programId
-    );
-    borrowIx.keys =
-      this.obligation!.state.elevationGroup > 0 || this.obligation!.refreshedStats.potentialElevationGroupUpdate > 0
-        ? borrowIx.keys.concat([...depositReserveAccountMetas])
-        : borrowIx.keys;
-    this.lendingIxs.push(borrowIx);
-  }
-
-  /// @deprecated -- use addWithdrawIxV2 instead
-  async addWithdrawIx(collateralAmount: BN) {
-    this.lendingIxsLabels.push(`withdrawObligationCollateralAndRedeemReserveCollateral`);
-    this.lendingIxs.push(
-      withdrawObligationCollateralAndRedeemReserveCollateral(
-        {
-          collateralAmount,
-        },
-        {
-          owner: this.owner,
-          obligation: this.getObligationPda(),
-          lendingMarket: this.kaminoMarket.getAddress(),
-          lendingMarketAuthority: 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: this.userTokenAccountAddress,
-          placeholderUserDestinationCollateral: this.kaminoMarket.programId,
-          collateralTokenProgram: TOKEN_PROGRAM_ID,
-          liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
-        },
-        this.kaminoMarket.programId
-      )
-    );
-  }
-
-  async addWithdrawIxV2(collateralAmount: BN) {
-    const farmsAccounts = this.reserve.state.farmCollateral.equals(PublicKey.default)
-      ? {
-          obligationFarmUserState: PROGRAM_ID,
-          reserveFarmState: PROGRAM_ID,
-        }
-      : {
-          obligationFarmUserState: obligationFarmStatePda(
-            this.getObligationPda(),
-            this.reserve.state.farmCollateral
-          )[0],
-          reserveFarmState: this.reserve.state.farmCollateral,
-        };
-
-    this.lendingIxsLabels.push(`withdrawObligationCollateralAndRedeemReserveCollateralV2`);
-    this.lendingIxs.push(
-      withdrawObligationCollateralAndRedeemReserveCollateralV2(
-        {
-          collateralAmount,
-        },
-        {
-          withdrawAccounts: {
-            owner: this.owner,
-            obligation: this.getObligationPda(),
-            lendingMarket: this.kaminoMarket.getAddress(),
-            lendingMarketAuthority: 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: this.userTokenAccountAddress,
-            placeholderUserDestinationCollateral: this.kaminoMarket.programId,
-            collateralTokenProgram: TOKEN_PROGRAM_ID,
-            liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
-            instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
-          },
-          farmsAccounts: farmsAccounts,
-          farmsProgram: farmsId,
-        },
-        this.kaminoMarket.programId
-      )
-    );
-  }
-
-  /// @deprecated -- use addRepayIxV2 instead
-  async addRepayIx() {
-    this.lendingIxsLabels.push(
-      `repayObligationLiquidity(reserve=${this.reserve.address})(obligation=${this.getObligationPda()})`
-    );
-
-    const depositReservesList = this.getAdditionalDepositReservesList();
-
-    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
-    });
-
-    const repayIx = repayObligationLiquidity(
-      {
-        liquidityAmount: this.amount,
-      },
-      {
-        owner: this.payer,
-        obligation: this.getObligationPda(),
-        lendingMarket: this.kaminoMarket.getAddress(),
-        repayReserve: this.reserve.address,
-        reserveLiquidityMint: this.reserve.getLiquidityMint(),
-        userSourceLiquidity: this.userTokenAccountAddress,
-        reserveDestinationLiquidity: this.reserve.state.liquidity.supplyVault,
-        tokenProgram: this.reserve.getLiquidityTokenProgram(),
-        instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
-      },
-      this.kaminoMarket.programId
-    );
-
-    repayIx.keys =
-      this.obligation!.state.elevationGroup > 0 ? repayIx.keys.concat([...depositReserveAccountMetas]) : repayIx.keys;
-
-    this.lendingIxs.push(repayIx);
-  }
-
-  async addRepayIxV2() {
-    this.lendingIxsLabels.push(
-      `repayObligationLiquidityV2(reserve=${this.reserve.address})(obligation=${this.getObligationPda()})`
-    );
-
-    const depositReservesList = this.getAdditionalDepositReservesList();
-
-    const farmsAccounts = this.reserve.state.farmDebt.equals(PublicKey.default)
-      ? {
-          obligationFarmUserState: PROGRAM_ID,
-          reserveFarmState: PROGRAM_ID,
-        }
-      : {
-          obligationFarmUserState: obligationFarmStatePda(this.getObligationPda(), this.reserve.state.farmDebt)[0],
-          reserveFarmState: this.reserve.state.farmDebt,
-        };
-    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
-    });
-
-    const repayIx = repayObligationLiquidityV2(
-      {
-        liquidityAmount: this.amount,
-      },
-      {
-        repayAccounts: {
-          owner: this.payer,
-          obligation: this.getObligationPda(),
-          lendingMarket: this.kaminoMarket.getAddress(),
-          repayReserve: this.reserve.address,
-          reserveLiquidityMint: this.reserve.getLiquidityMint(),
-          userSourceLiquidity: this.userTokenAccountAddress,
-          reserveDestinationLiquidity: this.reserve.state.liquidity.supplyVault,
-          tokenProgram: this.reserve.getLiquidityTokenProgram(),
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
-        },
-        lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
-        farmsAccounts,
-        farmsProgram: farmsId,
-      },
-      this.kaminoMarket.programId
-    );
-
-    repayIx.keys =
-      this.obligation!.state.elevationGroup > 0 ? repayIx.keys.concat([...depositReserveAccountMetas]) : repayIx.keys;
-
-    this.lendingIxs.push(repayIx);
-  }
-
-  async addDepositAndBorrowIx() {
+  addDepositAndBorrowIx() {
     this.lendingIxsLabels.push(`depositReserveLiquidityAndObligationCollateral`);
     this.lendingIxsLabels.push(`borrowObligationLiquidity`);
     this.lendingIxs.push(
@@ -1729,137 +1509,25 @@ export class KaminoAction {
 
     const borrowIx = borrowObligationLiquidity(
       {
-        liquidityAmount: this.outflowAmount,
-      },
-      {
-        owner: this.owner,
-        obligation: this.getObligationPda(),
-        lendingMarket: this.kaminoMarket.getAddress(),
-        lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
-        borrowReserve: this.outflowReserve.address,
-        borrowReserveLiquidityMint: this.outflowReserve.getLiquidityMint(),
-        reserveSourceLiquidity: this.outflowReserve.state.liquidity.supplyVault,
-        userDestinationLiquidity: this.additionalTokenAccountAddress,
-        borrowReserveLiquidityFeeReceiver: this.outflowReserve.state.liquidity.feeVault,
-        referrerTokenState: referrerTokenStatePda(
-          this.referrer,
-          this.outflowReserve.address,
-          this.kaminoMarket.programId
-        )[0],
-        tokenProgram: this.outflowReserve.getLiquidityTokenProgram(),
-        instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
-      },
-      this.kaminoMarket.programId
-    );
-
-    borrowIx.keys = borrowIx.keys.concat([...depositReserveAccountMetas]);
-
-    this.lendingIxs.push(borrowIx);
-  }
-
-  async addDepositAndBorrowIxV2() {
-    const collateralFarmsAccounts = this.reserve.state.farmCollateral.equals(PublicKey.default)
-      ? {
-          obligationFarmUserState: PROGRAM_ID,
-          reserveFarmState: PROGRAM_ID,
-        }
-      : {
-          obligationFarmUserState: obligationFarmStatePda(
-            this.getObligationPda(),
-            this.reserve.state.farmCollateral
-          )[0],
-          reserveFarmState: this.reserve.state.farmCollateral,
-        };
-
-    this.lendingIxsLabels.push(`depositReserveLiquidityAndObligationCollateralV2`);
-    this.lendingIxsLabels.push(`borrowObligationLiquidityV2`);
-    this.lendingIxs.push(
-      depositReserveLiquidityAndObligationCollateralV2(
-        {
-          liquidityAmount: this.amount,
-        },
-        {
-          depositAccounts: {
-            owner: this.owner,
-            obligation: this.getObligationPda(),
-            lendingMarket: this.kaminoMarket.getAddress(),
-            lendingMarketAuthority: 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: this.userTokenAccountAddress,
-            placeholderUserDestinationCollateral: this.kaminoMarket.programId,
-            collateralTokenProgram: TOKEN_PROGRAM_ID,
-            liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
-            instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
-          },
-          farmsAccounts: collateralFarmsAccounts,
-          farmsProgram: farmsId,
-        },
-        this.kaminoMarket.programId
-      )
-    );
-
-    if (!this.outflowReserve) {
-      throw new Error(`outflowReserve not set`);
-    }
-
-    if (!this.additionalTokenAccountAddress) {
-      throw new Error(`additionalTokenAccountAddress not set`);
-    }
-
-    if (!this.outflowAmount) {
-      throw new Error(`outflowAmount not set`);
-    }
-
-    const depositReservesList = this.getAdditionalDepositReservesList();
-    if (depositReservesList.length === 0) {
-      depositReservesList.push(this.reserve.address);
-    }
-    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
-    });
-
-    const debtFarmsAccounts = this.outflowReserve.state.farmDebt.equals(PublicKey.default)
-      ? {
-          obligationFarmUserState: PROGRAM_ID,
-          reserveFarmState: PROGRAM_ID,
-        }
-      : {
-          obligationFarmUserState: obligationFarmStatePda(
-            this.getObligationPda(),
-            this.outflowReserve.state.farmDebt!
-          )[0],
-          reserveFarmState: this.outflowReserve.state.farmDebt,
-        };
-
-    const borrowIx = borrowObligationLiquidityV2(
-      {
-        liquidityAmount: this.outflowAmount,
-      },
-      {
-        borrowAccounts: {
-          owner: this.owner,
-          obligation: this.getObligationPda(),
-          lendingMarket: this.kaminoMarket.getAddress(),
-          lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
-          borrowReserve: this.outflowReserve.address,
-          borrowReserveLiquidityMint: this.outflowReserve.getLiquidityMint(),
-          reserveSourceLiquidity: this.outflowReserve.state.liquidity.supplyVault,
-          userDestinationLiquidity: this.additionalTokenAccountAddress,
-          borrowReserveLiquidityFeeReceiver: this.outflowReserve.state.liquidity.feeVault,
-          referrerTokenState: referrerTokenStatePda(
-            this.referrer,
-            this.outflowReserve.address,
-            this.kaminoMarket.programId
-          )[0],
-          tokenProgram: this.outflowReserve.getLiquidityTokenProgram(),
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
-        },
-        farmsAccounts: debtFarmsAccounts,
-        farmsProgram: farmsId,
+        liquidityAmount: this.outflowAmount,
+      },
+      {
+        owner: this.owner,
+        obligation: this.getObligationPda(),
+        lendingMarket: this.kaminoMarket.getAddress(),
+        lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+        borrowReserve: this.outflowReserve.address,
+        borrowReserveLiquidityMint: this.outflowReserve.getLiquidityMint(),
+        reserveSourceLiquidity: this.outflowReserve.state.liquidity.supplyVault,
+        userDestinationLiquidity: this.additionalTokenAccountAddress,
+        borrowReserveLiquidityFeeReceiver: this.outflowReserve.state.liquidity.feeVault,
+        referrerTokenState: referrerTokenStatePda(
+          this.referrer,
+          this.outflowReserve.address,
+          this.kaminoMarket.programId
+        )[0],
+        tokenProgram: this.outflowReserve.getLiquidityTokenProgram(),
+        instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
       },
       this.kaminoMarket.programId
     );
@@ -1869,7 +1537,7 @@ export class KaminoAction {
     this.lendingIxs.push(borrowIx);
   }
 
-  async addRepayAndWithdrawIxs(withdrawCollateralAmount: BN) {
+  addRepayAndWithdrawIxs(withdrawCollateralAmount: BN) {
     this.lendingIxsLabels.push(
       `repayObligationLiquidity(reserve=${this.reserve!.address})(obligation=${this.getObligationPda()})`
     );
@@ -1939,31 +1607,61 @@ export class KaminoAction {
     );
   }
 
-  async addRepayAndWithdrawIxsV2(withdrawCollateralAmount: BN) {
+  addRepayAndWithdrawV2Ixs(withdrawCollateralAmount: BN) {
     this.lendingIxsLabels.push(
-      `repayObligationLiquidityV2(reserve=${this.reserve!.address})(obligation=${this.getObligationPda()})`
+      `repayAndWithdrawAndRedeem(repayReserve=${this.reserve!.address})(withdrawReserve=${
+        this.outflowReserve!.address
+      })(obligation=${this.getObligationPda()})`
     );
-    this.lendingIxsLabels.push(`withdrawObligationCollateralAndRedeemReserveCollateralV2`);
 
     const depositReservesList = this.getAdditionalDepositReservesList();
 
     const depositReserveAccountMetas = depositReservesList.map((reserve) => {
       return { pubkey: reserve, isSigner: false, isWritable: true };
     });
+    const borrowReserveAccountMetas = this.borrowReserves.map((reserve) => {
+      return { pubkey: reserve, isSigner: false, isWritable: true };
+    });
+
+    if (!this.outflowAmount) {
+      throw new Error(`outflowAmount not set`);
+    }
+
+    if (!this.outflowReserve) {
+      throw new Error(`outflowReserve not set`);
+    }
+
+    if (!this.additionalTokenAccountAddress) {
+      throw new Error(`additionalTokenAccountAddress not set`);
+    }
+
+    const collateralFarmsAccounts = this.outflowReserve.state.farmCollateral.equals(PublicKey.default)
+      ? {
+          obligationFarmUserState: this.kaminoMarket.programId,
+          reserveFarmState: this.kaminoMarket.programId,
+        }
+      : {
+          obligationFarmUserState: obligationFarmStatePda(
+            this.outflowReserve.state.farmCollateral,
+            this.getObligationPda()
+          ),
+          reserveFarmState: this.outflowReserve.state.farmCollateral,
+        };
 
     const debtFarmsAccounts = this.reserve.state.farmDebt.equals(PublicKey.default)
       ? {
-          obligationFarmUserState: PROGRAM_ID,
-          reserveFarmState: PROGRAM_ID,
+          obligationFarmUserState: this.kaminoMarket.programId,
+          reserveFarmState: this.kaminoMarket.programId,
         }
       : {
-          obligationFarmUserState: obligationFarmStatePda(this.getObligationPda(), this.reserve.state.farmDebt)[0],
+          obligationFarmUserState: obligationFarmStatePda(this.reserve.state.farmDebt, this.getObligationPda()),
           reserveFarmState: this.reserve.state.farmDebt,
         };
 
-    const repayIx = repayObligationLiquidityV2(
+    const repayAndWithdrawIx = repayAndWithdrawAndRedeem(
       {
-        liquidityAmount: this.amount,
+        repayAmount: this.amount,
+        withdrawCollateralAmount,
       },
       {
         repayAccounts: {
@@ -1977,16 +1675,57 @@ export class KaminoAction {
           tokenProgram: this.reserve.getLiquidityTokenProgram(),
           instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
         },
-        lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
-        farmsAccounts: debtFarmsAccounts,
+        withdrawAccounts: {
+          owner: this.owner,
+          obligation: this.getObligationPda(),
+          lendingMarket: this.kaminoMarket.getAddress(),
+          lendingMarketAuthority: 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: this.additionalTokenAccountAddress,
+          placeholderUserDestinationCollateral: this.kaminoMarket.programId,
+          collateralTokenProgram: TOKEN_PROGRAM_ID,
+          liquidityTokenProgram: this.outflowReserve.getLiquidityTokenProgram(),
+          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+        },
+        collateralFarmsAccounts,
+        debtFarmsAccounts,
         farmsProgram: farmsId,
       },
       this.kaminoMarket.programId
     );
 
-    repayIx.keys = repayIx.keys.concat([...depositReserveAccountMetas]);
+    repayAndWithdrawIx.keys = repayAndWithdrawIx.keys.concat([
+      ...depositReserveAccountMetas,
+      ...borrowReserveAccountMetas,
+    ]);
+
+    this.lendingIxs.push(repayAndWithdrawIx);
+  }
+
+  addDepositAndWithdrawV2Ixs(withdrawCollateralAmount: BN) {
+    this.lendingIxsLabels.push(
+      `depositAndWithdrawV2(depositReserve=${this.reserve!.address})(withdrawReserve=${
+        this.outflowReserve!.address
+      })(obligation=${this.getObligationPda()})`
+    );
+
+    const depositReservesList = this.getAdditionalDepositReservesList();
+
+    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
+      return { pubkey: reserve, isSigner: false, isWritable: true };
+    });
+    const borrowReserveAccountMetas = this.borrowReserves.map((reserve) => {
+      return { pubkey: reserve, isSigner: false, isWritable: true };
+    });
+
+    if (!this.outflowAmount) {
+      throw new Error(`outflowAmount not set`);
+    }
 
-    this.lendingIxs.push(repayIx);
     if (!this.outflowReserve) {
       throw new Error(`outflowReserve not set`);
     }
@@ -1995,54 +1734,145 @@ export class KaminoAction {
       throw new Error(`additionalTokenAccountAddress not set`);
     }
 
-    if (!this.outflowAmount) {
-      throw new Error(`outflowAmount not set`);
-    }
-
-    const collateralFarmsAccounts = this.outflowReserve.state.farmCollateral.equals(PublicKey.default)
+    const depositFarmsAccounts = this.reserve.state.farmCollateral.equals(PublicKey.default)
       ? {
-          obligationFarmUserState: PROGRAM_ID,
-          reserveFarmState: PROGRAM_ID,
+          obligationFarmUserState: this.kaminoMarket.programId,
+          reserveFarmState: this.kaminoMarket.programId,
+        }
+      : {
+          obligationFarmUserState: obligationFarmStatePda(this.reserve.state.farmDebt, this.getObligationPda()),
+          reserveFarmState: this.reserve.state.farmCollateral,
+        };
+    const withdrawFarmsAccounts = this.outflowReserve.state.farmCollateral.equals(PublicKey.default)
+      ? {
+          obligationFarmUserState: this.kaminoMarket.programId,
+          reserveFarmState: this.kaminoMarket.programId,
         }
       : {
           obligationFarmUserState: obligationFarmStatePda(
-            this.getObligationPda(),
-            this.outflowReserve.state.farmCollateral
-          )[0],
+            this.outflowReserve.state.farmCollateral,
+            this.getObligationPda()
+          ),
           reserveFarmState: this.outflowReserve.state.farmCollateral,
         };
 
+    const depositAndWithdrawIx = depositAndWithdraw(
+      {
+        liquidityAmount: this.amount,
+        withdrawCollateralAmount,
+      },
+      {
+        depositAccounts: {
+          owner: this.owner,
+          obligation: this.getObligationPda(),
+          lendingMarket: this.kaminoMarket.getAddress(),
+          lendingMarketAuthority: 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: this.userTokenAccountAddress,
+          placeholderUserDestinationCollateral: this.kaminoMarket.programId,
+          collateralTokenProgram: TOKEN_PROGRAM_ID,
+          liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
+          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+        },
+        withdrawAccounts: {
+          owner: this.owner,
+          obligation: this.getObligationPda(),
+          lendingMarket: this.kaminoMarket.getAddress(),
+          lendingMarketAuthority: 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: this.additionalTokenAccountAddress,
+          placeholderUserDestinationCollateral: this.kaminoMarket.programId,
+          collateralTokenProgram: TOKEN_PROGRAM_ID,
+          liquidityTokenProgram: this.outflowReserve.getLiquidityTokenProgram(),
+          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+        },
+        depositFarmsAccounts,
+        withdrawFarmsAccounts,
+        farmsProgram: farmsId,
+      },
+      this.kaminoMarket.programId
+    );
+
+    depositAndWithdrawIx.keys = depositAndWithdrawIx.keys.concat([
+      ...depositReserveAccountMetas,
+      ...borrowReserveAccountMetas,
+    ]);
+
+    this.lendingIxs.push(depositAndWithdrawIx);
+  }
+
+  addWithdrawIx(withdrawCollateralAmount: BN) {
+    this.lendingIxsLabels.push(`withdrawObligationCollateralAndRedeemReserveCollateral`);
     this.lendingIxs.push(
-      withdrawObligationCollateralAndRedeemReserveCollateralV2(
+      withdrawObligationCollateralAndRedeemReserveCollateral(
         {
           collateralAmount: withdrawCollateralAmount,
         },
         {
-          withdrawAccounts: {
-            owner: this.owner,
-            obligation: this.getObligationPda(),
-            lendingMarket: this.kaminoMarket.getAddress(),
-            lendingMarketAuthority: 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: this.additionalTokenAccountAddress,
-            placeholderUserDestinationCollateral: this.kaminoMarket.programId,
-            collateralTokenProgram: TOKEN_PROGRAM_ID,
-            liquidityTokenProgram: this.outflowReserve.getLiquidityTokenProgram(),
-            instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
-          },
-          farmsAccounts: collateralFarmsAccounts,
-          farmsProgram: farmsId,
+          owner: this.owner,
+          obligation: this.getObligationPda(),
+          lendingMarket: this.kaminoMarket.getAddress(),
+          lendingMarketAuthority: 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: this.userTokenAccountAddress,
+          placeholderUserDestinationCollateral: this.kaminoMarket.programId,
+          collateralTokenProgram: TOKEN_PROGRAM_ID,
+          liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
+          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
         },
         this.kaminoMarket.programId
       )
     );
   }
 
-  async addLiquidateIx(maxAllowedLtvOverridePercent: number = 0) {
+  addRepayIx() {
+    this.lendingIxsLabels.push(
+      `repayObligationLiquidity(reserve=${this.reserve.address})(obligation=${this.getObligationPda()})`
+    );
+
+    const depositReservesList = this.getAdditionalDepositReservesList();
+
+    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
+      return { pubkey: reserve, isSigner: false, isWritable: true };
+    });
+
+    const repayIx = repayObligationLiquidity(
+      {
+        liquidityAmount: this.amount,
+      },
+      {
+        owner: this.payer,
+        obligation: this.getObligationPda(),
+        lendingMarket: this.kaminoMarket.getAddress(),
+        repayReserve: this.reserve.address,
+        reserveLiquidityMint: this.reserve.getLiquidityMint(),
+        userSourceLiquidity: this.userTokenAccountAddress,
+        reserveDestinationLiquidity: this.reserve.state.liquidity.supplyVault,
+        tokenProgram: this.reserve.getLiquidityTokenProgram(),
+        instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+      },
+      this.kaminoMarket.programId
+    );
+
+    repayIx.keys =
+      this.obligation!.state.elevationGroup > 0 ? repayIx.keys.concat([...depositReserveAccountMetas]) : repayIx.keys;
+
+    this.lendingIxs.push(repayIx);
+  }
+
+  addLiquidateIx(maxAllowedLtvOverridePercent: number = 0) {
     this.lendingIxsLabels.push(`liquidateObligationAndRedeemReserveCollateral`);
     if (!this.outflowReserve) {
       throw Error(`Withdraw reserve during liquidation is not defined`);
@@ -2094,97 +1924,16 @@ export class KaminoAction {
     this.lendingIxs.push(liquidateIx);
   }
 
-  async addLiquidateIxV2(maxAllowedLtvOverridePercent: number = 0) {
-    this.lendingIxsLabels.push(`liquidateObligationAndRedeemReserveCollateralV2`);
-    if (!this.outflowReserve) {
-      throw Error(`Withdraw reserve during liquidation is not defined`);
-    }
-    if (!this.additionalTokenAccountAddress) {
-      throw Error(`Liquidating token account address is not defined`);
-    }
-
-    const depositReservesList = this.getAdditionalDepositReservesList();
-    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
-    });
-
-    const collateralFarmsAccounts = this.outflowReserve.state.farmCollateral.equals(PublicKey.default)
-      ? {
-          obligationFarmUserState: PROGRAM_ID,
-          reserveFarmState: PROGRAM_ID,
-        }
-      : {
-          obligationFarmUserState: obligationFarmStatePda(
-            this.getObligationPda(),
-            this.outflowReserve.state.farmCollateral
-          )[0],
-          reserveFarmState: this.outflowReserve.state.farmCollateral,
-        };
-
-    const debtFarmsAccounts = this.reserve.state.farmDebt.equals(PublicKey.default)
-      ? {
-          obligationFarmUserState: PROGRAM_ID,
-          reserveFarmState: PROGRAM_ID,
-        }
-      : {
-          obligationFarmUserState: obligationFarmStatePda(this.getObligationPda(), this.reserve.state.farmDebt)[0],
-          reserveFarmState: this.reserve.state.farmDebt,
-        };
-
-    const liquidateIx = liquidateObligationAndRedeemReserveCollateralV2(
-      {
-        liquidityAmount: this.amount,
-        // TODO: Configure this when updating liquidator with new interface
-        minAcceptableReceivedLiquidityAmount: this.outflowAmount || new BN(0),
-        maxAllowedLtvOverridePercent: new BN(maxAllowedLtvOverridePercent),
-      },
-      {
-        liquidationAccounts: {
-          liquidator: this.owner,
-          obligation: this.getObligationPda(),
-          lendingMarket: this.kaminoMarket.getAddress(),
-          lendingMarketAuthority: 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: this.additionalTokenAccountAddress,
-          userDestinationCollateral: this.userCollateralAccountAddress,
-          userDestinationLiquidity: this.userTokenAccountAddress,
-          withdrawReserveLiquidityFeeReceiver: this.outflowReserve.state.liquidity.feeVault,
-          collateralTokenProgram: TOKEN_PROGRAM_ID,
-          repayLiquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
-          withdrawLiquidityTokenProgram: this.outflowReserve.getLiquidityTokenProgram(),
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
-        },
-        debtFarmsAccounts,
-        collateralFarmsAccounts,
-        farmsProgram: farmsId,
-      },
-      this.kaminoMarket.programId
-    );
-    liquidateIx.keys =
-      this.obligation!.state.elevationGroup > 0
-        ? liquidateIx.keys.concat([...depositReserveAccountMetas])
-        : liquidateIx.keys;
-    this.lendingIxs.push(liquidateIx);
-  }
-
   async addInBetweenIxs(
     action: ActionType,
     includeAtaIxns: boolean,
     requestElevationGroup: boolean,
-    addInitObligationForFarm: boolean,
-    useV2Ixs: boolean
+    addInitObligationForFarm: boolean
   ) {
     await this.addSupportIxsWithoutInitObligation(
       action,
       includeAtaIxns,
-      useV2Ixs,
+      false,
       'inBetween',
       requestElevationGroup,
       addInitObligationForFarm
@@ -2239,6 +1988,7 @@ export class KaminoAction {
         'repay',
         'depositAndBorrow',
         'repayAndWithdraw',
+        'repayAndWithdrawV2',
         'refreshObligation',
       ].includes(action)
     ) {
@@ -2257,12 +2007,17 @@ export class KaminoAction {
 
       let currentReserves: KaminoReserve[] = [];
 
-      if (action === 'liquidate' || action === 'depositAndBorrow' || action === 'repayAndWithdraw') {
+      if (
+        action === 'liquidate' ||
+        action === 'depositAndBorrow' ||
+        action === 'repayAndWithdraw' ||
+        action === 'repayAndWithdrawV2'
+      ) {
         if (!this.outflowReserve) {
           throw new Error('outflowReserve is undefined');
         }
 
-        if (action === 'depositAndBorrow' || action === 'repayAndWithdraw') {
+        if (action === 'depositAndBorrow' || action === 'repayAndWithdraw' || action === 'repayAndWithdrawV2') {
           currentReserves = [this.reserve, this.outflowReserve];
           if (action === 'depositAndBorrow') {
             if (this.obligation) {
@@ -2307,7 +2062,12 @@ export class KaminoAction {
           if (this.outflowReserve) {
             await this.addInitObligationForFarm(this.outflowReserve, ReserveFarmKind.Debt, addAsSupportIx);
           }
-        } else if (action === 'repayAndWithdraw' || action === 'borrow' || action === 'repay') {
+        } else if (
+          action === 'repayAndWithdraw' ||
+          action === 'borrow' ||
+          action === 'repay' ||
+          action === 'repayAndWithdrawV2'
+        ) {
           // todo - probably don't need to add both debt and collateral for everything here
           await this.addInitObligationForFarm(this.reserve, ReserveFarmKind.Debt, addAsSupportIx);
           if (this.outflowReserve) {
@@ -2338,7 +2098,7 @@ export class KaminoAction {
       }
 
       if (requestElevationGroup) {
-        if (action === 'repay') {
+        if (action === 'repay' || action === 'repayAndWithdrawV2') {
           const repayObligationLiquidity = this.obligation!.borrows.get(this.reserve.address);
 
           if (!repayObligationLiquidity) {
@@ -2527,7 +2287,7 @@ export class KaminoAction {
       if (action === 'deposit' && this.outflowReserve) {
         await this.addInitReferrerTokenStateIx(this.outflowReserve);
       }
-      await this.addInitObligationIxs();
+      this.addInitObligationIxs();
     }
 
     await this.addSupportIxsWithoutInitObligation(
@@ -2759,7 +2519,7 @@ export class KaminoAction {
         farms.push([
           ReserveFarmKind.Collateral,
           kaminoReserve.state.farmCollateral,
-          obligationFarmStatePda(this.getObligationPda(), kaminoReserve.state.farmCollateral)[0],
+          obligationFarmStatePda(kaminoReserve.state.farmCollateral, this.getObligationPda()),
           kaminoReserve,
         ]);
       }
@@ -2767,7 +2527,7 @@ export class KaminoAction {
         farms.push([
           ReserveFarmKind.Debt,
           kaminoReserve.state.farmDebt,
-          obligationFarmStatePda(this.getObligationPda(), kaminoReserve.state.farmDebt)[0],
+          obligationFarmStatePda(kaminoReserve.state.farmDebt, this.getObligationPda()),
           kaminoReserve,
         ]);
       }
@@ -2851,18 +2611,18 @@ export class KaminoAction {
     const farms: [number, PublicKey, PublicKey][] = [];
 
     if (mode === ReserveFarmKind.Collateral && isNotNullPubkey(reserve.state.farmCollateral)) {
-      const userPda = obligationFarmStatePda(this.getObligationPda(), reserve.state.farmCollateral)[0];
-      const account = await this.kaminoMarket.getConnection().getAccountInfo(userPda);
+      const pda = obligationFarmStatePda(reserve.state.farmCollateral, this.getObligationPda());
+      const account = await this.kaminoMarket.getConnection().getAccountInfo(pda);
       if (!account) {
-        farms.push([ReserveFarmKind.Collateral.discriminator, reserve.state.farmCollateral, userPda]);
+        farms.push([ReserveFarmKind.Collateral.discriminator, reserve.state.farmCollateral, pda]);
       }
     }
 
     if (mode === ReserveFarmKind.Debt && isNotNullPubkey(reserve.state.farmDebt)) {
-      const userPda = obligationFarmStatePda(this.getObligationPda(), reserve.state.farmDebt)[0];
-      const account = await this.kaminoMarket.getConnection().getAccountInfo(userPda);
+      const pda = obligationFarmStatePda(reserve.state.farmDebt, this.getObligationPda());
+      const account = await this.kaminoMarket.getConnection().getAccountInfo(pda);
       if (!account) {
-        farms.push([ReserveFarmKind.Debt.discriminator, reserve.state.farmDebt, userPda]);
+        farms.push([ReserveFarmKind.Debt.discriminator, reserve.state.farmDebt, pda]);
       }
     }
 
@@ -2896,7 +2656,7 @@ export class KaminoAction {
     });
   }
 
-  private async addInitObligationIxs() {
+  private addInitObligationIxs() {
     if (!this.obligation) {
       const obligationPda = this.getObligationPda();
       const [userMetadataAddress, _bump] = userMetadataPda(this.owner, this.kaminoMarket.programId);
@@ -3119,7 +2879,7 @@ export class KaminoAction {
 
     let safeRepay = new BN(this.amount);
 
-    if (this.obligation && action === 'repay' && this.amount.eq(new BN(U64_MAX))) {
+    if (this.obligation && (action === 'repay' || action === 'repayAndWithdrawV2') && this.amount.eq(new BN(U64_MAX))) {
       const borrow = this.obligation.state.borrows.find(
         (borrow) => borrow.borrowReserve.toString() === this.reserve.address.toString()
       );
@@ -3133,7 +2893,7 @@ export class KaminoAction {
         this.currentSlot,
         this.kaminoMarket.state.referralFeeBps
       );
-      // TODO: shouldn't this calc be added to all other stuff as well?
+
       safeRepay = new BN(
         Math.floor(
           KaminoObligation.getBorrowAmount(borrow)
@@ -3161,6 +2921,7 @@ export class KaminoAction {
     const sendAction =
       action === 'deposit' ||
       action === 'repay' ||
+      action === 'repayAndWithdrawV2' ||
       action === 'mint' ||
       (action === 'liquidate' && this.secondaryMint?.equals(NATIVE_MINT)); // only sync WSOL amount if liquidator repays SOL which is secondaryMint
 
@@ -3270,7 +3031,7 @@ export class KaminoAction {
       additionalUserTokenAccountAddress = userOutflowTokenAccountAddress;
       primaryMint = inflowTokenMint;
       secondaryMint = outflowTokenMint;
-    } else if (action === 'repayAndWithdraw') {
+    } else if (action === 'repayAndWithdraw' || action === 'repayAndWithdrawV2') {
       primaryMint = inflowTokenMint;
       secondaryMint = outflowTokenMint;
       userTokenAccountAddress = userInflowTokenAccountAddress;