@kamino-finance/klend-sdk 6.0.4 → 6.0.5-beta.1

package/src/classes/action.ts

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