@kamino-finance/klend-sdk 3.2.26 → 4.0.0

package/src/utils/ata.ts

@@ -0,0 +1,195 @@
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  TOKEN_PROGRAM_ID,
+  createAssociatedTokenAccountIdempotentInstruction as createAtaIx,
+} from '@solana/spl-token';
+import { ComputeBudgetProgram, Connection, PublicKey, SystemProgram, TransactionInstruction } from '@solana/web3.js';
+import { SOL_MINTS } from '../leverage';
+import Decimal from 'decimal.js';
+import { AnchorProvider } from '@coral-xyz/anchor';
+
+/**
+ * Create an idempotent create ATA instruction
+ * Overrides the create ATA ix to use the idempotent version as the spl-token library does not provide this ix yet
+ * @param owner - owner of the ATA
+ * @param mint - mint of the ATA
+ * @param payer - payer of the transaction
+ * @param tokenProgram - optional token program address - spl-token if not provided
+ * @param ata - optional ata address - derived if not provided
+ * @returns The ATA address public key and the transaction instruction
+ */
+export function createAssociatedTokenAccountIdempotentInstruction(
+  owner: PublicKey,
+  mint: PublicKey,
+  payer: PublicKey = owner,
+  tokenProgram: PublicKey = TOKEN_PROGRAM_ID,
+  ata?: PublicKey
+): [PublicKey, TransactionInstruction] {
+  let ataAddress = ata;
+  if (!ataAddress) {
+    ataAddress = getAssociatedTokenAddress(mint, owner, true, tokenProgram, ASSOCIATED_TOKEN_PROGRAM_ID);
+  }
+  const createUserTokenAccountIx = createAtaIx(
+    payer,
+    ataAddress,
+    owner,
+    mint,
+    tokenProgram,
+    ASSOCIATED_TOKEN_PROGRAM_ID
+  );
+  return [ataAddress, createUserTokenAccountIx];
+}
+
+export function getAssociatedTokenAddress(
+  mint: PublicKey,
+  owner: PublicKey,
+  allowOwnerOffCurve = true,
+  programId = TOKEN_PROGRAM_ID,
+  associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID
+): PublicKey {
+  if (!allowOwnerOffCurve && !PublicKey.isOnCurve(owner.toBuffer())) throw new Error('Token owner off curve');
+
+  const [address] = PublicKey.findProgramAddressSync(
+    [owner.toBuffer(), programId.toBuffer(), mint.toBuffer()],
+    associatedTokenProgramId
+  );
+
+  return address;
+}
+
+export const getAtasWithCreateIxnsIfMissing = async (
+  connection: Connection,
+  user: PublicKey,
+  mints: PublicKey[],
+  tokenProgramId: PublicKey[]
+) => {
+  const requests = mints.map((x, index) => createAtaIfMissing(connection, user, x, tokenProgramId[index]));
+  const result = await Promise.all(requests);
+
+  const atas = result.map((res) => res.ata);
+  const createAtasIxns = result.reduce((sum, item) => {
+    sum = sum.concat(item.createIxns);
+    return sum;
+  }, [] as TransactionInstruction[]);
+
+  const closeAtasIxns: TransactionInstruction[] = result.reduce((sum, item) => {
+    sum = sum.concat(item.closeIxns);
+    return sum;
+  }, [] as TransactionInstruction[]);
+
+  return {
+    atas,
+    createAtasIxns,
+    closeAtasIxns,
+  };
+};
+
+const createAtaIfMissing = async (
+  connection: Connection,
+  user: PublicKey,
+  mint: PublicKey,
+  tokenProgram: PublicKey = TOKEN_PROGRAM_ID
+) => {
+  const ata = getAssociatedTokenAddress(mint, user, true, tokenProgram);
+  const doesAtaExist = Boolean(await getAtaByTokenMint(connection, user, mint));
+  const createIxns = !doesAtaExist
+    ? createAssociatedTokenAccountIdempotentInstruction(user, mint, user, tokenProgram)[1]
+    : [];
+  const closeIxns: TransactionInstruction[] = [];
+  return {
+    ata,
+    createIxns,
+    closeIxns,
+  };
+};
+
+export const checkIfAccountExists = async (connection: Connection, account: PublicKey): Promise<boolean> => {
+  const acc = await connection.getAccountInfo(account);
+  return acc !== null;
+};
+
+const getAtaByTokenMint = async (
+  connection: Connection,
+  user: PublicKey,
+  tokenMint: PublicKey,
+  tokenProgram: PublicKey = TOKEN_PROGRAM_ID
+): Promise<PublicKey | null> => {
+  if (tokenMint.equals(SOL_MINTS[0])) {
+    return user;
+  }
+
+  const ataAddress = getAssociatedTokenAddress(tokenMint, user, true, tokenProgram);
+  if (await checkIfAccountExists(connection, ataAddress)) {
+    return ataAddress;
+  }
+
+  return null;
+};
+
+export function getDepositWsolIxns(owner: PublicKey, ata: PublicKey, amountLamports: Decimal) {
+  const ixns: TransactionInstruction[] = [];
+
+  ixns.push(
+    SystemProgram.transfer({
+      fromPubkey: owner,
+      toPubkey: ata,
+      lamports: amountLamports.toNumber(),
+    })
+  );
+
+  ixns.push(
+    new TransactionInstruction({
+      keys: [
+        {
+          pubkey: ata,
+          isSigner: false,
+          isWritable: true,
+        },
+      ],
+      data: Buffer.from(new Uint8Array([17])),
+      programId: TOKEN_PROGRAM_ID,
+    })
+  );
+
+  return ixns;
+}
+
+export function removeBudgetAndAtaIxns(ixns: TransactionInstruction[], mints: string[]): TransactionInstruction[] {
+  return ixns.filter((ixn) => {
+    const { programId, keys } = ixn;
+
+    if (programId.equals(ComputeBudgetProgram.programId)) {
+      return false;
+    }
+
+    if (programId.equals(ASSOCIATED_TOKEN_PROGRAM_ID)) {
+      const mint = keys[3];
+
+      return !mints.includes(mint.pubkey.toString());
+    }
+
+    return true;
+  });
+}
+
+export async function getTokenAccountBalance(provider: AnchorProvider, tokenAccount: PublicKey): Promise<number> {
+  const tokenAccountBalance = await provider.connection.getTokenAccountBalance(tokenAccount);
+
+  return Number(tokenAccountBalance.value.amount).valueOf();
+}
+
+export async function getTokenAccountBalanceDecimal(
+  connection: Connection,
+  mint: PublicKey,
+  owner: PublicKey
+): Promise<Decimal> {
+  const tokenAta = await getAssociatedTokenAddress(mint, owner);
+  const ataExists = await checkIfAccountExists(connection, tokenAta);
+
+  if (!ataExists) {
+    return new Decimal(0);
+  } else {
+    const tokenData = (await connection.getTokenAccountBalance(tokenAta)).value;
+    return new Decimal(tokenData.uiAmountString!);
+  }
+}

