@kamino-finance/kliquidity-sdk 8.1.0 → 8.1.3

package/src/utils/pubkey.ts

@@ -0,0 +1,249 @@
+import { PublicKey } from '@solana/web3.js';
+import BN from 'bn.js';
+
+/**
+ * Custom set implementation for PublicKey
+ * Calling toString() on a PublicKey is pretty slow and pubkeys do not support `SameValueZero` comparison, so we use a custom set implementation where keys are compared with `PublicKey.equals(PublicKey)`
+ */
+export class PublicKeySet<T extends PublicKey> {
+  private items: T[] = [];
+
+  constructor(items: Array<T>) {
+    items.forEach((item) => this.add(item));
+  }
+
+  add(item: T): void {
+    if (!this.contains(item)) {
+      this.items.push(item);
+    }
+  }
+
+  contains(item: T): boolean {
+    return this.items.some((existingItem) => this.equals(existingItem, item));
+  }
+
+  private equals(item1: T, item2: T): boolean {
+    return item1.equals(item2);
+  }
+
+  isEmpty(): boolean {
+    return this.items.length === 0;
+  }
+
+  toArray(): T[] {
+    return this.items.slice(); // Return a copy of the array to prevent external modifications
+  }
+}
+
+/**
+ * Custom map implementation for PublicKey, backed by a list for o(n) lookup speed
+ * Calling toString() on a PublicKey is pretty slow and pubkeys do not support `SameValueZero` comparison, so we use a custom map implementation where keys are compared with `PublicKey.equals(PublicKey)`
+ */
+export class PublicKeyMap<K extends PublicKey, V> {
+  private record: { key: K; value: V }[] = [];
+
+  set(key: K, value: V): void {
+    const index = this.findIndex(key);
+    if (index !== -1) {
+      // Update existing entry
+      this.record[index].value = value;
+    } else {
+      // Add new entry
+      this.record.push({ key, value });
+    }
+  }
+
+  get(key: K): V | undefined {
+    const index = this.findIndex(key);
+    return index !== -1 ? this.record[index].value : undefined;
+  }
+
+  has(key: K): boolean {
+    return this.findIndex(key) !== -1;
+  }
+
+  delete(key: K): void {
+    const index = this.findIndex(key);
+    if (index !== -1) {
+      this.record.splice(index, 1);
+    }
+  }
+
+  private findIndex(key: K): number {
+    return this.record.findIndex((entry) => entry.key.equals(key));
+  }
+
+  clear(): void {
+    this.record = [];
+  }
+
+  forEach(callback: (value: V, key: K) => void): void {
+    this.record.forEach((entry) => {
+      callback(entry.value, entry.key);
+    });
+  }
+
+  keys(): K[] {
+    return this.record.map((entry) => entry.key);
+  }
+
+  values(): V[] {
+    return this.record.map((entry) => entry.value);
+  }
+
+  entries(): [K, V][] {
+    return this.record.map((entry) => [entry.key, entry.value]);
+  }
+
+  isEmpty(): boolean {
+    return this.record.length === 0;
+  }
+}
+
+/**
+ * Custom map implementation for PublicKey, backed by a hashmap for o(1) lookup speed
+ * Calling toString() on a PublicKey is pretty slow and pubkeys do not support `SameValueZero` comparison, so we use a custom map implementation where keys are compared with `PublicKey.equals(PublicKey)`, and a hash is derived from the final 32 bits of the public key
+ */
+export class PubkeyHashMap<K extends PublicKey, V> implements Map<K, V> {
+  private buckets: Map<
+    number,
+    {
+      key: K;
+      value: V;
+    }[]
+  >;
+  size: number;
+
+  constructor(entries?: readonly (readonly [K, V])[] | null) {
+    this.buckets = new Map();
+    this.size = 0;
+    if (entries) {
+      for (const [key, value] of entries) {
+        this.set(key, value);
+      }
+    }
+  }
+
+  *[Symbol.iterator](): IterableIterator<[K, V]> {
+    for (const [, bucket] of this.buckets) {
+      for (const { key, value } of bucket) {
+        yield [key, value];
+      }
+    }
+  }
+
+  [Symbol.toStringTag]: string = 'PubkeyHashMap';
+
+  set(key: K, value: V): this {
+    const hash = new HashablePublicKey(key).hashCode();
+    const bucket = this.buckets.get(hash);
+    if (!bucket) {
+      this.buckets.set(hash, [{ key, value }]);
+      this.size++;
+    } else {
+      const entry = bucket.find((entry) => entry.key.equals(key));
+      if (entry) {
+        entry.value = value;
+      } else {
+        bucket.push({ key, value });
+        this.size++;
+      }
+    }
+    return this;
+  }
+
+  get(key: K): V | undefined {
+    const hash = new HashablePublicKey(key).hashCode();
+    const bucket = this.buckets.get(hash);
+    if (!bucket) {
+      return undefined;
+    }
+    const entry = bucket.find((entry) => entry.key.equals(key));
+    return entry ? entry.value : undefined;
+  }
+
+  has(key: K): boolean {
+    const hash = new HashablePublicKey(key).hashCode();
+    const bucket = this.buckets.get(hash);
+    if (!bucket) {
+      return false;
+    }
+    const entry = bucket.find((entry) => entry.key.equals(key));
+    return !!entry;
+  }
+
+  delete(key: K): boolean {
+    const hash = new HashablePublicKey(key).hashCode();
+    const bucket = this.buckets.get(hash);
+    if (!bucket) {
+      return false;
+    }
+    const index = bucket.findIndex((entry) => entry.key.equals(key));
+    if (index === -1) {
+      return false;
+    }
+    bucket.splice(index, 1);
+    if (bucket.length === 0) {
+      this.buckets.delete(hash);
+    }
+    this.size--;
+    return true;
+  }
+
+  clear(): void {
+    this.buckets = new Map();
+    this.size = 0;
+  }
+
+  isEmpty(): boolean {
+    return this.size === 0;
+  }
+
+  forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void {
+    this.buckets.forEach((bucket) => {
+      bucket.forEach((entry) => {
+        callbackfn(entry.value, entry.key, this);
+      }, thisArg);
+    }, thisArg);
+  }
+
+  *keys(): IterableIterator<K> {
+    for (const [key] of this) {
+      yield key;
+    }
+  }
+
+  *values(): IterableIterator<V> {
+    for (const [, value] of this) {
+      yield value;
+    }
+  }
+
+  entries(): IterableIterator<[K, V]> {
+    return this[Symbol.iterator]();
+  }
+}
+
+export class HashablePublicKey extends PublicKey implements IEquality<HashablePublicKey> {
+  // We only use the last 32 bits of the public key for hashing
+  static MASK = new BN(1).shln(32).subn(1);
+  constructor(value: PublicKey | string | Buffer | Uint8Array | Array<number>) {
+    super(value);
+  }
+
+  hashCode(): number {
+    let hash = 13;
+    hash = hash * 7 + this.getBN().clone().iuand(HashablePublicKey.MASK).toNumber();
+    return hash;
+  }
+
+  private getBN(): BN {
+    //@ts-ignore
+    return this._bn;
+  }
+}
+
+interface IEquality<T extends IEquality<T>> {
+  equals(other: T): boolean;
+  hashCode(): number;
+}

