@kamino-finance/klend-sdk 6.0.5-beta.5 → 6.0.5

package/src/classes/action.ts

@@ -1,28 +1,23 @@
 import {
-  Connection,
-  PublicKey,
-  RpcResponseAndContext,
-  SimulatedTransactionResponse,
-  SystemProgram,
-  SYSVAR_INSTRUCTIONS_PUBKEY,
-  SYSVAR_RENT_PUBKEY,
-  Transaction,
-  TransactionInstruction,
-  TransactionSignature,
-} from '@solana/web3.js';
-import {
-  ASSOCIATED_TOKEN_PROGRAM_ID,
-  NATIVE_MINT,
-  TOKEN_PROGRAM_ID,
-  createCloseAccountInstruction,
-  createSyncNativeInstruction,
-} from '@solana/spl-token';
+  AccountRole,
+  Address,
+  fetchEncodedAccount,
+  IAccountMeta,
+  IInstruction,
+  isNone,
+  isSome,
+  none,
+  Option,
+  Slot,
+  some,
+  TransactionSigner,
+} from '@solana/kit';
 import BN from 'bn.js';
 import Decimal from 'decimal.js';
 import {
   borrowObligationLiquidity,
-  depositAndWithdraw,
   borrowObligationLiquidityV2,
+  depositAndWithdraw,
   depositObligationCollateral,
   depositObligationCollateralV2,
   depositReserveLiquidity,
@@ -52,33 +47,38 @@ import {
   withdrawObligationCollateralAndRedeemReserveCollateral,
   withdrawObligationCollateralAndRedeemReserveCollateralV2,
   withdrawReferrerFees,
-} from '../idl_codegen/instructions';
+} from '../@codegen/klend/instructions';
 import {
   buildComputeBudgetIx,
   createAssociatedTokenAccountIdempotentInstruction,
-  ObligationType,
-  U64_MAX,
-  referrerTokenStatePda,
-  userMetadataPda,
+  createAtasIdempotent,
   createLookupTableIx,
-  isNotNullPubkey,
-  PublicKeySet,
+  DEFAULT_PUBLIC_KEY,
   getAssociatedTokenAddress,
+  isNotNullPubkey,
+  obligationFarmStatePda,
+  ObligationType,
+  referrerTokenStatePda,
   ScopePriceRefreshConfig,
-  createAtasIdempotent,
   SOL_PADDING_FOR_INTEREST,
-  obligationFarmStatePda,
+  U64_MAX,
+  userMetadataPda,
+  WRAPPED_SOL_MINT,
 } from '../utils';
 import { getTokenIdsForScopeRefresh, KaminoMarket } from './market';
 import { isKaminoObligation, KaminoObligation } from './obligation';
 import { KaminoReserve } from './reserve';
-import { ReserveFarmKind } from '../idl_codegen/types';
-import { farmsId } from '@kamino-finance/farms-sdk';
-import { Reserve } from '../idl_codegen/accounts';
+import { ReserveFarmKind } from '../@codegen/klend/types';
+import { PROGRAM_ID as FARMS_PROGRAM_ID } from '@kamino-finance/farms-sdk/dist/@codegen/farms/programId';
+import { Reserve } from '../@codegen/klend/accounts';
 import { VanillaObligation } from '../utils/ObligationType';
