@kamino-finance/klend-sdk 3.2.26 → 4.0.0

package/src/referrals/operations.ts

@@ -0,0 +1,325 @@
+import { Connection, Keypair, PublicKey } from '@solana/web3.js';
+import { KaminoMarket } from '../classes';
+import {
+  PublicKeyMap,
+  buildAndSendTxnWithLogs,
+  buildVersionedTransaction,
+  referrerStatePda,
+  shortUrlPda,
+} from '../utils';
+import {
+  getDeleteReferrerStateAndShortUrlIxns,
+  getInitAllReferrerTokenStateIxns,
+  getInitReferrerStateAndShortUrlIxns,
+} from './instructions';
+import { PROGRAM_ID, UserMetadata, ReferrerState, ShortUrl } from '../lib';
+import Decimal from 'decimal.js';
+
+/**
+ * Initialize all referrer token states for a given referrer
+ * @param referrer
+ * @param kaminoMarket
+ */
+export const initAllReferrerTokenStates = async ({
+  referrer,
+  kaminoMarket,
+}: {
+  referrer: Keypair;
+  kaminoMarket: KaminoMarket;
+}) => {
+  const ixns = await getInitAllReferrerTokenStateIxns({ referrer: referrer.publicKey, kaminoMarket });
+
+  const tx = await buildVersionedTransaction(kaminoMarket.getConnection(), referrer.publicKey, ixns);
+
+  console.log('Init Referral Token States');
+
+  return await buildAndSendTxnWithLogs(kaminoMarket.getConnection(), tx, referrer, [referrer]);
+};
+
+/**
+ * Initialize referrer state and short url
+ * @param connection
+ * @param referrer
+ * @param shortUrl
+ */
+export const createReferrerStateAndShortUrl = async ({
+  connection,
+  referrer,
+  shortUrl,
+  programId = PROGRAM_ID,
+}: {
+  connection: Connection;
+  referrer: Keypair;
+  shortUrl: string;
+  programId?: PublicKey;
+}) => {
+  const ixn = getInitReferrerStateAndShortUrlIxns({ referrer: referrer.publicKey, shortUrl, programId });
+
+  const tx = await buildVersionedTransaction(connection, referrer.publicKey, [ixn]);
+
+  console.log('Init ReferrerState for referrer ' + referrer.publicKey.toBase58() + ' and shortUrl ' + shortUrl);
+
+  return await buildAndSendTxnWithLogs(connection, tx, referrer, [referrer]);
+};
+
+/**
+ * Initialize referrer state and short url
+ * @param connection
+ * @param referrer
+ * @param newShortUrl
+ */
+export const updateReferrerStateAndShortUrl = async ({
+  connection,
+  referrer,
+  newShortUrl,
+  programId = PROGRAM_ID,
+}: {
+  connection: Connection;
+  referrer: Keypair;
+  newShortUrl: string;
+  programId?: PublicKey;
+}) => {
+  const deleteIxn = await getDeleteReferrerStateAndShortUrlIxns({
+    referrer: referrer.publicKey,
+    connection,
+    programId,
+  });
+
+  const initIxn = getInitReferrerStateAndShortUrlIxns({
+    referrer: referrer.publicKey,
+    shortUrl: newShortUrl,
+    programId,
+  });
+
+  const tx = await buildVersionedTransaction(connection, referrer.publicKey, [deleteIxn, initIxn]);
+
+  console.log('Update ReferrerState for referrer ' + referrer.publicKey.toBase58() + ' and shortUrl ' + newShortUrl);
+
+  return await buildAndSendTxnWithLogs(connection, tx, referrer, [referrer]);
+};
+
+/**
+ * Check if short URL available - also checks if short URL is valid (ascii-alphanumeric plus '_' '-', max 32 chars)
+ * @param connection
+ * @param shortUrl
+ * @param programId
+ */
+export async function isShortUrlAvailable(
+  connection: Connection,
+  shortUrl: string,
+  programId: PublicKey = PROGRAM_ID
+): Promise<boolean> {
+  if (shortUrl.length > 32) {
+    return false;
+  }
+
+  if (!/^[a-zA-Z0-9-_]+$/.test(shortUrl)) {
+    return false;
+  }
+
+  const [shortUrlAddress] = shortUrlPda(shortUrl, programId);
+  const info = await connection.getAccountInfo(shortUrlAddress);
+  return info === null;
+}
+
+/**
+ * Get referrer short URL address and shortUrl
+ * @param connection
+ * @param referrer
+ * @param programId
+ */
+export async function getReferrerShortUrl(
+  connection: Connection,
+  referrer: PublicKey,
+  programId: PublicKey = PROGRAM_ID
+): Promise<[PublicKey | null, string | null]> {
+  const [referrerStateAddress] = referrerStatePda(referrer, programId);
+  const referrerState = await ReferrerState.fetch(connection, referrerStateAddress, programId);
+  const shortUrlState = await ShortUrl.fetch(connection, referrerState!.shortUrl, programId);
+  const shortUrlAddress = referrerState ? referrerState.shortUrl : null;
+  const shortUrl = shortUrlState ? shortUrlState.shortUrl : null;
+  return [shortUrlAddress, shortUrl];
+}
+
+/**
+ * Get referrer for a given Short URL
+ * @param connection
+ * @param shortUrl
+ * @param programId
+ */
+export async function getReferrerForShortUrl(
+  connection: Connection,
+  shortUrl: string,
+  programId: PublicKey = PROGRAM_ID
+): Promise<PublicKey> {
+  const [shortUrlAddress] = shortUrlPda(shortUrl, programId);
+  const shortUrlState = await ShortUrl.fetch(connection, shortUrlAddress, programId);
+  return shortUrlState!.referrer;
+}
+
+/**
+ * Get referrer all UserMetadata user accounts linked to a given referrer
+ * @param connection
+ * @param referrer
+ * @param programId
+ */
+export async function getUserMetadatasByReferrer(
+  connection: Connection,
+  referrer: PublicKey,
+  programId: PublicKey = PROGRAM_ID
+): Promise<UserMetadata[]> {
+  const userMetadatas = await connection.getProgramAccounts(programId, {
+    filters: [
+      {
+        dataSize: UserMetadata.layout.span + 8,
+      },
+      {
+        memcmp: {
+          offset: 8,
+          bytes: referrer.toBase58(),
+        },
+      },
+    ],
+  });
+
+  return userMetadatas.map((userMetadata) => {
+    if (userMetadata.account === null) {
+      throw new Error('Invalid account');
+    }
+    if (!userMetadata.account.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program");
+    }
+
+    const userMetadataAccount = UserMetadata.decode(userMetadata.account.data);
+
+    if (!userMetadataAccount) {
+      throw Error('Could not parse obligation.');
+    }
+
+    return userMetadataAccount;
+  });
+}
+
+/**
+ * Get referrer all UserMetadata user accounts
+ * @param connection
+ * @param referrer
+ * @param programId
+ */
+export async function getAllUserMetadatas(
+  connection: Connection,
+  programId: PublicKey = PROGRAM_ID
+): Promise<UserMetadata[]> {
+  const userMetadatas = await connection.getProgramAccounts(programId, {
+    filters: [
+      {
+        dataSize: UserMetadata.layout.span + 8,
+      },
+    ],
+  });
+
+  return userMetadatas.map((userMetadata) => {
+    if (userMetadata.account === null) {
+      throw new Error('Invalid account');
+    }
+    if (!userMetadata.account.owner.equals(programId)) {
+      throw new Error("account doesn't belong to this program");
+    }
+
+    const userMetadataAccount = UserMetadata.decode(userMetadata.account.data);
+
+    if (!userMetadataAccount) {
+      throw Error('Could not parse obligation.');
+    }
+
+    return userMetadataAccount;
+  });
+}
+
+/**
+ * Get referrer all UserMetadata user accounts linked to a given referrer
+ * @param connection
+ * @param referrer
+ * @param programId
+ */
+export async function getTotalUsersReferred(
+  connection: Connection,
+  referrer: PublicKey,
+  programId: PublicKey = PROGRAM_ID
+): Promise<number> {
+  const userMetadatas = await getUserMetadatasByReferrer(connection, referrer, programId);
+  return userMetadatas.length;
+}
+
+export type ReferralRank = {
+  referrer: PublicKey;
+  totalUsersReferred: number;
+  totalEarningsUsd: Decimal;
+};
+
+/**
+ * Get ReferralRank array of all referrers ordered by how much they've earned in USD
+ * @param connection
+ * @param kaminoMarket
+ */
+export async function getReferralsRanking(connection: Connection, kaminoMarket: KaminoMarket): Promise<ReferralRank[]> {
+  const referrersUsersReferred = new PublicKeyMap<PublicKey, number>();
+
+  // counting users referred for each referrer
+  const userMetadatas = await getAllUserMetadatas(connection, kaminoMarket.programId);
+  for (const userMetadata of userMetadatas) {
+    const referrer = userMetadata.referrer;
+    const usersReferred = referrersUsersReferred.get(referrer);
+    if (usersReferred) {
+      referrersUsersReferred.set(referrer, usersReferred + 1);
+    } else {
+      referrersUsersReferred.set(referrer, 1);
+    }
+  }
+
+  const referralsRankArray: ReferralRank[] = [];
+
+  for (const referrer of referrersUsersReferred.keys()) {
+    const referrerTokenStates = await kaminoMarket.getAllReferrerFeesCumulative(referrer);
+    let totalEarningsUsd = new Decimal(0);
+    // calculating earnings for each referrer
+    for (const reserve of kaminoMarket.reserves.values()) {
+      totalEarningsUsd = totalEarningsUsd.add(
+        referrerTokenStates.get(reserve.getLiquidityMint())!.mul(reserve.getOracleMarketPrice())
+      );
+    }
+
+    referralsRankArray.push({
+      referrer: new PublicKey(referrer),
+      totalUsersReferred: referrersUsersReferred.get(referrer)!,
+      totalEarningsUsd: totalEarningsUsd,
+    });
+  }
+
+  referralsRankArray.sort((a, b) => {
+    return b.totalEarningsUsd.comparedTo(a.totalEarningsUsd);
+  });
+
+  return referralsRankArray;
+}
+
+/**
+ * Get ReferralRank array of all referrers ordered by how much they've earned in USD
+ * @param connection
+ * @param user
+ * @param kaminoMarket
+ */
+export async function getUserReferralRanking(
+  connection: Connection,
+  user: PublicKey,
+  kaminoMarket: KaminoMarket
+): Promise<number | undefined> {
+  const referralsRanking = await getReferralsRanking(connection, kaminoMarket);
+
+  for (let index = 0; index < referralsRanking.length; index++) {
+    if (user.equals(referralsRanking[index].referrer)) {
+      return index + 1;
+    }
+  }
+  return undefined;
+}

