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

package/src/utils/ObligationType.ts

@@ -11,6 +11,9 @@ export enum ObligationTypeTag {
   Multiply = 1,
   Lending = 2,
   Leverage = 3,
+  MultiplyFixedRate = 4,
+  LendingFixedRate = 5,
+  LeverageFixedRate = 6,
 }
 
 export type InitObligationArgsModel = {
@@ -76,6 +79,36 @@ export class MultiplyObligation {
   }
 }
 
+export class MultiplyObligationFixedRate {
+  readonly collReserveAddress: Address;
+  readonly debtReserveAddress: Address;
+  readonly programId: Address;
+  readonly id: number;
+  static tag = 4;
+
+  constructor(collReserveAddress: Address, debtReserveAddress: Address, programId: Address, id?: number) {
+    this.collReserveAddress = collReserveAddress;
+    this.debtReserveAddress = debtReserveAddress;
+    this.programId = programId;
+    this.id = id ?? 0;
+  }
+
+  toArgs() {
+    const initObligationArgs: InitObligationArgsModel = {
+      tag: MultiplyObligationFixedRate.tag,
+      id: this.id,
+      seed1: this.collReserveAddress,
+      seed2: this.debtReserveAddress,
+    };
+
+    return initObligationArgs;
+  }
+
+  toPda(market: Address, user: Address) {
+    return getObligationPdaWithArgs(market, user, this.toArgs(), this.programId);
+  }
+}
+
 export class LeverageObligation {
   readonly collToken: Address;
   readonly debtToken: Address;
@@ -106,6 +139,36 @@ export class LeverageObligation {
   }
 }
 
