@kamino-finance/kliquidity-sdk 6.2.2 → 6.3.1

package/src/utils/transactions.ts

@@ -0,0 +1,201 @@
+import {
+  AccountInfo,
+  ComputeBudgetProgram,
+  Connection,
+  PublicKey,
+  SystemProgram,
+  Transaction,
+  TransactionInstruction,
+} from '@solana/web3.js';
+import Decimal from 'decimal.js';
+import {
+  ASSOCIATED_TOKEN_PROGRAM_ID,
+  DECIMALS_SOL,
+  createAssociatedTokenAccountInstruction,
+  getAssociatedTokenAddress,
+} from './tokenUtils';
+import { NATIVE_MINT, Token, TOKEN_PROGRAM_ID } from '@solana/spl-token';
+import { collToLamportsDecimal } from './utils';
+import { CreateAta } from './types';
+
+export const MAX_ACCOUNTS_PER_TRANSACTION = 64;
+
+export const decodeSerializedTransaction = (tx: string | undefined) => {
+  if (!tx) {
+    return undefined;
+  }
+  return Transaction.from(Buffer.from(tx, 'base64'));
+};
+
+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;
+};
+
+export const createAtaIfMissingIx = async (
+  connection: Connection,
+  mint: PublicKey,
+  owner: PublicKey,
+  programId: PublicKey
+): Promise<TransactionInstruction | undefined> => {
+  const ata = getAssociatedTokenAddress(mint, owner, true, programId);
+  const doesAtaExist = Boolean(await checkIfAccountExists(connection, ata));
+  const createIxn = !doesAtaExist
+    ? createAssociatedTokenAccountInstruction(owner, ata, owner, mint, programId)
+    : undefined;
+  return createIxn;
+};
+
+export const getAtasWithCreateIxnsIfMissing = async (
+  connection: Connection,
+  mints: [PublicKey, PublicKey][],
+  owner: PublicKey
+): Promise<TransactionInstruction[]> => {
+  const requests = mints.map(async ([mint, tokenProgram]) => {
+    const createAtaIx = await createAtaIfMissingIx(connection, mint, owner, tokenProgram);
+    if (createAtaIx) {
+      return createAtaIx;
+    }
+    return undefined;
+  });
+  const result = (await Promise.all(requests.filter((x) => x !== undefined))).filter(
+    (ix) => ix !== undefined
+  ) as TransactionInstruction[];
+
+  return result;
+};
+
+export const createWsolAtaIfMissing = async (
+  connection: Connection,
+  amount: Decimal,
+  owner: PublicKey,
+  method: 'deposit' | 'withdraw' = 'deposit'
+): Promise<CreateAta> => {
+  const createIxns: TransactionInstruction[] = [];
+  const closeIxns: TransactionInstruction[] = [];
+
+  const wsolAta: PublicKey = await Token.getAssociatedTokenAddress(
+    ASSOCIATED_TOKEN_PROGRAM_ID,
+    TOKEN_PROGRAM_ID,
+    NATIVE_MINT,
+    owner
+  );
+
+  const solDeposit = amount.toNumber();
+  const wsolAtaAccountInfo: AccountInfo<Buffer> | null = await connection.getAccountInfo(wsolAta);
+
+  // This checks if we need to create it
+  if (isWsolInfoInvalid(wsolAtaAccountInfo)) {
+    createIxns.push(
+      Token.createAssociatedTokenAccountInstruction(
+        ASSOCIATED_TOKEN_PROGRAM_ID,
+        TOKEN_PROGRAM_ID,
+        NATIVE_MINT,
+        wsolAta,
+        owner,
+        owner
+      )
+    );
+  }
+
+  let uiAmount = 0;
+  try {
+    if (wsolAtaAccountInfo != null) {
+      const tokenBalance = await findAtaBalance(connection, wsolAta);
+      uiAmount = tokenBalance === null ? 0 : tokenBalance;
+    }
+  } catch (err) {
+    console.log('Err Token Balance', err);
+  }
+
+  if (solDeposit !== null && solDeposit > uiAmount && method === 'deposit') {
+    createIxns.push(
+      SystemProgram.transfer({
+        fromPubkey: owner,
+        toPubkey: wsolAta,
+        lamports: BigInt(
+          collToLamportsDecimal(new Decimal(solDeposit - uiAmount), DECIMALS_SOL)
+            .floor()
+            .toString()
+        ),
+      })
+    );
+  }
+
+  if (createIxns.length > 0) {
+    createIxns.push(
+      // Sync Native instruction. @solana/spl-token will release it soon. Here use the raw instruction temporally.
+      new TransactionInstruction({
+        keys: [
+          {
+            pubkey: wsolAta,
+            isSigner: false,
+            isWritable: true,
+          },
+        ],
+        data: Buffer.from(new Uint8Array([17])),
+        programId: TOKEN_PROGRAM_ID,
+      })
+    );
+  }
+
+  closeIxns.push(
+    Token.createCloseAccountInstruction(TOKEN_PROGRAM_ID, wsolAta, new PublicKey(owner), new PublicKey(owner), [])
+  );
+
+  return {
+    ata: wsolAta,
+    createIxns,
+    closeIxns,
+  };
+};
+
+export const isWsolInfoInvalid = (wsolAtaAccountInfo: any): boolean => {
+  const res =
+    wsolAtaAccountInfo === null ||
+    (wsolAtaAccountInfo !== null &&
+      wsolAtaAccountInfo.data.length === 0 &&
+      wsolAtaAccountInfo.owner.toString() === '11111111111111111111111111111111');
+
+  return res;
+};
+
+export async function checkIfAccountExists(connection: Connection, account: PublicKey): Promise<boolean> {
+  return (await connection.getAccountInfo(account)) != null;
+}
+
+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;
+  });
+}
+
+export const findAtaBalance = async (connection: Connection, ata: PublicKey): Promise<number | null> => {
+  const res = await connection.getTokenAccountBalance(ata);
+  if (res && res.value) {
+    return res.value.uiAmount;
+  }
+  return null;
+};

