@kamino-finance/klend-sdk 3.2.26 → 4.0.1

package/src/utils/seeds.ts

@@ -0,0 +1,183 @@
+import { PublicKey } from '@solana/web3.js';
+import { PROGRAM_ID } from '../idl_codegen/programId';
+
+/**
+ * Lending market authority seed
+ */
+export const LENDING_MARKET_AUTH_SEED = 'lma';
+/**
+ * Reserve liquidity supply seed
+ */
+export const RESERVE_LIQ_SUPPLY_SEED = 'reserve_liq_supply';
+/**
+ * Reserve fee vault seed
+ */
+export const FEE_RECEIVER_SEED = 'fee_receiver';
+/**
+ * Reserve collateral mint seed
+ */
+export const RESERVE_COLL_MINT_SEED = 'reserve_coll_mint';
+/**
+ * Reserve collateral supply seed
+ */
+export const RESERVE_COLL_SUPPLY_SEED = 'reserve_coll_supply';
+/**
+ * User metadata seed
+ */
+export const BASE_SEED_USER_METADATA = 'user_meta';
+/**
+ * Referrer token state seed
+ */
+export const BASE_SEED_REFERRER_TOKEN_STATE = 'referrer_acc';
+/**
+ * Referrer state seed
+ */
+export const BASE_SEED_REFERRER_STATE = 'ref_state';
+/**
+ * Short url seed
+ */
+export const BASE_SEED_SHORT_URL = 'short_url';
+
+/**
+ * Encapsulates all the PDAs for a given reserve
+ */
+export interface ReservePdas {
+  liquiditySupplyVault: PublicKey;
+  collateralMint: PublicKey;
+  collateralSupplyVault: PublicKey;
+  feeVault: PublicKey;
+}
+
+/**
+ * Returns all the PDAs for the given reserve
+ * @param programId
+ * @param market
+ * @param mint
+ * @returns ReservePdas
+ */
+export function reservePdas(programId: PublicKey, market: PublicKey, mint: PublicKey): ReservePdas {
+  return {
+    liquiditySupplyVault: reserveLiqSupplyPda(market, mint, programId)[0],
+    collateralMint: reserveCollateralMintPda(market, mint, programId)[0],
+    collateralSupplyVault: reserveCollateralSupplyPda(market, mint, programId)[0],
+    feeVault: reserveFeeVaultPda(market, mint, programId)[0],
+  };
+}
+
+/**
+ * Returns the PDA and bump for the lending market authority
+ * @param lendingMarket
+ * @param programId
+ * @returns [authority, bump]
+ */
+export function lendingMarketAuthPda(lendingMarket: PublicKey, programId: PublicKey = PROGRAM_ID) {
+  return PublicKey.findProgramAddressSync([Buffer.from(LENDING_MARKET_AUTH_SEED), lendingMarket.toBuffer()], programId);
+}
+
+/**
+ * Returns the PDA and bump for the reserve liquidity supply
+ * @param lendingMarket
+ * @param mint
+ * @param programId
+ * @returns [pda, bump]
+ */
+export function reserveLiqSupplyPda(lendingMarket: PublicKey, mint: PublicKey, programId: PublicKey = PROGRAM_ID) {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(RESERVE_LIQ_SUPPLY_SEED), lendingMarket.toBuffer(), mint.toBuffer()],
+    programId
+  );
+}
+
+/**
+ * Returns the PDA and bump for the reserve fee vault
+ * @param lendingMarket
+ * @param mint
+ * @param programId
+ * @returns [vaultPda, bump]
+ */
+export function reserveFeeVaultPda(lendingMarket: PublicKey, mint: PublicKey, programId: PublicKey = PROGRAM_ID) {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(FEE_RECEIVER_SEED), lendingMarket.toBuffer(), mint.toBuffer()],
+    programId
+  );
+}
+
+/**
+ * Returns the PDA and bump for the reserve collateral mint
+ * @param lendingMarket
+ * @param mint
+ * @param programId
+ * @returns [mintPda, bump]
+ */
+export function reserveCollateralMintPda(lendingMarket: PublicKey, mint: PublicKey, programId: PublicKey = PROGRAM_ID) {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(RESERVE_COLL_MINT_SEED), lendingMarket.toBuffer(), mint.toBuffer()],
+    programId
+  );
+}
+
+/**
+ * Returns the PDA and bump for the reserve collateral supply
+ * @param lendingMarket
+ * @param mint
+ * @param programId
+ * @returns [pda, bump]
+ */
+export function reserveCollateralSupplyPda(
+  lendingMarket: PublicKey,
+  mint: PublicKey,
+  programId: PublicKey = PROGRAM_ID
+) {
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(RESERVE_COLL_SUPPLY_SEED), lendingMarket.toBuffer(), mint.toBuffer()],
+    programId
+  );
+}
+
+/**
+ * Returns the PDA and bump for the user metadata state
+ * @param user
+ * @param programId
+ * @returns [pda, bump]
+ */
+export function userMetadataPda(user: PublicKey, programId: PublicKey = PROGRAM_ID) {
+  return PublicKey.findProgramAddressSync([Buffer.from(BASE_SEED_USER_METADATA), user.toBuffer()], programId);
+}
+
+/**
+ * Returns the PDA and bump for the referrer account for a mint
+ * @param referrer
+ * @param mint
+ * @param programId
+ * @returns [pda, bump]
+ */
+export function referrerTokenStatePda(referrer: PublicKey, reserve: PublicKey, programId: PublicKey = PROGRAM_ID) {
+  if (referrer.equals(PublicKey.default)) {
+    return [programId];
+  }
+
+  return PublicKey.findProgramAddressSync(
+    [Buffer.from(BASE_SEED_REFERRER_TOKEN_STATE), referrer.toBuffer(), reserve.toBuffer()],
+    programId
+  );
+}
+
+/**
+ * Returns the PDA and bump for the referrer state
+ * @param referrer
+ * @param programId
+ * @returns [pda, bump]
+ */
+export function referrerStatePda(referrer: PublicKey, programId: PublicKey = PROGRAM_ID) {
+  return PublicKey.findProgramAddressSync([Buffer.from(BASE_SEED_REFERRER_STATE), referrer.toBuffer()], programId);
+}
+
+/**
+ * Returns the PDA and bump for the short url
+ * @param shortUrl
+ * @param programId
+ * @returns [pda, bump]
+ */
+export function shortUrlPda(shortUrl: string, programId: PublicKey = PROGRAM_ID) {
+  return PublicKey.findProgramAddressSync([Buffer.from(BASE_SEED_SHORT_URL), Buffer.from(shortUrl)], programId);
+}