+export class LeverageObligationFixedRate {
+  readonly collReserveAddress: Address;
+  readonly debtReserveAddress: Address;
+  readonly programId: Address;
+  readonly id: number;
+  static tag = 6;
+
+  constructor(collReserveAddress: Address, debtReserveAddress: Address, programId: Address, id?: number) {
+    this.collReserveAddress = collReserveAddress;
+    this.debtReserveAddress = debtReserveAddress;
+    this.programId = programId;
+    this.id = id ?? 0;
+  }
+
+  toArgs() {
+    const initObligationArgs: InitObligationArgsModel = {
+      tag: LeverageObligationFixedRate.tag,
+      id: this.id,
+      seed1: this.collReserveAddress,
+      seed2: this.debtReserveAddress,
+    };
+
+    return initObligationArgs;
+  }
+
+  toPda(market: Address, user: Address) {
+    return getObligationPdaWithArgs(market, user, this.toArgs(), this.programId);
+  }
+}
+
 export class LendingObligation {
   readonly token: Address;
   readonly programId: Address;
@@ -121,7 +184,7 @@ export class LendingObligation {
   toArgs() {
     const initObligationArgs: InitObligationArgsModel = {
       tag: LendingObligation.tag,
-      id: 0,
+      id: this.id,
       seed1: this.token,
       seed2: this.token,
     };
@@ -134,6 +197,34 @@ export class LendingObligation {
   }
 }
 
+export class LendingObligationFixedRate {
+  readonly reserveAddress: Address;
+  readonly programId: Address;
+  readonly id: number;
+  static tag = 5;
+
+  constructor(reserveAddress: Address, programId: Address, id?: number) {
+    this.reserveAddress = reserveAddress;
+    this.programId = programId;
+    this.id = id ?? 0;
+  }
+
+  toArgs() {
+    const initObligationArgs: InitObligationArgsModel = {
+      tag: LendingObligationFixedRate.tag,
+      id: this.id,
+      seed1: this.reserveAddress,
+      seed2: this.reserveAddress,
+    };
+
+    return initObligationArgs;
+  }
+
+  toPda(market: Address, user: Address) {
+    return getObligationPdaWithArgs(market, user, this.toArgs(), this.programId);
+  }
+}
+
 export async function getObligationPdaWithArgs(
   market: Address,
   user: Address,

package/src/utils/api.ts

@@ -4,6 +4,7 @@ import { ConfigType, isEmptyObject } from '../classes';
 import { CDN_ENDPOINT, getApiEndpoint } from '../utils';
 import { IBackOffOptions, backOff } from 'exponential-backoff';
 import { PROGRAM_ID } from '../lib';
+import { Logger, LogLevel } from './Logger';
 
 export type ApiRequestOptions = {
   programId?: Address;
@@ -15,6 +16,17 @@ export type ApiFilterOptions = {
   isCurated?: boolean;
 };
 
+export type ApiLoggerOptions = {
+  logger?: Logger;
+  errorLevel?: LogLevel;
+};
+
+export type MarketsApiRequest = {
+  api?: ApiRequestOptions;
+  filter?: ApiFilterOptions;
+  log?: ApiLoggerOptions;
+};
+
 /**
  * Fetch config from the API
  * A good place to start to find active klend markets without expensive RPC calls
@@ -23,20 +35,29 @@ export type ApiFilterOptions = {
  * @param source - CDN is a json file hosted in the cloud, API is a webserver
  * @param apiBaseUrl - Optional base URL for the API, if not provided, defaults to the standard API endpoint, not used for CDN
  * @param filterOptions - Config options to filter markets by
+ * @param logger - pass a custom logger instance to log retries
+ * @param errorLevel - retry log level, NONE for no logs
  */
-export async function getMarketsFromApi(
-  { programId = PROGRAM_ID, source = 'CDN', apiBaseUrl }: ApiRequestOptions = {},
-  filterOptions: ApiFilterOptions = {}
-): Promise<ConfigType> {
+export async function getMarketsFromApi({
+  api: { programId = PROGRAM_ID, source = 'CDN', apiBaseUrl } = {},
+  filter: filterOptions = {},
+  log: { logger = console, errorLevel = LogLevel.WARN } = {},
+}: MarketsApiRequest = {}): Promise<ConfigType> {
   let unfilteredConfigs: ConfigType = {} as ConfigType;
   if (source === 'CDN') {
-    unfilteredConfigs = (await backOff(() => axios.get(`${CDN_ENDPOINT}/kamino_lend_config_v3.json`), KAMINO_CDN_RETRY))
-      .data[programId.toString()] as ConfigType;
+    unfilteredConfigs = (
+      await backOff(
+        () => axios.get(`${CDN_ENDPOINT}/kamino_lend_config_v3.json`),
+        getKaminoCdnRetry(logger, errorLevel)
+      )
+    ).data[programId.toString()] as ConfigType;
   }
 
   if (!unfilteredConfigs || isEmptyObject(unfilteredConfigs)) {
     const API_ENDPOINT = getApiEndpoint(programId, apiBaseUrl);
-    unfilteredConfigs = (await backOff(() => axios.get(API_ENDPOINT), KAMINO_API_RETRY)).data as ConfigType;
+    unfilteredConfigs = (
+      await backOff(() => axios.get(API_ENDPOINT), getKaminoApiRetry(logger, errorLevel, API_ENDPOINT))
+    ).data as ConfigType;
   }
 
   return unfilteredConfigs.filter((c) => {
@@ -47,30 +68,32 @@ export async function getMarketsFromApi(
   });
 }
 
-export const KAMINO_CDN_RETRY: Partial<IBackOffOptions> = {
-  maxDelay: 1000,
-  numOfAttempts: 3,
-  startingDelay: 10,
-  retry: (e: any, attemptNumber: number) => {
-    console.warn(e);
-    console.warn({
-      attemptNumber,
-      message: 'kamino CDN call failed, retrying with exponential backoff...',
-    });
-    return true;
-  },
-};
+function getKaminoCdnRetry(logger: Logger, errorLevel: LogLevel): Partial<IBackOffOptions> {
+  return {
+    maxDelay: 1000,
+    numOfAttempts: 3,
+    startingDelay: 10,
+    retry: (e: any, attemptNumber: number) => {
+      log(logger, errorLevel, `kamino CDN call #${attemptNumber} failed, retrying with exponential backoff...`, e);
+      return true;
+    },
+  };
+}
 
-export const KAMINO_API_RETRY: Partial<IBackOffOptions> = {
-  maxDelay: 1000,
-  numOfAttempts: 3,
-  startingDelay: 10,
-  retry: (e: any, attemptNumber: number) => {
-    console.warn(e);
-    console.warn({
-      attemptNumber,
-      message: 'api.kamino.finance call failed, retrying with exponential backoff...',
-    });
-    return true;
-  },
-};
+function getKaminoApiRetry(logger: Logger, errorLevel: LogLevel, apiUrl: string): Partial<IBackOffOptions> {
+  return {
+    maxDelay: 1000,
+    numOfAttempts: 3,
+    startingDelay: 10,
+    retry: (e: any, attemptNumber: number) => {
+      log(logger, errorLevel, `${apiUrl} call #${attemptNumber} failed, retrying with exponential backoff...`, e);
+      return true;
+    },
+  };
+}
+
+function log(logger: Logger, errorLevel: LogLevel, msg: string, ...meta: any[]): void {
+  if (errorLevel !== LogLevel.NONE) {
+    logger[errorLevel](msg, ...meta);
+  }
+}

package/src/utils/userMetadata.ts

@@ -25,6 +25,8 @@ import {
   UserMetadata,
   obligationFarmStatePda,
   DEFAULT_PUBLIC_KEY,
+  MultiplyObligationFixedRate,
+  LeverageObligationFixedRate,
 } from '../lib';
 import { KaminoReserve } from '../classes/reserve';
 import { Buffer } from 'buffer';
@@ -42,8 +44,8 @@ export const getUserLutAddressAndSetupIxs = async (
   user: TransactionSigner,
   referrer: Option<Address> = none(),
   withExtendLut: boolean = true,
-  multiplyMints: { coll: Address; debt: Address }[] = [],
-  leverageMints: { coll: Address; debt: Address }[] = [],
+  multiplyReserveAddresses: { coll: Address; debt: Address }[] = [],
+  leverageReserveAddresses: { coll: Address; debt: Address }[] = [],
   repayWithCollObligation: KaminoObligation | undefined = undefined,
   payer: TransactionSigner = user
 ): Promise<[Address, Instruction[][]]> => {
@@ -89,8 +91,8 @@ export const getUserLutAddressAndSetupIxs = async (
       userLookupTableAddress,
       user.address,
       referrer,
-      multiplyMints,
-      leverageMints,
+      multiplyReserveAddresses,
+      leverageReserveAddresses,
       userMetadataState !== null,
       repayWithCollObligation
     );
@@ -110,8 +112,8 @@ const getDedupUserLookupTableAddresses = async (
   tableAddress: Address,
   user: Address,
   referrer: Option<Address>,
-  multiplyMints: { coll: Address; debt: Address }[] = [],
-  leverageMints: { coll: Address; debt: Address }[] = [],
+  multiplyReserveAddresses: { coll: Address; debt: Address }[] = [],
+  leverageReserveAddresses: { coll: Address; debt: Address }[] = [],
   tableExists: boolean,
   repayWithCollObligation: KaminoObligation | undefined = undefined
 ): Promise<Address[]> => {
@@ -119,8 +121,8 @@ const getDedupUserLookupTableAddresses = async (
     kaminoMarket,
     user,
     referrer,
-    multiplyMints,
-    leverageMints,
+    multiplyReserveAddresses,
+    leverageReserveAddresses,
     repayWithCollObligation
   );
 
@@ -148,8 +150,8 @@ const getUserLookupTableAddresses = async (
   kaminoMarket: KaminoMarket,
   user: Address,
   referrer: Option<Address>,
-  multiplyMints: { coll: Address; debt: Address }[] = [],
-  leverageMints: { coll: Address; debt: Address }[] = [],
+  multiplyReserveAddresses: { coll: Address; debt: Address }[] = [],
+  leverageReserveAddresses: { coll: Address; debt: Address }[] = [],
   repayWithCollObligation: KaminoObligation | undefined = undefined
 ): Promise<{ address: Address; log: string }[]> => {
   const addresses: { address: Address; log: string }[] = [];
@@ -158,13 +160,22 @@ const getUserLookupTableAddresses = async (
   addresses.push({ address: userMetadataAddress, log: 'userMetadata address' });
 
   const allMints: Address[] = [];
-  multiplyMints.forEach(({ coll: collMint, debt: debtMint }) => {
-    allMints.push(collMint);
-    allMints.push(debtMint);
+  const allReserves: Address[] = [];
+  multiplyReserveAddresses.forEach(({ coll: collReserveAddress, debt: debtReserveAddress }) => {
+    const collReserveMint = kaminoMarket.getExistingReserveByAddress(collReserveAddress)!.getLiquidityMint();
+    const debtReserveMint = kaminoMarket.getExistingReserveByAddress(debtReserveAddress)!.getLiquidityMint();
+    allMints.push(collReserveMint);
+    allMints.push(debtReserveMint);
+    allReserves.push(collReserveAddress);
+    allReserves.push(debtReserveAddress);
   });
-  leverageMints.forEach(({ coll: collMint, debt: debtMint }) => {
-    allMints.push(collMint);
-    allMints.push(debtMint);
+  leverageReserveAddresses.forEach(({ coll: collReserveAddress, debt: debtReserveAddress }) => {
+    const collReserveMint = kaminoMarket.getExistingReserveByAddress(collReserveAddress)!.getLiquidityMint();
+    const debtReserveMint = kaminoMarket.getExistingReserveByAddress(debtReserveAddress)!.getLiquidityMint();
+    allMints.push(collReserveMint);
+    allMints.push(debtReserveMint);
+    allReserves.push(collReserveAddress);
+    allReserves.push(debtReserveAddress);
   });
 
   if (repayWithCollObligation) {
@@ -178,9 +189,10 @@ const getUserLookupTableAddresses = async (
   }
 
   const dedupMints = [...new Set(allMints)];
+  const dedupReserveAddresses = [...new Set(allReserves)];
   const reserves: KaminoReserve[] = [];
-  dedupMints.forEach((mint) => {
-    const kaminoReserve = kaminoMarket.getReserveByMint(mint);
+  dedupReserveAddresses.forEach((reserveAddress) => {
+    const kaminoReserve = kaminoMarket.getReserveByAddress(reserveAddress);
     if (kaminoReserve) {
       reserves.push(kaminoReserve);
     }
@@ -226,13 +238,13 @@ const getUserLookupTableAddresses = async (
   }
 
   const [multiplyObligations, multiplyObligationsFarmUserStates] =
-    await getMultiplyObligationAndObligationFarmStateAddresses(kaminoMarket, user, multiplyMints);
+    await getMultiplyObligationAndObligationFarmStateAddresses(kaminoMarket, user, multiplyReserveAddresses);
 
   addresses.push(...multiplyObligations);
   addresses.push(...multiplyObligationsFarmUserStates);
 
   const [leverageObligations, leverageObligationsFarmUserStates] =
-    await getLeverageObligationAndObligationFarmStateAddresses(kaminoMarket, user, leverageMints);
+    await getLeverageObligationAndObligationFarmStateAddresses(kaminoMarket, user, leverageReserveAddresses);
 
   addresses.push(...leverageObligations);
   addresses.push(...leverageObligationsFarmUserStates);
@@ -252,14 +264,16 @@ const getUserLookupTableAddresses = async (
 async function getMultiplyObligationAndObligationFarmStateAddresses(
   kaminoMarket: KaminoMarket,
   user: Address,
-  mints: { coll: Address; debt: Address }[]
+  reserveAddresses: { coll: Address; debt: Address }[]
 ): Promise<[{ address: Address; log: string }[], { address: Address; log: string }[]]> {
   const obligationPdas: { address: Address; log: string }[] = [];
   const farmUserStates: { address: Address; log: string }[] = [];
 
-  for (const { coll: collMint, debt: debtMint } of mints) {
-    const collReserve = kaminoMarket.getReserveByMint(collMint);
-    const debtReserve = kaminoMarket.getReserveByMint(debtMint);
+  for (const { coll: collReserveAddress, debt: debtReserveAddress } of reserveAddresses) {
+    const collReserve = kaminoMarket.getReserveByAddress(collReserveAddress);
+    const debtReserve = kaminoMarket.getReserveByAddress(debtReserveAddress);
+    const collMint = collReserve!.getLiquidityMint();
+    const debtMint = debtReserve!.getLiquidityMint();
     const collMintString = collMint.toString();
     const debtMintString = debtMint.toString();
     if (collReserve && debtReserve) {
@@ -268,6 +282,15 @@ async function getMultiplyObligationAndObligationFarmStateAddresses(
         address: await multiplyObligation.toPda(kaminoMarket.getAddress(), user),
         log: 'multiply obligation coll: ' + collMintString + ' debt: ' + debtMintString,
       });
+      const multiplyObligationFixedRate = new MultiplyObligationFixedRate(
+        collReserveAddress,
+        debtReserveAddress,
+        kaminoMarket.programId
+      );
+      obligationPdas.push({
+        address: await multiplyObligationFixedRate.toPda(kaminoMarket.getAddress(), user),
+        log: 'multiply obligation fixed rate coll: ' + collReserveAddress + ' debt: ' + debtReserveAddress,
+      });
       if (collReserve.state.farmCollateral !== DEFAULT_PUBLIC_KEY) {
         farmUserStates.push({
           address: await obligationFarmStatePda(
@@ -295,14 +318,16 @@ async function getMultiplyObligationAndObligationFarmStateAddresses(
 async function getLeverageObligationAndObligationFarmStateAddresses(
   kaminoMarket: KaminoMarket,
   user: Address,
-  mints: { coll: Address; debt: Address }[]
+  reserveAddresses: { coll: Address; debt: Address }[]
 ): Promise<[{ address: Address; log: string }[], { address: Address; log: string }[]]> {
   const obligationPdas: { address: Address; log: string }[] = [];
   const farmUserStates: { address: Address; log: string }[] = [];
 
-  for (const { coll: collMint, debt: debtMint } of mints) {
-    const collReserve = kaminoMarket.getReserveByMint(collMint);
-    const debtReserve = kaminoMarket.getReserveByMint(debtMint);
+  for (const { coll: collReserveAddress, debt: debtReserveAddress } of reserveAddresses) {
+    const collReserve = kaminoMarket.getReserveByAddress(collReserveAddress);
+    const debtReserve = kaminoMarket.getReserveByAddress(debtReserveAddress);
+    const collMint = collReserve!.getLiquidityMint();
+    const debtMint = debtReserve!.getLiquidityMint();
     const collMintString = collMint.toString();
     const debtMintString = debtMint.toString();
     if (collReserve && debtReserve) {
@@ -311,6 +336,15 @@ async function getLeverageObligationAndObligationFarmStateAddresses(
         address: await leverageObligation.toPda(kaminoMarket.getAddress(), user),
         log: 'leverage obligation coll: ' + collMintString + ' debt: ' + debtMintString,
       });
+      const leverageObligationFixedRate = new LeverageObligationFixedRate(
+        collReserveAddress,
+        debtReserveAddress,
+        kaminoMarket.programId
+      );
+      obligationPdas.push({
+        address: await leverageObligationFixedRate.toPda(kaminoMarket.getAddress(), user),
+        log: 'leverage obligation fixed rate coll: ' + collReserveAddress + ' debt: ' + debtReserveAddress,
+      });
       if (collReserve.state.farmCollateral !== DEFAULT_PUBLIC_KEY) {
         farmUserStates.push({
           address: await obligationFarmStatePda(
@@ -343,7 +377,7 @@ async function getRepayWithCollObligationFarmStateAddresses(
   const obligationString = obligation.obligationAddress.toString();
 
   for (const borrow of obligation.getBorrows()) {
-    const borrowReserve = kaminoMarket.getReserveByMint(borrow.mintAddress)!;
+    const borrowReserve = kaminoMarket.getReserveByAddress(borrow.reserveAddress)!;
     if (borrowReserve.state.farmDebt !== DEFAULT_PUBLIC_KEY) {
       farmUserStates.push({
         address: await obligationFarmStatePda(borrowReserve.state.farmDebt!, obligation.obligationAddress),
@@ -353,7 +387,7 @@ async function getRepayWithCollObligationFarmStateAddresses(
   }
 
   for (const deposit of obligation.getDeposits()) {
-    const depositReserve = kaminoMarket.getReserveByMint(deposit.mintAddress)!;
+    const depositReserve = kaminoMarket.getReserveByAddress(deposit.reserveAddress)!;
     if (depositReserve.state.farmCollateral !== DEFAULT_PUBLIC_KEY) {
       farmUserStates.push({
         address: await obligationFarmStatePda(depositReserve.state.farmCollateral!, obligation.obligationAddress),

package/src/utils/validations.ts

@@ -14,6 +14,11 @@ export function checkNotNull<T>(value: T | null, message: string = 'value null')
   return value as T;
 }
 
+export function checkArrayNotEmpty<T>(array: T[], message: string = 'array is empty'): T[] {
+  checkThat(array.length > 0, message);
+  return array;
+}
+
 export function getSingleElement<T>(iterable: Iterable<T>, nameWithinMessage: string = 'element'): T {
   const nothingReturnedMarker = {};
   let single: T | {} = nothingReturnedMarker;