package/src/utils/constants.ts

@@ -0,0 +1,81 @@
+import Decimal from 'decimal.js';
+import { PROGRAM_ID } from '../idl_codegen/programId';
+import { PublicKey } from '@solana/web3.js';
+
+export const STAGING_PROGRAM_ID: PublicKey = new PublicKey('SLendK7ySfcEzyaFqy93gDnD3RtrpXJcnRwb6zFHJSh');
+export const DEFAULT_KLEND_PROGRAM_ID: string = PROGRAM_ID.toString();
+export const U64_MAX = '18446744073709551615';
+const INITIAL_COLLATERAL_RATIO = 1;
+export const INITIAL_COLLATERAL_RATE = new Decimal(INITIAL_COLLATERAL_RATIO);
+
+export type ENV = 'mainnet-beta' | 'devnet' | 'localnet';
+
+export function isENV(value: any): value is ENV {
+  return value === 'mainnet-beta' || value === 'devnet' || value === 'localnet';
+}
+
+export function getApiEndpoint(programId: PublicKey) {
+  if (programId.equals(PROGRAM_ID)) {
+    return 'https://api.hubbleprotocol.io/v2/kamino-market';
+  } else {
+    return `https://api.hubbleprotocol.io/v2/kamino-market/?programId=${programId.toString()}`;
+  }
+}
+
+export const CDN_ENDPOINT = 'https://cdn.kamino.finance/kamino_lend_config_v2.json';
+
+export const ONE_HUNDRED_PCT_IN_BPS = 10_000;
+
+export function getProgramId(env: 'mainnet-beta' | 'staging' = 'mainnet-beta') {
+  if (env === 'mainnet-beta') {
+    return PROGRAM_ID;
+  } else {
+    return STAGING_PROGRAM_ID;
+  }
+}
+
+/**
+ * Number of slots per second
+ */
+export const SLOTS_PER_SECOND = 2;
+
+/**
+ * Number of slots per minute
+ * 2 (slots per second) * 60 = 120
+ */
+export const SLOTS_PER_MINUTE = SLOTS_PER_SECOND * 60;
+
+/**
+ * Number of slots per hour
+ * 2 (slots per second) * 60 * 60 = 7200
+ */
+export const SLOTS_PER_HOUR = SLOTS_PER_MINUTE * 60;
+
+/**
+ * Number of slots per day
+ * 2 (slots per second) * 60 * 60 * 24 = 172800
+ */
+export const SLOTS_PER_DAY = SLOTS_PER_HOUR * 24;
+
+/**
+ * Number of slots per year
+ * 2 (slots per second) * 60 * 60 * 24 * 365 = 63072000
+ */
+export const SLOTS_PER_YEAR = SLOTS_PER_DAY * 365;
+
+/**
+ * Minimum bonus for autodeleverage liquidations in bps
+ */
+export const MIN_AUTODELEVERAGE_BONUS_BPS = 50;
+
+/**
+ * WSOL Mint
+ */
+export const WRAPPED_SOL_MINT = new PublicKey('So11111111111111111111111111111111111111112');
+
+/**
+ * USDC Mint
+ */
+export const USDC_MAINNET_MINT = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
+
+export const MAINNET_BETA_CHAIN_ID = 101;

