@kamino-finance/klend-sdk 6.0.4 → 6.0.5-beta.1

package/src/utils/instruction.ts

@@ -1,29 +1,277 @@
 import Decimal from 'decimal.js';
 
-import { Address, IInstruction, Rpc, GetMultipleAccountsApi, Account, isAddress } from '@solana/kit';
+import {
+  AddressLookupTableAccount,
+  Blockhash,
+  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';
-import { getSetComputeUnitLimitInstruction, getSetComputeUnitPriceInstruction } from '@solana-program/compute-budget';
-import { AddressLookupTable, fetchAllAddressLookupTable } from '@solana-program/address-lookup-table';
-import { COMPUTE_BUDGET_PROGRAM_ID } from './pubkey';
+import { PublicKeySet } from './pubkey';
 
-export function buildComputeBudgetIx(units: number): IInstruction {
-  return getSetComputeUnitLimitInstruction({ units });
+export async function buildAndSendTxnWithLogs(
+  c: Connection,
+  tx: VersionedTransaction,
+  owner: Keypair,
+  signers: Signer[],
+  withLogsIfSuccess: boolean = false,
+  withDescription: string = '',
+  throwOnError: boolean = false // TODO(error-surfacing): the "recovery" logic is broken/outdated + the "hide error" behavior seems wrong in general - migrate to "just throw"
+): 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(1000);
+      const res = await c.getTransaction(sig, {
+        commitment: 'confirmed',
+        maxSupportedTransactionVersion: 6,
+      });
+      console.log('Transaction Logs:\n', res?.meta?.logMessages);
+    }
+    return sig;
+  } catch (e: any) {
+    if (throwOnError) {
+      throw e;
+    }
+    console.log(e);
+    process.stdout.write(e.logs.toString());
+    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,
+  ixs: TransactionInstruction[],
+  signers: Signer[],
+  lutAddresses: PublicKey[] = [],
+  description: string = ''
+): Promise<TransactionSignature> {
+  const tx = await buildVersionedTransaction(c, owner.publicKey, ixs, 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());
+    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 async function getLookupTableAccountsFromAddresses(
+  connection: Connection,
+  addresses: PublicKey[]
+): Promise<AddressLookupTableAccount[]> {
+  const lookupTablesAccounts = await Promise.all(
+    addresses.map((address) => {
+      return getLookupTableAccount(connection, address);
+    })
+  );
+  return lookupTablesAccounts.filter((account) => account !== null) as AddressLookupTableAccount[];
 }
 
+export const buildVersionedTransactionSync = (
+  payer: PublicKey,
+  instructions: TransactionInstruction[],
+  blockhash: Blockhash,
+  lookupTables: AddressLookupTableAccount[] = []
+): VersionedTransaction => {
+  const messageV0 = new TransactionMessage({
+    payerKey: payer,
+    recentBlockhash: blockhash,
+    instructions,
+  }).compileToV0Message(lookupTables.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(
-  rpc: Rpc<GetMultipleAccountsApi>,
-  addresses: Address[]
-): Promise<Account<AddressLookupTable>[]> {
-  return batchFetch(addresses, (batch) => fetchAllAddressLookupTable(rpc, batch));
+  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 getComputeBudgetAndPriorityFeeIxs = (units: number, priorityFeeLamports?: Decimal): IInstruction[] => {
-  const ixs: IInstruction[] = [];
-  ixs.push(getSetComputeUnitLimitInstruction({ units }));
+export const getComputeBudgetAndPriorityFeeIxs = (
+  units: number,
+  priorityFeeLamports?: Decimal
+): TransactionInstruction[] => {
+  const ixs: TransactionInstruction[] = [];
+  ixs.push(ComputeBudgetProgram.setComputeUnitLimit({ units }));
 
   if (priorityFeeLamports && priorityFeeLamports.gt(0)) {
     const unitPrice = priorityFeeLamports.mul(10 ** 6).div(units);
-    ixs.push(getSetComputeUnitPriceInstruction({ microLamports: BigInt(unitPrice.floor().toString()) }));
+    ixs.push(ComputeBudgetProgram.setComputeUnitPrice({ microLamports: BigInt(unitPrice.floor().toString()) }));
   }
 
   return ixs;
@@ -41,33 +289,35 @@ export function notEmpty<TValue>(value: TValue | null | undefined): value is TVa
 }
 
 export function uniqueAccountsWithProgramIds(
-  ixs: IInstruction[],
-  addressLookupTables: Address[] | Account<AddressLookupTable>[] = []
-): Array<Address> {
-  let luts: Address[];
-  if (
-    addressLookupTables.length > 0 &&
-    typeof addressLookupTables[0] === 'string' &&
-    isAddress(addressLookupTables[0])
-  ) {
-    luts = addressLookupTables as Address[];
+  ixs: TransactionInstruction[],
+  addressLookupTables: PublicKey[] | AddressLookupTableAccount[] = []
+): Array<PublicKey> {
+  let luts: PublicKey[];
+  if (addressLookupTables.length > 0 && addressLookupTables[0] instanceof AddressLookupTableAccount) {
+    luts = (addressLookupTables as AddressLookupTableAccount[]).map((lut) => lut.key);
   } else {
-    luts = (addressLookupTables as Account<AddressLookupTable>[]).map((lut) => lut.address);
+    luts = addressLookupTables as PublicKey[];
   }
 
-  const uniqueAccounts = new Set<Address>(luts);
+  const uniqueAccounts = new PublicKeySet<PublicKey>(luts);
   ixs.forEach((ix) => {
-    uniqueAccounts.add(ix.programAddress);
-    (ix.accounts || []).forEach((key) => {
-      uniqueAccounts.add(key.address);
+    uniqueAccounts.add(ix.programId);
+    ix.keys.forEach((key) => {
+      uniqueAccounts.add(key.pubkey);
     });
   });
 
-  return [...uniqueAccounts];
+  return uniqueAccounts.toArray();
 }
 
-export function removeBudgetIxs(ixs: IInstruction[]): IInstruction[] {
-  return ixs.filter(({ programAddress }) => {
-    return programAddress !== COMPUTE_BUDGET_PROGRAM_ID;
+export function removeBudgetIxs(ixs: TransactionInstruction[]): TransactionInstruction[] {
+  return ixs.filter((ix) => {
+    const { programId } = ix;
+
+    if (programId.equals(ComputeBudgetProgram.programId)) {
+      return false;
+    }
+
+    return true;
   });
 }

package/src/utils/kamino.ts

@@ -1,15 +1,12 @@
 import { Kamino } from '@kamino-finance/kliquidity-sdk';
-import { Address, getAddressEncoder, getProgramDerivedAddress, isSome } from '@solana/kit';
-import { fetchMint } from '@solana-program/token-2022';
-import { Buffer } from 'buffer';
+import { getMint } from '@solana/spl-token';
+import { PublicKey } from '@solana/web3.js';
 
-const addressEncoder = getAddressEncoder();
-
-export async function isKtoken(mint: Address, kamino: Kamino): Promise<boolean> {
-  const [expectedMintAuthority] = await getProgramDerivedAddress({
-    seeds: [Buffer.from('authority'), addressEncoder.encode(mint)],
-    programAddress: kamino.getProgramID(),
-  });
-  const mintState = await fetchMint(kamino.getConnection(), mint);
-  return isSome(mintState.data.mintAuthority) && mintState.data.mintAuthority.value === expectedMintAuthority;
+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/lookupTable.ts

@@ -1,116 +1,111 @@
-import { Address, GetAccountInfoApi, GetSlotApi, IInstruction, Rpc, Slot, TransactionSigner } from '@solana/kit';
-import {
-  fetchAddressLookupTable,
-  findAddressLookupTablePda,
-  getCloseLookupTableInstruction,
-  getCreateLookupTableInstruction,
-  getDeactivateLookupTableInstruction,
-  getExtendLookupTableInstruction,
-} from '@solana-program/address-lookup-table';
+import { AddressLookupTableProgram, Connection, PublicKey, TransactionInstruction } from '@solana/web3.js';
 
-export async function printAddressLookupTable(rpc: Rpc<GetAccountInfoApi>, lookupTablePk: Address): Promise<void> {
-  const lookupTableAccount = (await fetchAddressLookupTable(rpc, lookupTablePk)).data;
+export async function printAddressLookupTable(connection: Connection, lookupTablePk: PublicKey) {
+  const lookupTableAccount = (await connection.getAddressLookupTable(lookupTablePk)).value;
   if (!lookupTableAccount) {
     console.error('Lookup table is not found');
   }
   console.log(`Lookup table account, ${lookupTablePk.toString()}`);
-  lookupTableAccount.addresses.forEach((address: Address, index: number) => {
+  lookupTableAccount?.state.addresses.forEach((address: PublicKey, index: number) => {
     console.log(`Address: ${address.toString()} at index ${index}`);
   });
 }
 
 export async function createLookupTableIx(
-  connection: Rpc<GetSlotApi>,
-  authority: TransactionSigner
-): Promise<[IInstruction, Address]> {
-  const recentSlot = await connection.getSlot({ commitment: 'finalized' }).send();
-  return initLookupTableIx(authority, recentSlot);
+  connection: Connection,
+  wallet: PublicKey
+): Promise<[TransactionInstruction, PublicKey]> {
+  return initLookupTableIx(wallet, await connection.getSlot('confirmed'));
 }
 
 export function extendLookupTableChunkIx(
-  authority: TransactionSigner,
-  lookupTablePk: Address,
-  keys: Address[],
-  payer: TransactionSigner = authority
-): IInstruction {
-  return getExtendLookupTableInstruction({
-    authority,
-    payer,
-    address: lookupTablePk,
+  wallet: PublicKey,
+  lookupTablePk: PublicKey,
+  keys: PublicKey[],
+  payer: PublicKey = PublicKey.default
+): TransactionInstruction {
+  return AddressLookupTableProgram.extendLookupTable({
+    authority: wallet,
+    payer: payer.equals(PublicKey.default) ? wallet : payer,
+    lookupTable: lookupTablePk,
     addresses: keys,
   });
 }
 
 export const extendLookupTableIxs = (
-  authority: TransactionSigner,
-  table: Address,
-  keys: Address[],
-  payer: TransactionSigner = authority
-): IInstruction[] => {
+  wallet: PublicKey,
+  table: PublicKey,
+  keys: PublicKey[],
+  payer: PublicKey = PublicKey.default
+): TransactionInstruction[] => {
   const chunkSize = 25;
-  const extendLookupIxs: IInstruction[] = [];
+  const extendLookupIxs: TransactionInstruction[] = [];
   for (let i = 0; i < keys.length; i += chunkSize) {
     const chunk = keys.slice(i, i + chunkSize);
-    extendLookupIxs.push(extendLookupTableChunkIx(authority, table, chunk, payer));
+    extendLookupIxs.push(extendLookupTableChunkIx(wallet, table, chunk, payer));
   }
+
   return extendLookupIxs;
 };
 
 /**
- * This method returns an instruction that creates a lookup table, alongside the pubkey of the lookup table
- * @param authority - the owner of the lookup table
- * @param recentSlot - the current slot
+ * This method retuns an instruction that creates a lookup table, alongside the pubkey of the lookup table
+ * @param payer - the owner of the lookup table
+ * @param slot - the current slot
  * @returns - the instruction to create the lookup table and its address
  */
-export async function initLookupTableIx(
-  authority: TransactionSigner,
-  recentSlot: Slot
-): Promise<[IInstruction, Address]> {
-  const address = await findAddressLookupTablePda({ authority: authority.address, recentSlot });
-  const createLookupTableIx = getCreateLookupTableInstruction({
-    authority,
-    payer: authority,
-    recentSlot,
-    address,
+export function initLookupTableIx(payer: PublicKey, slot: number): [TransactionInstruction, PublicKey] {
+  const [ix, address] = AddressLookupTableProgram.createLookupTable({
+    authority: payer,
+    payer,
+    recentSlot: slot,
   });
-  return [createLookupTableIx, address[0]];
+
+  return [ix, address];
 }
 
 /**
  * This method retuns an instruction that deactivates a lookup table, which is needed to close it
- * @param authority - the owner of the lookup table
+ * @param payer - the owner of the lookup table
  * @param lookupTable - the lookup table to deactivate
  * @returns - the instruction to deactivate the lookup table
  */
-export function deactivateLookupTableIx(authority: TransactionSigner, lookupTable: Address): IInstruction {
-  return getDeactivateLookupTableInstruction({
-    authority,
-    address: lookupTable,
+export function deactivateLookupTableIx(payer: PublicKey, lookupTable: PublicKey): TransactionInstruction {
+  const ix = AddressLookupTableProgram.deactivateLookupTable({
+    authority: payer,
+    lookupTable: lookupTable,
   });
+
+  return ix;
 }
 
 /**
  * This method returns an instruction that closes a lookup table. That lookup table needs to be disabled at least 500 blocks before closing it.
- * @param authority - the owner of the lookup table
+ * @param payer - the owner of the lookup table
  * @param lookupTable - the lookup table to close
  * @returns - the instruction to close the lookup table
  */
 /// this require the LUT to be deactivated at least 500 blocks before
-export function closeLookupTableIx(authority: TransactionSigner, lookupTable: Address): IInstruction {
-  return getCloseLookupTableInstruction({
-    authority,
-    address: lookupTable,
-    recipient: authority.address,
+export function closeLookupTableIx(payer: PublicKey, lookupTable: PublicKey): TransactionInstruction {
+  const ix = AddressLookupTableProgram.closeLookupTable({
+    authority: payer,
+    recipient: payer,
+    lookupTable: lookupTable,
   });
+
+  return ix;
 }
 
 /**
  * Returns the accounts in a lookup table
- * @param rpc
  * @param lookupTable - lookup table to get the accounts from
  * @returns - an array of accounts in the lookup table
  */
-export async function getAccountsInLut(rpc: Rpc<GetAccountInfoApi>, lookupTable: Address): Promise<Address[]> {
-  const lutState = await fetchAddressLookupTable(rpc, lookupTable);
-  return lutState.data.addresses;
+export async function getAccountsInLUT(connection: Connection, lookupTable: PublicKey): Promise<PublicKey[]> {
+  const lutState = await connection.getAddressLookupTable(lookupTable);
+  if (!lutState || !lutState.value) {
+    throw new Error(`Lookup table ${lookupTable} not found`);
+  }
+
+  return lutState.value.state.addresses;
 }