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

package/src/classes/actionTypes.ts

@@ -0,0 +1,295 @@
+import { Address, Option, Slot, TransactionSigner } from '@solana/kit';
+import BN from 'bn.js';
+import { ObligationType, ScopePriceRefreshConfig } from '../utils';
+import { KaminoObligation } from './obligation';
+import { KaminoMarket } from './market';
+import { ActionType } from './action';
+
+/**
+ * Props for KaminoAction.initialize
+ */
+export interface InitializeActionProps {
+  kaminoMarket: KaminoMarket;
+  action: ActionType;
+  amount: string | BN;
+  reserveAddress: Address;
+  owner: TransactionSigner;
+  obligation: KaminoObligation | ObligationType;
+  referrer?: Option<Address>;
+  currentSlot?: Slot;
+  payer?: TransactionSigner;
+}
+
+/**
+ * Props for KaminoAction.buildDepositTxns
+ */
+export interface BuildDepositTxnsProps {
+  kaminoMarket: KaminoMarket;
+  amount: string | BN;
+  reserveAddress: Address;
+  owner: TransactionSigner;
+  obligation: KaminoObligation | ObligationType;
+  useV2Ixs: boolean;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  initUserMetadata?: { skipInitialization: boolean; skipLutCreation: boolean };
+  referrer?: Option<Address>;
+  currentSlot?: Slot;
+  overrideElevationGroupRequest?: number;
+}
+
+/**
+ * Props for KaminoAction.buildBorrowTxns
+ */
+export interface BuildBorrowTxnsProps {
+  kaminoMarket: KaminoMarket;
+  amount: string | BN;
+  reserveAddress: Address;
+  owner: TransactionSigner;
+  obligation: KaminoObligation | ObligationType;
+  useV2Ixs: boolean;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  initUserMetadata?: { skipInitialization: boolean; skipLutCreation: boolean };
+  referrer?: Option<Address>;
+  currentSlot?: Slot;
+  overrideElevationGroupRequest?: number;
+}
+
+/**
+ * Props for KaminoAction.buildDepositReserveLiquidityTxns
+ */
+export interface BuildDepositReserveLiquidityTxnsProps {
+  kaminoMarket: KaminoMarket;
+  amount: string | BN;
+  reserveAddress: Address;
+  owner: TransactionSigner;
+  obligation: KaminoObligation | ObligationType;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  referrer?: Option<Address>;
+  currentSlot?: Slot;
+}
+
+/**
+ * Props for KaminoAction.buildRedeemReserveCollateralTxns
+ */
+export interface BuildRedeemReserveCollateralTxnsProps {
+  kaminoMarket: KaminoMarket;
+  amount: string | BN;
+  reserveAddress: Address;
+  owner: TransactionSigner;
+  obligation: KaminoObligation | ObligationType;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  referrer?: Option<Address>;
+  currentSlot?: Slot;
+}
+
+/**
+ * Props for KaminoAction.buildWithdrawTxns
+ */
+export interface BuildWithdrawTxnsProps {
+  kaminoMarket: KaminoMarket;
+  amount: string | BN;
+  reserveAddress: Address;
+  owner: TransactionSigner;
+  obligation: KaminoObligation | ObligationType;
+  useV2Ixs: boolean;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  initUserMetadata?: { skipInitialization: boolean; skipLutCreation: boolean };
+  referrer?: Option<Address>;
+  currentSlot?: Slot;
+  overrideElevationGroupRequest?: number;
+  obligationCustomizations?: {
+    addedDepositReserves?: Address[];
+  };
+}
+
+/**
+ * Props for KaminoAction.buildRepayTxns
+ */
+export interface BuildRepayTxnsProps {
+  kaminoMarket: KaminoMarket;
+  amount: string | BN;
+  reserveAddress: Address;
+  owner: TransactionSigner;
+  obligation: KaminoObligation | ObligationType;
+  useV2Ixs: boolean;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  currentSlot: Slot;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  payer?: TransactionSigner;
+  initUserMetadata?: { skipInitialization: boolean; skipLutCreation: boolean };
+  referrer?: Option<Address>;
+}
+
+/**
+ * Props for KaminoAction.buildDepositAndBorrowTxns
+ */
+export interface BuildDepositAndBorrowTxnsProps {
+  kaminoMarket: KaminoMarket;
+  depositAmount: string | BN;
+  depositReserveAddress: Address;
+  borrowAmount: string | BN;
+  borrowReserveAddress: Address;
+  owner: TransactionSigner;
+  obligation: KaminoObligation | ObligationType;
+  useV2Ixs: boolean;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  initUserMetadata?: { skipInitialization: boolean; skipLutCreation: boolean };
+  referrer?: Option<Address>;
+  currentSlot?: Slot;
+}
+
+/**
+ * Props for KaminoAction.buildRefreshObligationTxns
+ */
+export interface BuildRefreshObligationTxnsProps {
+  kaminoMarket: KaminoMarket;
+  payer: TransactionSigner;
+  obligation: KaminoObligation;
+  extraComputeBudget?: number;
+  currentSlot?: Slot;
+}
+
+/**
+ * Props for KaminoAction.buildRequestElevationGroupTxns
+ */
+export interface BuildRequestElevationGroupTxnsProps {
+  kaminoMarket: KaminoMarket;
+  owner: TransactionSigner;
+  obligation: KaminoObligation;
+  elevationGroup: number;
+  extraComputeBudget?: number;
+  currentSlot?: Slot;
+}
+
+/**
+ * Props for KaminoAction.buildDepositAndWithdrawV2Txns
+ */
+export interface BuildDepositAndWithdrawV2TxnsProps {
+  kaminoMarket: KaminoMarket;
+  depositAmount: string | BN;
+  depositReserveAddress: Address;
+  withdrawAmount: string | BN;
+  withdrawReserveAddress: Address;
+  owner: TransactionSigner;
+  currentSlot: Slot;
+  obligation: KaminoObligation | ObligationType;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  initUserMetadata?: { skipInitialization: boolean; skipLutCreation: boolean };
+  referrer?: Option<Address>;
+}
+
+/**
+ * Props for KaminoAction.buildRepayAndWithdrawTxns
+ */
+export interface BuildRepayAndWithdrawTxnsProps {
+  kaminoMarket: KaminoMarket;
+  repayAmount: string | BN;
+  repayReserveAddress: Address;
+  withdrawAmount: string | BN;
+  withdrawReserveAddress: Address;
+  payer: TransactionSigner;
+  currentSlot: Slot;
+  obligation: KaminoObligation | ObligationType;
+  useV2Ixs: boolean;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  initUserMetadata?: { skipInitialization: boolean; skipLutCreation: boolean };
+  referrer?: Option<Address>;
+}
+
+/**
+ * Props for KaminoAction.buildRepayAndWithdrawV2Txns
+ */
+export interface BuildRepayAndWithdrawV2TxnsProps {
+  kaminoMarket: KaminoMarket;
+  repayAmount: string | BN;
+  repayReserveAddress: Address;
+  withdrawAmount: string | BN;
+  withdrawReserveAddress: Address;
+  payer: TransactionSigner;
+  currentSlot: Slot;
+  obligation: KaminoObligation | ObligationType;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  initUserMetadata?: { skipInitialization: boolean; skipLutCreation: boolean };
+  referrer?: Option<Address>;
+}
+
+/**
+ * Props for KaminoAction.buildLiquidateTxns
+ */
+export interface BuildLiquidateTxnsProps {
+  kaminoMarket: KaminoMarket;
+  amount: string | BN;
+  minCollateralReceiveAmount: string | BN;
+  repayReserveAddress: Address;
+  withdrawReserveAddress: Address;
+  liquidator: TransactionSigner;
+  obligationOwner: Address;
+  obligation: KaminoObligation | ObligationType;
+  useV2Ixs: boolean;
+  scopeRefreshConfig?: ScopePriceRefreshConfig;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  initUserMetadata?: { skipInitialization: boolean; skipLutCreation: boolean };
+  referrer?: Option<Address>;
+  maxAllowedLtvOverridePercent?: number;
+  currentSlot?: Slot;
+}
+
+/**
+ * Props for KaminoAction.buildWithdrawReferrerFeeTxns
+ */
+export interface BuildWithdrawReferrerFeeTxnsProps {
+  owner: TransactionSigner;
+  reserveAddress: Address;
+  kaminoMarket: KaminoMarket;
+  currentSlot?: Slot;
+}
+
+/**
+ * Props for KaminoAction.buildDepositObligationCollateralTxns
+ */
+export interface BuildDepositObligationCollateralTxnsProps {
+  kaminoMarket: KaminoMarket;
+  amount: string | BN;
+  reserveAddress: Address;
+  owner: TransactionSigner;
+  obligation: KaminoObligation | ObligationType;
+  useV2Ixs: boolean;
+  scopeRefreshConfig: ScopePriceRefreshConfig | undefined;
+  extraComputeBudget?: number;
+  includeAtaIxs?: boolean;
+  requestElevationGroup?: boolean;
+  initUserMetadata?: { skipInitialization: boolean; skipLutCreation: boolean };
+  referrer?: Option<Address>;
+  currentSlot?: Slot;
+}