package/src/utils/idl.ts

@@ -0,0 +1,4 @@
+import { Idl } from '@coral-xyz/anchor';
+import rawIdl from '../idl.json';
+
+export const idl: Idl = rawIdl as Idl;

package/src/utils/index.ts

@@ -0,0 +1,16 @@
+export * from './api';
+export * from './ata';
+export * from './constants';
+export * from './idl';
+export * from './instruction';
+export * from './layout';
+export * from './ObligationType';
+export * from './seeds';
+export * from './slots';
+export * from './syncNative';
+export * from './userMetadata';
+export * from './pubkey';
+export * from './oracle';
+export * from './lookupTable';
+export * from './sendTransactionsUtils';
+export * from './managerTypes';

package/src/utils/instruction.ts

@@ -0,0 +1,258 @@
+import Decimal from 'decimal.js';
+
+import {
+  AddressLookupTableAccount,
+  Commitment,
+  ComputeBudgetProgram,
+  Connection,
+  Keypair,
+  PublicKey,
+  SendOptions,
+  Signer,
+  Transaction,
+  TransactionInstruction,
+  TransactionMessage,
+  TransactionResponse,
+  TransactionSignature,
+  VersionedTransaction,
+  VersionedTransactionResponse,
+} from '@solana/web3.js';
+import { fromTxError } from '../idl_codegen/errors';
+import { sleep } from '../classes/utils';
+import { batchFetch } from '@kamino-finance/kliquidity-sdk';
+
+export async function buildAndSendTxnWithLogs(
+  c: Connection,
+  tx: VersionedTransaction,
+  owner: Keypair,
+  signers: Signer[],
+  withLogsIfSuccess: boolean = false,
+  withDescription: string = ''
+): Promise<TransactionSignature> {
+  tx.sign([owner, ...signers]);
+
+  try {
+    const sig: string = await sendAndConfirmVersionedTransaction(c, tx, 'confirmed', {
+      preflightCommitment: 'processed',
+    });
+    console.log('Transaction Hash:', withDescription, sig);
+    if (withLogsIfSuccess) {
+      await sleep(5000);
+      const res = await c.getTransaction(sig, {
+        commitment: 'confirmed',
+        maxSupportedTransactionVersion: 6,
+      });
+      console.log('Transaction Logs:\n', res?.meta?.logMessages);
+    }
+    return sig;
+  } catch (e: any) {
+    console.log(e);
+    process.stdout.write(e.logs.toString());
+    await sleep(5000);
+    const sig = e.toString().split(' failed ')[0].split('Transaction ')[1];
+    const res: VersionedTransactionResponse | null = await c.getTransaction(sig, {
+      commitment: 'confirmed',
+      maxSupportedTransactionVersion: 6,
+    });
+    console.log('Txn', res!.meta!.logMessages);
+    return sig;
+  }
+}
+
+export async function buildAndSendTxn(
+  c: Connection,
+  owner: Keypair,
+  ixns: TransactionInstruction[],
+  signers: Signer[],
+  lutAddresses: PublicKey[] = [],
+  description: string = ''
+): Promise<TransactionSignature> {
+  const tx = await buildVersionedTransaction(c, owner.publicKey, ixns, lutAddresses);
+
+  return await buildAndSendTxnWithLogs(c, tx, owner, signers, true, description);
+}
+
+export async function sendAndConfirmVersionedTransaction(
+  c: Connection,
+  tx: VersionedTransaction,
+  commitment: Commitment = 'confirmed',
+  sendTransactionOptions: SendOptions = { preflightCommitment: 'processed' }
+) {
+  const defaultOptions: SendOptions = { skipPreflight: true };
+  const txId = await c.sendTransaction(tx, { ...defaultOptions, ...sendTransactionOptions });
+
+  const latestBlockHash = await c.getLatestBlockhash('finalized');
+  const t = await c.confirmTransaction(
+    {
+      blockhash: latestBlockHash.blockhash,
+      lastValidBlockHeight: latestBlockHash.lastValidBlockHeight,
+      signature: txId,
+    },
+    commitment
+  );
+  if (t.value && t.value.err) {
+    const txDetails = await c.getTransaction(txId, {
+      maxSupportedTransactionVersion: 0,
+      commitment: 'confirmed',
+    });
+    if (txDetails) {
+      throw { err: txDetails.meta?.err, logs: txDetails.meta?.logMessages || [] };
+    }
+    throw t.value.err;
+  }
+  return txId;
+}
+
+export async function simulateTxn(c: Connection, tx: Transaction, owner: Keypair, signers: Signer[]) {
+  const { blockhash } = await c.getLatestBlockhash();
+  tx.recentBlockhash = blockhash;
+  tx.feePayer = owner.publicKey;
+
+  try {
+    const simulation = await c.simulateTransaction(tx, [owner, ...signers]);
+    console.log('Transaction Hash:', simulation);
+  } catch (e: any) {
+    console.log(e);
+    process.stdout.write(e.logs.toString());
+    await sleep(5000);
+    const sig = e.toString().split(' failed ')[0].split('Transaction ')[1];
+    const res: TransactionResponse | null = await c.getTransaction(sig, {
+      commitment: 'confirmed',
+    });
+    console.log('Txn', res!.meta!.logMessages);
+    return sig;
+  }
+}
+
+export function buildComputeBudgetIx(units: number): TransactionInstruction {
+  return ComputeBudgetProgram.setComputeUnitLimit({ units });
+}
+
+/**
+ * Send a transaction with optional address lookup tables
+ * Translates anchor errors into anchor error types
+ * @param connection
+ * @param payer
+ * @param instructions
+ * @param lookupTables
+ */
+export async function sendTransactionV0(
+  connection: Connection,
+  payer: Keypair,
+  instructions: TransactionInstruction[],
+  lookupTables: AddressLookupTableAccount[] | undefined = undefined,
+  options?: SendOptions
+): Promise<string> {
+  const recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
+
+  const messageV0 = new TransactionMessage({
+    payerKey: payer.publicKey,
+    recentBlockhash,
+    instructions,
+  }).compileToV0Message(lookupTables);
+
+  const tx = new VersionedTransaction(messageV0);
+  tx.sign([payer]);
+  try {
+    return await connection.sendTransaction(tx, options);
+  } catch (err) {
+    throw fromTxError(err) ?? err;
+  }
+}
+
+export async function simulateTransactionV0(
+  connection: Connection,
+  payer: Keypair,
+  instructions: TransactionInstruction[],
+  lookupTables: AddressLookupTableAccount[] | undefined = undefined
+) {
+  const recentBlockhash = (await connection.getLatestBlockhash()).blockhash;
+
+  const messageV0 = new TransactionMessage({
+    payerKey: payer.publicKey,
+    recentBlockhash,
+    instructions,
+  }).compileToV0Message(lookupTables);
+
+  const tx = new VersionedTransaction(messageV0);
+  tx.sign([payer]);
+  try {
+    return await connection.simulateTransaction(tx);
+  } catch (err) {
+    throw fromTxError(err) ?? err;
+  }
+}
+
+export const buildVersionedTransaction = async (
+  connection: Connection,
+  payer: PublicKey,
+  instructions: TransactionInstruction[],
+  lookupTables: PublicKey[] = []
+): Promise<VersionedTransaction> => {
+  const blockhash = await connection.getLatestBlockhash('confirmed').then((res) => res.blockhash);
+
+  const lookupTablesAccounts = await Promise.all(
+    lookupTables.map((address) => {
+      return getLookupTableAccount(connection, address);
+    })
+  );
+
+  const messageV0 = new TransactionMessage({
+    payerKey: payer,
+    recentBlockhash: blockhash,
+    instructions,
+  }).compileToV0Message(lookupTablesAccounts.filter(notEmpty));
+
+  return new VersionedTransaction(messageV0);
+};
+
+export const getLookupTableAccount = async (connection: Connection, address: PublicKey) => {
+  return connection.getAddressLookupTable(address).then((res) => res.value);
+};
+
+export async function getLookupTableAccounts(
+  connection: Connection,
+  addresses: PublicKey[]
+): Promise<AddressLookupTableAccount[]> {
+  const lookupTableAccounts: AddressLookupTableAccount[] = [];
+  const accountInfos = await batchFetch(addresses, (batch) => connection.getMultipleAccountsInfo(batch));
+  for (let i = 0; i < addresses.length; i++) {
+    const info = accountInfos[i];
+    if (!info) {
+      throw new Error(`Lookup table ${addresses[i]} is not found`);
+    }
+    lookupTableAccounts.push(
+      new AddressLookupTableAccount({
+        key: addresses[i],
+        state: AddressLookupTableAccount.deserialize(info.data),
+      })
+    );
+  }
+  return lookupTableAccounts;
+}
+
+export const getComputeBudgetAndPriorityFeeIxns = (
+  units: number,
+  priorityFeeLamports?: Decimal
+): TransactionInstruction[] => {
+  const ixns: TransactionInstruction[] = [];
+  ixns.push(ComputeBudgetProgram.setComputeUnitLimit({ units }));
+
+  if (priorityFeeLamports && priorityFeeLamports.gt(0)) {
+    const unitPrice = priorityFeeLamports.mul(10 ** 6).div(units);
+    ixns.push(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: BigInt(unitPrice.floor().toString()) }));
+  }
+
+  return ixns;
+};
+
+// filters null values from array and make typescript happy
+export function notEmpty<TValue>(value: TValue | null | undefined): value is TValue {
+  if (value === null || value === undefined) {
+    return false;
+  }
+  //
+  // eslint-disable-next-line no-unused-vars,@typescript-eslint/no-unused-vars
+  const testDummy: TValue = value;
+  return true;
+}