-import { PROGRAM_ID } from '../lib';
 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 { getTransferSolInstruction, SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
+import { noopSigner } from '../utils/signer';
 
 export type ActionType =
   | 'deposit'
@@ -106,68 +106,68 @@ export class KaminoAction {
 
   outflowReserve: KaminoReserve | undefined;
 
-  owner: PublicKey;
-  payer: PublicKey;
+  owner: TransactionSigner;
+  payer: TransactionSigner;
 
   obligation: KaminoObligation | ObligationType;
 
-  referrer: PublicKey;
+  referrer: Option<Address>;
 
   /**
    * Null unless the obligation is not passed
    */
   obligationType: ObligationType | null = null;
 
-  mint: PublicKey;
+  mint: Address;
 
-  secondaryMint?: PublicKey;
+  secondaryMint?: Address;
 
   positions?: number;
 
   amount: BN;
   outflowAmount?: BN;
 
-  computeBudgetIxs: Array<TransactionInstruction>;
+  computeBudgetIxs: Array<IInstruction>;
   computeBudgetIxsLabels: Array<string>;
 
-  setupIxs: Array<TransactionInstruction>;
+  setupIxs: Array<IInstruction>;
   setupIxsLabels: Array<string>;
 
-  inBetweenIxs: Array<TransactionInstruction>;
+  inBetweenIxs: Array<IInstruction>;
   inBetweenIxsLabels: Array<string>;
 
-  lendingIxs: Array<TransactionInstruction>;
+  lendingIxs: Array<IInstruction>;
   lendingIxsLabels: Array<string>;
 
-  cleanupIxs: Array<TransactionInstruction>;
+  cleanupIxs: Array<IInstruction>;
   cleanupIxsLabels: Array<string>;
 
-  refreshFarmsCleanupTxnIxs: Array<TransactionInstruction>;
+  refreshFarmsCleanupTxnIxs: Array<IInstruction>;
   refreshFarmsCleanupTxnIxsLabels: Array<string>;
 
-  depositReserves: Array<PublicKey>;
-  borrowReserves: Array<PublicKey>;
+  depositReserves: Array<Address>;
+  borrowReserves: Array<Address>;
 
-  preLoadedDepositReservesSameTx: Array<PublicKey>;
+  preLoadedDepositReservesSameTx: Array<Address>;
 
-  currentSlot: number;
+  currentSlot: Slot;
 
   private constructor(
     kaminoMarket: KaminoMarket,
-    owner: PublicKey,
+    owner: TransactionSigner,
     obligation: KaminoObligation | ObligationType,
-    mint: PublicKey,
+    mint: Address,
     positions: number,
     amount: string | BN,
-    depositReserves: Array<PublicKey>,
-    borrowReserves: Array<PublicKey>,
+    depositReserves: Array<Address>,
+    borrowReserves: Array<Address>,
     reserveState: KaminoReserve,
-    currentSlot: number,
-    secondaryMint?: PublicKey,
+    currentSlot: Slot,
+    secondaryMint?: Address,
     outflowReserveState?: KaminoReserve,
     outflowAmount?: string | BN,
-    referrer?: PublicKey,
-    payer?: PublicKey
+    referrer: Option<Address> = none(),
+    payer?: TransactionSigner
   ) {
     this.kaminoMarket = kaminoMarket;
     this.obligation = obligation;
@@ -195,30 +195,30 @@ export class KaminoAction {
     this.outflowReserve = outflowReserveState;
     this.outflowAmount = outflowAmount ? new BN(outflowAmount) : undefined;
     this.preLoadedDepositReservesSameTx = [];
-    this.referrer = referrer ? referrer : PublicKey.default;
+    this.referrer = referrer;
     this.currentSlot = currentSlot;
   }
 
   static async initialize(
     action: ActionType,
     amount: string | BN,
-    mint: PublicKey,
-    owner: PublicKey,
+    mint: Address,
+    owner: TransactionSigner,
     kaminoMarket: KaminoMarket,
     obligation: KaminoObligation | ObligationType,
-    referrer: PublicKey = PublicKey.default,
-    currentSlot: number = 0,
-    payer?: PublicKey
+    referrer: Option<Address> = none(),
+    currentSlot: Slot = 0n,
+    payer: TransactionSigner = owner
   ) {
     const reserve = kaminoMarket.getReserveByMint(mint);
     if (reserve === undefined) {
-      throw new Error(`Reserve ${mint} not found in market ${kaminoMarket.getAddress().toBase58()}`);
+      throw new Error(`Reserve ${mint} not found in market ${kaminoMarket.getAddress()}`);
     }
 
     const { kaminoObligation, depositReserves, borrowReserves, distinctReserveCount } =
-      await KaminoAction.loadObligation(action, kaminoMarket, owner, reserve.address, obligation);
+      await KaminoAction.loadObligation(action, kaminoMarket, owner.address, reserve.address, obligation);
 
-    const referrerKey = await this.getReferrerKey(kaminoMarket, owner, kaminoObligation, referrer);
+    const referrerKey = await this.getReferrerKey(kaminoMarket, owner.address, kaminoObligation, referrer);
 
     return new KaminoAction(
       kaminoMarket,
@@ -239,21 +239,21 @@ export class KaminoAction {
     );
   }
 
-  private static getUserAccountAddresses(owner: PublicKey, reserve: Reserve) {
-    const userTokenAccountAddress = getAssociatedTokenAddress(
-      reserve.liquidity.mintPubkey,
-      owner,
-      true,
-      reserve.liquidity.tokenProgram,
-      ASSOCIATED_TOKEN_PROGRAM_ID
-    );
-    const userCollateralAccountAddress = getAssociatedTokenAddress(
-      reserve.collateral.mintPubkey,
-      owner,
-      true,
-      TOKEN_PROGRAM_ID,
-      ASSOCIATED_TOKEN_PROGRAM_ID
-    );
+  private static async getUserAccountAddresses(owner: Address, reserve: Reserve) {
+    const [userTokenAccountAddress, userCollateralAccountAddress] = await Promise.all([
+      getAssociatedTokenAddress(
+        reserve.liquidity.mintPubkey,
+        owner,
+        reserve.liquidity.tokenProgram,
+        ASSOCIATED_TOKEN_PROGRAM_ADDRESS
+      ),
+      getAssociatedTokenAddress(
+        reserve.collateral.mintPubkey,
+        owner,
+        TOKEN_PROGRAM_ADDRESS,
+        ASSOCIATED_TOKEN_PROGRAM_ADDRESS
+      ),
+    ]);
 
     return { userTokenAccountAddress, userCollateralAccountAddress };
   }
@@ -261,18 +261,18 @@ export class KaminoAction {
   private static async loadObligation(
     action: ActionType,
     kaminoMarket: KaminoMarket,
-    owner: PublicKey,
-    reserve: PublicKey,
+    owner: Address,
+    reserve: Address,
     obligation: KaminoObligation | ObligationType,
-    outflowReserve?: PublicKey
+    outflowReserve?: Address
   ) {
     let kaminoObligation: KaminoObligation | null;
-    const depositReserves: Array<PublicKey> = [];
-    const borrowReserves: Array<PublicKey> = [];
+    const depositReserves: Array<Address> = [];
+    const borrowReserves: Array<Address> = [];
     if (obligation instanceof KaminoObligation) {
       kaminoObligation = obligation;
     } else {
-      const obligationAddress = obligation.toPda(kaminoMarket.getAddress(), owner);
+      const obligationAddress = await obligation.toPda(kaminoMarket.getAddress(), owner);
       kaminoObligation = await KaminoObligation.load(kaminoMarket, obligationAddress);
     }
     if (kaminoObligation !== null) {
@@ -286,16 +286,16 @@ export class KaminoAction {
 
     // Union of addresses
     const distinctReserveCount =
-      new PublicKeySet<PublicKey>([
+      new Set<Address>([
         ...borrowReserves.map((e) => e),
         ...(action === 'borrow' ? [reserve] : []),
         ...(action === 'depositAndBorrow' ? [reserve] : []),
-      ]).toArray().length +
-      new PublicKeySet<PublicKey>([
+      ]).size +
+      new Set<Address>([
         ...depositReserves.map((e) => e),
         ...(action === 'deposit' ? [reserve] : []),
         ...(action === 'depositAndBorrow' ? [outflowReserve!] : []),
-      ]).toArray().length;
+      ]).size;
 
     return {
       kaminoObligation,
@@ -307,22 +307,22 @@ export class KaminoAction {
 
   static async buildRefreshObligationTxns(
     kaminoMarket: KaminoMarket,
-    payer: PublicKey,
+    payer: TransactionSigner,
     obligation: KaminoObligation,
     extraComputeBudget: number = 1_000_000, // if > 0 then adds the ix
-    currentSlot: number = 0
+    currentSlot: Slot = 0n
   ) {
     //  placeholder for action initialization
     const firstReserve = obligation.getDeposits()[0].reserveAddress;
     const firstKaminoReserve = kaminoMarket.getReserveByAddress(firstReserve);
     if (!firstKaminoReserve) {
-      throw new Error(`Reserve ${firstReserve.toBase58()} not found`);
+      throw new Error(`Reserve ${firstReserve} not found`);
     }
     const axn = await KaminoAction.initialize(
       'refreshObligation',
       '0',
       firstKaminoReserve?.getLiquidityMint(),
-      obligation.state.owner,
+      noopSigner(obligation.state.owner), // owner does not need to sign for refresh
       kaminoMarket,
       obligation,
       undefined,
@@ -333,31 +333,29 @@ export class KaminoAction {
       axn.addComputeBudgetIxn(extraComputeBudget);
     }
 
-    axn.addRefreshObligation(payer);
+    await axn.addRefreshObligation(payer);
 
     return axn;
   }
 
   static async buildRequestElevationGroupTxns(
     kaminoMarket: KaminoMarket,
-    payer: PublicKey,
+    owner: TransactionSigner,
     obligation: KaminoObligation,
     elevationGroup: number,
     extraComputeBudget: number = 1_000_000, // if > 0 then adds the ix
-    currentSlot: number = 0
+    currentSlot: Slot = 0n
   ) {
-    const firstReserve = obligation.state.deposits.find(
-      (x) => !x.depositReserve.equals(PublicKey.default)
-    )!.depositReserve;
+    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.toBase58()} not found`);
+      throw new Error(`Reserve ${firstReserve} not found`);
     }
     const axn = await KaminoAction.initialize(
       'requestElevationGroup',
       '0',
       firstKaminoReserve?.getLiquidityMint(),
-      obligation.state.owner,
+      owner,
       kaminoMarket,
       obligation,
       undefined,
@@ -368,8 +366,8 @@ export class KaminoAction {
       axn.addComputeBudgetIxn(extraComputeBudget);
     }
 
-    axn.addRefreshObligation(payer);
-    axn.addRequestElevationIx(elevationGroup, 'setup');
+    await axn.addRefreshObligation(owner);
+    await axn.addRequestElevationIx(elevationGroup, 'setup');
 
     return axn;
   }
@@ -377,8 +375,8 @@ export class KaminoAction {
   static async buildDepositTxns(
     kaminoMarket: KaminoMarket,
     amount: string | BN,
-    mint: PublicKey,
-    owner: PublicKey,
+    mint: Address,
+    owner: TransactionSigner,
     obligation: KaminoObligation | ObligationType,
     useV2Ixs: boolean,
     scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
@@ -389,8 +387,8 @@ export class KaminoAction {
       skipInitialization: false,
       skipLutCreation: false,
     },
-    referrer: PublicKey = PublicKey.default,
-    currentSlot: number = 0,
+    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(
@@ -421,9 +419,9 @@ export class KaminoAction {
       overrideElevationGroupRequest
     );
     if (useV2Ixs) {
-      axn.addDepositIxV2();
+      await axn.addDepositIxV2();
     } else {
-      axn.addDepositIx();
+      await axn.addDepositIx();
     }
     axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
 
@@ -445,8 +443,8 @@ export class KaminoAction {
   static async buildBorrowTxns(
     kaminoMarket: KaminoMarket,
     amount: string | BN,
-    mint: PublicKey,
-    owner: PublicKey,
+    mint: Address,
+    owner: TransactionSigner,
     obligation: KaminoObligation | ObligationType,
     useV2Ixs: boolean,
     scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
@@ -457,8 +455,8 @@ export class KaminoAction {
       skipInitialization: false,
       skipLutCreation: false,
     },
-    referrer: PublicKey = PublicKey.default,
-    currentSlot: number = 0,
+    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(
@@ -476,14 +474,14 @@ export class KaminoAction {
       axn.addComputeBudgetIxn(extraComputeBudget);
     }
 
-    if (!axn.referrer.equals(PublicKey.default)) {
-      const referrerTokenState = referrerTokenStatePda(
-        axn.referrer,
+    if (isSome(axn.referrer)) {
+      const referrerTokenState = await referrerTokenStatePda(
+        axn.referrer.value,
         axn.reserve.address,
         axn.kaminoMarket.programId
-      )[0];
-      const account = await axn.kaminoMarket.getConnection().getAccountInfo(referrerTokenState);
-      if (!account) {
+      );
+      const account = await fetchEncodedAccount(kaminoMarket.getRpc(), referrerTokenState);
+      if (!account.exists) {
         axn.addInitReferrerTokenStateIx(axn.reserve, referrerTokenState);
       }
     }
@@ -500,9 +498,9 @@ export class KaminoAction {
       overrideElevationGroupRequest
     );
     if (useV2Ixs) {
-      axn.addBorrowIxV2();
+      await axn.addBorrowIxV2();
     } else {
-      axn.addBorrowIx();
+      await axn.addBorrowIx();
     }
     axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
 
@@ -512,15 +510,15 @@ export class KaminoAction {
   static async buildDepositReserveLiquidityTxns(
     kaminoMarket: KaminoMarket,
     amount: string | BN,
-    mint: PublicKey,
-    owner: PublicKey,
+    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: PublicKey = PublicKey.default,
-    currentSlot: number = 0
+    referrer: Option<Address> = none(),
+    currentSlot: Slot = 0n
   ) {
     const axn = await KaminoAction.initialize(
       'mint',
@@ -547,7 +545,7 @@ export class KaminoAction {
       scopeRefreshConfig,
       { skipInitialization: true, skipLutCreation: true }
     );
-    axn.addDepositReserveLiquidityIx();
+    await axn.addDepositReserveLiquidityIx();
     axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
     return axn;
   }
@@ -555,15 +553,15 @@ export class KaminoAction {
   static async buildRedeemReserveCollateralTxns(
     kaminoMarket: KaminoMarket,
     amount: string | BN,
-    mint: PublicKey,
-    owner: PublicKey,
+    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: PublicKey = PublicKey.default,
-    currentSlot: number = 0
+    referrer: Option<Address> = none(),
+    currentSlot: Slot = 0n
   ) {
     const axn = await KaminoAction.initialize(
       'redeem',
@@ -590,7 +588,7 @@ export class KaminoAction {
       scopeRefreshConfig,
       { skipInitialization: true, skipLutCreation: true }
     );
-    axn.addRedeemReserveCollateralIx();
+    await axn.addRedeemReserveCollateralIx();
     axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
     return axn;
   }
@@ -598,8 +596,8 @@ export class KaminoAction {
   static async buildDepositObligationCollateralTxns(
     kaminoMarket: KaminoMarket,
     amount: string | BN,
-    mint: PublicKey,
-    owner: PublicKey,
+    mint: Address,
+    owner: TransactionSigner,
     obligation: KaminoObligation | ObligationType,
     useV2Ixs: boolean,
     scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
@@ -610,8 +608,8 @@ export class KaminoAction {
       skipInitialization: false,
       skipLutCreation: false,
     },
-    referrer: PublicKey = PublicKey.default,
-    currentSlot: number = 0
+    referrer: Option<Address> = none(),
+    currentSlot: Slot = 0n
   ) {
     const axn = await KaminoAction.initialize(
       'depositCollateral',
@@ -639,9 +637,9 @@ export class KaminoAction {
       initUserMetadata
     );
     if (useV2Ixs) {
-      axn.addDepositObligationCollateralIxV2();
+      await axn.addDepositObligationCollateralIxV2();
     } else {
-      axn.addDepositObligationCollateralIx();
+      await axn.addDepositObligationCollateralIx();
     }
     axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
     return axn;
@@ -650,10 +648,10 @@ export class KaminoAction {
   static async buildDepositAndBorrowTxns(
     kaminoMarket: KaminoMarket,
     depositAmount: string | BN,
-    depositMint: PublicKey,
+    depositMint: Address,
     borrowAmount: string | BN,
-    borrowMint: PublicKey,
-    payer: PublicKey,
+    borrowMint: Address,
+    owner: TransactionSigner,
     obligation: KaminoObligation | ObligationType,
     useV2Ixs: boolean,
     scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
@@ -664,8 +662,8 @@ export class KaminoAction {
       skipInitialization: false,
       skipLutCreation: false,
     },
-    referrer: PublicKey = PublicKey.default,
-    currentSlot: number = 0
+    referrer: Option<Address> = none(),
+    currentSlot: Slot = 0n
   ) {
     const axn = await KaminoAction.initializeMultiTokenAction(
       kaminoMarket,
@@ -673,8 +671,8 @@ export class KaminoAction {
       depositAmount,
       depositMint,
       borrowMint,
-      payer,
-      payer,
+      owner,
+      owner.address,
       obligation,
       borrowAmount,
       referrer,
@@ -688,14 +686,14 @@ export class KaminoAction {
       axn.addComputeBudgetIxn(extraComputeBudget);
     }
 
-    if (!axn.referrer.equals(PublicKey.default)) {
-      const referrerTokenState = referrerTokenStatePda(
-        axn.referrer,
+    if (isSome(axn.referrer)) {
+      const referrerTokenState = await referrerTokenStatePda(
+        axn.referrer.value,
         axn.outflowReserve!.address,
         axn.kaminoMarket.programId
-      )[0];
-      const account = await axn.kaminoMarket.getConnection().getAccountInfo(referrerTokenState);
-      if (!account) {
+      );
+      const account = await fetchEncodedAccount(axn.kaminoMarket.getRpc(), referrerTokenState);
+      if (!account.exists) {
         axn.addInitReferrerTokenStateIx(axn.outflowReserve!, referrerTokenState);
       }
     }
@@ -724,14 +722,16 @@ export class KaminoAction {
     );
     axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
 
-    // Create the scope refresh ix in here to ensure it's the first ix in the txn
-    const allReserves = new PublicKeySet<PublicKey>([
-      ...axn.depositReserves,
-      ...axn.borrowReserves,
-      axn.reserve.address,
-      ...(axn.outflowReserve ? [axn.outflowReserve.address] : []),
-      ...(axn.preLoadedDepositReservesSameTx ? axn.preLoadedDepositReservesSameTx : []),
-    ]).toArray();
+    // Create the scope refresh ix in here to ensure it's the first ix in the tx
+    const allReserves = [
+      ...new Set<Address>([
+        ...axn.depositReserves,
+        ...axn.borrowReserves,
+        axn.reserve.address,
+        ...(axn.outflowReserve ? [axn.outflowReserve.address] : []),
+        ...(axn.preLoadedDepositReservesSameTx ? axn.preLoadedDepositReservesSameTx : []),
+      ]),
+    ];
     const tokenIds = getTokenIdsForScopeRefresh(axn.kaminoMarket, allReserves);
 
     if (tokenIds.length > 0 && scopeRefreshConfig) {
@@ -743,11 +743,11 @@ export class KaminoAction {
   static async buildDepositAndWithdrawV2Txns(
     kaminoMarket: KaminoMarket,
     depositAmount: string | BN,
-    depositMint: PublicKey,
+    depositMint: Address,
     withdrawAmount: string | BN,
-    withdrawMint: PublicKey,
-    payer: PublicKey,
-    currentSlot: number,
+    withdrawMint: Address,
+    owner: TransactionSigner,
+    currentSlot: Slot,
     obligation: KaminoObligation | ObligationType,
     scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
     extraComputeBudget: number = 1_000_000, // if > 0 then adds the ix
@@ -757,7 +757,7 @@ export class KaminoAction {
       skipInitialization: false,
       skipLutCreation: false,
     },
-    referrer: PublicKey = PublicKey.default
+    referrer: Option<Address> = none()
   ) {
     const axn = await KaminoAction.initializeMultiTokenAction(
       kaminoMarket,
@@ -765,8 +765,8 @@ export class KaminoAction {
       depositAmount,
       depositMint,
       withdrawMint,
-      payer,
-      payer,
+      owner,
+      owner.address,
       obligation,
       withdrawAmount,
       referrer,
@@ -789,7 +789,7 @@ export class KaminoAction {
       twoTokenAction
     );
     const withdrawCollateralAmount = axn.getWithdrawCollateralAmount(axn.outflowReserve!, axn.outflowAmount!);
-    axn.addDepositAndWithdrawV2Ixs(withdrawCollateralAmount);
+    await axn.addDepositAndWithdrawV2Ixs(withdrawCollateralAmount);
 
     return axn;
   }
@@ -797,11 +797,11 @@ export class KaminoAction {
   static async buildRepayAndWithdrawV2Txns(
     kaminoMarket: KaminoMarket,
     repayAmount: string | BN,
-    repayMint: PublicKey,
+    repayMint: Address,
     withdrawAmount: string | BN,
-    withdrawMint: PublicKey,
-    payer: PublicKey,
-    currentSlot: number,
+    withdrawMint: Address,
+    payer: TransactionSigner,
+    currentSlot: Slot,
     obligation: KaminoObligation | ObligationType,
     scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
     extraComputeBudget: number = 1_000_000, // if > 0 then adds the ix
@@ -811,7 +811,7 @@ export class KaminoAction {
       skipInitialization: false,
       skipLutCreation: false,
     },
-    referrer: PublicKey = PublicKey.default
+    referrer: Option<Address> = none()
   ) {
     const axn = await KaminoAction.initializeMultiTokenAction(
       kaminoMarket,
@@ -820,7 +820,7 @@ export class KaminoAction {
       repayMint,
       withdrawMint,
       payer,
-      payer,
+      payer.address,
       obligation,
       withdrawAmount,
       referrer,
@@ -843,7 +843,7 @@ export class KaminoAction {
       twoTokenAction
     );
     const withdrawCollateralAmount = axn.getWithdrawCollateralAmount(axn.outflowReserve!, axn.outflowAmount!);
-    axn.addRepayAndWithdrawV2Ixs(withdrawCollateralAmount);
+    await axn.addRepayAndWithdrawV2Ixs(withdrawCollateralAmount);
 
     return axn;
   }
@@ -851,11 +851,11 @@ export class KaminoAction {
   static async buildRepayAndWithdrawTxns(
     kaminoMarket: KaminoMarket,
     repayAmount: string | BN,
-    repayMint: PublicKey,
+    repayMint: Address,
     withdrawAmount: string | BN,
-    withdrawMint: PublicKey,
-    payer: PublicKey,
-    currentSlot: number,
+    withdrawMint: Address,
+    payer: TransactionSigner,
+    currentSlot: Slot,
     obligation: KaminoObligation | ObligationType,
     useV2Ixs: boolean,
     scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
@@ -866,7 +866,7 @@ export class KaminoAction {
       skipInitialization: false,
       skipLutCreation: false,
     },
-    referrer: PublicKey = PublicKey.default
+    referrer: Option<Address> = none()
   ) {
     const axn = await KaminoAction.initializeMultiTokenAction(
       kaminoMarket,
@@ -875,7 +875,7 @@ export class KaminoAction {
       repayMint,
       withdrawMint,
       payer,
-      payer,
+      payer.address,
       obligation,
       withdrawAmount,
       referrer,
@@ -914,14 +914,16 @@ export class KaminoAction {
       useV2Ixs
     );
     axn.addRefreshFarmsCleanupTxnIxsToCleanupIxs();
-    // Create the scope refresh ix in here to ensure it's the first ix in the txn
-    const allReserves = new PublicKeySet<PublicKey>([
-      ...axn.depositReserves,
-      ...axn.borrowReserves,
-      axn.reserve.address,
-      ...(axn.outflowReserve ? [axn.outflowReserve.address] : []),
-      ...(axn.preLoadedDepositReservesSameTx ? axn.preLoadedDepositReservesSameTx : []),
-    ]).toArray();
+    // Create the scope refresh ix in here to ensure it's the first ix in the tx
+    const allReserves = [
+      ...new Set<Address>([
+        ...axn.depositReserves,
+        ...axn.borrowReserves,
+        axn.reserve.address,
+        ...(axn.outflowReserve ? [axn.outflowReserve.address] : []),
+        ...(axn.preLoadedDepositReservesSameTx ? axn.preLoadedDepositReservesSameTx : []),
+      ]),
+    ];
     const tokenIds = getTokenIdsForScopeRefresh(axn.kaminoMarket, allReserves);
 
     if (tokenIds.length > 0 && scopeRefreshConfig) {
@@ -933,8 +935,8 @@ export class KaminoAction {
   static async buildWithdrawTxns(
     kaminoMarket: KaminoMarket,
     amount: string | BN,
-    mint: PublicKey,
-    owner: PublicKey,
+    mint: Address,
+    owner: TransactionSigner,
     obligation: KaminoObligation | ObligationType,
     useV2Ixs: boolean,
     scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
@@ -945,13 +947,13 @@ export class KaminoAction {
       skipInitialization: false,
       skipLutCreation: false,
     },
-    referrer: PublicKey = PublicKey.default,
-    currentSlot: number = 0,
+    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?: PublicKey[];
+      addedDepositReserves?: Address[];
     }
   ) {
     const axn = await KaminoAction.initialize(
@@ -1003,24 +1005,26 @@ export class KaminoAction {
    * @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 includeUserMetadata - if true it includes user metadata
+   * @param initUserMetadata
    * @param referrer
    */
   static async buildRepayTxns(
     kaminoMarket: KaminoMarket,
     amount: string | BN,
-    mint: PublicKey,
-    owner: PublicKey,
+    mint: Address,
+    owner: TransactionSigner,
     obligation: KaminoObligation | ObligationType,
     useV2Ixs: boolean,
     scopeRefreshConfig: ScopePriceRefreshConfig | undefined,
-    currentSlot: number,
-    payer: PublicKey | undefined = undefined,
+    currentSlot: Slot,
+    payer: TransactionSigner = owner,
     extraComputeBudget: number = 1_000_000,
     includeAtaIxs: boolean = true,
     requestElevationGroup: boolean = false,
@@ -1028,7 +1032,7 @@ export class KaminoAction {
       skipInitialization: false,
       skipLutCreation: false,
     },
-    referrer: PublicKey = PublicKey.default
+    referrer: Option<Address> = none()
   ) {
     const axn = await KaminoAction.initialize(
       'repay',
@@ -1070,10 +1074,10 @@ export class KaminoAction {
     kaminoMarket: KaminoMarket,
     amount: string | BN,
     minCollateralReceiveAmount: string | BN,
-    repayTokenMint: PublicKey,
-    withdrawTokenMint: PublicKey,
-    liquidator: PublicKey,
-    obligationOwner: PublicKey,
+    repayTokenMint: Address,
+    withdrawTokenMint: Address,
+    liquidator: TransactionSigner,
+    obligationOwner: Address,
     obligation: KaminoObligation | ObligationType,
     useV2Ixs: boolean,
     scopeRefreshConfig: ScopePriceRefreshConfig | undefined = undefined,
@@ -1084,10 +1088,10 @@ export class KaminoAction {
       skipInitialization: false,
       skipLutCreation: false,
     },
-    referrer: PublicKey = PublicKey.default,
+    referrer: Option<Address> = none(),
     maxAllowedLtvOverridePercent: number = 0,
-    currentSlot: number = 0
-  ) {
+    currentSlot: Slot = 0n
+  ): Promise<KaminoAction> {
     const axn = await KaminoAction.initializeMultiTokenAction(
       kaminoMarket,
       'liquidate',
@@ -1127,10 +1131,10 @@ export class KaminoAction {
   }
 
   static async buildWithdrawReferrerFeeTxns(
-    owner: PublicKey,
-    tokenMint: PublicKey,
+    owner: TransactionSigner,
+    tokenMint: Address,
     kaminoMarket: KaminoMarket,
-    currentSlot: number = 0
+    currentSlot: Slot = 0n
   ) {
     const { axn, createAtaIxs } = await KaminoAction.initializeWithdrawReferrerFees(
       tokenMint,
@@ -1142,19 +1146,19 @@ export class KaminoAction {
     axn.setupIxs.push(...createAtaIxs);
     axn.setupIxsLabels.push(`createAtasIxs[${axn.owner.toString()}]`);
 
-    if (!axn.referrer.equals(PublicKey.default)) {
-      const referrerTokenState = referrerTokenStatePda(
-        axn.referrer,
+    if (isSome(axn.referrer)) {
+      const referrerTokenState = await referrerTokenStatePda(
+        axn.referrer.value,
         axn.reserve.address,
         axn.kaminoMarket.programId
-      )[0];
-      const account = await axn.kaminoMarket.getConnection().getAccountInfo(referrerTokenState);
-      if (!account) {
+      );
+      const account = await fetchEncodedAccount(axn.kaminoMarket.getRpc(), referrerTokenState);
+      if (!account.exists) {
         axn.addInitReferrerTokenStateIx(axn.reserve, referrerTokenState);
       }
     }
     axn.addRefreshReserveIxs([axn.reserve.address]);
-    axn.addWithdrawReferrerFeesIxs();
+    await axn.addWithdrawReferrerFeesIxs();
 
     return axn;
   }
@@ -1166,10 +1170,11 @@ export class KaminoAction {
    * setting the `null` state (i.e. cancelling the order).
    */
   static buildSetObligationOrderIxn(
+    owner: TransactionSigner,
     kaminoMarket: KaminoMarket,
     obligation: KaminoObligation,
     orderAtIndex: ObligationOrderAtIndex
-  ): TransactionInstruction {
+  ): IInstruction {
     return setObligationOrder(
       {
         index: orderAtIndex.index,
@@ -1178,81 +1183,13 @@ export class KaminoAction {
       {
         lendingMarket: kaminoMarket.getAddress(),
         obligation: obligation.obligationAddress,
-        owner: obligation.state.owner,
+        owner,
       },
       kaminoMarket.programId
     );
   }
 
-  async getTransactions() {
-    let txns: Transaction;
-
-    if (this.lendingIxs.length === 2) {
-      txns = new Transaction({
-        feePayer: this.owner,
-        recentBlockhash: (await this.kaminoMarket.getConnection().getLatestBlockhash()).blockhash,
-      }).add(
-        ...this.setupIxs,
-        ...[this.lendingIxs[0]],
-        ...this.inBetweenIxs,
-        ...[this.lendingIxs[1]],
-        ...this.cleanupIxs
-      );
-    } else {
-      txns = new Transaction({
-        feePayer: this.owner,
-        recentBlockhash: (await this.kaminoMarket.getConnection().getLatestBlockhash()).blockhash,
-      }).add(...this.setupIxs, ...this.lendingIxs, ...this.cleanupIxs);
-    }
-
-    return txns;
-  }
-
-  async sendTransactions(sendTransaction: (txn: Transaction, connection: Connection) => Promise<TransactionSignature>) {
-    const txns = await this.getTransactions();
-
-    const signature = await this.sendSingleTransaction(txns, sendTransaction);
-
-    return signature;
-  }
-
-  private async sendSingleTransaction(
-    txn: Transaction | null,
-    sendTransaction: (txn: Transaction, connection: Connection) => Promise<TransactionSignature>
-  ) {
-    if (!txn) return '';
-
-    const signature = await sendTransaction(txn, this.kaminoMarket.getConnection());
-    await this.kaminoMarket.getConnection().confirmTransaction(signature);
-
-    return signature;
-  }
-
-  async simulateTransactions(
-    sendTransaction: (
-      txn: Transaction,
-      connection: Connection
-    ) => Promise<RpcResponseAndContext<SimulatedTransactionResponse>>
-  ) {
-    const txns = await this.getTransactions();
-
-    const signature = await this.simulateSingleTransaction(txns, sendTransaction);
-
-    return signature;
-  }
-
-  private async simulateSingleTransaction(
-    txn: Transaction | null,
-    sendTransaction: (
-      txn: Transaction,
-      connection: Connection
-    ) => Promise<RpcResponseAndContext<SimulatedTransactionResponse>>
-  ) {
-    if (!txn) return '';
-    return await sendTransaction(txn, this.kaminoMarket.getConnection());
-  }
-
-  addDepositReserveLiquidityIx() {
+  async addDepositReserveLiquidityIx() {
     this.lendingIxsLabels.push(`depositReserveLiquidity`);
     this.lendingIxs.push(
       depositReserveLiquidity(
@@ -1262,23 +1199,23 @@ export class KaminoAction {
         {
           owner: this.owner,
           lendingMarket: this.kaminoMarket.getAddress(),
-          lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+          lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
           reserve: this.reserve.address,
           reserveLiquidityMint: this.reserve.getLiquidityMint(),
           reserveLiquiditySupply: this.reserve.state.liquidity.supplyVault,
           reserveCollateralMint: this.reserve.getCTokenMint(),
-          userSourceLiquidity: this.getUserTokenAccountAddress(this.reserve),
-          userDestinationCollateral: this.getUserCollateralAccountAddress(this.reserve),
-          collateralTokenProgram: TOKEN_PROGRAM_ID,
+          userSourceLiquidity: await this.getUserTokenAccountAddress(this.reserve),
+          userDestinationCollateral: await this.getUserCollateralAccountAddress(this.reserve),
+          collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
           liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
         },
         this.kaminoMarket.programId
       )
     );
   }
 
-  addRedeemReserveCollateralIx() {
+  async addRedeemReserveCollateralIx() {
     this.lendingIxsLabels.push(`redeemReserveCollateral`);
     this.lendingIxs.push(
       redeemReserveCollateral(
@@ -1288,16 +1225,16 @@ export class KaminoAction {
         {
           owner: this.owner,
           lendingMarket: this.kaminoMarket.getAddress(),
-          lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+          lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
           reserve: this.reserve.address,
           reserveLiquidityMint: this.reserve.getLiquidityMint(),
           reserveLiquiditySupply: this.reserve.state.liquidity.supplyVault,
           reserveCollateralMint: this.reserve.getCTokenMint(),
-          userSourceCollateral: this.getUserCollateralAccountAddress(this.reserve),
-          userDestinationLiquidity: this.getUserTokenAccountAddress(this.reserve),
-          collateralTokenProgram: TOKEN_PROGRAM_ID,
+          userSourceCollateral: await this.getUserCollateralAccountAddress(this.reserve),
+          userDestinationLiquidity: await this.getUserTokenAccountAddress(this.reserve),
+          collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
           liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
         },
         this.kaminoMarket.programId
       )
@@ -1305,7 +1242,7 @@ export class KaminoAction {
   }
 
   // @deprecated -- use addDepositIxV2 instead
-  addDepositIx() {
+  async addDepositIx() {
     this.lendingIxsLabels.push(`depositReserveLiquidityAndObligationCollateral`);
     this.lendingIxs.push(
       depositReserveLiquidityAndObligationCollateral(
@@ -1314,36 +1251,30 @@ export class KaminoAction {
         },
         {
           owner: this.owner,
-          obligation: this.getObligationPda(),
+          obligation: await this.getObligationPda(),
           lendingMarket: this.kaminoMarket.getAddress(),
-          lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+          lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
           reserve: this.reserve.address,
           reserveLiquidityMint: this.reserve.getLiquidityMint(),
           reserveLiquiditySupply: this.reserve.state.liquidity.supplyVault,
           reserveCollateralMint: this.reserve.getCTokenMint(),
           reserveDestinationDepositCollateral: this.reserve.state.collateral.supplyVault, // destinationCollateral
-          userSourceLiquidity: this.getUserTokenAccountAddress(this.reserve),
-          placeholderUserDestinationCollateral: this.kaminoMarket.programId,
-          collateralTokenProgram: TOKEN_PROGRAM_ID,
+          userSourceLiquidity: await this.getUserTokenAccountAddress(this.reserve),
+          placeholderUserDestinationCollateral: none(),
+          collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
           liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
         },
         this.kaminoMarket.programId
       )
     );
   }
 
-  addDepositIxV2() {
-    const farmsAccounts = this.reserve.state.farmCollateral.equals(PublicKey.default)
-      ? {
-          obligationFarmUserState: this.kaminoMarket.programId,
-          reserveFarmState: this.kaminoMarket.programId,
-        }
-      : {
-          obligationFarmUserState: obligationFarmStatePda(this.reserve.state.farmCollateral, this.getObligationPda()),
-          reserveFarmState: this.reserve.state.farmCollateral,
-        };
-
+  async addDepositIxV2() {
+    const { collateralFarmAccounts: farmsAccounts } = await KaminoAction.getFarmAccountsForReserve(
+      await this.getObligationPda(),
+      this.reserve
+    );
     this.lendingIxsLabels.push(`depositReserveLiquidityAndObligationCollateralV2`);
     this.lendingIxs.push(
       depositReserveLiquidityAndObligationCollateralV2(
@@ -1353,22 +1284,22 @@ export class KaminoAction {
         {
           depositAccounts: {
             owner: this.owner,
-            obligation: this.getObligationPda(),
+            obligation: await this.getObligationPda(),
             lendingMarket: this.kaminoMarket.getAddress(),
-            lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+            lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
             reserve: this.reserve.address,
             reserveLiquidityMint: this.reserve.getLiquidityMint(),
             reserveLiquiditySupply: this.reserve.state.liquidity.supplyVault,
             reserveCollateralMint: this.reserve.getCTokenMint(),
             reserveDestinationDepositCollateral: this.reserve.state.collateral.supplyVault, // destinationCollateral
-            userSourceLiquidity: this.getUserTokenAccountAddress(this.reserve),
-            placeholderUserDestinationCollateral: this.kaminoMarket.programId,
-            collateralTokenProgram: TOKEN_PROGRAM_ID,
+            userSourceLiquidity: await this.getUserTokenAccountAddress(this.reserve),
+            placeholderUserDestinationCollateral: none(),
+            collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
             liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
-            instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+            instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
           },
           farmsAccounts,
-          farmsProgram: farmsId,
+          farmsProgram: FARMS_PROGRAM_ID,
         },
         this.kaminoMarket.programId
       )
@@ -1376,7 +1307,7 @@ export class KaminoAction {
   }
 
   /// @deprecated -- use addDepositObligationCollateralIxV2 instead
-  addDepositObligationCollateralIx() {
+  async addDepositObligationCollateralIx() {
     this.lendingIxsLabels.push(`depositObligationCollateral`);
     this.lendingIxs.push(
       depositObligationCollateral(
@@ -1385,29 +1316,25 @@ export class KaminoAction {
         },
         {
           owner: this.owner,
-          obligation: this.getObligationPda(),
+          obligation: await this.getObligationPda(),
           lendingMarket: this.kaminoMarket.getAddress(),
           depositReserve: this.reserve.address,
           reserveDestinationCollateral: this.reserve.state.collateral.supplyVault,
-          userSourceCollateral: this.getUserCollateralAccountAddress(this.reserve),
-          tokenProgram: TOKEN_PROGRAM_ID,
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+          userSourceCollateral: await this.getUserCollateralAccountAddress(this.reserve),
+          tokenProgram: TOKEN_PROGRAM_ADDRESS,
+          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
         },
         this.kaminoMarket.programId
       )
     );
   }
 
-  addDepositObligationCollateralIxV2() {
-    const farmsAccounts = this.reserve.state.farmCollateral.equals(PublicKey.default)
-      ? {
-          obligationFarmUserState: this.kaminoMarket.programId,
-          reserveFarmState: this.kaminoMarket.programId,
-        }
-      : {
-          obligationFarmUserState: obligationFarmStatePda(this.reserve.state.farmCollateral, this.getObligationPda()),
-          reserveFarmState: this.reserve.state.farmCollateral,
-        };
+  async addDepositObligationCollateralIxV2() {
+    const obligationAddress = await this.getObligationPda();
+    const { collateralFarmAccounts: farmsAccounts } = await KaminoAction.getFarmAccountsForReserve(
+      obligationAddress,
+      this.reserve
+    );
 
     this.lendingIxsLabels.push(`depositObligationCollateralV2`);
     this.lendingIxs.push(
@@ -1418,17 +1345,17 @@ export class KaminoAction {
         {
           depositAccounts: {
             owner: this.owner,
-            obligation: this.getObligationPda(),
+            obligation: obligationAddress,
             lendingMarket: this.kaminoMarket.getAddress(),
             depositReserve: this.reserve.address,
             reserveDestinationCollateral: this.reserve.state.collateral.supplyVault,
-            userSourceCollateral: this.getUserCollateralAccountAddress(this.reserve),
-            tokenProgram: TOKEN_PROGRAM_ID,
-            instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+            userSourceCollateral: await this.getUserCollateralAccountAddress(this.reserve),
+            tokenProgram: TOKEN_PROGRAM_ADDRESS,
+            instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
           },
-          lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+          lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
           farmsAccounts,
-          farmsProgram: farmsId,
+          farmsProgram: FARMS_PROGRAM_ID,
         },
         this.kaminoMarket.programId
       )
@@ -1436,95 +1363,93 @@ export class KaminoAction {
   }
 
   /// @deprecated -- use addDepositObligationCollateralIxV2 instead
-  addBorrowIx() {
+  async addBorrowIx() {
     this.lendingIxsLabels.push(`borrowObligationLiquidity`);
 
     const depositReservesList = this.getAdditionalDepositReservesList();
 
-    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
+    const depositReserveAccountMetas: IAccountMeta[] = depositReservesList.map((reserve) => {
+      return { address: reserve, role: AccountRole.WRITABLE };
     });
 
-    const borrowIx = borrowObligationLiquidity(
+    let borrowIx = borrowObligationLiquidity(
       {
         liquidityAmount: this.amount,
       },
       {
         owner: this.owner,
-        obligation: this.getObligationPda(),
+        obligation: await this.getObligationPda(),
         lendingMarket: this.kaminoMarket.getAddress(),
-        lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+        lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
         borrowReserve: this.reserve.address,
         borrowReserveLiquidityMint: this.reserve.getLiquidityMint(),
         reserveSourceLiquidity: this.reserve.state.liquidity.supplyVault,
-        userDestinationLiquidity: this.getUserTokenAccountAddress(this.reserve),
+        userDestinationLiquidity: await this.getUserTokenAccountAddress(this.reserve),
         borrowReserveLiquidityFeeReceiver: this.reserve.state.liquidity.feeVault,
-        referrerTokenState: referrerTokenStatePda(this.referrer, this.reserve.address, this.kaminoMarket.programId)[0],
+        referrerTokenState: await this.getReferrerTokenStateAddress(this.reserve.address),
         tokenProgram: this.reserve.getLiquidityTokenProgram(),
-        instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+        instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
       },
       this.kaminoMarket.programId
     );
-    borrowIx.keys =
-      isKaminoObligation(this.obligation) &&
-      (this.obligation.state.elevationGroup > 0 || this.obligation.refreshedStats.potentialElevationGroupUpdate > 0)
-        ? borrowIx.keys.concat([...depositReserveAccountMetas])
-        : borrowIx.keys;
+    borrowIx = {
+      ...borrowIx,
+      accounts:
+        isKaminoObligation(this.obligation) &&
+        (this.obligation.state.elevationGroup > 0 || this.obligation.refreshedStats.potentialElevationGroupUpdate > 0)
+          ? borrowIx.accounts!.concat(depositReserveAccountMetas)
+          : borrowIx.accounts,
+    };
     this.lendingIxs.push(borrowIx);
   }
 
-  addBorrowIxV2() {
+  async addBorrowIxV2() {
     this.lendingIxsLabels.push(`borrowObligationLiquidityV2`);
 
     const depositReservesList = this.getAdditionalDepositReservesList();
 
-    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
+    const depositReserveAccountMetas: IAccountMeta[] = depositReservesList.map((reserve) => {
+      return { address: reserve, role: AccountRole.WRITABLE };
     });
 
-    const farmsAccounts = this.reserve.state.farmDebt.equals(PublicKey.default)
-      ? {
-          obligationFarmUserState: this.kaminoMarket.programId,
-          reserveFarmState: this.kaminoMarket.programId,
-        }
-      : {
-          obligationFarmUserState: obligationFarmStatePda(this.reserve.state.farmDebt, this.getObligationPda()),
-          reserveFarmState: this.reserve.state.farmDebt,
-        };
+    const obligationAddress = await this.getObligationPda();
+    const { debtFarmAccounts: farmsAccounts } = await KaminoAction.getFarmAccountsForReserve(
+      obligationAddress,
+      this.reserve
+    );
 
-    const borrowIx = borrowObligationLiquidityV2(
+    let borrowIx = borrowObligationLiquidityV2(
       {
         liquidityAmount: this.amount,
       },
       {
         borrowAccounts: {
           owner: this.owner,
-          obligation: this.getObligationPda(),
+          obligation: obligationAddress,
           lendingMarket: this.kaminoMarket.getAddress(),
-          lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+          lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
           borrowReserve: this.reserve.address,
           borrowReserveLiquidityMint: this.reserve.getLiquidityMint(),
           reserveSourceLiquidity: this.reserve.state.liquidity.supplyVault,
-          userDestinationLiquidity: this.getUserTokenAccountAddress(this.reserve),
+          userDestinationLiquidity: await this.getUserTokenAccountAddress(this.reserve),
           borrowReserveLiquidityFeeReceiver: this.reserve.state.liquidity.feeVault,
-          referrerTokenState: referrerTokenStatePda(
-            this.referrer,
-            this.reserve.address,
-            this.kaminoMarket.programId
-          )[0],
+          referrerTokenState: await this.getReferrerTokenStateAddress(this.reserve.address),
           tokenProgram: this.reserve.getLiquidityTokenProgram(),
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
         },
         farmsAccounts,
-        farmsProgram: farmsId,
+        farmsProgram: FARMS_PROGRAM_ID,
       },
       this.kaminoMarket.programId
     );
-    borrowIx.keys =
-      isKaminoObligation(this.obligation) &&
-      (this.obligation.state.elevationGroup > 0 || this.obligation.refreshedStats.potentialElevationGroupUpdate > 0)
-        ? borrowIx.keys.concat([...depositReserveAccountMetas])
-        : borrowIx.keys;
+    borrowIx = {
+      ...borrowIx,
+      accounts:
+        isKaminoObligation(this.obligation) &&
+        (this.obligation.state.elevationGroup > 0 || this.obligation.refreshedStats.potentialElevationGroupUpdate > 0)
+          ? borrowIx.accounts!.concat(depositReserveAccountMetas)
+          : borrowIx.accounts,
+    };
     this.lendingIxs.push(borrowIx);
   }
 
@@ -1538,36 +1463,31 @@ export class KaminoAction {
         },
         {
           owner: this.owner,
-          obligation: this.getObligationPda(),
+          obligation: await this.getObligationPda(),
           lendingMarket: this.kaminoMarket.getAddress(),
-          lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+          lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
           withdrawReserve: this.reserve.address,
           reserveLiquidityMint: this.reserve.getLiquidityMint(),
           reserveCollateralMint: this.reserve.getCTokenMint(),
           reserveLiquiditySupply: this.reserve.state.liquidity.supplyVault,
           reserveSourceCollateral: this.reserve.state.collateral.supplyVault,
-          userDestinationLiquidity: this.getUserTokenAccountAddress(this.reserve),
-          placeholderUserDestinationCollateral: this.kaminoMarket.programId,
-          collateralTokenProgram: TOKEN_PROGRAM_ID,
+          userDestinationLiquidity: await this.getUserTokenAccountAddress(this.reserve),
+          placeholderUserDestinationCollateral: none(),
+          collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
           liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
         },
         this.kaminoMarket.programId
       )
     );
   }
 
-  async addWithdrawIxV2(collateralAmount: BN) {
-    const farmsAccounts = this.reserve.state.farmCollateral.equals(PublicKey.default)
-      ? {
-          obligationFarmUserState: this.kaminoMarket.programId,
-          reserveFarmState: this.kaminoMarket.programId,
-        }
-      : {
-          obligationFarmUserState: obligationFarmStatePda(this.reserve.state.farmCollateral, this.getObligationPda()),
-          reserveFarmState: this.reserve.state.farmCollateral,
-        };
-
+  async addWithdrawIxV2(collateralAmount: BN): Promise<void> {
+    const obligationAddress = await this.getObligationPda();
+    const { collateralFarmAccounts: farmsAccounts } = await KaminoAction.getFarmAccountsForReserve(
+      obligationAddress,
+      this.reserve
+    );
     this.lendingIxsLabels.push(`withdrawObligationCollateralAndRedeemReserveCollateralV2`);
     this.lendingIxs.push(
       withdrawObligationCollateralAndRedeemReserveCollateralV2(
@@ -1577,22 +1497,22 @@ export class KaminoAction {
         {
           withdrawAccounts: {
             owner: this.owner,
-            obligation: this.getObligationPda(),
+            obligation: obligationAddress,
             lendingMarket: this.kaminoMarket.getAddress(),
-            lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+            lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
             withdrawReserve: this.reserve.address,
             reserveLiquidityMint: this.reserve.getLiquidityMint(),
             reserveCollateralMint: this.reserve.getCTokenMint(),
             reserveLiquiditySupply: this.reserve.state.liquidity.supplyVault,
             reserveSourceCollateral: this.reserve.state.collateral.supplyVault,
-            userDestinationLiquidity: this.getUserTokenAccountAddress(this.reserve),
-            placeholderUserDestinationCollateral: this.kaminoMarket.programId,
-            collateralTokenProgram: TOKEN_PROGRAM_ID,
+            userDestinationLiquidity: await this.getUserTokenAccountAddress(this.reserve),
+            placeholderUserDestinationCollateral: none(),
+            collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
             liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
-            instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+            instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
           },
           farmsAccounts: farmsAccounts,
-          farmsProgram: farmsId,
+          farmsProgram: FARMS_PROGRAM_ID,
         },
         this.kaminoMarket.programId
       )
@@ -1601,108 +1521,113 @@ export class KaminoAction {
 
   /// @deprecated -- use addRepayIxV2 instead
   async addRepayIx() {
+    const obligationAddress = await this.getObligationPda();
     this.lendingIxsLabels.push(
-      `repayObligationLiquidity(reserve=${this.reserve.address})(obligation=${this.getObligationPda()})`
+      `repayObligationLiquidity(reserve=${this.reserve.address})(obligation=${obligationAddress})`
     );
 
     const depositReservesList = this.getAdditionalDepositReservesList();
 
-    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
+    const depositReserveAccountMetas: IAccountMeta[] = depositReservesList.map((reserve) => {
+      return { address: reserve, role: AccountRole.WRITABLE };
     });
 
-    const repayIx = repayObligationLiquidity(
+    let repayIx = repayObligationLiquidity(
       {
         liquidityAmount: this.amount,
       },
       {
         owner: this.payer,
-        obligation: this.getObligationPda(),
+        obligation: obligationAddress,
         lendingMarket: this.kaminoMarket.getAddress(),
         repayReserve: this.reserve.address,
         reserveLiquidityMint: this.reserve.getLiquidityMint(),
-        userSourceLiquidity: this.getTokenAccountAddressByUser(this.reserve, this.payer),
+        userSourceLiquidity: await this.getTokenAccountAddressByUser(this.reserve, this.payer.address),
         reserveDestinationLiquidity: this.reserve.state.liquidity.supplyVault,
         tokenProgram: this.reserve.getLiquidityTokenProgram(),
-        instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+        instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
       },
       this.kaminoMarket.programId
     );
 
-    repayIx.keys =
-      isKaminoObligation(this.obligation) && this.obligation.state.elevationGroup > 0
-        ? repayIx.keys.concat([...depositReserveAccountMetas])
-        : repayIx.keys;
+    repayIx = {
+      ...repayIx,
+      accounts:
+        isKaminoObligation(this.obligation) && this.obligation.state.elevationGroup > 0
+          ? repayIx.accounts!.concat(depositReserveAccountMetas)
+          : repayIx.accounts,
+    };
 
     this.lendingIxs.push(repayIx);
   }
 
   async addRepayIxV2() {
+    const obligationAddress = await this.getObligationPda();
     this.lendingIxsLabels.push(
-      `repayObligationLiquidityV2(reserve=${this.reserve.address})(obligation=${this.getObligationPda()})`
+      `repayObligationLiquidityV2(reserve=${this.reserve.address})(obligation=${obligationAddress})`
     );
 
     const depositReservesList = this.getAdditionalDepositReservesList();
 
-    const farmsAccounts = this.reserve.state.farmDebt.equals(PublicKey.default)
-      ? {
-          obligationFarmUserState: this.kaminoMarket.programId,
-          reserveFarmState: this.kaminoMarket.programId,
-        }
-      : {
-          obligationFarmUserState: obligationFarmStatePda(this.reserve.state.farmDebt, this.getObligationPda()),
-          reserveFarmState: this.reserve.state.farmDebt,
-        };
-    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
+    const { debtFarmAccounts: farmsAccounts } = await KaminoAction.getFarmAccountsForReserve(
+      obligationAddress,
+      this.reserve
+    );
+
+    const depositReserveAccountMetas: IAccountMeta[] = depositReservesList.map((reserve) => {
+      return { address: reserve, role: AccountRole.WRITABLE };
     });
 
-    const repayIx = repayObligationLiquidityV2(
+    let repayIx = repayObligationLiquidityV2(
       {
         liquidityAmount: this.amount,
       },
       {
         repayAccounts: {
           owner: this.payer,
-          obligation: this.getObligationPda(),
+          obligation: obligationAddress,
           lendingMarket: this.kaminoMarket.getAddress(),
           repayReserve: this.reserve.address,
           reserveLiquidityMint: this.reserve.getLiquidityMint(),
-          userSourceLiquidity: this.getTokenAccountAddressByUser(this.reserve, this.payer),
+          userSourceLiquidity: await this.getTokenAccountAddressByUser(this.reserve, this.payer.address),
           reserveDestinationLiquidity: this.reserve.state.liquidity.supplyVault,
           tokenProgram: this.reserve.getLiquidityTokenProgram(),
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
         },
-        lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+        lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
         farmsAccounts,
-        farmsProgram: farmsId,
+        farmsProgram: FARMS_PROGRAM_ID,
       },
       this.kaminoMarket.programId
     );
 
-    repayIx.keys =
+    repayIx = {
+      ...repayIx,
       // TODO: potential elev group update?
-      isKaminoObligation(this.obligation) && this.obligation.state.elevationGroup > 0
-        ? repayIx.keys.concat([...depositReserveAccountMetas])
-        : repayIx.keys;
+      accounts:
+        isKaminoObligation(this.obligation) && this.obligation.state.elevationGroup > 0
+          ? repayIx.accounts!.concat(depositReserveAccountMetas)
+          : repayIx.accounts,
+    };
 
     this.lendingIxs.push(repayIx);
   }
 
-  addRepayAndWithdrawV2Ixs(withdrawCollateralAmount: BN) {
+  async addRepayAndWithdrawV2Ixs(withdrawCollateralAmount: BN): Promise<void> {
+    const obligationAddress = await this.getObligationPda();
     this.lendingIxsLabels.push(
       `repayAndWithdrawAndRedeem(repayReserve=${this.reserve!.address})(withdrawReserve=${
         this.outflowReserve!.address
-      })(obligation=${this.getObligationPda()})`
+      })(obligation=${obligationAddress})`
     );
 
     const depositReservesList = this.getAdditionalDepositReservesList();
 
-    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
+    const depositReserveAccountMetas: IAccountMeta[] = depositReservesList.map((reserve) => {
+      return { address: reserve, role: AccountRole.WRITABLE };
     });
-    const borrowReserveAccountMetas = this.borrowReserves.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
+    const borrowReserveAccountMetas: IAccountMeta[] = this.borrowReserves.map((reserve) => {
+      return { address: reserve, role: AccountRole.WRITABLE };
     });
 
     if (!this.outflowAmount) {
@@ -1713,30 +1638,13 @@ export class KaminoAction {
       throw new Error(`outflowReserve 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: this.kaminoMarket.programId,
-          reserveFarmState: this.kaminoMarket.programId,
-        }
-      : {
-          obligationFarmUserState: obligationFarmStatePda(this.reserve.state.farmDebt, this.getObligationPda()),
-          reserveFarmState: this.reserve.state.farmDebt,
-        };
+    const { collateralFarmAccounts } = await KaminoAction.getFarmAccountsForReserve(
+      obligationAddress,
+      this.outflowReserve
+    );
+    const { debtFarmAccounts } = await KaminoAction.getFarmAccountsForReserve(obligationAddress, this.reserve);
 
-    const repayAndWithdrawIx = repayAndWithdrawAndRedeem(
+    let repayAndWithdrawIx = repayAndWithdrawAndRedeem(
       {
         repayAmount: this.amount,
         withdrawCollateralAmount,
@@ -1744,60 +1652,61 @@ export class KaminoAction {
       {
         repayAccounts: {
           owner: this.owner,
-          obligation: this.getObligationPda(),
+          obligation: obligationAddress,
           lendingMarket: this.kaminoMarket.getAddress(),
           repayReserve: this.reserve!.address,
           reserveLiquidityMint: this.reserve.getLiquidityMint(),
-          userSourceLiquidity: this.getUserTokenAccountAddress(this.reserve),
+          userSourceLiquidity: await this.getUserTokenAccountAddress(this.reserve),
           reserveDestinationLiquidity: this.reserve.state.liquidity.supplyVault,
           tokenProgram: this.reserve.getLiquidityTokenProgram(),
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
         },
         withdrawAccounts: {
           owner: this.owner,
-          obligation: this.getObligationPda(),
+          obligation: obligationAddress,
           lendingMarket: this.kaminoMarket.getAddress(),
-          lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+          lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
           withdrawReserve: this.outflowReserve.address,
           reserveLiquidityMint: this.outflowReserve.getLiquidityMint(),
           reserveCollateralMint: this.outflowReserve.getCTokenMint(),
           reserveLiquiditySupply: this.outflowReserve.state.liquidity.supplyVault,
           reserveSourceCollateral: this.outflowReserve.state.collateral.supplyVault,
-          userDestinationLiquidity: this.getUserTokenAccountAddress(this.outflowReserve),
-          placeholderUserDestinationCollateral: this.kaminoMarket.programId,
-          collateralTokenProgram: TOKEN_PROGRAM_ID,
+          userDestinationLiquidity: await this.getUserTokenAccountAddress(this.outflowReserve),
+          placeholderUserDestinationCollateral: none(),
+          collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
           liquidityTokenProgram: this.outflowReserve.getLiquidityTokenProgram(),
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
         },
-        collateralFarmsAccounts,
-        debtFarmsAccounts,
-        farmsProgram: farmsId,
+        collateralFarmsAccounts: collateralFarmAccounts,
+        debtFarmsAccounts: debtFarmAccounts,
+        farmsProgram: FARMS_PROGRAM_ID,
       },
       this.kaminoMarket.programId
     );
 
-    repayAndWithdrawIx.keys = repayAndWithdrawIx.keys.concat([
-      ...depositReserveAccountMetas,
-      ...borrowReserveAccountMetas,
-    ]);
+    repayAndWithdrawIx = {
+      ...repayAndWithdrawIx,
+      accounts: repayAndWithdrawIx.accounts!.concat(depositReserveAccountMetas).concat(borrowReserveAccountMetas),
+    };
 
     this.lendingIxs.push(repayAndWithdrawIx);
   }
 
-  addDepositAndWithdrawV2Ixs(withdrawCollateralAmount: BN) {
+  async addDepositAndWithdrawV2Ixs(withdrawCollateralAmount: BN): Promise<void> {
+    const obligationAddress = await this.getObligationPda();
     this.lendingIxsLabels.push(
       `depositAndWithdrawV2(depositReserve=${this.reserve!.address})(withdrawReserve=${
         this.outflowReserve!.address
-      })(obligation=${this.getObligationPda()})`
+      })(obligation=${obligationAddress})`
     );
 
     const depositReservesList = this.getAdditionalDepositReservesList();
 
-    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
+    const depositReserveAccountMetas: IAccountMeta[] = depositReservesList.map((reserve) => {
+      return { address: reserve, role: AccountRole.WRITABLE };
     });
-    const borrowReserveAccountMetas = this.borrowReserves.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
+    const borrowReserveAccountMetas: IAccountMeta[] = this.borrowReserves.map((reserve) => {
+      return { address: reserve, role: AccountRole.WRITABLE };
     });
 
     if (!this.outflowAmount) {
@@ -1808,29 +1717,17 @@ export class KaminoAction {
       throw new Error(`outflowReserve not set`);
     }
 
-    const depositFarmsAccounts = this.reserve.state.farmCollateral.equals(PublicKey.default)
-      ? {
-          obligationFarmUserState: this.kaminoMarket.programId,
-          reserveFarmState: this.kaminoMarket.programId,
-        }
-      : {
-          obligationFarmUserState: obligationFarmStatePda(this.reserve.state.farmCollateral, 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.outflowReserve.state.farmCollateral,
-            this.getObligationPda()
-          ),
-          reserveFarmState: this.outflowReserve.state.farmCollateral,
-        };
+    const { collateralFarmAccounts: depositFarmsAccounts } = await KaminoAction.getFarmAccountsForReserve(
+      obligationAddress,
+      this.reserve
+    );
+    const { collateralFarmAccounts: withdrawFarmsAccounts } = await KaminoAction.getFarmAccountsForReserve(
+      obligationAddress,
+      this.outflowReserve
+    );
 
-    const depositAndWithdrawIx = depositAndWithdraw(
+    const lendingMarketAuthority = await this.kaminoMarket.getLendingMarketAuthority();
+    let depositAndWithdrawIx = depositAndWithdraw(
       {
         liquidityAmount: this.amount,
         withdrawCollateralAmount,
@@ -1838,47 +1735,47 @@ export class KaminoAction {
       {
         depositAccounts: {
           owner: this.owner,
-          obligation: this.getObligationPda(),
+          obligation: obligationAddress,
           lendingMarket: this.kaminoMarket.getAddress(),
-          lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+          lendingMarketAuthority,
           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.getUserTokenAccountAddress(this.reserve),
-          placeholderUserDestinationCollateral: this.kaminoMarket.programId,
-          collateralTokenProgram: TOKEN_PROGRAM_ID,
+          userSourceLiquidity: await this.getUserTokenAccountAddress(this.reserve),
+          placeholderUserDestinationCollateral: none(),
+          collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
           liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
         },
         withdrawAccounts: {
           owner: this.owner,
-          obligation: this.getObligationPda(),
+          obligation: obligationAddress,
           lendingMarket: this.kaminoMarket.getAddress(),
-          lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+          lendingMarketAuthority,
           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.getUserTokenAccountAddress(this.outflowReserve),
-          placeholderUserDestinationCollateral: this.kaminoMarket.programId,
-          collateralTokenProgram: TOKEN_PROGRAM_ID,
+          userDestinationLiquidity: await this.getUserTokenAccountAddress(this.outflowReserve),
+          placeholderUserDestinationCollateral: none(),
+          collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
           liquidityTokenProgram: this.outflowReserve.getLiquidityTokenProgram(),
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
         },
         depositFarmsAccounts,
         withdrawFarmsAccounts,
-        farmsProgram: farmsId,
+        farmsProgram: FARMS_PROGRAM_ID,
       },
       this.kaminoMarket.programId
     );
 
-    depositAndWithdrawIx.keys = depositAndWithdrawIx.keys.concat([
-      ...depositReserveAccountMetas,
-      ...borrowReserveAccountMetas,
-    ]);
+    depositAndWithdrawIx = {
+      ...depositAndWithdrawIx,
+      accounts: depositAndWithdrawIx.accounts!.concat(depositReserveAccountMetas).concat(borrowReserveAccountMetas),
+    };
 
     this.lendingIxs.push(depositAndWithdrawIx);
   }
@@ -1893,19 +1790,19 @@ export class KaminoAction {
         },
         {
           owner: this.owner,
-          obligation: this.getObligationPda(),
+          obligation: await this.getObligationPda(),
           lendingMarket: this.kaminoMarket.getAddress(),
-          lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+          lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
           reserve: this.reserve.address,
           reserveLiquidityMint: this.reserve.getLiquidityMint(),
           reserveLiquiditySupply: this.reserve.state.liquidity.supplyVault,
           reserveCollateralMint: this.reserve.getCTokenMint(),
           reserveDestinationDepositCollateral: this.reserve.state.collateral.supplyVault, // destinationCollateral
-          userSourceLiquidity: this.getUserTokenAccountAddress(this.reserve),
-          placeholderUserDestinationCollateral: this.kaminoMarket.programId,
-          collateralTokenProgram: TOKEN_PROGRAM_ID,
+          userSourceLiquidity: await this.getUserTokenAccountAddress(this.reserve),
+          placeholderUserDestinationCollateral: none(),
+          collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
           liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
         },
         this.kaminoMarket.programId
       )
@@ -1923,50 +1820,45 @@ export class KaminoAction {
     if (depositReservesList.length === 0) {
       depositReservesList.push(this.reserve.address);
     }
-    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
+    const depositReserveAccountMetas: IAccountMeta[] = depositReservesList.map((reserve) => {
+      return { address: reserve, role: AccountRole.WRITABLE };
     });
 
-    const borrowIx = borrowObligationLiquidity(
+    let borrowIx = borrowObligationLiquidity(
       {
         liquidityAmount: this.outflowAmount,
       },
       {
         owner: this.owner,
-        obligation: this.getObligationPda(),
+        obligation: await this.getObligationPda(),
         lendingMarket: this.kaminoMarket.getAddress(),
-        lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+        lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
         borrowReserve: this.outflowReserve.address,
         borrowReserveLiquidityMint: this.outflowReserve.getLiquidityMint(),
         reserveSourceLiquidity: this.outflowReserve.state.liquidity.supplyVault,
-        userDestinationLiquidity: this.getUserTokenAccountAddress(this.outflowReserve),
+        userDestinationLiquidity: await this.getUserTokenAccountAddress(this.outflowReserve),
         borrowReserveLiquidityFeeReceiver: this.outflowReserve.state.liquidity.feeVault,
-        referrerTokenState: referrerTokenStatePda(
-          this.referrer,
-          this.outflowReserve.address,
-          this.kaminoMarket.programId
-        )[0],
+        referrerTokenState: await this.getReferrerTokenStateAddress(this.outflowReserve.address),
         tokenProgram: this.outflowReserve.getLiquidityTokenProgram(),
-        instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+        instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
       },
       this.kaminoMarket.programId
     );
 
-    borrowIx.keys = borrowIx.keys.concat([...depositReserveAccountMetas]);
+    borrowIx = {
+      ...borrowIx,
+      accounts: borrowIx.accounts!.concat(depositReserveAccountMetas),
+    };
 
     this.lendingIxs.push(borrowIx);
   }
 
-  async addDepositAndBorrowIxV2() {
-    const collateralFarmsAccounts = this.reserve.state.farmCollateral.equals(PublicKey.default)
-      ? {
-          obligationFarmUserState: this.kaminoMarket.programId,
-          reserveFarmState: this.kaminoMarket.programId,
-        }
-      : {
-          obligationFarmUserState: obligationFarmStatePda(this.reserve.state.farmCollateral, this.getObligationPda()),
-          reserveFarmState: this.reserve.state.farmCollateral,
-        };
+  async addDepositAndBorrowIxV2(): Promise<void> {
+    const obligationAddress = await this.getObligationPda();
+    const { collateralFarmAccounts: collateralFarmsAccounts } = await KaminoAction.getFarmAccountsForReserve(
+      obligationAddress,
+      this.reserve
+    );
 
     this.lendingIxsLabels.push(`depositReserveLiquidityAndObligationCollateralV2`);
     this.lendingIxsLabels.push(`borrowObligationLiquidityV2`);
@@ -1978,22 +1870,22 @@ export class KaminoAction {
         {
           depositAccounts: {
             owner: this.owner,
-            obligation: this.getObligationPda(),
+            obligation: obligationAddress,
             lendingMarket: this.kaminoMarket.getAddress(),
-            lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+            lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
             reserve: this.reserve.address,
             reserveLiquidityMint: this.reserve.getLiquidityMint(),
             reserveLiquiditySupply: this.reserve.state.liquidity.supplyVault,
             reserveCollateralMint: this.reserve.getCTokenMint(),
             reserveDestinationDepositCollateral: this.reserve.state.collateral.supplyVault, // destinationCollateral
-            userSourceLiquidity: this.getUserTokenAccountAddress(this.reserve),
-            placeholderUserDestinationCollateral: this.kaminoMarket.programId,
-            collateralTokenProgram: TOKEN_PROGRAM_ID,
+            userSourceLiquidity: await this.getUserTokenAccountAddress(this.reserve),
+            placeholderUserDestinationCollateral: none(),
+            collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
             liquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
-            instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+            instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
           },
           farmsAccounts: collateralFarmsAccounts,
-          farmsProgram: farmsId,
+          farmsProgram: FARMS_PROGRAM_ID,
         },
         this.kaminoMarket.programId
       )
@@ -2011,84 +1903,82 @@ export class KaminoAction {
     if (depositReservesList.length === 0) {
       depositReservesList.push(this.reserve.address);
     }
-    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
+    const depositReserveAccountMetas: IAccountMeta[] = depositReservesList.map((reserve) => {
+      return { address: reserve, role: AccountRole.WRITABLE };
     });
 
-    const debtFarmsAccounts = this.outflowReserve.state.farmDebt.equals(PublicKey.default)
-      ? {
-          obligationFarmUserState: this.kaminoMarket.programId,
-          reserveFarmState: this.kaminoMarket.programId,
-        }
-      : {
-          obligationFarmUserState: obligationFarmStatePda(this.outflowReserve.state.farmDebt, this.getObligationPda()),
-          reserveFarmState: this.outflowReserve.state.farmDebt,
-        };
+    const { debtFarmAccounts: debtFarmsAccounts } = await KaminoAction.getFarmAccountsForReserve(
+      obligationAddress,
+      this.outflowReserve
+    );
 
-    const borrowIx = borrowObligationLiquidityV2(
+    let borrowIx = borrowObligationLiquidityV2(
       {
         liquidityAmount: this.outflowAmount,
       },
       {
         borrowAccounts: {
           owner: this.owner,
-          obligation: this.getObligationPda(),
+          obligation: obligationAddress,
           lendingMarket: this.kaminoMarket.getAddress(),
-          lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+          lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
           borrowReserve: this.outflowReserve.address,
           borrowReserveLiquidityMint: this.outflowReserve.getLiquidityMint(),
           reserveSourceLiquidity: this.outflowReserve.state.liquidity.supplyVault,
-          userDestinationLiquidity: this.getUserTokenAccountAddress(this.outflowReserve),
+          userDestinationLiquidity: await this.getUserTokenAccountAddress(this.outflowReserve),
           borrowReserveLiquidityFeeReceiver: this.outflowReserve.state.liquidity.feeVault,
-          referrerTokenState: referrerTokenStatePda(
-            this.referrer,
-            this.outflowReserve.address,
-            this.kaminoMarket.programId
-          )[0],
+          referrerTokenState: await this.getReferrerTokenStateAddress(this.outflowReserve.address),
           tokenProgram: this.outflowReserve.getLiquidityTokenProgram(),
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
         },
         farmsAccounts: debtFarmsAccounts,
-        farmsProgram: farmsId,
+        farmsProgram: FARMS_PROGRAM_ID,
       },
       this.kaminoMarket.programId
     );
 
-    borrowIx.keys = borrowIx.keys.concat([...depositReserveAccountMetas]);
+    borrowIx = {
+      ...borrowIx,
+      accounts: borrowIx.accounts!.concat(depositReserveAccountMetas),
+    };
 
     this.lendingIxs.push(borrowIx);
   }
 
   async addRepayAndWithdrawIxs(withdrawCollateralAmount: BN) {
+    const obligationAddress = await this.getObligationPda();
     this.lendingIxsLabels.push(
-      `repayObligationLiquidity(reserve=${this.reserve!.address})(obligation=${this.getObligationPda()})`
+      `repayObligationLiquidity(reserve=${this.reserve!.address})(obligation=${obligationAddress})`
     );
     this.lendingIxsLabels.push(`withdrawObligationCollateralAndRedeemReserveCollateral`);
 
     const depositReservesList = this.getAdditionalDepositReservesList();
 
-    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
+    const depositReserveAccountMetas: IAccountMeta[] = depositReservesList.map((reserve) => {
+      return { address: reserve, role: AccountRole.WRITABLE };
     });
-    const repayIx = repayObligationLiquidity(
+    let repayIx = repayObligationLiquidity(
       {
         liquidityAmount: this.amount,
       },
       {
         owner: this.owner,
-        obligation: this.getObligationPda(),
+        obligation: obligationAddress,
         lendingMarket: this.kaminoMarket.getAddress(),
         repayReserve: this.reserve!.address,
         reserveLiquidityMint: this.reserve.getLiquidityMint(),
-        userSourceLiquidity: this.getUserTokenAccountAddress(this.reserve),
+        userSourceLiquidity: await this.getUserTokenAccountAddress(this.reserve),
         reserveDestinationLiquidity: this.reserve.state.liquidity.supplyVault,
         tokenProgram: this.reserve.getLiquidityTokenProgram(),
-        instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+        instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
       },
       this.kaminoMarket.programId
     );
 
-    repayIx.keys = repayIx.keys.concat([...depositReserveAccountMetas]);
+    repayIx = {
+      ...repayIx,
+      accounts: repayIx.accounts!.concat(depositReserveAccountMetas),
+    };
 
     this.lendingIxs.push(repayIx);
     if (!this.outflowReserve) {
@@ -2106,19 +1996,19 @@ export class KaminoAction {
         },
         {
           owner: this.owner,
-          obligation: this.getObligationPda(),
+          obligation: obligationAddress,
           lendingMarket: this.kaminoMarket.getAddress(),
-          lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+          lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
           withdrawReserve: this.outflowReserve.address,
           reserveLiquidityMint: this.outflowReserve.getLiquidityMint(),
           reserveCollateralMint: this.outflowReserve.getCTokenMint(),
           reserveLiquiditySupply: this.outflowReserve.state.liquidity.supplyVault,
           reserveSourceCollateral: this.outflowReserve.state.collateral.supplyVault,
-          userDestinationLiquidity: this.getUserTokenAccountAddress(this.outflowReserve),
-          placeholderUserDestinationCollateral: this.kaminoMarket.programId,
-          collateralTokenProgram: TOKEN_PROGRAM_ID,
+          userDestinationLiquidity: await this.getUserTokenAccountAddress(this.outflowReserve),
+          placeholderUserDestinationCollateral: none(),
+          collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
           liquidityTokenProgram: this.outflowReserve.getLiquidityTokenProgram(),
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
         },
         this.kaminoMarket.programId
       )
@@ -2126,8 +2016,9 @@ export class KaminoAction {
   }
 
   async addRepayAndWithdrawIxsV2(withdrawCollateralAmount: BN) {
+    const obligationAddress = await this.getObligationPda();
     this.lendingIxsLabels.push(
-      `repayObligationLiquidityV2(reserve=${this.reserve!.address})(obligation=${this.getObligationPda()})`
+      `repayObligationLiquidityV2(reserve=${this.reserve!.address})(obligation=${obligationAddress})`
     );
     this.lendingIxsLabels.push(`withdrawObligationCollateralAndRedeemReserveCollateralV2`);
 
@@ -2137,45 +2028,45 @@ export class KaminoAction {
 
     const depositReservesList = this.getAdditionalDepositReservesList();
 
-    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
+    const depositReserveAccountMetas: IAccountMeta[] = depositReservesList.map((reserve) => {
+      return { address: reserve, role: AccountRole.WRITABLE };
     });
 
-    const debtFarmsAccounts = this.reserve.state.farmDebt.equals(PublicKey.default)
-      ? {
-          obligationFarmUserState: this.kaminoMarket.programId,
-          reserveFarmState: this.kaminoMarket.programId,
-        }
-      : {
-          obligationFarmUserState: obligationFarmStatePda(this.reserve.state.farmDebt, this.getObligationPda()),
-          reserveFarmState: this.reserve.state.farmDebt,
-        };
+    const { debtFarmAccounts: debtFarmsAccounts } = await KaminoAction.getFarmAccountsForReserve(
+      obligationAddress,
+      this.reserve
+    );
 
-    const repayIx = repayObligationLiquidityV2(
+    let repayIx = repayObligationLiquidityV2(
       {
         liquidityAmount: this.amount,
       },
       {
         repayAccounts: {
           owner: this.owner,
-          obligation: this.getObligationPda(),
+          obligation: obligationAddress,
           lendingMarket: this.kaminoMarket.getAddress(),
           repayReserve: this.reserve!.address,
           reserveLiquidityMint: this.reserve.getLiquidityMint(),
-          userSourceLiquidity: this.getUserTokenAccountAddress(this.reserve),
+          userSourceLiquidity: await this.getUserTokenAccountAddress(this.reserve),
           reserveDestinationLiquidity: this.reserve.state.liquidity.supplyVault,
           tokenProgram: this.reserve.getLiquidityTokenProgram(),
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
         },
-        lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+        lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
         farmsAccounts: debtFarmsAccounts,
-        farmsProgram: farmsId,
+        farmsProgram: FARMS_PROGRAM_ID,
       },
       this.kaminoMarket.programId
     );
 
-    repayIx.keys =
-      this.obligation.state.elevationGroup > 0 ? repayIx.keys.concat([...depositReserveAccountMetas]) : repayIx.keys;
+    repayIx = {
+      ...repayIx,
+      accounts:
+        this.obligation.state.elevationGroup > 0
+          ? repayIx.accounts!.concat(depositReserveAccountMetas)
+          : repayIx.accounts,
+    };
 
     this.lendingIxs.push(repayIx);
     if (!this.outflowReserve) {
@@ -2186,18 +2077,10 @@ export class KaminoAction {
       throw new Error(`outflowAmount 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 { collateralFarmAccounts: collateralFarmsAccounts } = await KaminoAction.getFarmAccountsForReserve(
+      obligationAddress,
+      this.outflowReserve
+    );
 
     this.lendingIxs.push(
       withdrawObligationCollateralAndRedeemReserveCollateralV2(
@@ -2207,29 +2090,29 @@ export class KaminoAction {
         {
           withdrawAccounts: {
             owner: this.owner,
-            obligation: this.getObligationPda(),
+            obligation: obligationAddress,
             lendingMarket: this.kaminoMarket.getAddress(),
-            lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+            lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
             withdrawReserve: this.outflowReserve.address,
             reserveLiquidityMint: this.outflowReserve.getLiquidityMint(),
             reserveCollateralMint: this.outflowReserve.getCTokenMint(),
             reserveLiquiditySupply: this.outflowReserve.state.liquidity.supplyVault,
             reserveSourceCollateral: this.outflowReserve.state.collateral.supplyVault,
-            userDestinationLiquidity: this.getUserTokenAccountAddress(this.outflowReserve),
-            placeholderUserDestinationCollateral: this.kaminoMarket.programId,
-            collateralTokenProgram: TOKEN_PROGRAM_ID,
+            userDestinationLiquidity: await this.getUserTokenAccountAddress(this.outflowReserve),
+            placeholderUserDestinationCollateral: none(),
+            collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
             liquidityTokenProgram: this.outflowReserve.getLiquidityTokenProgram(),
-            instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+            instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
           },
           farmsAccounts: collateralFarmsAccounts,
-          farmsProgram: farmsId,
+          farmsProgram: FARMS_PROGRAM_ID,
         },
         this.kaminoMarket.programId
       )
     );
   }
 
-  addLiquidateIx(maxAllowedLtvOverridePercent: number = 0) {
+  async addLiquidateIx(maxAllowedLtvOverridePercent: number = 0): Promise<void> {
     this.lendingIxsLabels.push(`liquidateObligationAndRedeemReserveCollateral`);
     if (!this.outflowReserve) {
       throw Error(`Withdraw reserve during liquidation is not defined`);
@@ -2240,11 +2123,11 @@ export class KaminoAction {
     }
 
     const depositReservesList = this.getAdditionalDepositReservesList();
-    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
+    const depositReserveAccountMetas: IAccountMeta[] = depositReservesList.map((reserve) => {
+      return { address: reserve, role: AccountRole.WRITABLE };
     });
 
-    const liquidateIx = liquidateObligationAndRedeemReserveCollateral(
+    let liquidateIx = liquidateObligationAndRedeemReserveCollateral(
       {
         liquidityAmount: this.amount,
         // TODO: Configure this when updating liquidator with new interface
@@ -2253,9 +2136,9 @@ export class KaminoAction {
       },
       {
         liquidator: this.owner,
-        obligation: this.getObligationPda(),
+        obligation: await this.getObligationPda(),
         lendingMarket: this.kaminoMarket.getAddress(),
-        lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+        lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
         repayReserve: this.reserve.address,
         repayReserveLiquidityMint: this.reserve.getLiquidityMint(),
         repayReserveLiquiditySupply: this.reserve.state.liquidity.supplyVault,
@@ -2264,21 +2147,24 @@ export class KaminoAction {
         withdrawReserveCollateralMint: this.outflowReserve.getCTokenMint(),
         withdrawReserveCollateralSupply: this.outflowReserve.state.collateral.supplyVault,
         withdrawReserveLiquiditySupply: this.outflowReserve.state.liquidity.supplyVault,
-        userSourceLiquidity: this.getUserTokenAccountAddress(this.reserve),
-        userDestinationCollateral: this.getUserCollateralAccountAddress(this.outflowReserve),
-        userDestinationLiquidity: this.getUserTokenAccountAddress(this.outflowReserve),
+        userSourceLiquidity: await this.getUserTokenAccountAddress(this.reserve),
+        userDestinationCollateral: await this.getUserCollateralAccountAddress(this.outflowReserve),
+        userDestinationLiquidity: await this.getUserTokenAccountAddress(this.outflowReserve),
         withdrawReserveLiquidityFeeReceiver: this.outflowReserve.state.liquidity.feeVault,
-        collateralTokenProgram: TOKEN_PROGRAM_ID,
+        collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
         repayLiquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
         withdrawLiquidityTokenProgram: this.outflowReserve.getLiquidityTokenProgram(),
-        instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+        instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
       },
       this.kaminoMarket.programId
     );
-    liquidateIx.keys =
-      this.obligation.state.elevationGroup > 0
-        ? liquidateIx.keys.concat([...depositReserveAccountMetas])
-        : liquidateIx.keys;
+    liquidateIx = {
+      ...liquidateIx,
+      accounts:
+        this.obligation.state.elevationGroup > 0
+          ? liquidateIx.accounts!.concat(depositReserveAccountMetas)
+          : liquidateIx.accounts,
+    };
     this.lendingIxs.push(liquidateIx);
   }
 
@@ -2293,34 +2179,21 @@ export class KaminoAction {
     }
 
     const depositReservesList = this.getAdditionalDepositReservesList();
-    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
+    const depositReserveAccountMetas: IAccountMeta[] = depositReservesList.map((reserve) => {
+      return { address: reserve, role: AccountRole.WRITABLE };
     });
 
-    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: this.kaminoMarket.programId,
-          reserveFarmState: this.kaminoMarket.programId,
-        }
-      : {
-          obligationFarmUserState: obligationFarmStatePda(this.reserve.state.farmDebt, this.getObligationPda()),
-          reserveFarmState: this.reserve.state.farmDebt,
-        };
+    const obligationAddress = await this.getObligationPda();
+    const { collateralFarmAccounts: collateralFarmsAccounts } = await KaminoAction.getFarmAccountsForReserve(
+      obligationAddress,
+      this.outflowReserve
+    );
+    const { debtFarmAccounts: debtFarmsAccounts } = await KaminoAction.getFarmAccountsForReserve(
+      await this.getObligationPda(),
+      this.reserve
+    );
 
-    const liquidateIx = liquidateObligationAndRedeemReserveCollateralV2(
+    let liquidateIx = liquidateObligationAndRedeemReserveCollateralV2(
       {
         liquidityAmount: this.amount,
         // TODO: Configure this when updating liquidator with new interface
@@ -2330,9 +2203,9 @@ export class KaminoAction {
       {
         liquidationAccounts: {
           liquidator: this.owner,
-          obligation: this.getObligationPda(),
+          obligation: obligationAddress,
           lendingMarket: this.kaminoMarket.getAddress(),
-          lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+          lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
           repayReserve: this.reserve.address,
           repayReserveLiquidityMint: this.reserve.getLiquidityMint(),
           repayReserveLiquiditySupply: this.reserve.state.liquidity.supplyVault,
@@ -2341,25 +2214,28 @@ export class KaminoAction {
           withdrawReserveCollateralMint: this.outflowReserve.getCTokenMint(),
           withdrawReserveCollateralSupply: this.outflowReserve.state.collateral.supplyVault,
           withdrawReserveLiquiditySupply: this.outflowReserve.state.liquidity.supplyVault,
-          userSourceLiquidity: this.getUserTokenAccountAddress(this.reserve),
-          userDestinationCollateral: this.getUserCollateralAccountAddress(this.outflowReserve),
-          userDestinationLiquidity: this.getUserTokenAccountAddress(this.outflowReserve),
+          userSourceLiquidity: await this.getUserTokenAccountAddress(this.reserve),
+          userDestinationCollateral: await this.getUserCollateralAccountAddress(this.outflowReserve),
+          userDestinationLiquidity: await this.getUserTokenAccountAddress(this.outflowReserve),
           withdrawReserveLiquidityFeeReceiver: this.outflowReserve.state.liquidity.feeVault,
-          collateralTokenProgram: TOKEN_PROGRAM_ID,
+          collateralTokenProgram: TOKEN_PROGRAM_ADDRESS,
           repayLiquidityTokenProgram: this.reserve.getLiquidityTokenProgram(),
           withdrawLiquidityTokenProgram: this.outflowReserve.getLiquidityTokenProgram(),
-          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_PUBKEY,
+          instructionSysvarAccount: SYSVAR_INSTRUCTIONS_ADDRESS,
         },
         debtFarmsAccounts,
         collateralFarmsAccounts,
-        farmsProgram: farmsId,
+        farmsProgram: FARMS_PROGRAM_ID,
       },
       this.kaminoMarket.programId
     );
-    liquidateIx.keys =
-      this.obligation!.state.elevationGroup > 0
-        ? liquidateIx.keys.concat([...depositReserveAccountMetas])
-        : liquidateIx.keys;
+    liquidateIx = {
+      ...liquidateIx,
+      accounts:
+        this.obligation!.state.elevationGroup > 0
+          ? liquidateIx.accounts!.concat(depositReserveAccountMetas)
+          : liquidateIx.accounts,
+    };
     this.lendingIxs.push(liquidateIx);
   }
 
@@ -2380,27 +2256,27 @@ export class KaminoAction {
     );
   }
 
-  addRefreshObligation(crank: PublicKey) {
-    const uniqueReserveAddresses = new PublicKeySet(this.depositReserves.concat(this.borrowReserves)).toArray();
+  async addRefreshObligation(crank: TransactionSigner): Promise<void> {
+    const uniqueReserveAddresses = [...new Set<Address>(this.depositReserves.concat(this.borrowReserves))];
 
     const addAllToSetupIxs = 'setup';
     // Union of addresses
     const allReservesExcludingCurrent = [...uniqueReserveAddresses];
 
     this.addRefreshReserveIxs(allReservesExcludingCurrent, addAllToSetupIxs);
-    this.addRefreshFarmsForReserve(
+    await this.addRefreshFarmsForReserve(
       this.depositReserves.map((r) => this.kaminoMarket.getReserveByAddress(r)!),
       addAllToSetupIxs,
       ReserveFarmKind.Collateral,
       crank
     );
-    this.addRefreshFarmsForReserve(
+    await this.addRefreshFarmsForReserve(
       this.borrowReserves.map((r) => this.kaminoMarket.getReserveByAddress(r)!),
       addAllToSetupIxs,
       ReserveFarmKind.Debt,
       crank
     );
-    this.addRefreshObligationIx(addAllToSetupIxs);
+    await this.addRefreshObligationIx(addAllToSetupIxs);
   }
 
   async addSupportIxsWithoutInitObligation(
@@ -2471,7 +2347,7 @@ export class KaminoAction {
               this.preLoadedDepositReservesSameTx.push(this.reserve.address);
             }
           }
-        } else if (action === 'liquidate' && !this.outflowReserve.address.equals(this.reserve.address)) {
+        } else if (action === 'liquidate' && this.outflowReserve.address !== this.reserve.address) {
           currentReserves = [this.outflowReserve, this.reserve];
         } else {
           currentReserves = [this.reserve];
@@ -2480,12 +2356,12 @@ export class KaminoAction {
         currentReserves = [this.reserve];
       }
 
-      const uniqueReserveAddresses = new PublicKeySet(this.depositReserves.concat(this.borrowReserves));
-      const currentReserveAddresses = new PublicKeySet(currentReserves.map((reserve) => reserve.address));
+      const uniqueReserveAddresses = new Set<Address>(this.depositReserves.concat(this.borrowReserves));
+      const currentReserveAddresses = new Set<Address>(currentReserves.map((reserve) => reserve.address));
 
       // Union of addresses
-      const allReservesExcludingCurrent = [...uniqueReserveAddresses.toArray()].filter(
-        (address) => !currentReserveAddresses.contains(address)
+      const allReservesExcludingCurrent = [...uniqueReserveAddresses].filter(
+        (address) => !currentReserveAddresses.has(address)
       );
 
       this.addRefreshReserveIxs(allReservesExcludingCurrent, addAsSupportIx);
@@ -2524,7 +2400,7 @@ export class KaminoAction {
           }
         }
       }
-      this.addRefreshReserveIxs(currentReserveAddresses.toArray(), addAsSupportIx);
+      this.addRefreshReserveIxs([...currentReserveAddresses], addAsSupportIx);
 
       if (action === 'repayAndWithdraw' && addAsSupportIx === 'inBetween') {
         if (!isKaminoObligation(this.obligation)) {
@@ -2537,9 +2413,9 @@ export class KaminoAction {
         const repaidBorrowReservesToSkip = repayObligationLiquidity.amount.lte(new Decimal(this.amount.toString()))
           ? [repayObligationLiquidity.reserveAddress]
           : [];
-        this.addRefreshObligationIx(addAsSupportIx, repaidBorrowReservesToSkip);
+        await this.addRefreshObligationIx(addAsSupportIx, repaidBorrowReservesToSkip);
       } else {
-        this.addRefreshObligationIx(addAsSupportIx);
+        await this.addRefreshObligationIx(addAsSupportIx);
       }
 
       if (requestElevationGroup) {
@@ -2560,8 +2436,8 @@ export class KaminoAction {
           ) {
             this.addRefreshReserveIxs(allReservesExcludingCurrent, 'cleanup');
             // Skip the borrow reserve, since we repay in the same tx
-            this.addRefreshObligationIx('cleanup', [this.reserve.address]);
-            this.addRequestElevationIx(overrideElevationGroupRequest ?? 0, 'cleanup', [this.reserve.address]);
+            await this.addRefreshObligationIx('cleanup', [this.reserve.address]);
+            await this.addRequestElevationIx(overrideElevationGroupRequest ?? 0, 'cleanup', [this.reserve.address]);
           }
         } else if (action === 'depositAndBorrow' || action === 'borrow') {
           let newElevationGroup: number = -1;
@@ -2616,10 +2492,10 @@ export class KaminoAction {
             newElevationGroup >= 0 &&
             newElevationGroup !== (isKaminoObligation(this.obligation) ? this.obligation.state.elevationGroup : 0)
           ) {
-            this.addRequestElevationIx(newElevationGroup, addAsSupportIx);
+            await this.addRequestElevationIx(newElevationGroup, addAsSupportIx);
             this.addRefreshReserveIxs(allReservesExcludingCurrent, addAsSupportIx);
-            this.addRefreshReserveIxs(currentReserveAddresses.toArray(), addAsSupportIx);
-            this.addRefreshObligationIx(addAsSupportIx);
+            this.addRefreshReserveIxs([...currentReserveAddresses], addAsSupportIx);
+            await this.addRefreshObligationIx(addAsSupportIx);
 
             if (action === 'borrow') {
               if (!isKaminoObligation(this.obligation)) {
@@ -2636,10 +2512,10 @@ export class KaminoAction {
         ) {
           const addAsSupportIx: AuxiliaryIx = 'setup';
           console.log('Deposit: Requesting elevation group', overrideElevationGroupRequest);
-          this.addRequestElevationIx(overrideElevationGroupRequest, addAsSupportIx);
+          await this.addRequestElevationIx(overrideElevationGroupRequest, addAsSupportIx);
           this.addRefreshReserveIxs(allReservesExcludingCurrent, addAsSupportIx);
-          this.addRefreshReserveIxs(currentReserveAddresses.toArray(), addAsSupportIx);
-          this.addRefreshObligationIx(addAsSupportIx);
+          this.addRefreshReserveIxs([...currentReserveAddresses], addAsSupportIx);
+          await this.addRefreshObligationIx(addAsSupportIx);
         } else if (
           action === 'withdraw' &&
           overrideElevationGroupRequest !== undefined
@@ -2648,8 +2524,8 @@ export class KaminoAction {
           console.log('Withdraw: Requesting elevation group', overrideElevationGroupRequest);
           // Skip the withdrawn reserve if we are in the process of closing it:
           const skipReserveIfClosing = this.amount.eq(new BN(U64_MAX)) ? [this.reserve.address] : [];
-          this.addRefreshObligationIx('cleanup', skipReserveIfClosing);
-          this.addRequestElevationIx(overrideElevationGroupRequest, 'cleanup', skipReserveIfClosing);
+          await this.addRefreshObligationIx('cleanup', skipReserveIfClosing);
+          await this.addRequestElevationIx(overrideElevationGroupRequest, 'cleanup', skipReserveIfClosing);
         }
       }
 
@@ -2658,15 +2534,15 @@ export class KaminoAction {
           // If this is an setup ix (therefore not an in-between), it means it's either a one off action
           // or the first of a two-token-action
           if (action === 'liquidate') {
-            this.addRefreshFarmsForReserve([this.outflowReserve!], addAsSupportIx, ReserveFarmKind.Collateral);
-            this.addRefreshFarmsForReserve([this.reserve], addAsSupportIx, ReserveFarmKind.Debt);
+            await this.addRefreshFarmsForReserve([this.outflowReserve!], addAsSupportIx, ReserveFarmKind.Collateral);
+            await this.addRefreshFarmsForReserve([this.reserve], addAsSupportIx, ReserveFarmKind.Debt);
           } else if (
             action === 'depositAndBorrow' ||
             action === 'depositCollateral' ||
             action === 'withdraw' ||
             action === 'deposit'
           ) {
-            this.addRefreshFarmsForReserve(
+            await this.addRefreshFarmsForReserve(
               currentReserves,
               addAsSupportIx,
               ReserveFarmKind.Collateral,
@@ -2674,7 +2550,7 @@ export class KaminoAction {
               twoTokenAction
             );
           } else if (action === 'repayAndWithdraw' || action === 'borrow' || action === 'repay') {
-            this.addRefreshFarmsForReserve(
+            await this.addRefreshFarmsForReserve(
               currentReserves,
               addAsSupportIx,
               ReserveFarmKind.Debt,
@@ -2689,9 +2565,9 @@ export class KaminoAction {
           // so we skip the refresh farm obligation of the first reserve as that operation already happened
           // add added to 'setup' ixs
           if (action === 'depositAndBorrow') {
-            this.addRefreshFarmsForReserve([this.outflowReserve!], addAsSupportIx, ReserveFarmKind.Debt);
+            await this.addRefreshFarmsForReserve([this.outflowReserve!], addAsSupportIx, ReserveFarmKind.Debt);
           } else if (action === 'repayAndWithdraw') {
-            this.addRefreshFarmsForReserve([this.outflowReserve!], addAsSupportIx, ReserveFarmKind.Collateral);
+            await this.addRefreshFarmsForReserve([this.outflowReserve!], addAsSupportIx, ReserveFarmKind.Collateral);
           } else {
             throw new Error(`Could not decide on refresh farm for action ${action}`);
           }
@@ -2712,19 +2588,16 @@ export class KaminoAction {
     overrideElevationGroupRequest?: number
   ) {
     if (!['mint', 'redeem'].includes(action)) {
-      const [, ownerUserMetadata] = await this.kaminoMarket.getUserMetadata(this.owner);
+      const [, ownerUserMetadata] = await this.kaminoMarket.getUserMetadata(this.owner.address);
       if (!ownerUserMetadata && !initUserMetadata.skipInitialization) {
-        let lookupTable: PublicKey = PublicKey.default;
+        let lookupTable: Address = DEFAULT_PUBLIC_KEY;
         if (!initUserMetadata.skipLutCreation) {
-          const [createLutIx, lookupTableAddress] = await createLookupTableIx(
-            this.kaminoMarket.getConnection(),
-            this.owner
-          );
+          const [createLutIx, lookupTableAddress] = await createLookupTableIx(this.kaminoMarket.getRpc(), this.owner);
           lookupTable = lookupTableAddress;
           this.setupIxs.push(createLutIx);
-          this.setupIxsLabels.push(`createUserLutIx[${lookupTableAddress.toString()}]`);
+          this.setupIxsLabels.push(`createUserLutIx[${lookupTableAddress}]`);
         }
-        this.addInitUserMetadataIxs(lookupTable);
+        await this.addInitUserMetadataIxs(lookupTable);
       }
 
       await this.addInitObligationIxs();
@@ -2741,13 +2614,15 @@ export class KaminoAction {
       overrideElevationGroupRequest
     );
 
-    const allReserves = new PublicKeySet<PublicKey>([
-      ...this.depositReserves,
-      ...this.borrowReserves,
-      this.reserve.address,
-      ...(this.outflowReserve ? [this.outflowReserve.address] : []),
-      ...(this.preLoadedDepositReservesSameTx ? this.preLoadedDepositReservesSameTx : []),
-    ]).toArray();
+    const allReserves = [
+      ...new Set<Address>([
+        ...this.depositReserves,
+        ...this.borrowReserves,
+        this.reserve.address,
+        ...(this.outflowReserve ? [this.outflowReserve.address] : []),
+        ...(this.preLoadedDepositReservesSameTx ? this.preLoadedDepositReservesSameTx : []),
+      ]),
+    ];
     const tokenIds = getTokenIdsForScopeRefresh(this.kaminoMarket, allReserves);
 
     if (tokenIds.length > 0 && scopeRefreshConfig) {
@@ -2755,15 +2630,15 @@ export class KaminoAction {
     }
   }
 
-  private static optionalAccount(pubkey: PublicKey, programId: PublicKey = PROGRAM_ID): PublicKey {
+  private static optionalAccount(pubkey: Address): Option<Address> {
     if (isNotNullPubkey(pubkey)) {
-      return pubkey;
+      return some(pubkey);
     } else {
-      return programId;
+      return none();
     }
   }
 
-  private addRefreshReserveIxs(reserves: PublicKey[], addAsSupportIx: AuxiliaryIx = 'setup') {
+  private addRefreshReserveIxs(reserves: Address[], addAsSupportIx: AuxiliaryIx = 'setup') {
     reserves.forEach((reserveAddress) => {
       const foundReserve = this.kaminoMarket.getReserveByAddress(reserveAddress);
       if (!foundReserve) {
@@ -2776,22 +2651,14 @@ export class KaminoAction {
         {
           lendingMarket: this.kaminoMarket.getAddress(),
           reserve: reserveAddress,
-          pythOracle: KaminoAction.optionalAccount(
-            state.config.tokenInfo.pythConfiguration.price,
-            this.kaminoMarket.programId
-          ),
+          pythOracle: KaminoAction.optionalAccount(state.config.tokenInfo.pythConfiguration.price),
           switchboardPriceOracle: KaminoAction.optionalAccount(
-            state.config.tokenInfo.switchboardConfiguration.priceAggregator,
-            this.kaminoMarket.programId
+            state.config.tokenInfo.switchboardConfiguration.priceAggregator
           ),
           switchboardTwapOracle: KaminoAction.optionalAccount(
-            state.config.tokenInfo.switchboardConfiguration.twapAggregator,
-            this.kaminoMarket.programId
-          ),
-          scopePrices: KaminoAction.optionalAccount(
-            state.config.tokenInfo.scopeConfiguration.priceFeed,
-            this.kaminoMarket.programId
+            state.config.tokenInfo.switchboardConfiguration.twapAggregator
           ),
+          scopePrices: KaminoAction.optionalAccount(state.config.tokenInfo.scopeConfiguration.priceFeed),
         },
         this.kaminoMarket.programId
       );
@@ -2809,8 +2676,8 @@ export class KaminoAction {
     });
   }
 
-  public static getRefreshAllReserves(kaminoMarket: KaminoMarket, reserves: PublicKey[]): TransactionInstruction[] {
-    return reserves.map((reserveAddress): TransactionInstruction => {
+  public static getRefreshAllReserves(kaminoMarket: KaminoMarket, reserves: Address[]): IInstruction[] {
+    return reserves.map((reserveAddress): IInstruction => {
       const foundReserve = kaminoMarket.getReserveByAddress(reserveAddress);
       if (!foundReserve) {
         throw new Error(`Could not find reserve ${reserveAddress} in reserves`);
@@ -2821,29 +2688,23 @@ export class KaminoAction {
         {
           reserve: reserveAddress,
           lendingMarket: state.lendingMarket,
-          pythOracle: this.optionalAccount(state.config.tokenInfo.pythConfiguration.price, kaminoMarket.programId),
-          switchboardPriceOracle: this.optionalAccount(
-            state.config.tokenInfo.switchboardConfiguration.priceAggregator,
-            kaminoMarket.programId
-          ),
-          switchboardTwapOracle: this.optionalAccount(
-            state.config.tokenInfo.switchboardConfiguration.twapAggregator,
-            kaminoMarket.programId
-          ),
-          scopePrices: this.optionalAccount(
-            state.config.tokenInfo.scopeConfiguration.priceFeed,
-            kaminoMarket.programId
-          ),
+          pythOracle: this.optionalAccount(state.config.tokenInfo.pythConfiguration.price),
+          switchboardPriceOracle: this.optionalAccount(state.config.tokenInfo.switchboardConfiguration.priceAggregator),
+          switchboardTwapOracle: this.optionalAccount(state.config.tokenInfo.switchboardConfiguration.twapAggregator),
+          scopePrices: this.optionalAccount(state.config.tokenInfo.scopeConfiguration.priceFeed),
         },
         kaminoMarket.programId
       );
     });
   }
 
-  private addRefreshObligationIx(addAsSupportIx: AuxiliaryIx = 'setup', skipReserves: PublicKey[] = []) {
+  private async addRefreshObligationIx(
+    addAsSupportIx: AuxiliaryIx = 'setup',
+    skipReserves: Address[] = []
+  ): Promise<void> {
     const marketAddress = this.kaminoMarket.getAddress();
-    const obligationPda = this.getObligationPda();
-    const refreshObligationIx = refreshObligation(
+    const obligationPda = await this.getObligationPda();
+    let refreshObligationIx = refreshObligation(
       {
         lendingMarket: marketAddress,
         obligation: obligationPda,
@@ -2851,35 +2712,39 @@ export class KaminoAction {
       this.kaminoMarket.programId
     );
 
-    const skipReservesSet = new PublicKeySet(skipReserves);
+    const skipReservesSet = new Set<Address>(skipReserves);
 
     const depositReservesList = this.getAdditionalDepositReservesList().filter(
-      (reserve) => !skipReservesSet.contains(reserve)
+      (reserve) => !skipReservesSet.has(reserve)
     );
-    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
+    const depositReserveAccountMetas: IAccountMeta[] = depositReservesList.map((reserve) => {
+      return { address: reserve, role: AccountRole.WRITABLE };
     });
 
-    const borrowReservesList = this.borrowReserves.filter((reserve) => !skipReservesSet.contains(reserve));
-    const borrowReserveAccountMetas = borrowReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
+    const borrowReservesList = this.borrowReserves.filter((reserve) => !skipReservesSet.has(reserve));
+    const borrowReserveAccountMetas: IAccountMeta[] = borrowReservesList.map((reserve) => {
+      return { address: reserve, role: AccountRole.WRITABLE };
     });
 
-    const borrowReservesReferrerTokenStates = borrowReservesList
-      .map((reserve) => {
-        if (this.referrer.equals(PublicKey.default)) {
-          return { pubkey: this.kaminoMarket.programId, isSigner: false, isWritable: false };
-        }
-        const referrerTokenStateAddress = referrerTokenStatePda(this.referrer, reserve, this.kaminoMarket.programId)[0];
-        return { pubkey: referrerTokenStateAddress, isSigner: false, isWritable: true };
-      })
-      .filter((x) => !x.pubkey.equals(this.kaminoMarket.programId));
-
-    refreshObligationIx.keys = refreshObligationIx.keys.concat([
-      ...depositReserveAccountMetas,
-      ...borrowReserveAccountMetas,
-      ...borrowReservesReferrerTokenStates,
-    ]);
+    const borrowReservesReferrerTokenStates: IAccountMeta[] = [];
+    if (isSome(this.referrer)) {
+      borrowReservesReferrerTokenStates.push(
+        ...(await Promise.all(
+          borrowReservesList.map((reserve) => {
+            return this.getReferrerTokenStateAccountMeta(reserve, true);
+          })
+        ))
+      );
+    }
+
+    refreshObligationIx = {
+      ...refreshObligationIx,
+      accounts: refreshObligationIx.accounts!.concat([
+        ...depositReserveAccountMetas,
+        ...borrowReserveAccountMetas,
+        ...borrowReservesReferrerTokenStates,
+      ]),
+    };
 
     if (addAsSupportIx === 'setup') {
       this.setupIxs.push(refreshObligationIx);
@@ -2893,8 +2758,12 @@ export class KaminoAction {
     }
   }
 
-  private addRequestElevationIx(elevationGroup: number, addAsSupportIx: AuxiliaryIx, skipReserves: PublicKey[] = []) {
-    const obligationPda = this.getObligationPda();
+  private async addRequestElevationIx(
+    elevationGroup: number,
+    addAsSupportIx: AuxiliaryIx,
+    skipReserves: Address[] = []
+  ): Promise<void> {
+    const obligationPda = await this.getObligationPda();
     const args: RequestElevationGroupArgs = {
       elevationGroup,
     };
@@ -2904,42 +2773,41 @@ export class KaminoAction {
       lendingMarket: this.kaminoMarket.getAddress(),
     };
 
-    const requestElevationGroupIx = requestElevationGroup(args, accounts, this.kaminoMarket.programId);
+    let requestElevationGroupIx = requestElevationGroup(args, accounts, this.kaminoMarket.programId);
 
-    const skipReservesSet = new PublicKeySet<PublicKey>(skipReserves);
+    const skipReservesSet = new Set<Address>(skipReserves);
 
     const depositReservesList = this.getAdditionalDepositReservesList().filter(
-      (reserve) => !skipReservesSet.contains(reserve)
+      (reserve) => !skipReservesSet.has(reserve)
     );
-    const depositReserveAccountMetas = depositReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
+    const depositReserveAccountMetas: IAccountMeta[] = depositReservesList.map((reserve) => {
+      return { address: reserve, role: AccountRole.WRITABLE };
     });
 
-    const borrowReservesList = this.borrowReserves.filter((reserve) => !skipReservesSet.contains(reserve));
-    const borrowReserveAccountMetas = borrowReservesList.map((reserve) => {
-      return { pubkey: reserve, isSigner: false, isWritable: true };
+    const borrowReservesList = this.borrowReserves.filter((reserve) => !skipReservesSet.has(reserve));
+    const borrowReserveAccountMetas: IAccountMeta[] = borrowReservesList.map((reserve) => {
+      return { address: reserve, role: AccountRole.WRITABLE };
     });
 
-    const borrowReservesReferrerTokenStates = borrowReservesList
-      .map((reserve) => {
-        if (this.referrer.equals(PublicKey.default)) {
-          return { pubkey: this.kaminoMarket.programId, isSigner: false, isWritable: false };
-        }
-        const reserveState = this.kaminoMarket.getReserveByAddress(reserve)!;
-        const referrerTokenStateAddress = referrerTokenStatePda(
-          this.referrer,
-          reserveState.address,
-          this.kaminoMarket.programId
-        )[0];
-        return { pubkey: referrerTokenStateAddress, isSigner: false, isWritable: true };
-      })
-      .filter((x) => !x.pubkey.equals(this.kaminoMarket.programId));
-
-    requestElevationGroupIx.keys = requestElevationGroupIx.keys.concat([
-      ...depositReserveAccountMetas,
-      ...borrowReserveAccountMetas,
-      ...borrowReservesReferrerTokenStates,
-    ]);
+    const borrowReservesReferrerTokenStates: IAccountMeta[] = [];
+    if (isSome(this.referrer)) {
+      borrowReservesReferrerTokenStates.push(
+        ...(await Promise.all(
+          borrowReservesList.map((reserve) => {
+            return this.getReferrerTokenStateAccountMeta(reserve, false);
+          })
+        ))
+      );
+    }
+
+    requestElevationGroupIx = {
+      ...requestElevationGroupIx,
+      accounts: requestElevationGroupIx.accounts!.concat([
+        ...depositReserveAccountMetas,
+        ...borrowReserveAccountMetas,
+        ...borrowReservesReferrerTokenStates,
+      ]),
+    };
 
     if (addAsSupportIx === 'setup') {
       this.setupIxs.push(requestElevationGroupIx);
@@ -2953,102 +2821,94 @@ export class KaminoAction {
     }
   }
 
-  private addRefreshFarmsForReserve(
+  private async addRefreshFarmsForReserve(
     reserves: KaminoReserve[],
     addAsSupportIx: AuxiliaryIx = 'setup',
     mode: typeof ReserveFarmKind.Collateral | typeof ReserveFarmKind.Debt,
-    crank: PublicKey = this.payer,
+    crank: TransactionSigner = this.payer,
     twoTokenAction: boolean = false
-  ) {
-    const farms: [
-      typeof ReserveFarmKind.Collateral | typeof ReserveFarmKind.Debt,
-      PublicKey,
-      PublicKey,
-      KaminoReserve
-    ][] = [];
+  ): Promise<void> {
+    const farms: [typeof ReserveFarmKind.Collateral | typeof ReserveFarmKind.Debt, Address, Address, KaminoReserve][] =
+      [];
 
+    const obligationAddress = await this.getObligationPda();
     for (const kaminoReserve of reserves) {
-      if (mode === ReserveFarmKind.Collateral && !kaminoReserve.state.farmCollateral.equals(PublicKey.default)) {
+      if (mode === ReserveFarmKind.Collateral && kaminoReserve.state.farmCollateral !== DEFAULT_PUBLIC_KEY) {
         farms.push([
           ReserveFarmKind.Collateral,
           kaminoReserve.state.farmCollateral,
-          obligationFarmStatePda(kaminoReserve.state.farmCollateral, this.getObligationPda()),
+          await obligationFarmStatePda(kaminoReserve.state.farmCollateral, obligationAddress),
           kaminoReserve,
         ]);
       }
-      if (mode === ReserveFarmKind.Debt && !kaminoReserve.state.farmDebt.equals(PublicKey.default)) {
+      if (mode === ReserveFarmKind.Debt && kaminoReserve.state.farmDebt !== DEFAULT_PUBLIC_KEY) {
         farms.push([
           ReserveFarmKind.Debt,
           kaminoReserve.state.farmDebt,
-          obligationFarmStatePda(kaminoReserve.state.farmDebt, this.getObligationPda()),
+          await obligationFarmStatePda(kaminoReserve.state.farmDebt, obligationAddress),
           kaminoReserve,
         ]);
       }
     }
 
-    farms.forEach(
-      (arg: [typeof ReserveFarmKind.Collateral | typeof ReserveFarmKind.Debt, PublicKey, PublicKey, KaminoReserve]) => {
-        const args: RefreshObligationFarmsForReserveArgs = { mode: arg[0].discriminator };
-        const accounts: RefreshObligationFarmsForReserveAccounts = {
-          crank,
-          baseAccounts: {
-            obligation: this.getObligationPda(),
-            lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
-            reserve: arg[3].address,
-            reserveFarmState: arg[1],
-            obligationFarmUserState: arg[2],
-            lendingMarket: this.kaminoMarket.getAddress(),
-          },
-          farmsProgram: farmsId,
-          rent: SYSVAR_RENT_PUBKEY,
-          systemProgram: SystemProgram.programId,
-        };
-        const refreshFarmForObligationix = refreshObligationFarmsForReserve(
-          args,
-          accounts,
-          this.kaminoMarket.programId
-        );
+    const lendingMarketAuthority = await this.kaminoMarket.getLendingMarketAuthority();
+    for (const arg of farms) {
+      const args: RefreshObligationFarmsForReserveArgs = { mode: arg[0].discriminator };
+      const accounts: RefreshObligationFarmsForReserveAccounts = {
+        crank,
+        baseAccounts: {
+          obligation: obligationAddress,
+          lendingMarketAuthority,
+          reserve: arg[3].address,
+          reserveFarmState: arg[1],
+          obligationFarmUserState: arg[2],
+          lendingMarket: this.kaminoMarket.getAddress(),
+        },
+        farmsProgram: FARMS_PROGRAM_ID,
+        rent: SYSVAR_RENT_ADDRESS,
+        systemProgram: SYSTEM_PROGRAM_ADDRESS,
+      };
+      const refreshFarmForObligationix = refreshObligationFarmsForReserve(args, accounts, this.kaminoMarket.programId);
 
-        if (addAsSupportIx === 'setup') {
-          this.setupIxs.push(refreshFarmForObligationix);
-          this.setupIxsLabels.push(
-            `RefreshFarmForObligation[${
-              arg[0].kind
-            }, res=${arg[3].address.toString()}, obl=${this.getObligationPda().toString()}]`
-          );
-          if (twoTokenAction) {
-            // If two token action, this refresh needs to be the first inbetween ix
-            this.inBetweenIxs.push(refreshFarmForObligationix);
-            this.inBetweenIxsLabels.push(
-              `RefreshFarmForObligation[${
-                arg[0].kind
-              }, res=${arg[3].address.toString()}, obl=${this.getObligationPda().toString()}]`
-            );
-          } else {
-            this.refreshFarmsCleanupTxnIxs.push(refreshFarmForObligationix);
-            this.refreshFarmsCleanupTxnIxsLabels.push(
-              `RefreshFarmForObligation[${
-                arg[0].kind
-              }, res=${arg[3].address.toString()}, obl=${this.getObligationPda().toString()}]`
-            );
-          }
-        } else if (addAsSupportIx === 'inBetween') {
+      if (addAsSupportIx === 'setup') {
+        this.setupIxs.push(refreshFarmForObligationix);
+        this.setupIxsLabels.push(
+          `RefreshFarmForObligation[${
+            arg[0].kind
+          }, res=${arg[3].address.toString()}, obl=${await this.getObligationPda()}]`
+        );
+        if (twoTokenAction) {
+          // If two token action, this refresh needs to be the first inbetween ix
           this.inBetweenIxs.push(refreshFarmForObligationix);
           this.inBetweenIxsLabels.push(
             `RefreshFarmForObligation[${
               arg[0].kind
-            }, res=${arg[3].address.toString()}, obl=${this.getObligationPda().toString()}]`
+            }, res=${arg[3].address.toString()}, obl=${await this.getObligationPda()}]`
           );
-
+        } else {
           this.refreshFarmsCleanupTxnIxs.push(refreshFarmForObligationix);
           this.refreshFarmsCleanupTxnIxsLabels.push(
             `RefreshFarmForObligation[${
               arg[0].kind
-            }, res=${arg[3].address.toString()}, obl=${this.getObligationPda().toString()}]`
+            }, res=${arg[3].address.toString()}, obl=${await this.getObligationPda()}]`
           );
         }
+      } else if (addAsSupportIx === 'inBetween') {
+        this.inBetweenIxs.push(refreshFarmForObligationix);
+        this.inBetweenIxsLabels.push(
+          `RefreshFarmForObligation[${
+            arg[0].kind
+          }, res=${arg[3].address.toString()}, obl=${await this.getObligationPda()}]`
+        );
+
+        this.refreshFarmsCleanupTxnIxs.push(refreshFarmForObligationix);
+        this.refreshFarmsCleanupTxnIxsLabels.push(
+          `RefreshFarmForObligation[${
+            arg[0].kind
+          }, res=${arg[3].address.toString()}, obl=${await this.getObligationPda()}]`
+        );
       }
-    );
+    }
   }
 
   private addRefreshFarmsCleanupTxnIxsToCleanupIxs() {
@@ -3061,58 +2921,60 @@ export class KaminoAction {
     mode: typeof ReserveFarmKind.Collateral | typeof ReserveFarmKind.Debt,
     addAsSupportIx: AuxiliaryIx = 'setup'
   ): Promise<void> {
-    const farms: [number, PublicKey, PublicKey][] = [];
+    const farms: [number, Address, Address][] = [];
 
+    const obligationAddress = await this.getObligationPda();
     if (mode === ReserveFarmKind.Collateral && isNotNullPubkey(reserve.state.farmCollateral)) {
-      const pda = obligationFarmStatePda(reserve.state.farmCollateral, this.getObligationPda());
-      const account = await this.kaminoMarket.getConnection().getAccountInfo(pda);
-      if (!account) {
+      const pda = await obligationFarmStatePda(reserve.state.farmCollateral, obligationAddress);
+      const account = await fetchEncodedAccount(this.kaminoMarket.getRpc(), pda);
+      if (!account.exists) {
         farms.push([ReserveFarmKind.Collateral.discriminator, reserve.state.farmCollateral, pda]);
       }
     }
 
     if (mode === ReserveFarmKind.Debt && isNotNullPubkey(reserve.state.farmDebt)) {
-      const pda = obligationFarmStatePda(reserve.state.farmDebt, this.getObligationPda());
-      const account = await this.kaminoMarket.getConnection().getAccountInfo(pda);
-      if (!account) {
+      const pda = await obligationFarmStatePda(reserve.state.farmDebt, obligationAddress);
+      const account = await fetchEncodedAccount(this.kaminoMarket.getRpc(), pda);
+      if (!account.exists) {
         farms.push([ReserveFarmKind.Debt.discriminator, reserve.state.farmDebt, pda]);
       }
     }
 
-    farms.forEach((arg: [number, PublicKey, PublicKey]) => {
+    const lendingMarketAuthority = await this.kaminoMarket.getLendingMarketAuthority();
+    farms.forEach((arg: [number, Address, Address]) => {
       const args: InitObligationFarmsForReserveArgs = { mode: arg[0] };
       const accounts: InitObligationFarmsForReserveAccounts = {
-        owner: isKaminoObligation(this.obligation) ? this.obligation.state.owner : this.owner,
+        owner: isKaminoObligation(this.obligation) ? this.obligation.state.owner : this.owner.address,
         payer: this.owner,
-        obligation: this.getObligationPda(),
-        lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+        obligation: obligationAddress,
+        lendingMarketAuthority,
         reserve: reserve.address,
         reserveFarmState: arg[1],
         obligationFarm: arg[2],
         lendingMarket: this.kaminoMarket.getAddress(),
-        farmsProgram: farmsId,
-        rent: SYSVAR_RENT_PUBKEY,
-        systemProgram: SystemProgram.programId,
+        farmsProgram: FARMS_PROGRAM_ID,
+        rent: SYSVAR_RENT_ADDRESS,
+        systemProgram: SYSTEM_PROGRAM_ADDRESS,
       };
       const initObligationForFarm = initObligationFarmsForReserve(args, accounts, this.kaminoMarket.programId);
       if (addAsSupportIx === 'setup') {
         this.setupIxs.push(initObligationForFarm);
         this.setupIxsLabels.push(
-          `InitObligationForFarm[${reserve.address.toString()}, ${this.getObligationPda().toString()}]`
+          `InitObligationForFarm[${reserve.address.toString()}, ${obligationAddress.toString()}]`
         );
       } else if (addAsSupportIx === 'inBetween') {
         this.inBetweenIxs.push(initObligationForFarm);
         this.inBetweenIxsLabels.push(
-          `InitObligationForFarm[${reserve.address.toString()}, ${this.getObligationPda().toString()}]`
+          `InitObligationForFarm[${reserve.address.toString()}, ${obligationAddress.toString()}]`
         );
       }
     });
   }
 
-  private addInitObligationIxs() {
+  private async addInitObligationIxs(): Promise<void> {
     if (!isKaminoObligation(this.obligation)) {
-      const obligationPda = this.getObligationPda();
-      const [userMetadataAddress, _bump] = userMetadataPda(this.owner, this.kaminoMarket.programId);
+      const obligationPda = await this.getObligationPda();
+      const [userMetadataAddress] = await userMetadataPda(this.owner.address, this.kaminoMarket.programId);
       const initObligationIx = initObligation(
         {
           args: {
@@ -3128,8 +2990,8 @@ export class KaminoAction {
           seed1Account: this.obligation.toArgs().seed1,
           seed2Account: this.obligation.toArgs().seed2,
           ownerUserMetadata: userMetadataAddress,
-          rent: SYSVAR_RENT_PUBKEY,
-          systemProgram: SystemProgram.programId,
+          rent: SYSVAR_RENT_ADDRESS,
+          systemProgram: SYSTEM_PROGRAM_ADDRESS,
         },
         this.kaminoMarket.programId
       );
@@ -3138,11 +3000,13 @@ export class KaminoAction {
     }
   }
 
-  private addInitUserMetadataIxs(lookupTableAddress: PublicKey) {
-    const [userMetadataAddress, _bump] = userMetadataPda(this.owner, this.kaminoMarket.programId);
-    const referrerUserMetadataAddress = this.referrer.equals(PublicKey.default)
-      ? this.kaminoMarket.programId
-      : userMetadataPda(this.referrer, this.kaminoMarket.programId)[0];
+  private async addInitUserMetadataIxs(lookupTableAddress: Address): Promise<void> {
+    const [userMetadataAddress] = await userMetadataPda(this.owner.address, this.kaminoMarket.programId);
+    const referrerUserMetadataAddress = await KaminoAction.getReferrerMetadataAccount(
+      this.referrer,
+      this.kaminoMarket.programId
+    );
+
     const initUserMetadataIx = initUserMetadata(
       {
         userLookupTable: lookupTableAddress,
@@ -3152,8 +3016,8 @@ export class KaminoAction {
         feePayer: this.payer,
         userMetadata: userMetadataAddress,
         referrerUserMetadata: referrerUserMetadataAddress,
-        rent: SYSVAR_RENT_PUBKEY,
-        systemProgram: SystemProgram.programId,
+        rent: SYSVAR_RENT_ADDRESS,
+        systemProgram: SYSTEM_PROGRAM_ADDRESS,
       },
       this.kaminoMarket.programId
     );
@@ -3161,16 +3025,19 @@ export class KaminoAction {
     this.setupIxsLabels.push(`initUserMetadata[${userMetadataAddress.toString()}]`);
   }
 
-  private addInitReferrerTokenStateIx(reserve: KaminoReserve, referrerTokenState: PublicKey) {
+  private addInitReferrerTokenStateIx(reserve: KaminoReserve, referrerTokenState: Address) {
+    if (isNone(this.referrer)) {
+      throw new Error('Referrer is not set');
+    }
     const initReferrerTokenStateIx = initReferrerTokenState(
       {
         lendingMarket: this.kaminoMarket.getAddress(),
         payer: this.owner,
         reserve: reserve.address,
-        referrer: this.referrer,
+        referrer: this.referrer.value,
         referrerTokenState,
-        rent: SYSVAR_RENT_PUBKEY,
-        systemProgram: SystemProgram.programId,
+        rent: SYSVAR_RENT_ADDRESS,
+        systemProgram: SYSTEM_PROGRAM_ADDRESS,
       },
       this.kaminoMarket.programId
     );
@@ -3178,12 +3045,12 @@ export class KaminoAction {
     this.setupIxsLabels.unshift(`InitReferrerTokenState[${referrerTokenState.toString()} res=${reserve.address}]`);
   }
 
-  private addWithdrawReferrerFeesIxs() {
-    const referrerTokenStateAddress = referrerTokenStatePda(
-      this.owner,
+  private async addWithdrawReferrerFeesIxs(): Promise<void> {
+    const referrerTokenStateAddress = await referrerTokenStatePda(
+      this.owner.address,
       this.reserve.address,
       this.kaminoMarket.programId
-    )[0];
+    );
 
     const withdrawReferrerFeesIx = withdrawReferrerFees(
       {
@@ -3193,8 +3060,8 @@ export class KaminoAction {
         reserveLiquidityMint: this.reserve.getLiquidityMint(),
         referrerTokenState: referrerTokenStateAddress,
         reserveSupplyLiquidity: this.reserve.state.liquidity.supplyVault,
-        referrerTokenAccount: this.getUserTokenAccountAddress(this.reserve),
-        lendingMarketAuthority: this.kaminoMarket.getLendingMarketAuthority(),
+        referrerTokenAccount: await this.getUserTokenAccountAddress(this.reserve),
+        lendingMarketAuthority: await this.kaminoMarket.getLendingMarketAuthority(),
         tokenProgram: this.reserve.getLiquidityTokenProgram(),
       },
       this.kaminoMarket.programId
@@ -3210,69 +3077,71 @@ export class KaminoAction {
   }
 
   private async addAtaIxs(action: ActionType) {
-    if (this.mint.equals(NATIVE_MINT) || this.secondaryMint?.equals(NATIVE_MINT)) {
+    if (this.mint === WRAPPED_SOL_MINT || this.secondaryMint === WRAPPED_SOL_MINT) {
       await this.updateWSOLAccount(action);
     }
 
-    if ((action === 'withdraw' || action === 'borrow' || action === 'redeem') && !this.mint.equals(NATIVE_MINT)) {
-      const [, createUserTokenAccountIx] = createAssociatedTokenAccountIdempotentInstruction(
+    if ((action === 'withdraw' || action === 'borrow' || action === 'redeem') && this.mint !== WRAPPED_SOL_MINT) {
+      const reserveAta = await this.getUserTokenAccountAddress(this.reserve);
+      const [, createUserTokenAccountIx] = await createAssociatedTokenAccountIdempotentInstruction(
         this.owner,
         this.reserve.getLiquidityMint(),
-        this.owner,
+        this.owner.address,
         this.reserve.getLiquidityTokenProgram(),
-        this.getUserTokenAccountAddress(this.reserve)
+        reserveAta
       );
 
       this.setupIxs.unshift(createUserTokenAccountIx);
-      this.setupIxsLabels.unshift(`CreateLiquidityUserAta[${this.owner}]`);
+      this.setupIxsLabels.unshift(`CreateLiquidityUserAta[${reserveAta}]`);
     }
 
     if (action === 'liquidate') {
       if (!this.outflowReserve) {
         throw new Error(`Outflow reserve state not found ${this.secondaryMint}`);
       }
+      const outflowReserveAta = await this.getUserTokenAccountAddress(this.outflowReserve);
 
-      const [, createUserTokenAccountIx] = createAssociatedTokenAccountIdempotentInstruction(
+      const [, createUserTokenAccountIx] = await createAssociatedTokenAccountIdempotentInstruction(
         this.owner,
         this.outflowReserve.getLiquidityMint(),
-        this.owner,
+        this.owner.address,
         this.outflowReserve.getLiquidityTokenProgram(),
-        this.getUserTokenAccountAddress(this.outflowReserve)
+        outflowReserveAta
       );
 
       this.setupIxs.unshift(createUserTokenAccountIx);
-      this.setupIxsLabels.unshift(`CreateUserAta[${this.getUserTokenAccountAddress(this.outflowReserve).toBase58()}]`);
+      this.setupIxsLabels.unshift(`CreateUserAta[${outflowReserveAta}]`);
 
-      const [, createUserCollateralAccountIx] = createAssociatedTokenAccountIdempotentInstruction(
+      const ctokenAta = await this.getUserCollateralAccountAddress(this.outflowReserve);
+      const [, createUserCollateralAccountIx] = await createAssociatedTokenAccountIdempotentInstruction(
         this.owner,
         this.outflowReserve.getCTokenMint(),
-        this.owner,
-        TOKEN_PROGRAM_ID,
-        this.getUserCollateralAccountAddress(this.outflowReserve)
+        this.owner.address,
+        TOKEN_PROGRAM_ADDRESS,
+        ctokenAta
       );
 
       this.setupIxs.unshift(createUserCollateralAccountIx);
-      this.setupIxsLabels.unshift(
-        `CreateCollateralUserAta[${this.getUserCollateralAccountAddress(this.outflowReserve).toString()}]`
-      );
+      this.setupIxsLabels.unshift(`CreateCollateralUserAta[${ctokenAta}]`);
     }
 
-    if (action === 'depositAndBorrow' || (action === 'repayAndWithdraw' && !this.secondaryMint?.equals(NATIVE_MINT))) {
+    if (action === 'depositAndBorrow' || (action === 'repayAndWithdraw' && this.secondaryMint !== WRAPPED_SOL_MINT)) {
       if (!this.outflowReserve) {
         throw new Error(`Outflow reserve state not found ${this.mint}`);
       }
 
-      const additionalUserTokenAccountAddress = this.getUserTokenAccountAddress(this.outflowReserve);
+      const additionalUserTokenAccountAddress = await this.getUserTokenAccountAddress(this.outflowReserve);
 
-      const additionalUserTokenAccountInfo = await this.kaminoMarket
-        .getConnection()
-        .getAccountInfo(additionalUserTokenAccountAddress);
+      const additionalUserTokenAccountInfo = await fetchEncodedAccount(
+        this.kaminoMarket.getRpc(),
+        additionalUserTokenAccountAddress
+      );
 
-      if (!additionalUserTokenAccountInfo) {
-        const [, createUserTokenAccountIx] = createAssociatedTokenAccountIdempotentInstruction(
+      if (!additionalUserTokenAccountInfo.exists) {
+        const [, createUserTokenAccountIx] = await createAssociatedTokenAccountIdempotentInstruction(
           this.owner,
           this.outflowReserve.getLiquidityMint(),
-          this.owner,
+          this.owner.address,
           this.outflowReserve.getLiquidityTokenProgram(),
           additionalUserTokenAccountAddress
         );
@@ -3283,35 +3152,35 @@ export class KaminoAction {
     }
 
     if (action === 'withdraw' || action === 'mint' || action === 'deposit' || action === 'repayAndWithdraw') {
-      const [, createUserTokenAccountIx] = createAssociatedTokenAccountIdempotentInstruction(
+      const reserveAta = await this.getUserTokenAccountAddress(this.reserve);
+      const [, createUserTokenAccountIx] = await createAssociatedTokenAccountIdempotentInstruction(
         this.owner,
         this.reserve.getLiquidityMint(),
-        this.owner,
+        this.owner.address,
         this.reserve.getLiquidityTokenProgram(),
-        this.getUserTokenAccountAddress(this.reserve)
+        reserveAta
       );
       this.setupIxs.unshift(createUserTokenAccountIx);
-      this.setupIxsLabels.unshift(`CreateUserAta[${this.getUserTokenAccountAddress(this.reserve).toBase58()}]`);
+      this.setupIxsLabels.unshift(`CreateUserAta[${reserveAta}]`);
     }
     if (action === 'mint') {
-      const [, createUserCollateralAccountIx] = createAssociatedTokenAccountIdempotentInstruction(
+      const ctokenAta = await this.getUserCollateralAccountAddress(this.reserve);
+      const [, createUserCollateralAccountIx] = await createAssociatedTokenAccountIdempotentInstruction(
         this.owner,
         this.reserve.getCTokenMint(),
-        this.owner,
-        TOKEN_PROGRAM_ID,
-        this.getUserCollateralAccountAddress(this.reserve)
+        this.owner.address,
+        TOKEN_PROGRAM_ADDRESS,
+        ctokenAta
       );
 
       this.setupIxs.unshift(createUserCollateralAccountIx);
-      this.setupIxsLabels.unshift(
-        `CreateCollateralUserAta[${this.getUserCollateralAccountAddress(this.reserve).toString()}]`
-      );
+      this.setupIxsLabels.unshift(`CreateCollateralUserAta[${ctokenAta.toString()}]`);
     }
   }
 
   private async updateWSOLAccount(action: ActionType) {
-    const preIxs: Array<TransactionInstruction> = [];
-    const postIxs: Array<TransactionInstruction> = [];
+    const preIxs: Array<IInstruction> = [];
+    const postIxs: Array<IInstruction> = [];
     const preIxsLabels: Array<string> = [];
     const postIxsLabels: Array<string> = [];
 
@@ -3331,7 +3200,7 @@ export class KaminoAction {
       );
 
       if (!borrow) {
-        throw Error(`Unable to find obligation borrow to repay for ${this.obligation.state.owner.toBase58()}`);
+        throw Error(`Unable to find obligation borrow to repay for ${this.obligation.state.owner}`);
       }
 
       const cumulativeBorrowRateObligation = KaminoObligation.getCumulativeBorrowRate(borrow);
@@ -3351,19 +3220,18 @@ export class KaminoAction {
       );
     }
 
-    let userTokenAccountAddress = this.getUserTokenAccountAddress(this.reserve);
-    if (this.secondaryMint?.equals(NATIVE_MINT)) {
+    let userTokenAccountAddress = await this.getUserTokenAccountAddress(this.reserve);
+    if (this.secondaryMint === WRAPPED_SOL_MINT) {
       if (!this.outflowReserve) {
         throw new Error(`Outflow reserve state not found ${this.secondaryMint}`);
       }
 
-      const additionalUserTokenAccountAddress = this.getUserTokenAccountAddress(this.outflowReserve);
-      userTokenAccountAddress = additionalUserTokenAccountAddress;
+      userTokenAccountAddress = await this.getUserTokenAccountAddress(this.outflowReserve);
     }
 
-    const userWSOLAccountInfo = await this.kaminoMarket.getConnection().getAccountInfo(userTokenAccountAddress);
+    const userWSOLAccountInfo = await fetchEncodedAccount(this.kaminoMarket.getRpc(), userTokenAccountAddress);
 
-    const rentExempt = await this.kaminoMarket.getConnection().getMinimumBalanceForRentExemption(165);
+    const rentExemptLamports = await this.kaminoMarket.getRpc().getMinimumBalanceForRentExemption(165n).send();
 
     // Add rent exemption lamports for WSOL accounts that need to be pre-funded for inflow/send transactions
     const sendAction =
@@ -3371,26 +3239,32 @@ export class KaminoAction {
       action === 'repay' ||
       action === 'repayAndWithdrawV2' ||
       action === 'mint' ||
-      (action === 'liquidate' && this.mint?.equals(NATIVE_MINT)); // only sync WSOL amount if liquidator repays SOL which is secondaryMint
+      (action === 'liquidate' && this.mint === WRAPPED_SOL_MINT); // only sync WSOL amount if liquidator repays SOL which is secondaryMint
 
-    const transferLamportsIx = SystemProgram.transfer({
-      fromPubkey: this.owner,
-      toPubkey: userTokenAccountAddress,
-      lamports: (userWSOLAccountInfo ? 0 : rentExempt) + (sendAction ? parseInt(safeRepay.toString(), 10) : 0),
+    const transferLamportsIx = getTransferSolInstruction({
+      amount: (userWSOLAccountInfo.exists ? 0n : rentExemptLamports) + (sendAction ? BigInt(safeRepay.toString()) : 0n),
+      source: this.owner,
+      destination: userTokenAccountAddress,
     });
     preIxs.push(transferLamportsIx);
     preIxsLabels.push(`TransferLamportsToUserAtaSOL[${userTokenAccountAddress}]`);
 
-    const closeWSOLAccountIx = createCloseAccountInstruction(
-      userTokenAccountAddress,
-      this.owner,
-      this.owner,
-      [],
-      TOKEN_PROGRAM_ID
+    const closeWSOLAccountIx = getCloseAccountInstruction(
+      {
+        owner: this.owner,
+        account: userTokenAccountAddress,
+        destination: this.owner.address,
+      },
+      { programAddress: TOKEN_PROGRAM_ADDRESS }
     );
 
-    const syncIx = createSyncNativeInstruction(userTokenAccountAddress);
-    if (userWSOLAccountInfo) {
+    const syncIx = getSyncNativeInstruction(
+      {
+        account: userTokenAccountAddress,
+      },
+      { programAddress: TOKEN_PROGRAM_ADDRESS }
+    );
+    if (userWSOLAccountInfo.exists) {
       if (sendAction) {
         preIxs.push(syncIx);
         preIxsLabels.push(`SyncUserAtaSOL[${userTokenAccountAddress}]`);
@@ -3399,11 +3273,11 @@ export class KaminoAction {
         postIxsLabels.push(`CloseUserAtaSOL[${userTokenAccountAddress}]`);
       }
     } else {
-      const [, createUserWSOLAccountIx] = createAssociatedTokenAccountIdempotentInstruction(
-        this.owner,
-        NATIVE_MINT,
+      const [, createUserWSOLAccountIx] = await createAssociatedTokenAccountIdempotentInstruction(
         this.owner,
-        TOKEN_PROGRAM_ID,
+        WRAPPED_SOL_MINT,
+        this.owner.address,
+        TOKEN_PROGRAM_ADDRESS,
         userTokenAccountAddress
       );
       preIxs.push(createUserWSOLAccountIx);
@@ -3424,21 +3298,17 @@ export class KaminoAction {
     kaminoMarket: KaminoMarket,
     action: ActionType,
     inflowAmount: string | BN,
-    inflowTokenMint: PublicKey,
-    outflowTokenMint: PublicKey,
-    payer: PublicKey,
-    obligationOwner: PublicKey,
+    inflowTokenMint: Address,
+    outflowTokenMint: Address,
+    signer: TransactionSigner,
+    obligationOwner: Address,
     obligation: KaminoObligation | ObligationType,
     outflowAmount?: string | BN,
-    referrer: PublicKey = PublicKey.default,
-    currentSlot: number = 0
+    referrer: Option<Address> = none(),
+    currentSlot: Slot = 0n
   ) {
-    const inflowReserve = kaminoMarket.getReserveByMint(inflowTokenMint);
-    const outflowReserve = kaminoMarket.getReserveByMint(outflowTokenMint);
-
-    if (!outflowReserve || !inflowReserve) {
-      throw new Error('reserve states are not fetched');
-    }
+    const inflowReserve = kaminoMarket.getExistingReserveByMint(inflowTokenMint);
+    const outflowReserve = kaminoMarket.getExistingReserveByMint(outflowTokenMint);
 
     const { kaminoObligation, depositReserves, borrowReserves, distinctReserveCount } =
       await KaminoAction.loadObligation(
@@ -3449,10 +3319,10 @@ export class KaminoAction {
         obligation,
         outflowReserve.address
       );
-    const referrerKey = await this.getReferrerKey(kaminoMarket, payer, kaminoObligation, referrer);
+    const referrerKey = await this.getReferrerKey(kaminoMarket, signer.address, kaminoObligation, referrer);
 
-    let secondaryMint: PublicKey;
-    let primaryMint: PublicKey;
+    let secondaryMint: Address;
+    let primaryMint: Address;
 
     if (
       action === 'liquidate' ||
@@ -3468,7 +3338,7 @@ export class KaminoAction {
 
     return new KaminoAction(
       kaminoMarket,
-      payer,
+      signer,
       kaminoObligation || obligation,
       primaryMint,
       distinctReserveCount,
@@ -3485,17 +3355,17 @@ export class KaminoAction {
   }
 
   static async initializeWithdrawReferrerFees(
-    mint: PublicKey,
-    owner: PublicKey,
+    mint: Address,
+    owner: TransactionSigner,
     kaminoMarket: KaminoMarket,
-    currentSlot: number = 0
+    currentSlot: Slot = 0n
   ) {
     const reserve = kaminoMarket.getReserveByMint(mint);
     if (reserve === undefined) {
-      throw new Error(`Reserve ${mint} not found in market ${kaminoMarket.getAddress().toBase58()}`);
+      throw new Error(`Reserve ${mint} not found in market ${kaminoMarket.getAddress()}`);
     }
 
-    const [{ createAtaIx }] = createAtasIdempotent(owner, [
+    const [{ createAtaIx }] = await createAtasIdempotent(owner, [
       {
         mint: reserve.getLiquidityMint(),
         tokenProgram: reserve.getLiquidityTokenProgram(),
@@ -3535,17 +3405,17 @@ export class KaminoAction {
       : new BN(new Decimal(amount.toString()).mul(collateralExchangeRate).ceil().toString());
   }
 
-  getObligationPda(): PublicKey {
+  async getObligationPda(): Promise<Address> {
     return isKaminoObligation(this.obligation)
       ? this.obligation.obligationAddress
-      : this.obligation.toPda(this.kaminoMarket.getAddress(), this.owner);
+      : await this.obligation.toPda(this.kaminoMarket.getAddress(), this.owner.address);
   }
 
   isObligationInitialized() {
     return this.obligation instanceof KaminoObligation;
   }
 
-  getAdditionalDepositReservesList(): PublicKey[] {
+  getAdditionalDepositReservesList(): Address[] {
     const depositReservesList = this.depositReserves;
 
     // check if there's any member in the preloadedDepositReserves that is not in the depositReserves
@@ -3555,7 +3425,7 @@ export class KaminoAction {
 
       // Check if the depositReserves array contains the current preloadedDepositReserve
       const found = this.depositReserves.some((depositReserve) => {
-        return depositReserve.equals(preloadedDepositReserve);
+        return depositReserve === preloadedDepositReserve;
       });
 
       // If not found, push the current preloadedDepositReserve to the depositReserves array
@@ -3567,47 +3437,60 @@ export class KaminoAction {
     return depositReservesList;
   }
 
-  private static async getReferrerKey(
-    kaminoMarket: KaminoMarket,
-    owner: PublicKey,
-    kaminoObligation: KaminoObligation | null,
-    referrer: PublicKey
-  ): Promise<PublicKey> {
-    let referrerKey = referrer;
-    if (!referrer || referrer.equals(PublicKey.default)) {
-      if (kaminoObligation === null) {
-        const [_, userMetadata] = await kaminoMarket.getUserMetadata(owner);
-        if (userMetadata) {
-          referrerKey = userMetadata.referrer;
-        }
-      } else {
-        referrerKey = kaminoObligation.state.referrer;
-      }
+  private static async getReferrerMetadataAccount(
+    referrer: Option<Address>,
+    programId: Address
+  ): Promise<Option<Address>> {
+    if (isSome(referrer)) {
+      return some((await userMetadataPda(referrer.value, programId))[0]);
+    } else {
+      return none();
     }
-    return referrerKey;
   }
 
-  getUserTokenAccountAddress(reserve: KaminoReserve): PublicKey {
-    return getAssociatedTokenAddress(reserve.getLiquidityMint(), this.owner, true, reserve.getLiquidityTokenProgram());
+  private async getReferrerTokenStateAccountMeta(reserve: Address, writable: boolean): Promise<IAccountMeta> {
+    if (isSome(this.referrer)) {
+      return {
+        address: await referrerTokenStatePda(this.referrer.value, reserve, this.kaminoMarket.programId),
+        role: writable ? AccountRole.WRITABLE : AccountRole.READONLY,
+      };
+    } else {
+      return {
+        address: this.kaminoMarket.programId,
+        role: AccountRole.READONLY,
+      };
+    }
   }
 
-  getTokenAccountAddressByUser(reserve: KaminoReserve, user: PublicKey): PublicKey {
-    return getAssociatedTokenAddress(reserve.getLiquidityMint(), user, true, reserve.getLiquidityTokenProgram());
+  private async getReferrerTokenStateAddress(reserve: Address): Promise<Option<Address>> {
+    return KaminoAction.getReferrerTokenStateAddressImpl(this.referrer, reserve, this.kaminoMarket.programId);
   }
 
-  getUserCollateralAccountAddress(reserve: KaminoReserve): PublicKey {
-    return getAssociatedTokenAddress(reserve.getCTokenMint(), this.owner, true);
+  getUserTokenAccountAddress(reserve: KaminoReserve): Promise<Address> {
+    return getAssociatedTokenAddress(
+      reserve.getLiquidityMint(),
+      this.owner.address,
+      reserve.getLiquidityTokenProgram()
+    );
   }
 
-  public static actionToIxs(action: KaminoAction): Array<TransactionInstruction> {
-    const ixs: TransactionInstruction[] = [...action.computeBudgetIxs, ...action.setupIxs];
+  getTokenAccountAddressByUser(reserve: KaminoReserve, user: Address): Promise<Address> {
+    return getAssociatedTokenAddress(reserve.getLiquidityMint(), user, reserve.getLiquidityTokenProgram());
+  }
+
+  getUserCollateralAccountAddress(reserve: KaminoReserve): Promise<Address> {
+    return getAssociatedTokenAddress(reserve.getCTokenMint(), this.owner.address);
+  }
+
+  public static actionToIxs(action: KaminoAction): Array<IInstruction> {
+    const ixs: IInstruction[] = [...action.computeBudgetIxs, ...action.setupIxs];
     ixs.push(...KaminoAction.actionToLendingIxs(action));
     ixs.push(...action.cleanupIxs);
     return ixs;
   }
 
-  public static actionToLendingIxs(action: KaminoAction): Array<TransactionInstruction> {
-    const ixs: TransactionInstruction[] = [];
+  public static actionToLendingIxs(action: KaminoAction): Array<IInstruction> {
+    const ixs: IInstruction[] = [];
     for (let i = 0; i < action.lendingIxs.length; i++) {
       ixs.push(action.lendingIxs[i]);
       if (i !== action.lendingIxs.length - 1) {
@@ -3634,4 +3517,84 @@ export class KaminoAction {
     }
     return labels;
   }
+
+  private static async getFarmAccountsForReserve(
+    obligationAddress: Address,
+    reserve: KaminoReserve
+  ): Promise<{
+    debtFarmAccounts: {
+      obligationFarmUserState: Option<Address>;
+      reserveFarmState: Option<Address>;
+    };
+    collateralFarmAccounts: {
+      obligationFarmUserState: Option<Address>;
+      reserveFarmState: Option<Address>;
+    };
+  }> {
+    const collateralFarmAddress = reserve.getCollateralFarmAddress();
+    let collateralFarmAccounts: {
+      obligationFarmUserState: Option<Address>;
+      reserveFarmState: Option<Address>;
+    } = {
+      obligationFarmUserState: none(),
+      reserveFarmState: none(),
+    };
+    if (isSome(collateralFarmAddress)) {
+      collateralFarmAccounts = {
+        obligationFarmUserState: some(await obligationFarmStatePda(collateralFarmAddress.value, obligationAddress)),
+        reserveFarmState: collateralFarmAddress,
+      };
+    }
+    let debtFarmAccounts: {
+      obligationFarmUserState: Option<Address>;
+      reserveFarmState: Option<Address>;
+    } = {
+      obligationFarmUserState: none(),
+      reserveFarmState: none(),
+    };
+    const debtFarmAddress = reserve.getDebtFarmAddress();
+    if (isSome(debtFarmAddress)) {
+      debtFarmAccounts = {
+        obligationFarmUserState: some(await obligationFarmStatePda(debtFarmAddress.value, obligationAddress)),
+        reserveFarmState: debtFarmAddress,
+      };
+    }
+    return {
+      debtFarmAccounts,
+      collateralFarmAccounts,
+    };
+  }
+
+  private static async getReferrerKey(
+    kaminoMarket: KaminoMarket,
+    owner: Address,
+    kaminoObligation: KaminoObligation | null,
+    referrer: Option<Address>
+  ): Promise<Option<Address>> {
+    let referrerKey: Option<Address> = none();
+    if (isNone(referrer) || referrer.value === DEFAULT_PUBLIC_KEY) {
+      if (kaminoObligation === null) {
+        const [_, userMetadata] = await kaminoMarket.getUserMetadata(owner);
+        if (userMetadata && userMetadata.referrer !== DEFAULT_PUBLIC_KEY) {
+          referrerKey = some(userMetadata.referrer);
+        }
+      } else if (kaminoObligation.state.referrer !== DEFAULT_PUBLIC_KEY) {
+        referrerKey = some(kaminoObligation.state.referrer);
+      }
+    } else {
+      referrerKey = referrer;
+    }
+    return referrerKey;
+  }
+
+  private static async getReferrerTokenStateAddressImpl(
+    referrer: Option<Address>,
+    reserve: Address,
+    programId: Address
+  ): Promise<Option<Address>> {
+    if (isSome(referrer)) {
+      return some(await referrerTokenStatePda(referrer.value, reserve, programId));
+    }
+    return none();
+  }
 }