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

package/src/classes/action.ts

@@ -83,6 +83,24 @@ import {
 } 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'
@@ -203,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 } =
@@ -228,7 +248,7 @@ export class KaminoAction {
       kaminoMarket,
       owner,
       kaminoObligation || obligation,
-      mint,
+      reserve.getLiquidityMint(),
       distinctReserveCount,
       amount,
       depositReserves,
@@ -309,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);
@@ -342,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);
@@ -376,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) {
@@ -440,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);
@@ -507,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) {
@@ -550,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) {
@@ -593,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) {
@@ -645,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,
@@ -745,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,
@@ -799,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,
@@ -853,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,
@@ -942,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) {
@@ -1009,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) {
@@ -1080,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,
@@ -1140,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
@@ -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),
         [],