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

package/src/classes/action.ts

@@ -76,9 +76,31 @@ import { Scope } from '@kamino-finance/scope-sdk';
 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 {
+  getCloseAccountInstruction,
+  getSyncNativeInstruction,
+  TOKEN_2022_PROGRAM_ADDRESS,
+} from '@solana-program/token-2022';
 import { getTransferSolInstruction, SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
 import { noopSigner } from '../utils/signer';
+import {
+  BuildDepositTxnsProps,
+  BuildBorrowTxnsProps,
+  BuildDepositReserveLiquidityTxnsProps,
+  BuildRedeemReserveCollateralTxnsProps,
+  BuildWithdrawTxnsProps,
+  BuildRepayTxnsProps,
+  BuildDepositAndBorrowTxnsProps,
+  BuildRefreshObligationTxnsProps,
+  BuildRequestElevationGroupTxnsProps,
+  BuildDepositAndWithdrawV2TxnsProps,
+  BuildRepayAndWithdrawTxnsProps,
+  BuildRepayAndWithdrawV2TxnsProps,
+  BuildLiquidateTxnsProps,
+  BuildWithdrawReferrerFeeTxnsProps,
+  BuildDepositObligationCollateralTxnsProps,
+  InitializeActionProps,
+} from './actionTypes';
 
 export type ActionType =
   | 'deposit'
@@ -199,20 +221,22 @@ export class KaminoAction {
     this.currentSlot = currentSlot;
   }
 
-  static async initialize(
-    action: ActionType,
-    amount: string | BN,
-    mint: Address,
-    owner: TransactionSigner,
-    kaminoMarket: KaminoMarket,
-    obligation: KaminoObligation | ObligationType,
-    referrer: Option<Address> = none(),
-    currentSlot: Slot = 0n,
-    payer: TransactionSigner = owner
-  ) {
-    const reserve = kaminoMarket.getReserveByMint(mint);
+  static async initialize(props: InitializeActionProps) {
+    const {
+      kaminoMarket,
+      action,
+      amount,
+      reserveAddress,
+      owner,
+      obligation,
+      referrer = none(),
+      currentSlot = 0n,
+      payer = owner,
+    } = props;
+
+    const reserve = kaminoMarket.getReserveByAddress(reserveAddress);
     if (reserve === undefined) {
-      throw new Error(`Reserve ${mint} not found in market ${kaminoMarket.getAddress()}`);
+      throw new Error(`Reserve ${reserveAddress} not found in market ${kaminoMarket.getAddress()}`);
     }
 
     const { kaminoObligation, depositReserves, borrowReserves, distinctReserveCount } =
@@ -224,7 +248,7 @@ export class KaminoAction {
       kaminoMarket,
       owner,
       kaminoObligation || obligation,
-      mint,
+      reserve.getLiquidityMint(),
       distinctReserveCount,
       amount,
       depositReserves,
@@ -305,29 +329,23 @@ export class KaminoAction {
     };
   }
 
-  static async buildRefreshObligationTxns(
-    kaminoMarket: KaminoMarket,
-    payer: TransactionSigner,
-    obligation: KaminoObligation,
-    extraComputeBudget: number = 1_000_000, // if > 0 then adds the ix
-    currentSlot: Slot = 0n
-  ) {
+  static async buildRefreshObligationTxns(props: BuildRefreshObligationTxnsProps) {
+    const { kaminoMarket, payer, obligation, extraComputeBudget = 1_000_000, currentSlot = 0n } = props;
     //  placeholder for action initialization
     const firstReserve = obligation.getDeposits()[0].reserveAddress;
     const firstKaminoReserve = kaminoMarket.getReserveByAddress(firstReserve);
     if (!firstKaminoReserve) {
       throw new Error(`Reserve ${firstReserve} not found`);
     }
-    const axn = await KaminoAction.initialize(
-      'refreshObligation',
-      '0',
-      firstKaminoReserve?.getLiquidityMint(),
-      noopSigner(obligation.state.owner), // owner does not need to sign for refresh
+    const axn = await KaminoAction.initialize({
       kaminoMarket,
+      action: 'refreshObligation',
+      amount: '0',
+      reserveAddress: firstKaminoReserve.address,
+      owner: noopSigner(obligation.state.owner), // owner does not need to sign for refresh
       obligation,
-      undefined,
-      currentSlot
-    );
+      currentSlot,
+    });
 
     if (extraComputeBudget > 0) {
       axn.addComputeBudgetIx(extraComputeBudget);
@@ -338,29 +356,22 @@ export class KaminoAction {
     return axn;
   }
 
-  static async buildRequestElevationGroupTxns(
-    kaminoMarket: KaminoMarket,
-    owner: TransactionSigner,
-    obligation: KaminoObligation,
-    elevationGroup: number,
-    extraComputeBudget: number = 1_000_000, // if > 0 then adds the ix
-    currentSlot: Slot = 0n
-  ) {
+  static async buildRequestElevationGroupTxns(props: BuildRequestElevationGroupTxnsProps) {
+    const { kaminoMarket, owner, obligation, elevationGroup, extraComputeBudget = 1_000_000, currentSlot = 0n } = props;
     const firstReserve = obligation.state.deposits.find((x) => x.depositReserve !== DEFAULT_PUBLIC_KEY)!.depositReserve;
     const firstKaminoReserve = kaminoMarket.getReserveByAddress(firstReserve);
     if (!firstKaminoReserve) {
       throw new Error(`Reserve ${firstReserve} not found`);
     }
-    const axn = await KaminoAction.initialize(
-      'requestElevationGroup',
-      '0',
-      firstKaminoReserve?.getLiquidityMint(),
-      owner,
+    const axn = await KaminoAction.initialize({
       kaminoMarket,
+      action: 'requestElevationGroup',
+      amount: '0',
+      reserveAddress: firstKaminoReserve.address,
+      owner,
       obligation,
-      undefined,
-      currentSlot
-    );
+      currentSlot,
+    });
 
     if (extraComputeBudget > 0) {
       axn.addComputeBudgetIx(extraComputeBudget);
@@ -372,35 +383,34 @@ export class KaminoAction {
     return axn;
   }
 
-  static async buildDepositTxns(
-    kaminoMarket: KaminoMarket,
-    amount: string | BN,
-    mint: Address,
-    owner: TransactionSigner,
-    obligation: KaminoObligation | ObligationType,
-    useV2Ixs: boolean,
-    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 *before* the deposit
-    initUserMetadata: { skipInitialization: boolean; skipLutCreation: boolean } = {
-      skipInitialization: false,
-      skipLutCreation: false,
-    },
-    referrer: Option<Address> = none(),
-    currentSlot: Slot = 0n,
-    overrideElevationGroupRequest: number | undefined = undefined // if set, when an elevationgroup request is made, it will use this value
-  ) {
-    const axn = await KaminoAction.initialize(
-      'deposit',
+  static async buildDepositTxns(props: BuildDepositTxnsProps) {
+    const {
+      kaminoMarket,
       amount,
-      mint,
+      reserveAddress,
       owner,
+      obligation,
+      useV2Ixs,
+      scopeRefreshConfig,
+      extraComputeBudget = 1_000_000,
+      includeAtaIxs = true,
+      requestElevationGroup = false,
+      initUserMetadata = { skipInitialization: false, skipLutCreation: false },
+      referrer = none(),
+      currentSlot = 0n,
+      overrideElevationGroupRequest,
+    } = props;
+
+    const axn = await KaminoAction.initialize({
       kaminoMarket,
+      action: 'deposit',
+      amount,
+      reserveAddress,
+      owner,
       obligation,
       referrer,
-      currentSlot
-    );
+      currentSlot,
+    });
     const addInitObligationForFarm = true;
 
     if (extraComputeBudget > 0) {
@@ -436,35 +446,34 @@ export class KaminoAction {
     }
   }
 
-  static async buildBorrowTxns(
-    kaminoMarket: KaminoMarket,
-    amount: string | BN,
-    mint: Address,
-    owner: TransactionSigner,
-    obligation: KaminoObligation | ObligationType,
-    useV2Ixs: boolean,
-    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,
-    initUserMetadata: { skipInitialization: boolean; skipLutCreation: boolean } = {
-      skipInitialization: false,
-      skipLutCreation: false,
-    },
-    referrer: Option<Address> = none(),
-    currentSlot: Slot = 0n,
-    overrideElevationGroupRequest: number | undefined = undefined // if set, when an elevationgroup request is made, it will use this value
-  ) {
-    const axn = await KaminoAction.initialize(
-      'borrow',
+  static async buildBorrowTxns(props: BuildBorrowTxnsProps) {
+    const {
+      kaminoMarket,
       amount,
-      mint,
+      reserveAddress,
       owner,
+      obligation,
+      useV2Ixs,
+      scopeRefreshConfig,
+      extraComputeBudget = 1_000_000,
+      includeAtaIxs = true,
+      requestElevationGroup = false,
+      initUserMetadata = { skipInitialization: false, skipLutCreation: false },
+      referrer = none(),
+      currentSlot = 0n,
+      overrideElevationGroupRequest,
+    } = props;
+
+    const axn = await KaminoAction.initialize({
       kaminoMarket,
+      action: 'borrow',
+      amount,
+      reserveAddress,
+      owner,
       obligation,
       referrer,
-      currentSlot
-    );
+      currentSlot,
+    });
     const addInitObligationForFarm = true;
     if (extraComputeBudget > 0) {
       axn.addComputeBudgetIx(extraComputeBudget);
@@ -503,29 +512,31 @@ export class KaminoAction {
     return axn;
   }
 
-  static async buildDepositReserveLiquidityTxns(
-    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,
-    referrer: Option<Address> = none(),
-    currentSlot: Slot = 0n
-  ) {
-    const axn = await KaminoAction.initialize(
-      'mint',
+  static async buildDepositReserveLiquidityTxns(props: BuildDepositReserveLiquidityTxnsProps) {
+    const {
+      kaminoMarket,
       amount,
-      mint,
+      reserveAddress,
       owner,
+      obligation,
+      scopeRefreshConfig,
+      extraComputeBudget = 1_000_000,
+      includeAtaIxs = true,
+      requestElevationGroup = false,
+      referrer = none(),
+      currentSlot = 0n,
+    } = props;
+
+    const axn = await KaminoAction.initialize({
       kaminoMarket,
+      action: 'mint',
+      amount,
+      reserveAddress,
+      owner,
       obligation,
       referrer,
-      currentSlot
-    );
+      currentSlot,
+    });
     const addInitObligationForFarm = true;
 
     if (extraComputeBudget > 0) {
@@ -546,29 +557,31 @@ export class KaminoAction {
     return axn;
   }
 
-  static async buildRedeemReserveCollateralTxns(
-    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,
-    referrer: Option<Address> = none(),
-    currentSlot: Slot = 0n
-  ) {
-    const axn = await KaminoAction.initialize(
-      'redeem',
+  static async buildRedeemReserveCollateralTxns(props: BuildRedeemReserveCollateralTxnsProps) {
+    const {
+      kaminoMarket,
       amount,
-      mint,
+      reserveAddress,
       owner,
+      obligation,
+      scopeRefreshConfig,
+      extraComputeBudget = 1_000_000,
+      includeAtaIxs = true,
+      requestElevationGroup = false,
+      referrer = none(),
+      currentSlot = 0n,
+    } = props;
+
+    const axn = await KaminoAction.initialize({
       kaminoMarket,
+      action: 'redeem',
+      amount,
+      reserveAddress,
+      owner,
       obligation,
       referrer,
-      currentSlot
-    );
+      currentSlot,
+    });
     const addInitObligationForFarm = true;
 
     if (extraComputeBudget > 0) {
@@ -589,34 +602,32 @@ export class KaminoAction {
     return axn;
   }
 
-  static async buildDepositObligationCollateralTxns(
-    kaminoMarket: KaminoMarket,
-    amount: string | BN,
-    mint: Address,
-    owner: TransactionSigner,
-    obligation: KaminoObligation | ObligationType,
-    useV2Ixs: boolean,
-    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,
-    initUserMetadata: { skipInitialization: boolean; skipLutCreation: boolean } = {
-      skipInitialization: false,
-      skipLutCreation: false,
-    },
-    referrer: Option<Address> = none(),
-    currentSlot: Slot = 0n
-  ) {
-    const axn = await KaminoAction.initialize(
-      'depositCollateral',
+  static async buildDepositObligationCollateralTxns(props: BuildDepositObligationCollateralTxnsProps) {
+    const {
+      kaminoMarket,
       amount,
-      mint,
+      reserveAddress,
       owner,
+      obligation,
+      useV2Ixs,
+      scopeRefreshConfig,
+      extraComputeBudget = 1_000_000,
+      includeAtaIxs = true,
+      requestElevationGroup = false,
+      initUserMetadata = { skipInitialization: false, skipLutCreation: false },
+      referrer = none(),
+      currentSlot = 0n,
+    } = props;
+    const axn = await KaminoAction.initialize({
       kaminoMarket,
+      action: 'depositCollateral',
+      amount,
+      reserveAddress,
+      owner,
       obligation,
       referrer,
-      currentSlot
-    );
+      currentSlot,
+    });
     const addInitObligationForFarm = true;
 
     if (extraComputeBudget > 0) {
@@ -641,32 +652,30 @@ export class KaminoAction {
     return axn;
   }
 
-  static async buildDepositAndBorrowTxns(
-    kaminoMarket: KaminoMarket,
-    depositAmount: string | BN,
-    depositMint: Address,
-    borrowAmount: string | BN,
-    borrowMint: Address,
-    owner: TransactionSigner,
-    obligation: KaminoObligation | ObligationType,
-    useV2Ixs: boolean,
-    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,
-    initUserMetadata: { skipInitialization: boolean; skipLutCreation: boolean } = {
-      skipInitialization: false,
-      skipLutCreation: false,
-    },
-    referrer: Option<Address> = none(),
-    currentSlot: Slot = 0n
-  ) {
+  static async buildDepositAndBorrowTxns(props: BuildDepositAndBorrowTxnsProps) {
+    const {
+      kaminoMarket,
+      depositAmount,
+      depositReserveAddress,
+      borrowAmount,
+      borrowReserveAddress,
+      owner,
+      obligation,
+      useV2Ixs,
+      scopeRefreshConfig,
+      extraComputeBudget = 1_000_000,
+      includeAtaIxs = true,
+      requestElevationGroup = false,
+      initUserMetadata = { skipInitialization: false, skipLutCreation: false },
+      referrer = none(),
+      currentSlot = 0n,
+    } = props;
     const axn = await KaminoAction.initializeMultiTokenAction(
       kaminoMarket,
       'depositAndBorrow',
       depositAmount,
-      depositMint,
-      borrowMint,
+      depositReserveAddress,
+      borrowReserveAddress,
       owner,
       owner.address,
       obligation,
@@ -741,31 +750,29 @@ export class KaminoAction {
     return axn;
   }
 
-  static async buildDepositAndWithdrawV2Txns(
-    kaminoMarket: KaminoMarket,
-    depositAmount: string | BN,
-    depositMint: Address,
-    withdrawAmount: string | BN,
-    withdrawMint: Address,
-    owner: TransactionSigner,
-    currentSlot: Slot,
-    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,
-    initUserMetadata: { skipInitialization: boolean; skipLutCreation: boolean } = {
-      skipInitialization: false,
-      skipLutCreation: false,
-    },
-    referrer: Option<Address> = none()
-  ) {
+  static async buildDepositAndWithdrawV2Txns(props: BuildDepositAndWithdrawV2TxnsProps) {
+    const {
+      kaminoMarket,
+      depositAmount,
+      depositReserveAddress,
+      withdrawAmount,
+      withdrawReserveAddress,
+      owner,
+      currentSlot,
+      obligation,
+      scopeRefreshConfig,
+      extraComputeBudget = 1_000_000,
+      includeAtaIxs = true,
+      requestElevationGroup = false,
+      initUserMetadata = { skipInitialization: false, skipLutCreation: false },
+      referrer = none(),
+    } = props;
     const axn = await KaminoAction.initializeMultiTokenAction(
       kaminoMarket,
       'depositAndWithdraw',
       depositAmount,
-      depositMint,
-      withdrawMint,
+      depositReserveAddress,
+      withdrawReserveAddress,
       owner,
       owner.address,
       obligation,
@@ -795,31 +802,29 @@ export class KaminoAction {
     return axn;
   }
 
-  static async buildRepayAndWithdrawV2Txns(
-    kaminoMarket: KaminoMarket,
-    repayAmount: string | BN,
-    repayMint: Address,
-    withdrawAmount: string | BN,
-    withdrawMint: Address,
-    payer: TransactionSigner,
-    currentSlot: Slot,
-    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,
-    initUserMetadata: { skipInitialization: boolean; skipLutCreation: boolean } = {
-      skipInitialization: false,
-      skipLutCreation: false,
-    },
-    referrer: Option<Address> = none()
-  ) {
+  static async buildRepayAndWithdrawV2Txns(props: BuildRepayAndWithdrawV2TxnsProps) {
+    const {
+      kaminoMarket,
+      repayAmount,
+      repayReserveAddress,
+      withdrawAmount,
+      withdrawReserveAddress,
+      payer,
+      currentSlot,
+      obligation,
+      scopeRefreshConfig,
+      extraComputeBudget = 1_000_000,
+      includeAtaIxs = true,
+      requestElevationGroup = false,
+      initUserMetadata = { skipInitialization: false, skipLutCreation: false },
+      referrer = none(),
+    } = props;
     const axn = await KaminoAction.initializeMultiTokenAction(
       kaminoMarket,
       'repayAndWithdrawV2',
       repayAmount,
-      repayMint,
-      withdrawMint,
+      repayReserveAddress,
+      withdrawReserveAddress,
       payer,
       payer.address,
       obligation,
@@ -849,32 +854,30 @@ export class KaminoAction {
     return axn;
   }
 
-  static async buildRepayAndWithdrawTxns(
-    kaminoMarket: KaminoMarket,
-    repayAmount: string | BN,
-    repayMint: Address,
-    withdrawAmount: string | BN,
-    withdrawMint: Address,
-    payer: TransactionSigner,
-    currentSlot: Slot,
-    obligation: KaminoObligation | ObligationType,
-    useV2Ixs: boolean,
-    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,
-    initUserMetadata: { skipInitialization: boolean; skipLutCreation: boolean } = {
-      skipInitialization: false,
-      skipLutCreation: false,
-    },
-    referrer: Option<Address> = none()
-  ) {
+  static async buildRepayAndWithdrawTxns(props: BuildRepayAndWithdrawTxnsProps) {
+    const {
+      kaminoMarket,
+      repayAmount,
+      repayReserveAddress,
+      withdrawAmount,
+      withdrawReserveAddress,
+      payer,
+      currentSlot,
+      obligation,
+      useV2Ixs,
+      scopeRefreshConfig,
+      extraComputeBudget = 1_000_000,
+      includeAtaIxs = true,
+      requestElevationGroup = false,
+      initUserMetadata = { skipInitialization: false, skipLutCreation: false },
+      referrer = none(),
+    } = props;
     const axn = await KaminoAction.initializeMultiTokenAction(
       kaminoMarket,
       'repayAndWithdraw',
       repayAmount,
-      repayMint,
-      withdrawMint,
+      repayReserveAddress,
+      withdrawReserveAddress,
       payer,
       payer.address,
       obligation,
@@ -938,40 +941,35 @@ export class KaminoAction {
     return axn;
   }
 
-  static async buildWithdrawTxns(
-    kaminoMarket: KaminoMarket,
-    amount: string | BN,
-    mint: Address,
-    owner: TransactionSigner,
-    obligation: KaminoObligation | ObligationType,
-    useV2Ixs: boolean,
-    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[];
-    }
-  ) {
-    const axn = await KaminoAction.initialize(
-      'withdraw',
+  static async buildWithdrawTxns(props: BuildWithdrawTxnsProps) {
+    const {
+      kaminoMarket,
       amount,
-      mint,
+      reserveAddress,
       owner,
+      obligation,
+      useV2Ixs,
+      scopeRefreshConfig,
+      extraComputeBudget = 1_000_000,
+      includeAtaIxs = true,
+      requestElevationGroup = false,
+      initUserMetadata = { skipInitialization: false, skipLutCreation: false },
+      referrer = none(),
+      currentSlot = 0n,
+      overrideElevationGroupRequest,
+      obligationCustomizations,
+    } = props;
+
+    const axn = await KaminoAction.initialize({
       kaminoMarket,
+      action: 'withdraw',
+      amount,
+      reserveAddress,
+      owner,
       obligation,
       referrer,
-      currentSlot
-    );
+      currentSlot,
+    });
     const addInitObligationForFarm = true;
 
     if (extraComputeBudget > 0) {
@@ -1005,52 +1003,38 @@ export class KaminoAction {
   }
 
   /**
-   *
-   * @param kaminoMarket
-   * @param amount
-   * @param mint
-   * @param owner
-   * @param obligation - obligation to repay or the PDA seeds
-   * @param useV2Ixs
-   * @param scopeRefreshConfig
-   * @param currentSlot
-   * @param payer - if not set then owner is used
-   * @param extraComputeBudget - if > 0 then adds the ix
-   * @param includeAtaIxs - if true it includes create and close wsol and token atas
-   * @param requestElevationGroup
-   * @param initUserMetadata
-   * @param referrer
+   * Build repay transactions
+   * @param props - BuildRepayTxnsProps containing all required and optional parameters
    */
-  static async buildRepayTxns(
-    kaminoMarket: KaminoMarket,
-    amount: string | BN,
-    mint: Address,
-    owner: TransactionSigner,
-    obligation: KaminoObligation | ObligationType,
-    useV2Ixs: boolean,
-    scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
-    currentSlot: Slot,
-    payer: TransactionSigner = owner,
-    extraComputeBudget: number = 1_000_000,
-    includeAtaIxs: boolean = true,
-    requestElevationGroup: boolean = false,
-    initUserMetadata: { skipInitialization: boolean; skipLutCreation: boolean } = {
-      skipInitialization: false,
-      skipLutCreation: false,
-    },
-    referrer: Option<Address> = none()
-  ) {
-    const axn = await KaminoAction.initialize(
-      'repay',
+  static async buildRepayTxns(props: BuildRepayTxnsProps) {
+    const {
+      kaminoMarket,
       amount,
-      mint,
+      reserveAddress,
       owner,
+      obligation,
+      useV2Ixs,
+      scopeRefreshConfig,
+      currentSlot,
+      payer = owner,
+      extraComputeBudget = 1_000_000,
+      includeAtaIxs = true,
+      requestElevationGroup = false,
+      initUserMetadata = { skipInitialization: false, skipLutCreation: false },
+      referrer = none(),
+    } = props;
+
+    const axn = await KaminoAction.initialize({
       kaminoMarket,
+      action: 'repay',
+      amount,
+      reserveAddress,
+      owner,
       obligation,
       referrer,
       currentSlot,
-      payer
-    );
+      payer,
+    });
     const addInitObligationForFarm = true;
 
     if (extraComputeBudget > 0) {
@@ -1076,34 +1060,32 @@ export class KaminoAction {
     return axn;
   }
 
-  static async buildLiquidateTxns(
-    kaminoMarket: KaminoMarket,
-    amount: string | BN,
-    minCollateralReceiveAmount: string | BN,
-    repayTokenMint: Address,
-    withdrawTokenMint: Address,
-    liquidator: TransactionSigner,
-    obligationOwner: Address,
-    obligation: KaminoObligation | ObligationType,
-    useV2Ixs: boolean,
-    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
-  ): Promise<KaminoAction> {
+  static async buildLiquidateTxns(props: BuildLiquidateTxnsProps): Promise<KaminoAction> {
+    const {
+      kaminoMarket,
+      amount,
+      minCollateralReceiveAmount,
+      repayReserveAddress,
+      withdrawReserveAddress,
+      liquidator,
+      obligationOwner,
+      obligation,
+      useV2Ixs,
+      scopeRefreshConfig,
+      extraComputeBudget = 1_000_000,
+      includeAtaIxs = true,
+      requestElevationGroup = false,
+      initUserMetadata = { skipInitialization: false, skipLutCreation: false },
+      referrer = none(),
+      maxAllowedLtvOverridePercent = 0,
+      currentSlot = 0n,
+    } = props;
     const axn = await KaminoAction.initializeMultiTokenAction(
       kaminoMarket,
       'liquidate',
       amount,
-      repayTokenMint,
-      withdrawTokenMint,
+      repayReserveAddress,
+      withdrawReserveAddress,
       liquidator,
       obligationOwner,
       obligation,
@@ -1136,14 +1118,10 @@ export class KaminoAction {
     return axn;
   }
 
-  static async buildWithdrawReferrerFeeTxns(
-    owner: TransactionSigner,
-    tokenMint: Address,
-    kaminoMarket: KaminoMarket,
-    currentSlot: Slot = 0n
-  ) {
+  static async buildWithdrawReferrerFeeTxns(props: BuildWithdrawReferrerFeeTxnsProps) {
+    const { owner, reserveAddress, kaminoMarket, currentSlot = 0n } = props;
     const { axn, createAtaIxs } = await KaminoAction.initializeWithdrawReferrerFees(
-      tokenMint,
+      reserveAddress,
       owner,
       kaminoMarket,
       currentSlot
@@ -3289,8 +3267,13 @@ export class KaminoAction {
       action === 'mint' ||
       (action === 'liquidate' && this.mint === WRAPPED_SOL_MINT); // only sync WSOL amount if liquidator repays SOL which is secondaryMint
 
+    const isValidTokenAccount =
+      userWSOLAccountInfo.exists &&
+      (userWSOLAccountInfo.programAddress === TOKEN_PROGRAM_ADDRESS ||
+        userWSOLAccountInfo.programAddress === TOKEN_2022_PROGRAM_ADDRESS);
+
     const transferLamportsIx = getTransferSolInstruction({
-      amount: (userWSOLAccountInfo.exists ? 0n : rentExemptLamports) + (sendAction ? BigInt(safeRepay.toString()) : 0n),
+      amount: (isValidTokenAccount ? 0n : rentExemptLamports) + (sendAction ? BigInt(safeRepay.toString()) : 0n),
       source: this.owner,
       destination: userTokenAccountAddress,
     });
@@ -3312,29 +3295,20 @@ export class KaminoAction {
       },
       { programAddress: TOKEN_PROGRAM_ADDRESS }
     );
-    if (userWSOLAccountInfo.exists) {
-      if (sendAction) {
-        preIxs.push(syncIx);
-        preIxsLabels.push(`SyncUserAtaSOL[${userTokenAccountAddress}]`);
-      } else {
-        postIxs.push(closeWSOLAccountIx);
-        postIxsLabels.push(`CloseUserAtaSOL[${userTokenAccountAddress}]`);
-      }
-    } else {
-      const [, createUserWSOLAccountIx] = await createAssociatedTokenAccountIdempotentInstruction(
-        this.owner,
-        WRAPPED_SOL_MINT,
-        this.owner.address,
-        TOKEN_PROGRAM_ADDRESS,
-        userTokenAccountAddress
-      );
-      preIxs.push(createUserWSOLAccountIx);
-      preIxsLabels.push(`CreateUserAtaSOL[${userTokenAccountAddress}]`);
-      preIxs.push(syncIx);
-      preIxsLabels.push(`SyncUserAtaSOL[${userTokenAccountAddress}]`);
-      postIxs.push(closeWSOLAccountIx);
-      postIxsLabels.push(`CloseUserAtaSOL[${userTokenAccountAddress}]`);
-    }
+
+    const [, createUserWSOLAccountIx] = await createAssociatedTokenAccountIdempotentInstruction(
+      this.owner,
+      WRAPPED_SOL_MINT,
+      this.owner.address,
+      TOKEN_PROGRAM_ADDRESS,
+      userTokenAccountAddress
+    );
+    preIxs.push(createUserWSOLAccountIx);
+    preIxsLabels.push(`CreateUserAtaSOL[${userTokenAccountAddress}]`);
+    preIxs.push(syncIx);
+    preIxsLabels.push(`SyncUserAtaSOL[${userTokenAccountAddress}]`);
+    postIxs.push(closeWSOLAccountIx);
+    postIxsLabels.push(`CloseUserAtaSOL[${userTokenAccountAddress}]`);
 
     this.setupIxs.unshift(...preIxs);
     this.setupIxsLabels.unshift(...preIxsLabels);
@@ -3346,8 +3320,8 @@ export class KaminoAction {
     kaminoMarket: KaminoMarket,
     action: ActionType,
     inflowAmount: string | BN,
-    inflowTokenMint: Address,
-    outflowTokenMint: Address,
+    inflowReserveAddress: Address,
+    outflowReserveAddress: Address,
     signer: TransactionSigner,
     obligationOwner: Address,
     obligation: KaminoObligation | ObligationType,
@@ -3355,8 +3329,8 @@ export class KaminoAction {
     referrer: Option<Address> = none(),
     currentSlot: Slot = 0n
   ) {
-    const inflowReserve = kaminoMarket.getExistingReserveByMint(inflowTokenMint);
-    const outflowReserve = kaminoMarket.getExistingReserveByMint(outflowTokenMint);
+    const inflowReserve = kaminoMarket.getExistingReserveByAddress(inflowReserveAddress);
+    const outflowReserve = kaminoMarket.getExistingReserveByAddress(outflowReserveAddress);
 
     const { kaminoObligation, depositReserves, borrowReserves, distinctReserveCount } =
       await KaminoAction.loadObligation(
@@ -3378,8 +3352,8 @@ export class KaminoAction {
       action === 'repayAndWithdraw' ||
       action === 'repayAndWithdrawV2'
     ) {
-      primaryMint = inflowTokenMint;
-      secondaryMint = outflowTokenMint;
+      primaryMint = inflowReserve.getLiquidityMint();
+      secondaryMint = outflowReserve.getLiquidityMint();
     } else {
       throw new Error('Invalid action');
     }
@@ -3403,14 +3377,14 @@ export class KaminoAction {
   }
 
   static async initializeWithdrawReferrerFees(
-    mint: Address,
+    reserveAddress: Address,
     owner: TransactionSigner,
     kaminoMarket: KaminoMarket,
     currentSlot: Slot = 0n
   ) {
-    const reserve = kaminoMarket.getReserveByMint(mint);
+    const reserve = kaminoMarket.getReserveByAddress(reserveAddress);
     if (reserve === undefined) {
-      throw new Error(`Reserve ${mint} not found in market ${kaminoMarket.getAddress()}`);
+      throw new Error(`Reserve ${reserveAddress} not found in market ${kaminoMarket.getAddress()}`);
     }
 
     const [{ createAtaIx }] = await createAtasIdempotent(owner, [
@@ -3425,7 +3399,7 @@ export class KaminoAction {
         kaminoMarket,
         owner,
         new VanillaObligation(kaminoMarket.programId),
-        mint,
+        reserve.getLiquidityMint(),
         0,
         new BN(0),
         [],