package/src/utils/tokenUtils.ts

@@ -1,78 +1,121 @@
-import { Address, IInstruction, address, TransactionSigner, Rpc, GetAccountInfoApi, Account } from '@solana/kit';
-import { WhirlpoolStrategy } from '../@codegen/kliquidity/accounts';
+import {
+  AccountInfo,
+  Commitment,
+  ComputeBudgetProgram,
+  Connection,
+  PublicKey,
+  sendAndConfirmTransaction,
+  Signer,
+  SystemProgram,
+  Transaction,
+  TransactionInstruction,
+  TransactionSignature,
+} from '@solana/web3.js';
+import { sleep } from './utils';
+import { WhirlpoolStrategy } from '../kamino-client/accounts';
 import { tickIndexToPrice } from '@orca-so/whirlpool-sdk';
 import Decimal from 'decimal.js';
-import { CollateralInfo } from '../@codegen/kliquidity/types';
+import { CollateralInfo } from '../kamino-client/types';
 import { getPriceOfBinByBinIdWithDecimals } from './meteora';
-import { TOKEN_PROGRAM_ADDRESS } from '@solana-program/token';
-import {
-  ASSOCIATED_TOKEN_PROGRAM_ADDRESS,
-  fetchMaybeMint,
-  fetchMaybeToken,
-  findAssociatedTokenPda,
-  getCreateAssociatedTokenInstruction,
-  Token,
-} from '@solana-program/token-2022';
-import { SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
-import { getSetComputeUnitLimitInstruction } from '@solana-program/compute-budget';
+import { getAssociatedTokenAddress as getAta, unpackMint } from '@solana/spl-token';
+
+export const ASSOCIATED_TOKEN_PROGRAM_ID = new PublicKey('ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL');
+export const TOKEN_PROGRAM_ID = new PublicKey('TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA');
 
 export const SOL_MINTS = [
-  address('So11111111111111111111111111111111111111111'),
-  address('So11111111111111111111111111111111111111112'),
+  new PublicKey('So11111111111111111111111111111111111111111'),
+  new PublicKey('So11111111111111111111111111111111111111112'),
 ];
 export const DECIMALS_SOL = 9;
 
-export async function getAssociatedTokenAddressAndAccount(
-  connection: Rpc<GetAccountInfoApi>,
-  mint: Address,
-  owner: Address,
-  programId: Address = TOKEN_PROGRAM_ADDRESS
-): Promise<[Address, Account<Token> | null]> {
-  const ata = await getAssociatedTokenAddress(mint, owner, programId);
-  const account = await fetchMaybeToken(connection, ata);
-  return [ata, account.exists ? account : null];
+export async function getAssociatedTokenAddressAndData(
+  connection: Connection,
+  mint: PublicKey,
+  owner: PublicKey,
+  programId = TOKEN_PROGRAM_ID
+): Promise<[PublicKey, AccountInfo<Buffer> | null]> {
+  const ata = await getAssociatedTokenAddress(mint, owner, true, programId);
+  const data = await connection.getAccountInfo(ata);
+  return [ata, data];
 }
 
-export async function getAssociatedTokenAddress(
-  mint: Address,
-  owner: Address,
-  programId: Address = TOKEN_PROGRAM_ADDRESS,
-  associatedTokenProgramId: Address = ASSOCIATED_TOKEN_PROGRAM_ADDRESS
-): Promise<Address> {
-  const [ata] = await findAssociatedTokenPda(
-    {
-      mint,
-      owner,
-      tokenProgram: programId,
-    },
-    { programAddress: associatedTokenProgramId }
-  );
-  return ata;
+export function getAssociatedTokenAddress(
+  mint: PublicKey,
+  owner: PublicKey,
+  allowOwnerOffCurve = true,
+  programId = TOKEN_PROGRAM_ID,
+  associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID
+): Promise<PublicKey> {
+  return getAta(mint, owner, allowOwnerOffCurve, programId, associatedTokenProgramId);
 }
 
 export function createAssociatedTokenAccountInstruction(
-  payer: TransactionSigner,
-  associatedToken: Address,
-  owner: Address,
-  mint: Address,
-  programId: Address = TOKEN_PROGRAM_ADDRESS,
-  associatedTokenProgramId: Address = ASSOCIATED_TOKEN_PROGRAM_ADDRESS
-): IInstruction {
-  return getCreateAssociatedTokenInstruction(
-    {
-      mint,
-      owner,
-      ata: associatedToken,
-      payer: payer,
-      tokenProgram: programId,
-      systemProgram: SYSTEM_PROGRAM_ADDRESS,
-    },
-    { programAddress: associatedTokenProgramId }
-  );
+  payer: PublicKey,
+  associatedToken: PublicKey,
+  owner: PublicKey,
+  mint: PublicKey,
+  programId = TOKEN_PROGRAM_ID,
+  associatedTokenProgramId = ASSOCIATED_TOKEN_PROGRAM_ID
+): TransactionInstruction {
+  const keys = [
+    { pubkey: payer, isSigner: true, isWritable: true },
+    { pubkey: associatedToken, isSigner: false, isWritable: true },
+    { pubkey: owner, isSigner: false, isWritable: false },
+    { pubkey: mint, isSigner: false, isWritable: false },
+    { pubkey: SystemProgram.programId, isSigner: false, isWritable: false },
+    { pubkey: programId, isSigner: false, isWritable: false },
+  ];
+
+  return new TransactionInstruction({
+    keys,
+    programId: associatedTokenProgramId,
+    data: Buffer.alloc(0),
+  });
+}
+
+export function createAddExtraComputeUnitsIx(units: number): TransactionInstruction {
+  return ComputeBudgetProgram.setComputeUnitLimit({ units });
+}
+
+export function createTransactionWithExtraBudget(extraUnits: number = 400000) {
+  return new Transaction().add(createAddExtraComputeUnitsIx(extraUnits));
 }
 
-export function createComputeUnitLimitIx(units: number = 400000): IInstruction {
-  return getSetComputeUnitLimitInstruction({ units });
+export async function assignBlockInfoToTransaction(connection: Connection, transaction: Transaction, payer: PublicKey) {
+  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+  transaction.recentBlockhash = blockhash;
+  transaction.feePayer = payer;
+  transaction.lastValidBlockHeight = lastValidBlockHeight;
+  return transaction;
+}
+
+export async function sendTransactionWithLogs(
+  connection: Connection,
+  tx: Transaction,
+  payer: PublicKey,
+  signers: Signer[],
+  commitment: Commitment = 'processed',
+  skipPreflight: boolean = false
+): Promise<TransactionSignature | null> {
+  const txn = await assignBlockInfoToTransaction(connection, tx, payer);
+  try {
+    const res = await sendAndConfirmTransaction(connection, txn, signers, {
+      commitment: commitment,
+      skipPreflight: skipPreflight,
+    });
+
+    return res;
+  } catch (e) {
+    console.log('ERROR:', e);
+    await sleep(5000);
+    // @ts-ignore
+    const sig = e.toString().split(' failed ')[0].split('Transaction ')[1];
+    const res = await connection.getTransaction(sig, { commitment: 'confirmed' });
+    if (res && res.meta) {
+      console.log('Txn', res.meta.logMessages);
+    }
+    return null;
+  }
 }
 
 export function getStrategyPriceRangeOrca(
@@ -152,17 +195,36 @@ export function getTokenNameFromCollateralInfo(collateralInfo: CollateralInfo) {
   return String.fromCharCode(...collateralInfo.name.filter((x) => x > 0));
 }
 
-export const isSOLMint = (mint: Address): boolean => {
-  return SOL_MINTS.filter((m) => m === mint).length > 0;
+export const isSOLMint = (mint: PublicKey): boolean => {
+  return SOL_MINTS.filter((m) => m.equals(mint)).length > 0;
 };
 
-export async function getMintDecimals(rpc: Rpc<GetAccountInfoApi>, mint: Address): Promise<number> {
+export async function getMintDecimals(connection: Connection, mint: PublicKey): Promise<number> {
   if (isSOLMint(mint)) {
     return DECIMALS_SOL;
   }
-  const acc = await fetchMaybeMint(rpc, mint);
-  if (!acc.exists) {
-    throw new Error(`Mint ${mint} not found`);
+  const acc = await connection.getAccountInfo(mint);
+  if (!acc) {
+    throw new Error(`Mint ${mint.toBase58()} not found`);
   }
-  return acc.data.decimals;
+  const mintInfo = unpackMint(mint, acc, acc.owner);
+  return mintInfo.decimals;
+}
+
+export function removeBudgetAndAtaIxns(ixns: TransactionInstruction[], mints: PublicKey[]): 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);
+    }
+
+    return true;
+  });
 }