package/src/utils/kamino.ts

@@ -0,0 +1,12 @@
+import { Kamino } from '@kamino-finance/kliquidity-sdk';
+import { getMint } from '@solana/spl-token';
+import { PublicKey } from '@solana/web3.js';
+
+export async function isKtoken(mintKey: PublicKey, kamino: Kamino): Promise<boolean> {
+  const [expectedMintAuthority] = PublicKey.findProgramAddressSync(
+    [Buffer.from('authority'), mintKey.toBuffer()],
+    kamino.getProgramID()
+  );
+  const mint = await getMint(kamino.getConnection(), mintKey);
+  return mint.mintAuthority !== null && mint.mintAuthority.equals(expectedMintAuthority);
+}

package/src/utils/layout.ts

@@ -0,0 +1,118 @@
+import { PublicKey } from '@solana/web3.js';
+import BN from 'bn.js';
+import * as BufferLayout from 'buffer-layout';
+
+/**
+ * Layout for a public key
+ */
+export const publicKey = (property = 'publicKey'): unknown => {
+  const publicKeyLayout = BufferLayout.blob(32, property);
+
+  const _decode = publicKeyLayout.decode.bind(publicKeyLayout);
+  const _encode = publicKeyLayout.encode.bind(publicKeyLayout);
+
+  publicKeyLayout.decode = (buffer: Buffer, offset: number) => {
+    const data = _decode(buffer, offset);
+    return new PublicKey(data);
+  };
+
+  publicKeyLayout.encode = (key: PublicKey, buffer: Buffer, offset: number) => _encode(key.toBuffer(), buffer, offset);
+
+  return publicKeyLayout;
+};
+
+/**
+ * Layout for a 64bit unsigned value
+ */
+export const uint64 = (property = 'uint64'): unknown => {
+  const layout = BufferLayout.blob(8, property);
+
+  const _decode = layout.decode.bind(layout);
+  const _encode = layout.encode.bind(layout);
+
+  layout.decode = (buffer: Buffer, offset: number) => {
+    const data = _decode(buffer, offset);
+    return new BN(
+      [...data]
+        .reverse()
+        .map((i) => `00${i.toString(16)}`.slice(-2))
+        .join(''),
+      16
+    );
+  };
+
+  layout.encode = (num: BN, buffer: Buffer, offset: number) => {
+    const a = num.toArray().reverse();
+    let b = Buffer.from(a);
+    if (b.length !== 8) {
+      const zeroPad = Buffer.alloc(8);
+      b.copy(zeroPad);
+      b = zeroPad;
+    }
+    return _encode(b, buffer, offset);
+  };
+
+  return layout;
+};
+
+export const uint128 = (property = 'uint128'): unknown => {
+  const layout = BufferLayout.blob(16, property);
+
+  const _decode = layout.decode.bind(layout);
+  const _encode = layout.encode.bind(layout);
+
+  layout.decode = (buffer: Buffer, offset: number) => {
+    const data = _decode(buffer, offset);
+    return new BN(
+      [...data]
+        .reverse()
+        .map((i) => `00${i.toString(16)}`.slice(-2))
+        .join(''),
+      16
+    );
+  };
+
+  layout.encode = (num: BN, buffer: Buffer, offset: number) => {
+    const a = num.toArray().reverse();
+    let b = Buffer.from(a);
+    if (b.length !== 16) {
+      const zeroPad = Buffer.alloc(16);
+      b.copy(zeroPad);
+      b = zeroPad;
+    }
+
+    return _encode(b, buffer, offset);
+  };
+
+  return layout;
+};
+
+/**
+ * Layout for a Rust String type
+ */
+export const rustString = (property = 'string'): unknown => {
+  const rsl = BufferLayout.struct(
+    [
+      BufferLayout.u32('length'),
+      BufferLayout.u32('lengthPadding'),
+      BufferLayout.blob(BufferLayout.offset(BufferLayout.u32(), -8), 'chars'),
+    ],
+    property
+  );
+  const _decode = rsl.decode.bind(rsl);
+  const _encode = rsl.encode.bind(rsl);
+
+  rsl.decode = (buffer: Buffer, offset: number) => {
+    const data = _decode(buffer, offset);
+    return data.chars.toString('utf8');
+  };
+
+  rsl.encode = (str: string, buffer: Buffer, offset: number) => {
+    const data = {
+      chars: Buffer.from(str, 'utf8'),
+    };
+    return _encode(data, buffer, offset);
+  };
+
+  return rsl;
+};