package/src/utils/ObligationType.ts

@@ -0,0 +1,171 @@
+import { PublicKey } from '@solana/web3.js';
+import { KaminoMarket, KaminoObligation } from '../classes';
+
+export type ObligationType = VanillaObligation | MultiplyObligation | LendingObligation;
+
+export enum ObligationTypeTag {
+  Vanilla = 0,
+  Multiply = 1,
+  Lending = 2,
+  Leverage = 3,
+}
+
+export type InitObligationArgsModel = {
+  tag: number;
+  id: number;
+  seed1: PublicKey;
+  seed2: PublicKey;
+};
+
+export class VanillaObligation {
+  readonly programId: PublicKey;
+  static tag = 0;
+
+  constructor(programId: PublicKey) {
+    this.programId = programId;
+  }
+  toArgs() {
+    const initObligationArgs: InitObligationArgsModel = {
+      tag: VanillaObligation.tag,
+      id: 0,
+      seed1: PublicKey.default,
+      seed2: PublicKey.default,
+    };
+
+    return initObligationArgs;
+  }
+  toPda(market: PublicKey, user: PublicKey) {
+    return getObligationPdaWithArgs(market, user, this.toArgs(), this.programId);
+  }
+}
+
+export class MultiplyObligation {
+  readonly collToken: PublicKey;
+  readonly debtToken: PublicKey;
+  readonly programId: PublicKey;
+  static tag = 1;
+
+  constructor(collToken: PublicKey, debtToken: PublicKey, programId: PublicKey) {
+    this.collToken = collToken;
+    this.debtToken = debtToken;
+    this.programId = programId;
+  }
+
+  toArgs() {
+    const initObligationArgs: InitObligationArgsModel = {
+      tag: MultiplyObligation.tag,
+      id: 0,
+      seed1: this.collToken,
+      seed2: this.debtToken,
+    };
+
+    return initObligationArgs;
+  }
+  toPda(market: PublicKey, user: PublicKey) {
+    return getObligationPdaWithArgs(market, user, this.toArgs(), this.programId);
+  }
+}
+
+export class LeverageObligation {
+  readonly collToken: PublicKey;
+  readonly debtToken: PublicKey;
+  readonly programId: PublicKey;
+  static tag = 3;
+
+  constructor(collToken: PublicKey, debtToken: PublicKey, programId: PublicKey) {
+    this.collToken = collToken;
+    this.debtToken = debtToken;
+    this.programId = programId;
+  }
+
+  toArgs() {
+    const initObligationArgs: InitObligationArgsModel = {
+      tag: LeverageObligation.tag,
+      id: 0,
+      seed1: this.collToken,
+      seed2: this.debtToken,
+    };
+
+    return initObligationArgs;
+  }
+  toPda(market: PublicKey, user: PublicKey) {
+    return getObligationPdaWithArgs(market, user, this.toArgs(), this.programId);
+  }
+}
+
+export class LendingObligation {
+  readonly token: PublicKey;
+  readonly programId: PublicKey;
+  static tag = 2;
+
+  constructor(token: PublicKey, programId: PublicKey) {
+    this.token = token;
+    this.programId = programId;
+  }
+  toArgs() {
+    const initObligationArgs: InitObligationArgsModel = {
+      tag: LendingObligation.tag,
+      id: 0,
+      seed1: this.token,
+      seed2: this.token,
+    };
+
+    return initObligationArgs;
+  }
+  toPda(market: PublicKey, user: PublicKey) {
+    return getObligationPdaWithArgs(market, user, this.toArgs(), this.programId);
+  }
+}
+
+function getObligationPdaWithArgs(
+  market: PublicKey,
+  user: PublicKey,
+  args: InitObligationArgsModel,
+  programId: PublicKey
+) {
+  const seed = [
+    Buffer.from([args.tag]),
+    Buffer.from([args.id]),
+    user.toBuffer(),
+    market.toBuffer(),
+    args.seed1.toBuffer(),
+    args.seed2.toBuffer(),
+  ];
+  const [obligationAddress, _obligationAddressBump] = PublicKey.findProgramAddressSync(seed, programId);
+  return obligationAddress;
+}
+
+export function getObligationTypeFromObligation(
+  kaminoMarket: KaminoMarket,
+  obligation: KaminoObligation
+): ObligationType {
+  switch (obligation.obligationTag) {
+    case VanillaObligation.tag: {
+      return new VanillaObligation(kaminoMarket.programId);
+      break;
+    }
+    case MultiplyObligation.tag: {
+      return new MultiplyObligation(
+        obligation.getDeposits()[0].mintAddress,
+        obligation.getBorrows()[0].mintAddress,
+        kaminoMarket.programId
+      );
+      break;
+    }
+    case LeverageObligation.tag: {
+      return new LeverageObligation(
+        obligation.getDeposits()[0].mintAddress,
+        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/api.ts

@@ -0,0 +1,59 @@
+import { PublicKey } from '@solana/web3.js';
+import axios from 'axios';
+import { ConfigType, isEmptyObject } from '../classes';
+import { CDN_ENDPOINT, getApiEndpoint } from '../utils';
+import { IBackOffOptions, backOff } from 'exponential-backoff';
+import { PROGRAM_ID } from '../lib';
+
+/**
+ * Fetch config from the API
+ * A good place to start to find active klend markets without expensive RPC calls
+ *
+ * @param programId - The program id to retrieve config for
+ * @param source - CDN is a json file hosted in the cloud, API is a webserver
+ */
+export async function getMarketsFromApi(
+  programId: PublicKey = PROGRAM_ID,
+  source: 'API' | 'CDN' = 'CDN'
+): Promise<ConfigType> {
+  let configs: ConfigType = {} as ConfigType;
+
+  if (source === 'CDN') {
+    configs = (await backOff(() => axios.get(CDN_ENDPOINT), KAMINO_CDN_RETRY)).data[programId.toString()] as ConfigType;
+  }
+
+  if (!configs || isEmptyObject(configs)) {
+    const API_ENDPOINT = getApiEndpoint(programId);
+    configs = (await backOff(() => axios.get(API_ENDPOINT), KAMINO_API_RETRY)).data as ConfigType;
+  }
+
+  return configs;
+}
+
+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;
+  },
+};
+
+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;
+  },
+};