@kamino-finance/klend-sdk 5.10.12 → 5.10.13

package/src/classes/manager.ts

@@ -339,9 +339,10 @@ export class KaminoManager {
     user: PublicKey,
     vault: KaminoVault,
     tokenAmount: Decimal,
-    vaultReservesMap?: PubkeyHashMap<PublicKey, KaminoReserve>
+    vaultReservesMap?: PubkeyHashMap<PublicKey, KaminoReserve>,
+    farmState?: FarmState
   ): Promise<DepositIxs> {
-    return this._vaultClient.depositIxs(user, vault, tokenAmount, vaultReservesMap);
+    return this._vaultClient.depositIxs(user, vault, tokenAmount, vaultReservesMap, farmState);
   }
 
   /**
@@ -366,19 +367,21 @@ export class KaminoManager {
    * @param vault the vault to update
    * @param mode the field to update (based on VaultConfigFieldKind enum)
    * @param value the value to update the field with
+   * @param [signer] the signer of the transaction. Optional. If not provided the admin of the vault will be used. It should be used when changing the admin of the vault if we want to build or batch multiple ixs in the same tx
    * @returns a struct that contains the instruction to update the field and an optional list of instructions to update the lookup table
    */
   async updateVaultConfigIxs(
     vault: KaminoVault,
     mode: VaultConfigFieldKind | string,
-    value: string
+    value: string,
+    signer?: PublicKey
   ): Promise<UpdateVaultConfigIxs> {
     if (typeof mode === 'string') {
       const field = VaultConfigField.fromDecoded({ [mode]: '' });
-      return this._vaultClient.updateVaultConfigIxs(vault, field, value);
+      return this._vaultClient.updateVaultConfigIxs(vault, field, value, signer);
     }
 
-    return this._vaultClient.updateVaultConfigIxs(vault, mode, value);
+    return this._vaultClient.updateVaultConfigIxs(vault, mode, value, signer);
   }
 
   /** Sets the farm where the shares can be staked. This is store in vault state and a vault can only have one farm, so the new farm will ovveride the old farm
@@ -420,15 +423,18 @@ export class KaminoManager {
    * @param shareAmount - share amount to withdraw (in tokens, not lamports), in order to withdraw everything, any value > user share amount
    * @param slot - current slot, used to estimate the interest earned in the different reserves with allocation from the vault
    * @param [vaultReservesMap] - optional parameter; a hashmap from each reserve pubkey to the reserve state. If provided the function will be significantly faster as it will not have to fetch the reserves
+   * @param [farmState] - the state of the vault farm, if the vault has a farm. Optional. If not provided, it will be fetched
    * @returns an array of instructions to create missing ATAs if needed and the withdraw instructions
    */
   async withdrawFromVaultIxs(
     user: PublicKey,
     vault: KaminoVault,
     shareAmount: Decimal,
-    slot: number
+    slot: number,
+    vaultReservesMap?: PubkeyHashMap<PublicKey, KaminoReserve>,
+    farmState?: FarmState
   ): Promise<WithdrawIxs> {
-    return this._vaultClient.withdrawIxs(user, vault, shareAmount, slot);
+    return this._vaultClient.withdrawIxs(user, vault, shareAmount, slot, vaultReservesMap, farmState);
   }
 
   /**
@@ -447,7 +453,6 @@ export class KaminoManager {
    * @param payer - payer wallet pubkey
    * @param lookupTable - lookup table to insert the keys into
    * @param keys - keys to insert into the lookup table
-   * @param [accountsInLUT] - the existent accounts in the lookup table. Optional. If provided, the function will not fetch the accounts in the lookup table
    * @returns - an array of instructions to insert the missing keys into the lookup table
    */
   async insertIntoLUTIxs(payer: PublicKey, lut: PublicKey, keys: PublicKey[]): Promise<TransactionInstruction[]> {
@@ -697,6 +702,16 @@ export class KaminoManager {
     return this._vaultClient.getVaultOverview(vault, price, slot, vaultReserves, kaminoMarkets);
   }
 
+  /**
+   * Prints a vault in a human readable form
+   * @param vaultPubkey - the address of the vault
+   * @param [vaultState] - optional parameter to pass the vault state directly; this will save a network call
+   * @returns - void; prints the vault to the console
+   */
+  async printVault(vaultPubkey: PublicKey, vaultState?: VaultState) {
+    return this._vaultClient.printVault(vaultPubkey, vaultState);
+  }
+
   /**
    * This will return an aggregation of the current state of the vault with all the invested amounts and the utilization ratio of the vault
    * @param vault - the kamino vault to get available liquidity to withdraw for
@@ -797,15 +812,6 @@ export class KaminoManager {
     return this._vaultClient.loadVaultReserves(vaultState);
   }
 
-  /**
-   * This will get the list of all reserve pubkeys that the vault has allocations for
-   * @param vaultState - the vault state to load reserves for
-   * @returns a hashmap from each reserve pubkey to the reserve state
-   */
-  getAllVaultReserves(vault: VaultState): PublicKey[] {
-    return this._vaultClient.getAllVaultReserves(vault);
-  }
-
   /**
    * This will load the onchain state for all the reserves that the vault has allocations for
    * @param vaultState - the vault state to load reserves for
@@ -830,7 +836,7 @@ export class KaminoManager {
    * @param kaminoVault - vault to invest from
    * @returns - an array of invest instructions for each invest action required for the vault reserves
    */
-  async investAllReserves(payer: PublicKey, kaminoVault: KaminoVault): Promise<TransactionInstruction[]> {
+  async investAllReservesIxs(payer: PublicKey, kaminoVault: KaminoVault): Promise<TransactionInstruction[]> {
     return this._vaultClient.investAllReservesIxs(payer, kaminoVault);
   }
 
@@ -842,7 +848,7 @@ export class KaminoManager {
    * @param [vaultReservesMap] - optional parameter; a hashmap from each reserve pubkey to the reserve state. If provided the function will be significantly faster as it will not have to fetch the reserves
    * @returns - an array of invest instructions for each invest action required for the vault reserves
    */
-  async investSingleReserve(
+  async investSingleReserveIxs(
     payer: PublicKey,
     kaminoVault: KaminoVault,
     reserveWithAddress: ReserveWithAddress,

package/src/classes/obligation.ts

@@ -13,7 +13,14 @@ import {
   ObligationLiquidityFields,
 } from '../idl_codegen/types';
 import { positiveOrZero, valueOrZero } from './utils';
-import { isNotNullPubkey, PubkeyHashMap, U64_MAX } from '../utils';
+import {
+  getObligationPdaWithArgs,
+  getObligationType,
+  isNotNullPubkey,
+  PubkeyHashMap,
+  TOTAL_NUMBER_OF_IDS_TO_CHECK,
+  U64_MAX,
+} from '../utils';
 import { ActionType } from './action';
 
 export type Position = {
@@ -112,6 +119,39 @@ export class KaminoObligation {
     this.obligationTag = obligation.tag.toNumber();
   }
 
+  getObligationId(
+    market: KaminoMarket,
+    mintAddress1: PublicKey = PublicKey.default,
+    mintAddress2: PublicKey = PublicKey.default
+  ) {
+    if (!this.state.lendingMarket.equals(new PublicKey(market.address))) {
+      throw new Error('Obligation does not belong to this market');
+    }
+    let obligationId: number | undefined;
+    const type = getObligationType(market, this.obligationTag, mintAddress1, mintAddress2);
+    const baseArgs = type.toArgs();
+
+    for (let i = 0; i < TOTAL_NUMBER_OF_IDS_TO_CHECK; i++) {
+      const pda = getObligationPdaWithArgs(
+        new PublicKey(market.address),
+        this.state.owner,
+        {
+          ...baseArgs,
+          id: i,
+        },
+        market.programId
+      );
+      if (pda.equals(this.obligationAddress)) {
+        obligationId = i;
+        break;
+      }
+    }
+    if (obligationId === undefined) {
+      throw new Error(`obligation id not found for obligation ${this.obligationAddress.toString()}`);
+    }
+    return obligationId;
+  }
+
   static async load(kaminoMarket: KaminoMarket, obligationAddress: PublicKey): Promise<KaminoObligation | null> {
     const res = await kaminoMarket.getConnection().getAccountInfoAndContext(obligationAddress);
     if (res.value === null) {
@@ -484,7 +524,7 @@ export class KaminoObligation {
     const collateralReservePk = mintCollateral ? market.getReserveByMint(mintCollateral)!.address : undefined;
     const debtReservePk = mintDebt ? market.getReserveByMint(mintDebt)!.address : undefined;
 
-    const additionalReserves = [];
+    const additionalReserves: PublicKey[] = [];
     if (collateralReservePk !== undefined) {
       additionalReserves.push(collateralReservePk);
     }

package/src/classes/reserve.ts

@@ -1215,7 +1215,7 @@ export function updateEntireReserveConfigIx(
   const args: UpdateReserveConfigArgs = {
     mode: new anchor.BN(25),
     value: value,
-    skipValidation: true,
+    skipValidation: false,
   };
 
   const accounts: UpdateReserveConfigAccounts = {

package/src/classes/types_utils.ts

@@ -1,5 +1,5 @@
 import { pubkeyHashMapToJson } from './utils';
-import { VaultHoldings } from './vault';
+import { VaultHoldings, VaultHoldingsWithUSDValue, VaultOverview } from './vault';
 
 export function holdingsToJson(holdings: VaultHoldings) {
   return {
@@ -17,3 +17,30 @@ export function printHoldings(holdings: VaultHoldings) {
   console.log('  Total:', holdings.total.toString());
   console.log('  Invested in reserves:', pubkeyHashMapToJson(holdings.investedInReserves));
 }
+
+export function printHoldingsWithUSDValue(holdings: VaultHoldingsWithUSDValue) {
+  console.log('Holdings with USD value:');
+  console.log('  Available:', holdings.availableUSD.toString());
+  console.log('  Invested:', holdings.investedUSD.toString());
+  console.log('  Total:', holdings.totalUSD.toString());
+  console.log('  Invested in reserves:', pubkeyHashMapToJson(holdings.investedInReservesUSD));
+}
+
+export function printVaultOverview(vaultOverview: VaultOverview) {
+  console.log('Vault overview:');
+  printHoldingsWithUSDValue(vaultOverview.holdingsUSD);
+  console.log('  Theoretical Supply APY:', vaultOverview.theoreticalSupplyAPY.toString());
+  console.log('  Utilization ratio:', vaultOverview.utilizationRatio.toString());
+  console.log('  Total supplied:', vaultOverview.totalSupplied.toString());
+  console.log('  Borrowed amount:', vaultOverview.totalBorrowed.toString());
+
+  vaultOverview.reservesOverview.forEach((reserveOverview, pubkey) => {
+    console.log('  Reserve:', pubkey.toString());
+    console.log('    Total borrowed from reserve:', reserveOverview.totalBorrowedAmount.toString());
+    console.log('    Supplied:', reserveOverview.suppliedAmount.toString());
+    console.log('    Utilization ratio:', reserveOverview.utilizationRatio.toString());
+    console.log('    Liquidation Threshold Pct:', reserveOverview.liquidationThresholdPct.toString());
+    console.log('    Supply APY:', reserveOverview.supplyAPY.toString());
+    console.log('    Lending market:', reserveOverview.market.toString());
+  });
+}

package/src/classes/utils.ts

@@ -1,8 +1,9 @@
 import { PubkeyHashMap, SLOTS_PER_SECOND, SLOTS_PER_YEAR } from '../utils';
 import Decimal from 'decimal.js';
 import { AccountInfo, PublicKey } from '@solana/web3.js';
-import { SOL_MINTS } from '../lib';
+import { MarketOverview, ReserveOverview, SOL_MINTS } from '../lib';
 import { AccountLayout } from '@solana/spl-token';
+import { ReserveAllocationOverview } from './types';
 
 type ObligationFarmScoreType = {
   obligationId: string;
@@ -271,3 +272,51 @@ export function pubkeyHashMapToJson(map: PubkeyHashMap<PublicKey, any>): { [key:
 export function printPubkeyHashMap<V>(map: PubkeyHashMap<PublicKey, V>) {
   console.log(pubkeyHashMapToJson(map));
 }
+
+export function printReservesOverviewMap(map: PubkeyHashMap<PublicKey, ReserveOverview>) {
+  map.forEach((value, key) => {
+    console.log('Reserve:', key.toString());
+    printReserveOverview(value);
+  });
+}
+
+export function printReserveOverview(reserveOverview: ReserveOverview) {
+  console.log('Total borrowed from reserve:', reserveOverview.totalBorrowedAmount.toString());
+  console.log('Borrowed from the supplied amount:', reserveOverview.amountBorrowedFromSupplied.toString());
+  console.log('Supplied:', reserveOverview.suppliedAmount.toString());
+  console.log('Utilization ratio:', reserveOverview.utilizationRatio.toString());
+  console.log('Liquidation Threshold Pct:', reserveOverview.liquidationThresholdPct.toString());
+  console.log('Supply APY:', reserveOverview.supplyAPY.toString());
+  console.log('Lending market:', reserveOverview.market.toString());
+}
+
+export function printMarketsOverviewMap(map: PubkeyHashMap<PublicKey, MarketOverview>) {
+  map.forEach((value, key) => {
+    console.log('Reserve:', key.toString());
+    printMarketOverview(value);
+  });
+}
+
+export function printMarketOverview(marketOverview: MarketOverview) {
+  console.log('Market overview:');
+  console.log('  Address:', marketOverview.address.toString());
+  console.log('  Min LTV percentage:', marketOverview.minLTVPct.toString());
+  console.log('  Max LTV percentage:', marketOverview.maxLTVPct.toString());
+  marketOverview.reservesAsCollateral.forEach((reserve, _) => {
+    console.log('    Liquidation LTV percentage:', reserve.liquidationLTVPct.toString());
+  });
+}
+
+export function printReservesAllocationOverviewMap(map: PubkeyHashMap<PublicKey, ReserveAllocationOverview>) {
+  map.forEach((value, key) => {
+    console.log('Reserve:', key.toString());
+    printReserveAllocationOverview(value);
+  });
+}
+
+export function printReserveAllocationOverview(reserveAllocationOverview: ReserveAllocationOverview) {
+  console.log('Reserve allocation overview:');
+  console.log('  Target weight:', reserveAllocationOverview.targetWeight.toString());
+  console.log('  Token allocation cap:', reserveAllocationOverview.tokenAllocationCap.toString());
+  console.log('  Ctoken allocation:', reserveAllocationOverview.ctokenAllocation.toString());
+}

package/src/classes/vault.ts

@@ -338,7 +338,7 @@ export class KaminoVaultClient {
    * @param vault the vault to update
    * @param mode the field to update (based on VaultConfigFieldKind enum)
    * @param value the value to update the field with
-   * @param [signer] the signer of the transaction. Optional. If not provided the admin of the vault will be used. It should be used when changing the admin of the vault if we want to batch multiple ixs in the same tx
+   * @param [signer] the signer of the transaction. Optional. If not provided the admin of the vault will be used. It should be used when changing the admin of the vault if we want to build or batch multiple ixs in the same tx
    * @returns a struct that contains the instruction to update the field and an optional list of instructions to update the lookup table
    */
   async updateVaultConfigIxs(
@@ -404,7 +404,7 @@ export class KaminoVaultClient {
     updateVaultConfigIx.keys = updateVaultConfigIx.keys.concat(vaultReservesAccountMetas);
     updateVaultConfigIx.keys = updateVaultConfigIx.keys.concat(vaultReservesLendingMarkets);
 
-    const updateLUTIxs = [];
+    const updateLUTIxs: TransactionInstruction[] = [];
 
     if (mode.kind === new VaultConfigField.PendingVaultAdmin().kind) {
       const newPubkey = new PublicKey(value);
@@ -529,7 +529,7 @@ export class KaminoVaultClient {
       (account) => !account.equals(vaultState.adminAuthority)
     );
 
-    const LUTIxs = [];
+    const LUTIxs: TransactionInstruction[] = [];
     const [initNewLUTIx, newLUT] = initLookupTableIx(vaultState.pendingAdmin, await this.getConnection().getSlot());
 
     const insertIntoLUTIxs = await this.insertIntoLookupTableIxs(
@@ -1005,7 +1005,7 @@ export class KaminoVaultClient {
    */
   async investAllReservesIxs(payer: PublicKey, vault: KaminoVault): Promise<TransactionInstruction[]> {
     const vaultState = await vault.getState(this.getConnection());
-    const allReserves = this.getAllVaultReserves(vaultState);
+    const allReserves = this.getVaultReserves(vaultState);
     if (allReserves.length === 0) {
       throw new Error('No reserves found for the vault, please select at least one reserve for the vault');
     }
@@ -1488,7 +1488,7 @@ export class KaminoVaultClient {
     const holdings = await this.getVaultHoldings(vaultState);
     const initialVaultAllocations = this.getVaultAllocations(vaultState);
 
-    const allReserves = this.getAllVaultReserves(vaultState);
+    const allReserves = this.getVaultReserves(vaultState);
 
     let totalAllocation = new Decimal(0);
     initialVaultAllocations.forEach((allocation) => {
@@ -1746,14 +1746,16 @@ export class KaminoVaultClient {
    * @returns vault amount supplied in reserve in decimal
    */
   getSuppliedInReserve(vaultState: VaultState, slot: number, reserve: KaminoReserve): Decimal {
-    const reserveCollExchangeRate = reserve.getEstimatedCollateralExchangeRate(
-      slot,
-      new Fraction(reserve.state.liquidity.absoluteReferralRateSf)
+    let referralFeeBps = 0;
+    const denominator = reserve.state.config.protocolTakeRatePct / 100;
+    if (denominator > 0) {
+      referralFeeBps = new Fraction(reserve.state.liquidity.absoluteReferralRateSf)
         .toDecimal()
-        .div(reserve.state.config.protocolTakeRatePct / 100)
+        .div(denominator)
         .floor()
-        .toNumber()
-    );
+        .toNumber();
+    }
+    const reserveCollExchangeRate = reserve.getEstimatedCollateralExchangeRate(slot, referralFeeBps);
 
     const reserveAllocation = vaultState.vaultAllocationStrategy.find((allocation) =>
       allocation.reserve.equals(reserve.address)
@@ -1868,19 +1870,6 @@ export class KaminoVaultClient {
     return reserveAllocationAvailableLiquidityToWithdraw;
   }
 
-  /**
-   * This will get the list of all reserve pubkeys that the vault has allocations for
-   * @param vault - the vault state to load reserves for
-   * @returns a hashmap from each reserve pubkey to the reserve state
-   */
-  getAllVaultReserves(vault: VaultState): PublicKey[] {
-    return vault.vaultAllocationStrategy
-      .map((vaultAllocation) => vaultAllocation.reserve)
-      .filter((reserve) => {
-        return !reserve.equals(PublicKey.default);
-      });
-  }
-
   /**
    * This will get the list of all reserve pubkeys that the vault has allocations for ex
    * @param vault - the vault state to load reserves for
@@ -2212,6 +2201,9 @@ export class KaminoVaultClient {
     if (!totalInvested.isZero()) {
       utilizationRatio = totalBorrowed.div(totalInvested.add(totalAvailable));
     }
+
+    console.log('totalInvested', totalInvested.toString());
+    console.log('totalBorrowed', totalBorrowed.toString());
     return {
       totalInvested: totalInvested,
       totalBorrowed: totalBorrowed,
@@ -2245,11 +2237,13 @@ export class KaminoVaultClient {
       }
 
       const suppliedInReserve = this.getSuppliedInReserve(vault, slot, reserve);
+      const utilizationRatio = new Decimal(reserve.getEstimatedUtilizationRatio(slot, 0));
       const reserveOverview: ReserveOverview = {
         supplyAPY: new Decimal(reserve.totalSupplyAPY(slot)),
-        utilizationRatio: new Decimal(reserve.getEstimatedUtilizationRatio(slot, 0)),
+        utilizationRatio: utilizationRatio,
         liquidationThresholdPct: new Decimal(reserve.state.config.liquidationThresholdPct),
-        borrowedAmount: reserve.getBorrowedAmount(),
+        totalBorrowedAmount: reserve.getBorrowedAmount(),
+        amountBorrowedFromSupplied: suppliedInReserve.mul(utilizationRatio),
         market: reserve.state.lendingMarket,
         suppliedAmount: suppliedInReserve,
       };
@@ -2508,6 +2502,9 @@ export type VaultHoldings = {
   total: Decimal;
 };
 
+/**
+ * earnedInterest represents the interest earned from now until the slot provided in the future
+ */
 export type SimulatedVaultHoldingsWithEarnedInterest = {
   holdings: VaultHoldings;
   earnedInterest: Decimal;
@@ -2525,7 +2522,8 @@ export type ReserveOverview = {
   supplyAPY: Decimal;
   utilizationRatio: Decimal;
   liquidationThresholdPct: Decimal;
-  borrowedAmount: Decimal;
+  totalBorrowedAmount: Decimal;
+  amountBorrowedFromSupplied: Decimal;
   suppliedAmount: Decimal;
   market: PublicKey;
 };

package/src/client_kamino_manager.ts

@@ -737,7 +737,7 @@ async function main() {
       const kaminoManager = new KaminoManager(env.connection, env.kLendProgramId, env.kVaultProgramId);
 
       const kaminoVault = new KaminoVault(vaultAddress, undefined, env.kVaultProgramId);
-      const instructions = await kaminoManager.investAllReserves(env.payer.publicKey, kaminoVault);
+      const instructions = await kaminoManager.investAllReservesIxs(env.payer.publicKey, kaminoVault);
 
       for (let i = 0; i < instructions.length; i++) {
         const txInstructions: TransactionInstruction[] = [];
@@ -779,7 +779,7 @@ async function main() {
         state: reserveState,
       };
 
-      const instructions = await kaminoManager.investSingleReserve(
+      const instructions = await kaminoManager.investSingleReserveIxs(
         env.payer.publicKey,
         kaminoVault,
         reserveWithAddress

package/src/lending_operations/swap_collateral_operations.ts

@@ -319,7 +319,7 @@ function getAtaCreationIxns(context: SwapCollContext<any>) {
 }
 
 function getAtaCloseIxns(context: SwapCollContext<any>) {
-  const ataCloseIxns = [];
+  const ataCloseIxns: TransactionInstruction[] = [];
   if (
     context.sourceCollReserve.getLiquidityMint().equals(WRAPPED_SOL_MINT) ||
     context.targetCollReserve.getLiquidityMint().equals(WRAPPED_SOL_MINT)

package/src/pyth/accounts/index.ts

@@ -1,2 +1,2 @@
 export { PriceUpdateV2 } from './PriceUpdateV2';
-export { PriceUpdateV2Fields, PriceUpdateV2JSON } from './PriceUpdateV2';
+export type { PriceUpdateV2Fields, PriceUpdateV2JSON } from './PriceUpdateV2';

package/src/utils/ObligationType.ts

@@ -19,16 +19,18 @@ export type InitObligationArgsModel = {
 
 export class VanillaObligation {
   readonly programId: PublicKey;
+  readonly id: number;
   static tag = 0;
 
-  constructor(programId: PublicKey) {
+  constructor(programId: PublicKey, id?: number) {
     this.programId = programId;
+    this.id = id ?? 0;
   }
 
   toArgs() {
     const initObligationArgs: InitObligationArgsModel = {
       tag: VanillaObligation.tag,
-      id: 0,
+      id: this.id,
       seed1: PublicKey.default,
       seed2: PublicKey.default,
     };
@@ -45,18 +47,20 @@ export class MultiplyObligation {
   readonly collToken: PublicKey;
   readonly debtToken: PublicKey;
   readonly programId: PublicKey;
+  readonly id: number;
   static tag = 1;
 
-  constructor(collToken: PublicKey, debtToken: PublicKey, programId: PublicKey) {
+  constructor(collToken: PublicKey, debtToken: PublicKey, programId: PublicKey, id?: number) {
     this.collToken = collToken;
     this.debtToken = debtToken;
     this.programId = programId;
+    this.id = id ?? 0;
   }
 
   toArgs() {
     const initObligationArgs: InitObligationArgsModel = {
       tag: MultiplyObligation.tag,
-      id: 0,
+      id: this.id,
       seed1: this.collToken,
       seed2: this.debtToken,
     };
@@ -73,18 +77,20 @@ export class LeverageObligation {
   readonly collToken: PublicKey;
   readonly debtToken: PublicKey;
   readonly programId: PublicKey;
+  readonly id: number;
   static tag = 3;
 
-  constructor(collToken: PublicKey, debtToken: PublicKey, programId: PublicKey) {
+  constructor(collToken: PublicKey, debtToken: PublicKey, programId: PublicKey, id?: number) {
     this.collToken = collToken;
     this.debtToken = debtToken;
     this.programId = programId;
+    this.id = id ?? 0;
   }
 
   toArgs() {
     const initObligationArgs: InitObligationArgsModel = {
       tag: LeverageObligation.tag,
-      id: 0,
+      id: this.id,
       seed1: this.collToken,
       seed2: this.debtToken,
     };
@@ -100,11 +106,13 @@ export class LeverageObligation {
 export class LendingObligation {
   readonly token: PublicKey;
   readonly programId: PublicKey;
+  readonly id: number;
   static tag = 2;
 
-  constructor(token: PublicKey, programId: PublicKey) {
+  constructor(token: PublicKey, programId: PublicKey, id?: number) {
     this.token = token;
     this.programId = programId;
+    this.id = id ?? 0;
   }
 
   toArgs() {
@@ -123,7 +131,7 @@ export class LendingObligation {
   }
 }
 
-function getObligationPdaWithArgs(
+export function getObligationPdaWithArgs(
   market: PublicKey,
   user: PublicKey,
   args: InitObligationArgsModel,
@@ -141,6 +149,39 @@ function getObligationPdaWithArgs(
   return obligationAddress;
 }
 
+export function getObligationType(
+  kaminoMarket: KaminoMarket,
+  obligationTag: ObligationTypeTag,
+  mintAddress1: PublicKey = PublicKey.default,
+  mintAddress2: PublicKey = PublicKey.default
+): ObligationType {
+  switch (obligationTag) {
+    case VanillaObligation.tag: {
+      return new VanillaObligation(kaminoMarket.programId);
+    }
+    case MultiplyObligation.tag: {
+      return new MultiplyObligation(
+        mintAddress1,
+        mintAddress2,
+        kaminoMarket.programId
+      );
+    }
+    case LeverageObligation.tag: {
+      return new LeverageObligation(
+        mintAddress1,
+        mintAddress2,
+        kaminoMarket.programId
+      );
+    }
+    case LendingObligation.tag: {
+      return new LendingObligation(mintAddress1, kaminoMarket.programId);
+    }
+    default: {
+      throw new Error('Invalid obligation type');
+    }
+  }
+}
+
 export function getObligationTypeFromObligation(
   kaminoMarket: KaminoMarket,
   obligation: KaminoObligation
@@ -148,7 +189,6 @@ export function getObligationTypeFromObligation(
   switch (obligation.obligationTag) {
     case VanillaObligation.tag: {
       return new VanillaObligation(kaminoMarket.programId);
-      break;
     }
     case MultiplyObligation.tag: {
       return new MultiplyObligation(
@@ -156,7 +196,6 @@ export function getObligationTypeFromObligation(
         obligation.getBorrows()[0].mintAddress,
         kaminoMarket.programId
       );
-      break;
     }
     case LeverageObligation.tag: {
       return new LeverageObligation(
@@ -164,11 +203,9 @@ export function getObligationTypeFromObligation(
         obligation.getBorrows()[0].mintAddress,
         kaminoMarket.programId
       );
-      break;
     }
     case LendingObligation.tag: {
       return new LendingObligation(obligation.getDeposits()[0].mintAddress, kaminoMarket.programId);
-      break;
     }
     default: {
       throw new Error('Invalid obligation type');

package/src/utils/constants.ts

@@ -10,6 +10,8 @@ export const INITIAL_COLLATERAL_RATE = new Decimal(INITIAL_COLLATERAL_RATIO);
 
 export const SECONDS_PER_YEAR = 365.242_199 * 24.0 * 60.0 * 60.0;
 
+export const TOTAL_NUMBER_OF_IDS_TO_CHECK = 25;
+
 export type ENV = 'mainnet-beta' | 'devnet' | 'localnet';
 
 export function isENV(value: any): value is ENV {