package/src/utils/sendTransactionsUtils.ts

@@ -0,0 +1,207 @@
+import { Commitment, Connection, SendOptions, Signer, Transaction, VersionedTransaction } from '@solana/web3.js';
+import bs58 from 'bs58';
+import { ENV } from '../lib';
+
+export type Chain = {
+  name: ENV;
+  displayName: string;
+  endpoint: string;
+  chainID: number;
+  wsEndpoint?: string;
+};
+
+export class Web3Client {
+  private readonly _connection: Connection;
+
+  private readonly _sendConnection: Connection;
+
+  private readonly _sendConnectionsExtra: Connection[];
+
+  private readonly _endpoint: string;
+
+  private readonly _env: ENV;
+
+  private readonly _chain: Chain;
+
+  constructor(endpoint: Chain | string) {
+    let chain: Chain | undefined;
+    if (typeof endpoint === 'string') {
+      if (chain === undefined) {
+        throw Error(`Invalid environment - ${endpoint}`);
+      }
+    } else {
+      chain = endpoint;
+    }
+
+    this._chain = chain;
+    this._endpoint = chain.endpoint;
+    this._env = chain.name;
+    // use this connection to get data
+    this._connection = new Connection(this._endpoint, {
+      commitment: 'recent',
+      wsEndpoint: chain.wsEndpoint,
+      confirmTransactionInitialTimeout: 120 * 1000,
+    });
+
+    // use this one to submit transactions
+    this._sendConnection = new Connection(this._endpoint, {
+      commitment: 'confirmed',
+      wsEndpoint: chain.wsEndpoint,
+      confirmTransactionInitialTimeout: 120 * 1000,
+    });
+
+    this._sendConnectionsExtra = [this._sendConnection];
+  }
+
+  get endpoint(): string {
+    return this._endpoint;
+  }
+
+  get chain(): Chain {
+    return this._chain;
+  }
+
+  get env(): ENV {
+    return this._env;
+  }
+
+  get connection(): Connection {
+    return this._connection;
+  }
+
+  get sendConnection(): Connection {
+    return this._sendConnection;
+  }
+
+  get sendConnectionsExtra(): Connection[] {
+    return this._sendConnectionsExtra;
+  }
+}
+
+export async function signSendAndConfirmRawTransactionWithRetry({
+  mainConnection,
+  extraConnections = [],
+  tx,
+  signers,
+  commitment = 'confirmed',
+  sendTransactionOptions,
+}: {
+  mainConnection: Connection;
+  extraConnections?: Connection[];
+  tx: VersionedTransaction;
+  signers: Array<Signer>;
+  commitment?: Commitment;
+  sendTransactionOptions?: SendOptions;
+}) {
+  tx.sign(signers);
+  return sendAndConfirmRawTransactionWithRetry({
+    mainConnection,
+    extraConnections,
+    tx,
+    commitment,
+    sendTransactionOptions,
+  });
+}
+
+export async function sendAndConfirmRawTransactionWithRetry({
+  mainConnection,
+  extraConnections = [],
+  tx,
+  commitment = 'confirmed',
+  sendTransactionOptions,
+}: {
+  mainConnection: Connection;
+  extraConnections?: Connection[];
+  tx: Transaction | VersionedTransaction;
+  commitment?: Commitment;
+  sendTransactionOptions?: SendOptions;
+}) {
+  const signature = isVersionedTransaction(tx) ? bs58.encode(tx.signatures[0]) : tx.signatures?.toString();
+  console.log('Signature attempted: ', signature);
+  let confirmed = false;
+  const serialized = Buffer.from(tx.serialize());
+  const latestBlockHashAndContext = await mainConnection.getLatestBlockhashAndContext(commitment);
+  const defaultOptions: SendOptions = {
+    skipPreflight: true,
+    maxRetries: 0,
+    preflightCommitment: commitment,
+  };
+
+  if (!signature) {
+    throw new Error('Transaction is not signed. Refresh the page and try again');
+  }
+
+  // Listen for transaction confirmation
+  const waitForConfirmation = async (sig: string) => {
+    try {
+      const res = await mainConnection.confirmTransaction(
+        {
+          blockhash: latestBlockHashAndContext.value.blockhash,
+          lastValidBlockHeight: latestBlockHashAndContext.value.lastValidBlockHeight,
+          minContextSlot: latestBlockHashAndContext.context.slot,
+          signature: sig,
+        },
+        commitment
+      );
+      confirmed = true;
+
+      return res;
+    } catch (error) {
+      console.log(error);
+      return null;
+    }
+  };
+
+  // Send transaction and set interval to resend every X seconds
+  const sendTransaction = () => {
+    if (confirmed) {
+      return;
+    }
+    try {
+      mainConnection.sendRawTransaction(serialized, {
+        ...defaultOptions,
+        ...sendTransactionOptions,
+        minContextSlot: latestBlockHashAndContext.context.slot,
+      });
+
+      extraConnections.forEach((conn) => {
+        conn.sendRawTransaction(serialized, {
+          ...defaultOptions,
+          ...sendTransactionOptions,
+          minContextSlot: latestBlockHashAndContext.context.slot,
+        });
+      });
+    } catch (error) {
+      console.log(error);
+    }
+  };
+
+  sendTransaction();
+  const res = await waitForConfirmation(signature);
+
+  if (res && res.value && res.value.err) {
+    const txDetails = await mainConnection.getTransaction(signature, {
+      maxSupportedTransactionVersion: 0,
+      commitment: 'confirmed',
+    });
+    if (txDetails) {
+      // eslint-disable-next-line @typescript-eslint/no-throw-literal
+      throw {
+        err: txDetails.meta?.err,
+        logs: txDetails.meta?.logMessages || [],
+        signature,
+        tx,
+      };
+    }
+    // eslint-disable-next-line @typescript-eslint/no-throw-literal
+    throw { err: res.value.err, msg: res.value.err, signature, tx };
+  }
+
+  return signature;
+}
+
+export function isVersionedTransaction(
+  transaction: Transaction | VersionedTransaction
+): transaction is VersionedTransaction {
+  return 'version' in transaction;
+}