package/src/classes/configItems.ts

@@ -1,8 +1,6 @@
 import { struct, Layout } from '@coral-xyz/borsh';
 import { blobEquals, orThrow, toJson } from './utils';
 import { Buffer } from 'buffer';
-import { ReserveConfig } from '../lib';
-import { UpdateConfigModeKind, UpdateConfigMode } from '../@codegen/klend/types';
 
 /**
  * An object literal specifying *all* "update mode" enum values (of type {@code M}) and their corresponding config items
@@ -153,7 +151,7 @@ export class ConfigItemUpdater<C, A> {
  * A resolver of config item changes.
  */
 export class ConfigUpdater<M extends BorshEnum, C> {
-  protected readonly itemUpdaters: Map<M['kind'], [M, ConfigItemUpdater<C, any>[]]>;
+  private readonly itemUpdaters: Map<M['kind'], [M, ConfigItemUpdater<C, any>[]]>;
 
   /**
    * A resolving constructor.
@@ -237,61 +235,6 @@ export class ConfigUpdater<M extends BorshEnum, C> {
   }
 }
 
-export class EntireReserveConfigUpdater extends ConfigUpdater<UpdateConfigModeKind, ReserveConfig> {
-  encodeAllUpdates(
-    currentConfig: ReserveConfig | undefined,
-    newConfig: ReserveConfig
-  ): EncodedConfigUpdate<UpdateConfigModeKind>[] {
-    const updates: EncodedConfigUpdate<UpdateConfigModeKind>[] = [];
-    let ltvUpdate: EncodedConfigUpdate<UpdateConfigModeKind> | undefined;
-    let liquidationThresholdUpdate: EncodedConfigUpdate<UpdateConfigModeKind> | undefined;
-
-    for (const [mode, itemUpdaters] of this.itemUpdaters.values()) {
-      for (const itemUpdater of itemUpdaters) {
-        const value = itemUpdater.encodeUpdatedItemFrom(currentConfig, newConfig);
-        if (value === undefined) {
-          continue;
-        }
-
-        const update = { mode, value };
-
-        if (mode.discriminator === UpdateConfigMode.UpdateLoanToValuePct.discriminator) {
-          ltvUpdate = update;
-        } else if (mode.discriminator === UpdateConfigMode.UpdateLiquidationThresholdPct.discriminator) {
-          liquidationThresholdUpdate = update;
-          // If reserve is already initialized, skip fields that require global admin signature on update
-        } else {
-          updates.push(update);
-        }
-      }
-    }
-
-    // Handle ordering of LTV and LiquidationThreshold updates
-    // ensure LiquidationThreshold >= LTV at all times
-    if (ltvUpdate && liquidationThresholdUpdate) {
-      const currentLiquidationThreshold = currentConfig ? currentConfig.liquidationThresholdPct : 0;
-      const newLiquidationThreshold = newConfig.liquidationThresholdPct;
-
-      if (newLiquidationThreshold > currentLiquidationThreshold) {
-        // Liquidation threshold is increasing, so it must be updated first
-        updates.push(liquidationThresholdUpdate);
-        updates.push(ltvUpdate);
-      } else {
-        // All other cases, it's safer to update the LTV first
-        updates.push(ltvUpdate);
-        updates.push(liquidationThresholdUpdate);
-      }
-    } else if (ltvUpdate) {
-      updates.push(ltvUpdate);
-    } else if (liquidationThresholdUpdate) {
-      updates.push(liquidationThresholdUpdate);
-    }
-
-    updates.sort((left, right) => priorityOf(left.mode) - priorityOf(right.mode));
-    return updates;
-  }
-}
-
 /**
  * The update mode discriminator and the serialized value needed to construct an update ix.
  */
@@ -350,44 +293,3 @@ type Getter<C, A> = (config: C) => A;
 function toArray<T>(singleOrArray: SingleOrArray<T>): T[] {
   return Array.isArray(singleOrArray) ? singleOrArray : [singleOrArray];
 }
-
-// Lowest priority gets updated first
-function priorityOf(mode: UpdateConfigModeKind): number {
-  switch (mode.discriminator) {
-    case UpdateConfigMode.UpdateScopePriceFeed.discriminator:
-      return 0;
-    case UpdateConfigMode.UpdateTokenInfoScopeTwap.discriminator:
-      return 0;
-    case UpdateConfigMode.UpdateTokenInfoScopeChain.discriminator:
-      return 0;
-    case UpdateConfigMode.UpdateTokenInfoLowerHeuristic.discriminator:
-      return 0;
-    case UpdateConfigMode.UpdateTokenInfoUpperHeuristic.discriminator:
-      return 0;
-    case UpdateConfigMode.UpdateTokenInfoExpHeuristic.discriminator:
-      return 0;
-    case UpdateConfigMode.UpdateTokenInfoTwapDivergence.discriminator:
-      return 0;
-    case UpdateConfigMode.UpdateTokenInfoName.discriminator:
-      return 0;
-    case UpdateConfigMode.UpdateTokenInfoPriceMaxAge.discriminator:
-      return 0;
-    case UpdateConfigMode.UpdateTokenInfoTwapMaxAge.discriminator:
-      return 0;
-    case UpdateConfigMode.UpdateDeleveragingBonusIncreaseBpsPerDay.discriminator:
-      return priorityOf(new UpdateConfigMode.UpdateAutodeleverageEnabled()) - 1;
-    case UpdateConfigMode.UpdateDeleveragingMarginCallPeriod.discriminator:
-      return priorityOf(new UpdateConfigMode.UpdateAutodeleverageEnabled()) - 1;
-    case UpdateConfigMode.UpdateDeleveragingThresholdDecreaseBpsPerDay.discriminator:
-      return priorityOf(new UpdateConfigMode.UpdateAutodeleverageEnabled()) - 1;
-    case UpdateConfigMode.UpdateAutodeleverageEnabled.discriminator:
-      return 4;
-    // Always update last bc we cannot skip validation
-    case UpdateConfigMode.UpdateDepositLimit.discriminator:
-      return 63;
-    case UpdateConfigMode.UpdateBorrowLimit.discriminator:
-      return 63;
-    default:
-      return 10;
-  }
-}

package/src/classes/farm_utils.ts

@@ -8,6 +8,7 @@ import {
   scaleDownWads,
   WAD,
   RewardInfo,
+  RewardType,
 } from '@kamino-finance/farms-sdk';
 import {
   address,
@@ -174,7 +175,7 @@ export type UnstakeAndWithdrawFromFarmIxs = {
   withdrawIx: Instruction;
 };
 
-export function getRewardPerTimeUnitSecond(reward: RewardInfo) {
+export function getRewardPerTimeUnitSecond(reward: RewardInfo, farmTotalStakeLamports: Decimal) {
   const now = new Decimal(new Date().getTime()).div(1000);
   let rewardPerTimeUnitSecond = new Decimal(0);
   for (let i = 0; i < reward.rewardScheduleCurve.points.length - 1; i++) {
@@ -196,8 +197,11 @@ export function getRewardPerTimeUnitSecond(reward: RewardInfo) {
   const rewardTokenDecimals = reward.token.decimals.toNumber();
   const rewardAmountPerUnitDecimals = new Decimal(10).pow(reward.rewardsPerSecondDecimals.toString());
   const rewardAmountPerUnitLamports = new Decimal(10).pow(rewardTokenDecimals.toString());
+  const constantRewardStakeAdjustment =
+    reward.rewardType === RewardType.Constant.discriminator ? farmTotalStakeLamports : new Decimal(1);
 
   const rpsAdjusted = new Decimal(rewardPerTimeUnitSecond.toString())
+    .mul(constantRewardStakeAdjustment)
     .div(rewardAmountPerUnitDecimals)
     .div(rewardAmountPerUnitLamports);
 

package/src/classes/market.ts

@@ -34,8 +34,11 @@ import {
   isNotNullPubkey,
   lendingMarketAuthPda,
   LendingObligation,
+  LendingObligationFixedRate,
   LeverageObligation,
+  LeverageObligationFixedRate,
   MultiplyObligation,
+  MultiplyObligationFixedRate,
   ObligationType,
   PythPrices,
   referrerTokenStatePda,
@@ -53,7 +56,7 @@ import { Fraction } from './fraction';
 import { batchFetch, chunks, KaminoPrices, MintToPriceMap } from '@kamino-finance/kliquidity-sdk';
 import { parseTokenSymbol, parseZeroPaddedUtf8 } from './utils';
 import { ObligationZP } from '../@codegen/klend/zero_padding';
-import { checkDefined } from '../utils/validations';
+import { checkArrayNotEmpty, checkDefined } from '../utils/validations';
 import { Buffer } from 'buffer';
 import { ReserveStatus } from '../@codegen/klend/types';
 import { fetchKaminoCdnData } from '../utils/readCdnData';
@@ -121,6 +124,22 @@ export class KaminoMarket {
     );
   }
 
+  /**
+   * TESTING ONLY!
+   *
+   * Used to create mock markets for testing
+   */
+  static createMarket(
+    rpc: Rpc<KaminoMarketRpcApi>,
+    state: LendingMarket,
+    marketAddress: Address,
+    reserves: Map<Address, KaminoReserve>,
+    recentSlotDurationMs: number,
+    programId: Address = PROGRAM_ID
+  ) {
+    return new KaminoMarket(rpc, state, marketAddress, reserves, recentSlotDurationMs, programId);
+  }
+
   /**
    * Load a new market with all of its associated reserves
    * @param rpc
@@ -291,14 +310,22 @@ export class KaminoMarket {
     return parseZeroPaddedUtf8(this.state.name);
   }
 
-  async getObligationDepositByWallet(owner: Address, mint: Address, obligationType: ObligationType): Promise<Decimal> {
+  async getObligationDepositByWallet(
+    owner: Address,
+    depositReserveAddress: Address,
+    obligationType: ObligationType
+  ): Promise<Decimal> {
     const obligation = await this.getObligationByWallet(owner, obligationType);
-    return obligation?.getDepositByMint(mint)?.amount ?? new Decimal(0);
+    return obligation?.getDepositByReserve(depositReserveAddress)?.amount ?? new Decimal(0);
   }
 
-  async getObligationBorrowByWallet(owner: Address, mint: Address, obligationType: ObligationType): Promise<Decimal> {
+  async getObligationBorrowByWallet(
+    owner: Address,
+    borrowReserveAddress: Address,
+    obligationType: ObligationType
+  ): Promise<Decimal> {
     const obligation = await this.getObligationByWallet(owner, obligationType);
-    return obligation?.getBorrowByMint(mint)?.amount ?? new Decimal(0);
+    return obligation?.getBorrowByReserve(borrowReserveAddress)?.amount ?? new Decimal(0);
   }
 
   getTotalDepositTVL(): Decimal {
@@ -317,10 +344,10 @@ export class KaminoMarket {
     return tvl;
   }
 
-  getMaxLeverageForPair(collTokenMint: Address, debtTokenMint: Address): number {
+  getMaxLeverageForPair(collReserveAddress: Address, debtReserveAddress: Address): number {
     const { maxLtv: maxCollateralLtv, borrowFactor } = this.getMaxAndLiquidationLtvAndBorrowFactorForPair(
-      collTokenMint,
-      debtTokenMint
+      collReserveAddress,
+      debtReserveAddress
     );
 
     const maxLeverage =
@@ -345,12 +372,11 @@ export class KaminoMarket {
   }
 
   getMaxAndLiquidationLtvAndBorrowFactorForPair(
-    collTokenMint: Address,
-    debtTokenMint: Address
+    collReserveAddress: Address,
+    debtReserveAddress: Address
   ): { maxLtv: number; liquidationLtv: number; borrowFactor: number } {
-    const collReserve: KaminoReserve | undefined = this.getReserveByMint(collTokenMint);
-    const debtReserve: KaminoReserve | undefined = this.getReserveByMint(debtTokenMint);
-
+    const collReserve: KaminoReserve | undefined = this.getReserveByAddress(collReserveAddress);
+    const debtReserve: KaminoReserve | undefined = this.getReserveByAddress(debtReserveAddress);
     if (!collReserve || !debtReserve) {
       throw Error('Could not find one of the reserves.');
     }
@@ -405,6 +431,22 @@ export class KaminoMarket {
         );
         break;
       }
+      case LendingObligationFixedRate.tag: {
+        const reserveAddress = productType.toArgs().seed1;
+        obligations = obligations.filter((obligation) => obligation.getDepositByReserve(reserveAddress) !== undefined);
+        break;
+      }
+      case LeverageObligationFixedRate.tag:
+      case MultiplyObligationFixedRate.tag: {
+        const collReserveAddress = productType.toArgs().seed1;
+        const debtReserveAddress = productType.toArgs().seed2;
+        obligations = obligations.filter((obligation) => {
+          const collDeposit = obligation.getDepositByReserve(collReserveAddress);
+          const debtBorrow = obligation.getBorrowByReserve(debtReserveAddress);
+          return collDeposit !== undefined && debtBorrow !== undefined;
+        });
+        break;
+      }
       default:
         throw new Error('Invalid obligation type');
     }
@@ -457,7 +499,7 @@ export class KaminoMarket {
     obligation?: KaminoObligation
   ): Decimal {
     return obligation
-      ? obligation.getMaxBorrowAmount(this, debtReserve.getLiquidityMint(), slot, requestElevationGroup)
+      ? obligation.getMaxBorrowAmount(this, debtReserve.address, slot, requestElevationGroup)
       : debtReserve.getMaxBorrowAmountWithCollReserve(this, collReserve, slot);
   }
 
@@ -529,46 +571,47 @@ export class KaminoMarket {
     return checkDefined(this.getReserveByAddress(address), `${description} reserve ${address} not found`);
   }
 
-  getReserveByMint(address: Address): KaminoReserve | undefined {
+  getReservesByMint(address: Address): KaminoReserve[] {
+    const reserves: KaminoReserve[] = [];
     for (const reserve of this.reserves.values()) {
       if (reserve.getLiquidityMint() === address) {
-        return reserve;
+        reserves.push(reserve);
       }
     }
-    return undefined;
+    return reserves;
   }
 
   /**
    * Returns this market's reserve of the given mint address, or throws an error (including the given description) if
    * such reserve does not exist.
    */
-  getExistingReserveByMint(address: Address, description: string = 'Requested'): KaminoReserve {
-    return checkDefined(this.getReserveByMint(address), `${description} reserve with mint ${address} not found`);
+  getExistingReservesByMint(address: Address, description: string = 'Requested'): KaminoReserve[] {
+    return checkArrayNotEmpty(this.getReservesByMint(address), `${description} reserve with mint ${address} not found`);
   }
 
-  getReserveBySymbol(symbol: string) {
+  getReservesBySymbol(symbol: string): KaminoReserve[] {
+    const reserves: KaminoReserve[] = [];
     for (const reserve of this.reserves.values()) {
       if (reserve.symbol === symbol) {
-        return reserve;
+        reserves.push(reserve);
       }
     }
-    return undefined;
+    return reserves;
   }
 
   /**
    * Returns this market's reserve of the given symbol, or throws an error (including the given description) if
    * such reserve does not exist.
    */
-  getExistingReserveBySymbol(symbol: string, description: string = 'Requested'): KaminoReserve {
-    return checkDefined(this.getReserveBySymbol(symbol), `${description} reserve with symbol ${symbol} not found`);
-  }
-
-  getReserveMintBySymbol(symbol: string) {
-    return this.getReserveBySymbol(symbol)?.getLiquidityMint();
+  getExistingReservesBySymbol(symbol: string, description: string = 'Requested'): KaminoReserve[] {
+    return checkArrayNotEmpty(
+      this.getReservesBySymbol(symbol),
+      `${description} reserve with symbol ${symbol} not found`
+    );
   }
 
   async getReserveFarmInfo(
-    mint: Address,
+    reserveAddress: Address,
     getRewardPrice: (mint: Address) => Promise<number>
   ): Promise<{ borrowingRewards: ReserveRewardInfo; depositingRewards: ReserveRewardInfo }> {
     const { address } = this;
@@ -580,10 +623,10 @@ export class KaminoMarket {
     }
 
     // Find the reserve
-    const kaminoReserve = this.getReserveByMint(mint);
+    const kaminoReserve = this.getReserveByAddress(reserveAddress);
 
     if (!kaminoReserve) {
-      throw Error(`Could not find reserve. ${mint}`);
+      throw Error(`Could not find reserve ${reserveAddress}`);
     }
 
     const totalDepositAmount = lamportsToNumberDecimal(