package/src/utils/types.ts

@@ -0,0 +1,312 @@
+import { PublicKey, TransactionInstruction, TransactionMessage } from '@solana/web3.js';
+import { WhirlpoolStrategy } from '../kamino-client/accounts';
+import { Dex, collToLamportsDecimal } from './utils';
+import Decimal from 'decimal.js';
+import { RebalanceTypeKind } from '../kamino-client/types';
+
+export const RAYDIUM_DEVNET_PROGRAM_ID = new PublicKey('devi51mZmdwUJGU9hjN27vEz64Gps7uUefqxg27EAtH');
+
+export type StrategyType = 'NON_PEGGED' | 'PEGGED' | 'STABLE';
+export type StrategyCreationStatus = 'IGNORED' | 'SHADOW' | 'LIVE' | 'DEPRECATED' | 'STAGING';
+
+export type StrategiesFilters = {
+  strategyType?: StrategyType;
+  strategyCreationStatus?: StrategyCreationStatus;
+  isCommunity?: boolean;
+  owner?: PublicKey;
+};
+
+export function strategyTypeToBase58(strategyType: StrategyType): string {
+  switch (strategyType) {
+    case 'NON_PEGGED':
+      return '1';
+    case 'PEGGED':
+      return '2';
+    case 'STABLE':
+      return '3';
+    default:
+      throw new Error(`Invalid strategyType ${strategyType}`);
+  }
+}
+
+export function strategyTypeToNumber(strategyType: StrategyType): number {
+  switch (strategyType) {
+    case 'NON_PEGGED':
+      return 0;
+    case 'PEGGED':
+      return 1;
+    case 'STABLE':
+      return 2;
+    default:
+      throw new Error(`Invalid strategyType ${strategyType}`);
+  }
+}
+
+export function getStrategyTypeFromStrategy(strategy: WhirlpoolStrategy): StrategyType {
+  switch (strategy.strategyType.toNumber()) {
+    case 0:
+      return 'NON_PEGGED';
+    case 1:
+      return 'PEGGED';
+    case 2:
+      return 'STABLE';
+    default:
+      throw new Error(`Unknown strategyType value ${strategy.strategyType.toNumber()}`);
+  }
+}
+
+export function strategyCreationStatusToBase58(strategyCreationStatus: StrategyCreationStatus): string {
+  switch (strategyCreationStatus) {
+    case 'IGNORED':
+      return '1';
+    case 'SHADOW':
+      return '2';
+    case 'LIVE':
+      return '3';
+    case 'DEPRECATED':
+      return '4';
+    case 'STAGING':
+      return '5';
+    default:
+      throw new Error(`Invalid strategyCreationStatus ${strategyCreationStatus}`);
+  }
+}
+
+export function strategyCreationStatusToNumber(strategyCreationStatus: StrategyCreationStatus): number {
+  switch (strategyCreationStatus) {
+    case 'IGNORED':
+      return 0;
+    case 'SHADOW':
+      return 1;
+    case 'LIVE':
+      return 2;
+    case 'DEPRECATED':
+      return 3;
+    case 'STAGING':
+      return 4;
+    default:
+      throw new Error(`Invalid strategyCreationStatus ${strategyCreationStatus}`);
+  }
+}
+
+export function getStrategyCreationStatusFromStrategy(strategy: WhirlpoolStrategy): StrategyCreationStatus {
+  switch (strategy.creationStatus) {
+    case 0:
+      return 'IGNORED';
+    case 1:
+      return 'SHADOW';
+    case 2:
+      return 'LIVE';
+    case 3:
+      return 'DEPRECATED';
+    case 4:
+      return 'STAGING';
+    default:
+      throw new Error(`Invalid strategyCreationStatus ${strategy.creationStatus}`);
+  }
+}
+
+export interface GenericPoolInfo {
+  dex: Dex;
+  address: PublicKey;
+  tokenMintA: PublicKey;
+  tokenMintB: PublicKey;
+  price: Decimal;
+  feeRate: Decimal;
+  volumeOnLast7d: Decimal | undefined;
+  tvl: Decimal | undefined;
+  tickSpacing: Decimal;
+  positions: Decimal;
+}
+
+export interface GenericPositionRangeInfo {
+  estimatedApy: Decimal;
+  estimatedVolume: Decimal | undefined;
+}
+
+export interface VaultParameters {
+  tokenMintA: PublicKey;
+  tokenMintB: PublicKey;
+  dex: Dex;
+  feeTier: Decimal;
+  rebalancingParameters: RebalanceFieldInfo[];
+}
+
+export interface LiquidityDistribution {
+  currentPrice: Decimal;
+  currentTickIndex: number;
+  distribution: LiquidityForPrice[];
+}
+
+export interface LiquidityForPrice {
+  price: Decimal;
+  liquidity: Decimal;
+  tickIndex: number;
+}
+
+export interface DepositAmountsForSwap {
+  requiredAAmountToDeposit: Decimal;
+  requiredBAmountToDeposit: Decimal;
+  tokenAToSwapAmount: Decimal;
+  tokenBToSwapAmount: Decimal;
+}
+
+export function depositAmountsForSwapToLamports(
+  depositAmounts: DepositAmountsForSwap,
+  tokenADecimals: number,
+  tokenBDecimals: number
+): DepositAmountsForSwap {
+  return {
+    requiredAAmountToDeposit: collToLamportsDecimal(depositAmounts.requiredAAmountToDeposit, tokenADecimals),
+    requiredBAmountToDeposit: collToLamportsDecimal(depositAmounts.requiredBAmountToDeposit, tokenBDecimals),
+    tokenAToSwapAmount: collToLamportsDecimal(depositAmounts.tokenAToSwapAmount, tokenADecimals),
+    tokenBToSwapAmount: collToLamportsDecimal(depositAmounts.tokenBToSwapAmount, tokenBDecimals),
+  };
+}
+
+export interface RebalanceParams {
+  rebalanceType: RebalanceTypeKind;
+  lowerRangeBps?: Decimal;
+  upperRangeBps?: Decimal;
+  resetRangeLowerBps?: Decimal;
+  resetRangeUpperBps?: Decimal;
+  startMidTick?: Decimal;
+  ticksBelowMid?: Decimal;
+  ticksAboveMid?: Decimal;
+  secondsPerTick?: Decimal;
+  driftDirection?: Decimal;
+  period?: Decimal;
+  lowerRangePrice?: Decimal;
+  upperRangePrice?: Decimal;
+  destinationToken?: Decimal;
+}
+
+export interface RebalanceParamsAsPrices {
+  rebalanceType: RebalanceTypeKind;
+  rangePriceLower: Decimal;
+  rangePriceUpper: Decimal;
+  resetPriceLower?: Decimal;
+  resetPriceUpper?: Decimal;
+}
+
+export interface PositionRange {
+  lowerPrice: Decimal;
+  upperPrice: Decimal;
+}
+
+export interface MaybeTokensBalances {
+  a?: Decimal;
+  b?: Decimal;
+}
+
+export interface TokensBalances {
+  a: Decimal;
+  b: Decimal;
+}
+
+export interface SwapperIxBuilder {
+  (
+    input: DepositAmountsForSwap,
+    tokenAMint: PublicKey,
+    tokenBMint: PublicKey,
+    owner: PublicKey,
+    slippage: Decimal,
+    allKeys: PublicKey[]
+  ): Promise<[TransactionInstruction[], PublicKey[]]>;
+}
+
+export interface ProfiledFunctionExecution {
+  <T>(promise: Promise<T>, transactionName: string, tags: [string, string][]): Promise<T>;
+}
+
+export function noopProfiledFunctionExecution(promise: Promise<any>): Promise<any> {
+  return promise;
+}
+
+export interface CreateAta {
+  ata: PublicKey;
+  createIxns: TransactionInstruction[];
+  closeIxns: TransactionInstruction[];
+}
+
+export interface DeserializedVersionedTransaction {
+  txMessage: TransactionMessage[];
+  lookupTablesAddresses: PublicKey[];
+}
+
+export interface InstructionsWithLookupTables {
+  instructions: TransactionInstruction[];
+  lookupTablesAddresses: PublicKey[];
+}
+
+export interface PerformanceFees {
+  feesFeeBPS: Decimal;
+  reward0FeeBPS: Decimal;
+  reward1FeeBPS: Decimal;
+  reward2FeeBPS: Decimal;
+}
+
+export interface RebalanceFieldInfo {
+  label: string;
+  type: string;
+  value: Decimal | string;
+  enabled: boolean; // if true, the field is editable and it is one of the rebalancing fields; if false it is a field that is calculated/generated from the rebalancing fields + other data (price, fee tier, etc)
+}
+
+export type RebalanceFieldsDict = { [key: string]: Decimal };
+
+export interface PriceReferenceType {
+  name: string;
+  descriptionShort?: string;
+  description?: string;
+}
+
+export interface InputRebalanceFieldInfo {
+  label: string;
+  value: Decimal;
+}
+
+export interface InitStrategyIxs {
+  initStrategyIx: TransactionInstruction;
+  updateStrategyParamsIxs: TransactionInstruction[];
+  updateRebalanceParamsIx: TransactionInstruction;
+  openPositionIxs: TransactionInstruction[];
+}
+
+export interface WithdrawShares {
+  prerequisiteIxs: TransactionInstruction[];
+  withdrawIx: TransactionInstruction;
+  closeSharesAtaIx?: TransactionInstruction;
+}
+
+export interface MetadataProgramAddressesOrca {
+  position: PublicKey;
+  positionBump: number;
+  positionMetadata: PublicKey;
+  positionMetadataBump: number;
+}
+
+export interface MetadataProgramAddressesRaydium {
+  position: PublicKey;
+  positionBump: number;
+  protocolPosition: PublicKey;
+  protocolPositionBump: number;
+  positionMetadata: PublicKey;
+  positionMetadataBump: number;
+}
+
+export interface LowerAndUpperTickPubkeys {
+  lowerTick: PublicKey;
+  lowerTickBump: number;
+  upperTick: PublicKey;
+  upperTickBump: number;
+}
+export interface WithdrawAllAndCloseIxns {
+  withdrawIxns: TransactionInstruction[];
+  closeIxn: TransactionInstruction;
+}
+
+export interface InitPoolTickIfNeeded {
+  tick: PublicKey;
+  initTickIx: TransactionInstruction | undefined;
+}