package/src/utils/slots.ts

@@ -0,0 +1,28 @@
+import { SLOTS_PER_DAY, SLOTS_PER_HOUR, SLOTS_PER_SECOND } from './constants';
+
+/**
+ * Convert slots to seconds
+ * @param slots
+ * @return seconds
+ */
+export function toSeconds(slots: number): number {
+  return Math.trunc(slots / SLOTS_PER_SECOND);
+}
+
+/**
+ * Convert slots to hours
+ * @param slots
+ * @return hours
+ */
+export function toHours(slots: number): number {
+  return Math.trunc(slots / SLOTS_PER_HOUR);
+}
+
+/**
+ * Convert slots to days
+ * @param slots
+ * @return days
+ */
+export function toDays(slots: number): number {
+  return Math.trunc(slots / SLOTS_PER_DAY);
+}

package/src/utils/syncNative.ts

@@ -0,0 +1,22 @@
+import * as BufferLayout from 'buffer-layout';
+import { PublicKey, TransactionInstruction } from '@solana/web3.js';
+import { TOKEN_PROGRAM_ID } from '@solana/spl-token';
+
+const dataLayout = BufferLayout.struct([BufferLayout.u8('instruction')]);
+
+/**
+ * Construct a SyncNative instruction
+ *
+ * @param account   Native account to sync lamports from
+ * @param programId SPL Token program account
+ *
+ * @return Instruction to add to a transaction
+ */
+export function syncNative(account: PublicKey, programId = TOKEN_PROGRAM_ID): TransactionInstruction {
+  const keys = [{ pubkey: account, isSigner: false, isWritable: true }];
+
+  const data = Buffer.alloc(dataLayout.span);
+  dataLayout.encode({ instruction: 17 }, data);
+
+  return new TransactionInstruction({ keys, programId, data });
+}