@kamino-finance/kliquidity-sdk 6.2.1 → 6.3.0

package/src/utils/priceReferenceTypes.ts

@@ -0,0 +1,11 @@
+import { PriceReferenceType } from './types';
+
+export const PoolPriceReferenceType: PriceReferenceType = {
+  name: 'Pool',
+  description: "Use the pool's current price as the reference price for rebalancing",
+};
+
+export const TwapPriceReferenceType: PriceReferenceType = {
+  name: 'TWAP',
+  description: 'Use the time weighted average price as the reference price for rebalancing',
+};

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/raydium.ts

@@ -0,0 +1,10 @@
+import Decimal from 'decimal.js';
+
+export function priceToTickIndexWithRounding(price: number): number {
+  const tickIndex = new Decimal(Math.log(Math.sqrt(price)))
+    .div(new Decimal(Math.log(Math.sqrt(1.0001))))
+    .round()
+    .toNumber();
+
+  return tickIndex;
+}

package/src/utils/tokenUtils.ts

@@ -0,0 +1,259 @@
+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 '../kamino-client/types';
+import { getPriceOfBinByBinIdWithDecimals } from './meteora';
+import { MintInfo, MintLayout, u64 } 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 = [
+  new PublicKey('So11111111111111111111111111111111111111111'),
+  new PublicKey('So11111111111111111111111111111111111111112'),
+];
+export const DECIMALS_SOL = 9;
+
+export async function getAssociatedTokenAddressAndData(
+  connection: Connection,
+  mint: PublicKey,
+  owner: PublicKey,
+  programId = TOKEN_PROGRAM_ID
+): Promise<[PublicKey, AccountInfo<Buffer> | null]> {
+  const ata = getAssociatedTokenAddress(mint, owner, true, programId);
+  const data = await connection.getAccountInfo(ata);
+  return [ata, data];
+}
+
+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 function createAssociatedTokenAccountInstruction(
+  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 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(
+  tickLowerIndex: number,
+  tickUpperIndex: number,
+  strategy: WhirlpoolStrategy,
+  poolPrice: Decimal
+) {
+  const { priceLower, priceUpper } = getPriceLowerUpper(
+    tickLowerIndex,
+    tickUpperIndex,
+    Number(strategy.tokenAMintDecimals.toString()),
+    Number(strategy.tokenBMintDecimals.toString())
+  );
+  const strategyOutOfRange = poolPrice.lt(priceLower) || poolPrice.gt(priceUpper);
+  return { priceLower, poolPrice, priceUpper, strategyOutOfRange };
+}
+
+export function getStrategyPriceRangeRaydium(
+  tickLowerIndex: number,
+  tickUpperIndex: number,
+  tickCurrent: number,
+  tokenADecimals: number,
+  tokenBDecimals: number
+) {
+  const { priceLower, priceUpper } = getPriceLowerUpper(tickLowerIndex, tickUpperIndex, tokenADecimals, tokenBDecimals);
+  const poolPrice = tickIndexToPrice(tickCurrent, tokenADecimals, tokenBDecimals);
+  const strategyOutOfRange = poolPrice.lt(priceLower) || poolPrice.gt(priceUpper);
+  return { priceLower, poolPrice, priceUpper, strategyOutOfRange };
+}
+
+export function getStrategyPriceRangeMeteora(
+  priceLower: Decimal,
+  priceUpper: Decimal,
+  activeBinId: number,
+  binStep: number,
+  decimalsA: number,
+  decimalsB: number
+) {
+  const poolPrice = getPriceOfBinByBinIdWithDecimals(activeBinId, binStep, decimalsA, decimalsB);
+  const strategyOutOfRange = poolPrice.lt(priceLower) || poolPrice.gt(priceUpper);
+  return { priceLower, poolPrice, priceUpper, strategyOutOfRange };
+}
+
+export function getMeteoraPriceLowerUpper(
+  tickLowerIndex: number,
+  tickUpperIndex: number,
+  tokenAMintDecimals: number,
+  tokenBMintDecimals: number,
+  binStep: number
+) {
+  const priceLower = getPriceOfBinByBinIdWithDecimals(tickLowerIndex, binStep, tokenAMintDecimals, tokenBMintDecimals);
+  const priceUpper = getPriceOfBinByBinIdWithDecimals(tickUpperIndex, binStep, tokenAMintDecimals, tokenBMintDecimals);
+  return { priceLower, priceUpper };
+}
+
+export function getPriceLowerUpper(
+  tickLowerIndex: number,
+  tickUpperIndex: number,
+  tokenAMintDecimals: number,
+  tokenBMintDecimals: number
+) {
+  const priceLower = tickIndexToPrice(
+    tickLowerIndex,
+    Number(tokenAMintDecimals.toString()),
+    Number(tokenBMintDecimals.toString())
+  );
+  const priceUpper = tickIndexToPrice(
+    tickUpperIndex,
+    Number(tokenAMintDecimals.toString()),
+    Number(tokenBMintDecimals.toString())
+  );
+  return { priceLower, priceUpper };
+}
+
+export function getTokenNameFromCollateralInfo(collateralInfo: CollateralInfo) {
+  return String.fromCharCode(...collateralInfo.name.filter((x) => x > 0));
+}
+
+export const isSOLMint = (mint: PublicKey): boolean => {
+  return SOL_MINTS.filter((m) => m.equals(mint)).length > 0;
+};
+
+export async function getMintDecimals(connection: Connection, mint: PublicKey): Promise<number> {
+  if (isSOLMint(mint)) {
+    return DECIMALS_SOL;
+  }
+  const acc = await connection.getAccountInfo(mint);
+  if (!acc) {
+    throw new Error(`Mint ${mint.toBase58()} not found`);
+  }
+  const mintInfo = decodeMint(acc);
+  return mintInfo.decimals;
+}
+
+export function decodeMint(acc: AccountInfo<Buffer>): MintInfo {
+  const data = Buffer.from(acc.data);
+  const mintInfo = MintLayout.decode(data);
+
+  if (mintInfo.mintAuthorityOption === 0) {
+    mintInfo.mintAuthority = null;
+  } else {
+    mintInfo.mintAuthority = new PublicKey(mintInfo.mintAuthority);
+  }
+
+  mintInfo.supply = u64.fromBuffer(mintInfo.supply);
+  mintInfo.isInitialized = mintInfo.isInitialized != 0;
+
+  if (mintInfo.freezeAuthorityOption === 0) {
+    mintInfo.freezeAuthority = null;
+  } else {
+    mintInfo.freezeAuthority = new PublicKey(mintInfo.freezeAuthority);
+  }
+
+  return mintInfo;
+}
+
+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;
+  });
+}