@kamino-finance/kliquidity-sdk 8.4.7 → 8.4.8-beta.0

package/src/services/JupService.ts

@@ -1,19 +1,19 @@
-import { AccountRole, address, Address, Instruction as SolanaInstruction } from '@solana/kit';
+import { Connection, PublicKey, Transaction, TransactionMessage, VersionedTransaction } from '@solana/web3.js';
+import { SolanaCluster } from '@hubbleprotocol/hubble-config';
 import axios from 'axios';
 import Decimal from 'decimal.js';
-import {
-  QuoteResponse,
-  SwapInstructionsResponse as JupSwapInstructionsResponse,
-  createJupiterApiClient,
-  Instruction,
-} from '@jup-ag/api';
+import { DeserializedVersionedTransaction } from '../utils';
+import { QuoteResponse, SwapInstructionsResponse, SwapResponse, createJupiterApiClient } from '@jup-ag/api';
+import { PubkeyHashMap } from '../utils/pubkey';
 
-const USDC_MINT = address('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
+const USDC_MINT = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
 
 export const DEFAULT_JUP_API_ENDPOINT = 'https://lite-api.jup.ag';
 export const DEFAULT_JUP_SWAP_API = 'https://lite-api.jup.ag/swap/v1';
 
-const jupiterSwapApi = createJupiterApiClient({ basePath: DEFAULT_JUP_SWAP_API });
+const jupiterSwapApi = createJupiterApiClient({
+  basePath: DEFAULT_JUP_SWAP_API,
+});
 
 export type SwapTransactionsResponse = {
   setupTransaction: string | undefined;
@@ -21,27 +21,26 @@ export type SwapTransactionsResponse = {
   cleanupTransaction: string | undefined;
 };
 
-interface SwapInstructionsResponse {
-  tokenLedgerInstruction?: SolanaInstruction;
-  computeBudgetInstructions: Array<SolanaInstruction>;
-  setupInstructions: Array<SolanaInstruction>;
-  swapInstruction: SolanaInstruction;
-  cleanupInstruction?: SolanaInstruction;
-  addressLookupTableAddresses: Array<Address>;
-}
-
 export class JupService {
+  private readonly _connection: Connection;
+  private readonly _cluster: SolanaCluster;
+
+  constructor(connection: Connection, cluster: SolanaCluster) {
+    this._connection = connection;
+    this._cluster = cluster;
+  }
+
   // the amounts has to be in lamports
   static getBestRouteV6 = async (
-    userAddress: Address,
+    userPublicKey: PublicKey,
     amount: Decimal,
-    inputMint: Address,
-    outputMint: Address,
+    inputMint: PublicKey,
+    outputMint: PublicKey,
     slippageBps: number,
     asLegacyTransaction?: boolean,
     maxAccounts?: number,
     onlyDirectRoutes?: boolean
-  ): Promise<SwapInstructionsResponse> => {
+  ): Promise<SwapResponse> => {
     try {
       // https://lite-api.jup.ag/swap/v1/quote?inputMint=7dHbWXmci3dT8UFYWYZweBLXgycu7Y3iL6trKn1Y7ARj&outputMint=mSoLzYCxHdYgdzU16g5QSh3i5K3z3KZK7ytfqcJm7So&amount=71101983&slippageBps=10&onlyDirectRoutes=false&asLegacyTransaction=false&maxAccounts=33
 
@@ -55,24 +54,15 @@ export class JupService {
         onlyDirectRoutes
       );
 
-      const ixsResponse = await jupiterSwapApi.swapInstructionsPost({
-        swapRequest: { quoteResponse: res, userPublicKey: userAddress, wrapAndUnwrapSol: false },
+      const transaction: SwapResponse = await jupiterSwapApi.swapPost({
+        swapRequest: {
+          quoteResponse: res,
+          userPublicKey: userPublicKey.toString(),
+          wrapAndUnwrapSol: false,
+        },
       });
 
-      const swapIxs: SwapInstructionsResponse = {
-        tokenLedgerInstruction: ixsResponse.tokenLedgerInstruction
-          ? transformResponseIx(ixsResponse.tokenLedgerInstruction)
-          : undefined,
-        computeBudgetInstructions: ixsResponse.computeBudgetInstructions.map((ix) => transformResponseIx(ix)),
-        setupInstructions: ixsResponse.setupInstructions.map((ix) => transformResponseIx(ix)),
-        swapInstruction: transformResponseIx(ixsResponse.swapInstruction),
-        cleanupInstruction: ixsResponse.cleanupInstruction
-          ? transformResponseIx(ixsResponse.cleanupInstruction)
-          : undefined,
-        addressLookupTableAddresses: ixsResponse.addressLookupTableAddresses.map((a) => address(a)),
-      };
-
-      return swapIxs;
+      return transaction;
     } catch (error) {
       console.log('getBestRouteV6 error', error);
       throw error;
@@ -81,8 +71,8 @@ export class JupService {
 
   static getBestRouteQuoteV6 = async (
     amount: Decimal,
-    inputMint: Address,
-    outputMint: Address,
+    inputMint: PublicKey,
+    outputMint: PublicKey,
     slippageBps: number,
     asLegacyTransaction?: boolean,
     maxAccounts?: number,
@@ -91,8 +81,8 @@ export class JupService {
   ): Promise<QuoteResponse> => {
     try {
       const params = {
-        inputMint,
-        outputMint,
+        inputMint: inputMint.toString(),
+        outputMint: outputMint.toString(),
         amount: amount.floor().toNumber(),
         slippageBps,
         onlyDirectRoutes: onlyDirectRoutes,
@@ -110,16 +100,16 @@ export class JupService {
   };
 
   static getSwapIxsFromQuote = async (
-    userAddress: Address,
+    userPublicKey: PublicKey,
     quote: QuoteResponse,
     wrapUnwrapSOL = true,
     asLegacyTransaction?: boolean
-  ): Promise<JupSwapInstructionsResponse> => {
+  ): Promise<SwapInstructionsResponse> => {
     try {
       return await jupiterSwapApi.swapInstructionsPost({
         swapRequest: {
           quoteResponse: quote,
-          userPublicKey: userAddress,
+          userPublicKey: userPublicKey.toString(),
           wrapAndUnwrapSol: wrapUnwrapSOL,
           asLegacyTransaction: asLegacyTransaction,
         },
@@ -131,11 +121,15 @@ export class JupService {
   };
 
   static getPrice = async (
-    inputMint: Address | string,
-    outputMint: Address | string,
+    inputMint: PublicKey | string,
+    outputMint: PublicKey | string,
     jupEndpoint?: string
   ): Promise<number> => {
-    const params = { ids: inputMint.toString(), vsToken: outputMint.toString(), vsAmount: 1 };
+    const params = {
+      ids: inputMint.toString(),
+      vsToken: outputMint.toString(),
+      vsAmount: 1,
+    };
 
     // BONK token
     if (outputMint.toString() === 'DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263') {
@@ -148,12 +142,16 @@ export class JupService {
   };
 
   static getPrices = async (
-    inputMints: (Address | string)[],
-    outputMint: Address | string,
+    inputMints: (PublicKey | string)[],
+    outputMint: PublicKey | string,
     jupEndpoint?: string
-  ): Promise<Map<Address, Decimal>> => {
+  ): Promise<PubkeyHashMap<PublicKey, Decimal>> => {
     const mintsCommaSeparated = inputMints.map((mint) => mint.toString()).join(',');
-    const params = { ids: mintsCommaSeparated, vsToken: outputMint.toString(), vsAmount: 1 };
+    const params = {
+      ids: mintsCommaSeparated,
+      vsToken: outputMint.toString(),
+      vsAmount: 1,
+    };
 
     // BONK token
     if (outputMint.toString() === 'DezXAZ8z7PnrnRJjz3wXBoRgixCa6xjnB7YaB1pPB263') {
@@ -161,14 +159,14 @@ export class JupService {
     }
 
     const baseURL = jupEndpoint || DEFAULT_JUP_API_ENDPOINT;
-    const prices = new Map<Address, Decimal>();
+    const prices: PubkeyHashMap<PublicKey, Decimal> = new PubkeyHashMap();
     try {
       const res = await axios.get(`${baseURL}/price/v3`, { params });
       for (const mint of inputMints) {
         try {
-          prices.set(address(mint), new Decimal(res.data[mint.toString()].usdPrice));
+          prices.set(new PublicKey(mint), new Decimal(res.data[mint.toString()].usdPrice));
         } catch (e) {
-          prices.set(address(mint), new Decimal(0));
+          prices.set(new PublicKey(mint), new Decimal(0));
         }
       }
     } catch (e) {
@@ -178,35 +176,59 @@ export class JupService {
     return prices;
   };
 
-  static getDollarPrices(inputMints: (Address | string)[], jupEndpoint?: string): Promise<Map<Address, Decimal>> {
+  static getDollarPrices(
+    inputMints: (PublicKey | string)[],
+    jupEndpoint?: string
+  ): Promise<PubkeyHashMap<PublicKey, Decimal>> {
     return this.getPrices(inputMints, USDC_MINT, jupEndpoint);
   }
 
-  static getDollarPrice = async (inputMint: Address | string, jupEndpoint?: string): Promise<number> => {
+  static getDollarPrice = async (inputMint: PublicKey | string, jupEndpoint?: string): Promise<number> => {
     return this.getPrice(inputMint, USDC_MINT, jupEndpoint);
   };
-}
 
-export function transformResponseIx(ix: Instruction): SolanaInstruction {
-  return {
-    data: ix.data ? Buffer.from(ix.data, 'base64') : undefined,
-    programAddress: address(ix.programId),
-    accounts: ix.accounts.map((k) => ({
-      address: address(k.pubkey),
-      role: getAccountRole({ isSigner: k.isSigner, isMut: k.isWritable }),
-    })),
+  static buildTransactionsFromSerialized = (serializedTransactions: Array<string | undefined>): Transaction[] => {
+    return serializedTransactions.filter(Boolean).map((tx) => {
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      return Transaction.from(Buffer.from(tx!, 'base64'));
+    });
   };
-}
 
-export function getAccountRole({ isSigner, isMut }: { isSigner: boolean; isMut: boolean }): AccountRole {
-  if (isSigner && isMut) {
-    return AccountRole.WRITABLE_SIGNER;
-  }
-  if (isSigner && !isMut) {
-    return AccountRole.READONLY_SIGNER;
-  }
-  if (!isSigner && isMut) {
-    return AccountRole.WRITABLE;
-  }
-  return AccountRole.READONLY;
+  static deserealizeVersionedTransactions = async (
+    connection: Connection,
+    serializedTransactions: Array<string | undefined>
+  ): Promise<DeserializedVersionedTransaction> => {
+    const filtered = serializedTransactions.filter(Boolean);
+    const result: TransactionMessage[] = [];
+    let lookupTablesAddresses: PublicKey[] = [];
+
+    for (let i = 0; i < filtered.length; i++) {
+      const tx = filtered[i];
+      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+      // safe to use as it is filtered above at 120 line
+      const buffer = Buffer.from(tx!, 'base64');
+
+      const versionedTx = VersionedTransaction.deserialize(buffer);
+      const { addressTableLookups } = versionedTx.message;
+      lookupTablesAddresses = [...lookupTablesAddresses, ...addressTableLookups.map((item) => item.accountKey)];
+
+      const lookupTableAccountsRequests = addressTableLookups.map((item) => {
+        return JupService.getLookupTableAccount(connection, item.accountKey);
+      });
+
+      const lookupTableAccounts = await Promise.all(lookupTableAccountsRequests);
+
+      const decompiledMessage = TransactionMessage.decompile(versionedTx.message, {
+        // @ts-ignore
+        addressLookupTableAccounts: lookupTableAccounts,
+      });
+      result.push(decompiledMessage);
+    }
+
+    return { txMessage: result, lookupTablesAddresses };
+  };
+
+  static getLookupTableAccount = async (connection: Connection, address: string | PublicKey) => {
+    return connection.getAddressLookupTable(new PublicKey(address)).then((res) => res.value);
+  };
 }

package/src/services/MeteoraService.ts

@@ -1,7 +1,6 @@
-import { address, Address, Base58EncodedBytes, Rpc, SolanaRpcApi } from '@solana/kit';
+import { Connection, PublicKey } from '@solana/web3.js';
 import Decimal from 'decimal.js';
-import axios from 'axios';
-import { WhirlpoolStrategy } from '../@codegen/kliquidity/accounts';
+import { WhirlpoolStrategy } from '../kamino-client/accounts';
 import {
   aprToApy,
   GenericPoolInfo,
@@ -11,57 +10,46 @@ import {
   LiquidityDistribution,
   ZERO,
 } from '../utils';
-import { LbPair, PositionV2 } from '../@codegen/meteora/accounts';
+import { LbPair, PositionV2 } from '../meteora_client/accounts';
 import { WhirlpoolAprApy } from './WhirlpoolAprApy';
-import { PROGRAM_ID as METEORA_PROGRAM_ID } from '../@codegen/meteora/programId';
+import { METEORA_PROGRAM_ID } from '../meteora_client/programId';
 import { getPriceOfBinByBinIdWithDecimals } from '../utils/meteora';
-import { DEFAULT_PUBLIC_KEY } from '../constants/pubkeys';
-import { decompress } from 'fzstd';
-import { MeteoraPoolAPI, MeteoraPoolsResponse } from './MeteoraPoolsResponse';
 
 export interface MeteoraPool {
-  key: Address;
+  key: PublicKey;
   pool: LbPair;
 }
 
 export class MeteoraService {
-  private readonly _rpc: Rpc<SolanaRpcApi>;
-  private readonly _meteoraProgramId: Address;
-  private readonly _meteoraApiUrl: string;
+  private readonly _connection: Connection;
+  private readonly _meteoraProgramId: PublicKey;
 
-  constructor(rpc: Rpc<SolanaRpcApi>, meteoraProgramId: Address = METEORA_PROGRAM_ID) {
-    this._rpc = rpc;
+  constructor(connection: Connection, meteoraProgramId: PublicKey = METEORA_PROGRAM_ID) {
+    this._connection = connection;
     this._meteoraProgramId = meteoraProgramId;
-    this._meteoraApiUrl = 'https://dlmm-api.meteora.ag';
   }
 
-  getMeteoraProgramId(): Address {
+  getMeteoraProgramId(): PublicKey {
     return this._meteoraProgramId;
   }
 
-  async getPool(poolAddress: Address): Promise<LbPair | null> {
-    return await LbPair.fetch(this._rpc, poolAddress);
+  async getPool(poolAddress: PublicKey): Promise<LbPair | null> {
+    return await LbPair.fetch(this._connection, poolAddress);
   }
 
-  async getPosition(position: Address): Promise<PositionV2 | null> {
-    return await PositionV2.fetch(this._rpc, position);
+  async getPosition(position: PublicKey): Promise<PositionV2 | null> {
+    return await PositionV2.fetch(this._connection, position);
   }
 
   async getMeteoraPools(): Promise<MeteoraPool[]> {
-    const rawPools = await this._rpc
-      .getProgramAccounts(METEORA_PROGRAM_ID, {
-        commitment: 'confirmed',
-        filters: [{ dataSize: 904n }],
-        encoding: 'base64+zstd',
-      })
-      .send();
+    const rawPools = await this._connection.getProgramAccounts(METEORA_PROGRAM_ID, {
+      commitment: 'confirmed',
+      filters: [{ dataSize: 904 }],
+    });
     const pools: MeteoraPool[] = [];
     for (let i = 0; i < rawPools.length; i++) {
       try {
-        const compressedData = Buffer.from(rawPools[i].account.data[0], 'base64');
-        const decompressedData = decompress(compressedData);
-
-        const lbPair = LbPair.decode(Buffer.from(decompressedData));
+        const lbPair = LbPair.decode(rawPools[i].account.data);
         pools.push({ pool: lbPair, key: rawPools[i].pubkey });
       } catch (e) {
         console.log(e);
@@ -70,66 +58,6 @@ export class MeteoraService {
     return pools;
   }
 
-  // Fetch all Meteora pools from their API with pagination support
-  async getMeteoraPoolsFromAPI(tokens: Address[] = [], maxPages = 300, maxPageSize = 100): Promise<MeteoraPoolAPI[]> {
-    const allPoolsAPI: MeteoraPoolAPI[] = [];
-    let offset = 0;
-    let hasMore = true;
-    let pageCount = 0;
-
-    // First, fetch all pool data from the API
-    while (hasMore && pageCount < maxPages) {
-      pageCount++;
-      const url = new URL(`${this._meteoraApiUrl}/pair/all_with_pagination`);
-      url.searchParams.set('limit', maxPageSize.toString());
-      url.searchParams.set('offset', offset.toString());
-
-      // Add token filtering if provided
-      if (tokens.length === 1) {
-        url.searchParams.set('token', tokens[0]);
-      } else if (tokens.length === 2) {
-        url.searchParams.set('token_x', tokens[0]);
-        url.searchParams.set('token_y', tokens[1]);
-      }
-
-      const response = await axios.get<MeteoraPoolsResponse>(url.toString());
-      const data = response.data;
-
-      // Add pools from this page to our collection
-      // The Meteora API returns { pairs: [...pools...], total: number }
-      if (data.pairs && Array.isArray(data.pairs) && data.pairs.length > 0) {
-        allPoolsAPI.push(...data.pairs);
-        offset += data.pairs.length;
-      }
-
-      // Check if there are more pages
-      const responseLength = data.pairs ? data.pairs.length : 0;
-      if (responseLength < maxPageSize) {
-        hasMore = false;
-      }
-
-      // Check total if available
-      if (data.total && allPoolsAPI.length >= data.total) {
-        hasMore = false;
-      }
-
-      // Check pagination metadata if available
-      if (data.meta) {
-        if (data.meta.cursor && !data.meta.cursor.next) {
-          hasMore = false;
-        }
-        if (data.meta.total && allPoolsAPI.length >= data.meta.total) {
-          hasMore = false;
-        }
-      }
-    }
-
-    if (pageCount >= maxPages) {
-      throw new Error(`Reached maximum page limit (${maxPages}). There might be more pools available.`);
-    }
-    return allPoolsAPI;
-  }
-
   async getStrategyMeteoraPoolAprApy(strategy: WhirlpoolStrategy): Promise<WhirlpoolAprApy> {
     const position = await this.getPosition(strategy.position);
 
@@ -192,7 +120,7 @@ export class MeteoraService {
 
   // strongly recommended to pass lowestTick and highestTick because fetching the lowest and highest existent takes very long
   async getMeteoraLiquidityDistribution(
-    poolKey: Address,
+    poolKey: PublicKey,
     keepOrder: boolean = true,
     lowestTick?: number,
     highestTick?: number
@@ -213,8 +141,8 @@ export class MeteoraService {
     }
 
     const currentTickIndex = pool.activeId;
-    const tokenXDecimals = await getMintDecimals(this._rpc, pool.tokenXMint);
-    const tokenYDecimals = await getMintDecimals(this._rpc, pool.tokenYMint);
+    const tokenXDecimals = await getMintDecimals(this._connection, pool.tokenXMint);
+    const tokenYDecimals = await getMintDecimals(this._connection, pool.tokenYMint);
     const currentPrice = getPriceOfBinByBinIdWithDecimals(
       currentTickIndex,
       pool.binStep,
@@ -230,7 +158,7 @@ export class MeteoraService {
   }
 
   async getMeteoraPositionAprApy(
-    poolPubkey: Address,
+    poolPubkey: PublicKey,
     priceLower: Decimal,
     priceUpper: Decimal
   ): Promise<WhirlpoolAprApy> {
@@ -249,8 +177,8 @@ export class MeteoraService {
         totalApr: ZERO,
       };
     }
-    const tokenXDecimals = await getMintDecimals(this._rpc, pool.tokenXMint);
-    const tokenYDecimals = await getMintDecimals(this._rpc, pool.tokenYMint);
+    const tokenXDecimals = await getMintDecimals(this._connection, pool.tokenXMint);
+    const tokenYDecimals = await getMintDecimals(this._connection, pool.tokenYMint);
     const priceRange = getStrategyPriceRangeMeteora(
       priceLower,
       priceUpper,
@@ -284,14 +212,14 @@ export class MeteoraService {
     };
   }
 
-  async getGenericPoolInfo(poolPubkey: Address): Promise<GenericPoolInfo> {
+  async getGenericPoolInfo(poolPubkey: PublicKey): Promise<GenericPoolInfo> {
     const pool = await this.getPool(poolPubkey);
     if (!pool) {
       return {
         dex: 'METEORA',
-        address: DEFAULT_PUBLIC_KEY,
-        tokenMintA: DEFAULT_PUBLIC_KEY,
-        tokenMintB: DEFAULT_PUBLIC_KEY,
+        address: new PublicKey(0),
+        tokenMintA: new PublicKey(0),
+        tokenMintB: new PublicKey(0),
         price: new Decimal(0),
         feeRate: new Decimal(0),
         volumeOnLast7d: new Decimal(0),
@@ -300,13 +228,13 @@ export class MeteoraService {
         positions: new Decimal(0),
       };
     }
-    const tokenXDecimals = await getMintDecimals(this._rpc, pool.tokenXMint);
-    const tokenYDecimals = await getMintDecimals(this._rpc, pool.tokenYMint);
+    const tokenXDecimals = await getMintDecimals(this._connection, pool.tokenXMint);
+    const tokenYDecimals = await getMintDecimals(this._connection, pool.tokenYMint);
     const price = getPriceOfBinByBinIdWithDecimals(pool.activeId, pool.binStep, tokenXDecimals, tokenYDecimals);
 
     const poolInfo: GenericPoolInfo = {
       dex: 'METEORA',
-      address: address(poolPubkey),
+      address: new PublicKey(poolPubkey),
       tokenMintA: pool.tokenXMint,
       tokenMintB: pool.tokenYMint,
       price,
@@ -321,16 +249,11 @@ export class MeteoraService {
     return poolInfo;
   }
 
-  async getPositionsCountByPool(pool: Address): Promise<number> {
-    const rawPositions = await this._rpc
-      .getProgramAccounts(METEORA_PROGRAM_ID, {
-        commitment: 'confirmed',
-        filters: [
-          { dataSize: 8120n },
-          { memcmp: { bytes: pool.toString() as Base58EncodedBytes, offset: 8n, encoding: 'base58' } },
-        ],
-      })
-      .send();
+  async getPositionsCountByPool(pool: PublicKey): Promise<number> {
+    const rawPositions = await this._connection.getProgramAccounts(METEORA_PROGRAM_ID, {
+      commitment: 'confirmed',
+      filters: [{ dataSize: 8120 }, { memcmp: { bytes: pool.toBase58(), offset: 8 } }],
+    });
 
     return rawPositions.length;
   }