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

package/src/services/JupService.ts

@@ -1,19 +1,19 @@
-import { Connection, PublicKey, Transaction, TransactionMessage, VersionedTransaction } from '@solana/web3.js';
-import { SolanaCluster } from '@hubbleprotocol/hubble-config';
+import { AccountRole, address, Address, Instruction as SolanaInstruction } from '@solana/kit';
 import axios from 'axios';
 import Decimal from 'decimal.js';
-import { DeserializedVersionedTransaction } from '../utils';
-import { QuoteResponse, SwapInstructionsResponse, SwapResponse, createJupiterApiClient } from '@jup-ag/api';
-import { PubkeyHashMap } from '../utils/pubkey';
+import {
+  QuoteResponse,
+  SwapInstructionsResponse as JupSwapInstructionsResponse,
+  createJupiterApiClient,
+  Instruction,
+} from '@jup-ag/api';
 
-const USDC_MINT = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
+const USDC_MINT = address('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,26 +21,27 @@ export type SwapTransactionsResponse = {
   cleanupTransaction: string | undefined;
 };
 
-export class JupService {
-  private readonly _connection: Connection;
-  private readonly _cluster: SolanaCluster;
-
-  constructor(connection: Connection, cluster: SolanaCluster) {
-    this._connection = connection;
-    this._cluster = cluster;
-  }
+interface SwapInstructionsResponse {
+  tokenLedgerInstruction?: SolanaInstruction;
+  computeBudgetInstructions: Array<SolanaInstruction>;
+  setupInstructions: Array<SolanaInstruction>;
+  swapInstruction: SolanaInstruction;
+  cleanupInstruction?: SolanaInstruction;
+  addressLookupTableAddresses: Array<Address>;
+}
 
+export class JupService {
   // the amounts has to be in lamports
   static getBestRouteV6 = async (
-    userPublicKey: PublicKey,
+    userAddress: Address,
     amount: Decimal,
-    inputMint: PublicKey,
-    outputMint: PublicKey,
+    inputMint: Address,
+    outputMint: Address,
     slippageBps: number,
     asLegacyTransaction?: boolean,
     maxAccounts?: number,
     onlyDirectRoutes?: boolean
-  ): Promise<SwapResponse> => {
+  ): Promise<SwapInstructionsResponse> => {
     try {
       // https://lite-api.jup.ag/swap/v1/quote?inputMint=7dHbWXmci3dT8UFYWYZweBLXgycu7Y3iL6trKn1Y7ARj&outputMint=mSoLzYCxHdYgdzU16g5QSh3i5K3z3KZK7ytfqcJm7So&amount=71101983&slippageBps=10&onlyDirectRoutes=false&asLegacyTransaction=false&maxAccounts=33
 
@@ -54,15 +55,24 @@ export class JupService {
         onlyDirectRoutes
       );
 
-      const transaction: SwapResponse = await jupiterSwapApi.swapPost({
-        swapRequest: {
-          quoteResponse: res,
-          userPublicKey: userPublicKey.toString(),
-          wrapAndUnwrapSol: false,
-        },
+      const ixsResponse = await jupiterSwapApi.swapInstructionsPost({
+        swapRequest: { quoteResponse: res, userPublicKey: userAddress, wrapAndUnwrapSol: false },
       });
 
-      return transaction;
+      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;
     } catch (error) {
       console.log('getBestRouteV6 error', error);
       throw error;
@@ -71,8 +81,8 @@ export class JupService {
 
   static getBestRouteQuoteV6 = async (
     amount: Decimal,
-    inputMint: PublicKey,
-    outputMint: PublicKey,
+    inputMint: Address,
+    outputMint: Address,
     slippageBps: number,
     asLegacyTransaction?: boolean,
     maxAccounts?: number,
@@ -81,8 +91,8 @@ export class JupService {
   ): Promise<QuoteResponse> => {
     try {
       const params = {
-        inputMint: inputMint.toString(),
-        outputMint: outputMint.toString(),
+        inputMint,
+        outputMint,
         amount: amount.floor().toNumber(),
         slippageBps,
         onlyDirectRoutes: onlyDirectRoutes,
@@ -100,16 +110,16 @@ export class JupService {
   };
 
   static getSwapIxsFromQuote = async (
-    userPublicKey: PublicKey,
+    userAddress: Address,
     quote: QuoteResponse,
     wrapUnwrapSOL = true,
     asLegacyTransaction?: boolean
-  ): Promise<SwapInstructionsResponse> => {
+  ): Promise<JupSwapInstructionsResponse> => {
     try {
       return await jupiterSwapApi.swapInstructionsPost({
         swapRequest: {
           quoteResponse: quote,
-          userPublicKey: userPublicKey.toString(),
+          userPublicKey: userAddress,
           wrapAndUnwrapSol: wrapUnwrapSOL,
           asLegacyTransaction: asLegacyTransaction,
         },
@@ -121,15 +131,11 @@ export class JupService {
   };
 
   static getPrice = async (
-    inputMint: PublicKey | string,
-    outputMint: PublicKey | string,
+    inputMint: Address | string,
+    outputMint: Address | 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') {
@@ -142,16 +148,12 @@ export class JupService {
   };
 
   static getPrices = async (
-    inputMints: (PublicKey | string)[],
-    outputMint: PublicKey | string,
+    inputMints: (Address | string)[],
+    outputMint: Address | string,
     jupEndpoint?: string
-  ): Promise<PubkeyHashMap<PublicKey, Decimal>> => {
+  ): Promise<Map<Address, 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') {
@@ -159,14 +161,14 @@ export class JupService {
     }
 
     const baseURL = jupEndpoint || DEFAULT_JUP_API_ENDPOINT;
-    const prices: PubkeyHashMap<PublicKey, Decimal> = new PubkeyHashMap();
+    const prices = new Map<Address, Decimal>();
     try {
       const res = await axios.get(`${baseURL}/price/v3`, { params });
       for (const mint of inputMints) {
         try {
-          prices.set(new PublicKey(mint), new Decimal(res.data[mint.toString()].usdPrice));
+          prices.set(address(mint), new Decimal(res.data[mint.toString()].usdPrice));
         } catch (e) {
-          prices.set(new PublicKey(mint), new Decimal(0));
+          prices.set(address(mint), new Decimal(0));
         }
       }
     } catch (e) {
@@ -176,59 +178,35 @@ export class JupService {
     return prices;
   };
 
-  static getDollarPrices(
-    inputMints: (PublicKey | string)[],
-    jupEndpoint?: string
-  ): Promise<PubkeyHashMap<PublicKey, Decimal>> {
+  static getDollarPrices(inputMints: (Address | string)[], jupEndpoint?: string): Promise<Map<Address, Decimal>> {
     return this.getPrices(inputMints, USDC_MINT, jupEndpoint);
   }
 
-  static getDollarPrice = async (inputMint: PublicKey | string, jupEndpoint?: string): Promise<number> => {
+  static getDollarPrice = async (inputMint: Address | string, jupEndpoint?: string): Promise<number> => {
     return this.getPrice(inputMint, USDC_MINT, jupEndpoint);
   };
+}
 
-  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'));
-    });
-  };
-
-  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 };
+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 getLookupTableAccount = async (connection: Connection, address: string | PublicKey) => {
-    return connection.getAddressLookupTable(new PublicKey(address)).then((res) => res.value);
-  };
+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;
 }

package/src/services/MeteoraPoolsResponse.ts

@@ -0,0 +1,61 @@
+export interface MeteoraPoolsResponse {
+  pairs: MeteoraPoolAPI[];
+  total: number;
+  meta?: {
+    cursor?: {
+      previous: string | null;
+      next: string | null;
+    };
+    total?: number;
+    page?: number;
+    size?: number;
+  };
+}
+
+export interface MeteoraPoolAPI {
+  address: string;
+  name: string;
+  mint_x: string;
+  mint_y: string;
+  bin_step: number;
+  base_fee_percentage: string;
+  max_fee_percentage: string;
+  protocol_fee_percentage: string;
+  liquidity: string;
+  reward_fee_percentage: string;
+  fees_24h: string;
+  today_fees: string;
+  trade_volume_24h: string;
+  cumulative_trade_volume: string;
+  cumulative_fee_volume: string;
+  current_price: string;
+  apr: string;
+  apy: string;
+  farm_apr: string;
+  farm_apy: string;
+  hide: boolean;
+  pair_point_data?: {
+    pool_address: string;
+    total_point: string;
+    point_per_second: string;
+    updated_at: string;
+  };
+  token_x?: MeteoraTokenAPI;
+  token_y?: MeteoraTokenAPI;
+  active_bin?: {
+    bin_id: number;
+    price: string;
+    liquidity_x: string;
+    liquidity_y: string;
+  };
+}
+
+export interface MeteoraTokenAPI {
+  address: string;
+  name: string;
+  symbol: string;
+  decimals: number;
+  logo_uri?: string;
+  coingecko_id?: string;
+  tags?: string[];
+}

package/src/services/MeteoraService.ts

@@ -1,6 +1,7 @@
-import { Connection, PublicKey } from '@solana/web3.js';
+import { address, Address, Base58EncodedBytes, Rpc, SolanaRpcApi } from '@solana/kit';
 import Decimal from 'decimal.js';
-import { WhirlpoolStrategy } from '../kamino-client/accounts';
+import axios from 'axios';
+import { WhirlpoolStrategy } from '../@codegen/kliquidity/accounts';
 import {
   aprToApy,
   GenericPoolInfo,
@@ -10,46 +11,57 @@ import {
   LiquidityDistribution,
   ZERO,
 } from '../utils';
-import { LbPair, PositionV2 } from '../meteora_client/accounts';
+import { LbPair, PositionV2 } from '../@codegen/meteora/accounts';
 import { WhirlpoolAprApy } from './WhirlpoolAprApy';
-import { METEORA_PROGRAM_ID } from '../meteora_client/programId';
+import { PROGRAM_ID as METEORA_PROGRAM_ID } from '../@codegen/meteora/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: PublicKey;
+  key: Address;
   pool: LbPair;
 }
 
 export class MeteoraService {
-  private readonly _connection: Connection;
-  private readonly _meteoraProgramId: PublicKey;
+  private readonly _rpc: Rpc<SolanaRpcApi>;
+  private readonly _meteoraProgramId: Address;
+  private readonly _meteoraApiUrl: string;
 
-  constructor(connection: Connection, meteoraProgramId: PublicKey = METEORA_PROGRAM_ID) {
-    this._connection = connection;
+  constructor(rpc: Rpc<SolanaRpcApi>, meteoraProgramId: Address = METEORA_PROGRAM_ID) {
+    this._rpc = rpc;
     this._meteoraProgramId = meteoraProgramId;
+    this._meteoraApiUrl = 'https://dlmm-api.meteora.ag';
   }
 
-  getMeteoraProgramId(): PublicKey {
+  getMeteoraProgramId(): Address {
     return this._meteoraProgramId;
   }
 
-  async getPool(poolAddress: PublicKey): Promise<LbPair | null> {
-    return await LbPair.fetch(this._connection, poolAddress);
+  async getPool(poolAddress: Address): Promise<LbPair | null> {
+    return await LbPair.fetch(this._rpc, poolAddress);
   }
 
-  async getPosition(position: PublicKey): Promise<PositionV2 | null> {
-    return await PositionV2.fetch(this._connection, position);
+  async getPosition(position: Address): Promise<PositionV2 | null> {
+    return await PositionV2.fetch(this._rpc, position);
   }
 
   async getMeteoraPools(): Promise<MeteoraPool[]> {
-    const rawPools = await this._connection.getProgramAccounts(METEORA_PROGRAM_ID, {
-      commitment: 'confirmed',
-      filters: [{ dataSize: 904 }],
-    });
+    const rawPools = await this._rpc
+      .getProgramAccounts(METEORA_PROGRAM_ID, {
+        commitment: 'confirmed',
+        filters: [{ dataSize: 904n }],
+        encoding: 'base64+zstd',
+      })
+      .send();
     const pools: MeteoraPool[] = [];
     for (let i = 0; i < rawPools.length; i++) {
       try {
-        const lbPair = LbPair.decode(rawPools[i].account.data);
+        const compressedData = Buffer.from(rawPools[i].account.data[0], 'base64');
+        const decompressedData = decompress(compressedData);
+
+        const lbPair = LbPair.decode(Buffer.from(decompressedData));
         pools.push({ pool: lbPair, key: rawPools[i].pubkey });
       } catch (e) {
         console.log(e);
@@ -58,6 +70,66 @@ 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);
 
@@ -120,7 +192,7 @@ export class MeteoraService {
 
   // strongly recommended to pass lowestTick and highestTick because fetching the lowest and highest existent takes very long
   async getMeteoraLiquidityDistribution(
-    poolKey: PublicKey,
+    poolKey: Address,
     keepOrder: boolean = true,
     lowestTick?: number,
     highestTick?: number
@@ -141,8 +213,8 @@ export class MeteoraService {
     }
 
     const currentTickIndex = pool.activeId;
-    const tokenXDecimals = await getMintDecimals(this._connection, pool.tokenXMint);
-    const tokenYDecimals = await getMintDecimals(this._connection, pool.tokenYMint);
+    const tokenXDecimals = await getMintDecimals(this._rpc, pool.tokenXMint);
+    const tokenYDecimals = await getMintDecimals(this._rpc, pool.tokenYMint);
     const currentPrice = getPriceOfBinByBinIdWithDecimals(
       currentTickIndex,
       pool.binStep,
@@ -158,7 +230,7 @@ export class MeteoraService {
   }
 
   async getMeteoraPositionAprApy(
-    poolPubkey: PublicKey,
+    poolPubkey: Address,
     priceLower: Decimal,
     priceUpper: Decimal
   ): Promise<WhirlpoolAprApy> {
@@ -177,8 +249,8 @@ export class MeteoraService {
         totalApr: ZERO,
       };
     }
-    const tokenXDecimals = await getMintDecimals(this._connection, pool.tokenXMint);
-    const tokenYDecimals = await getMintDecimals(this._connection, pool.tokenYMint);
+    const tokenXDecimals = await getMintDecimals(this._rpc, pool.tokenXMint);
+    const tokenYDecimals = await getMintDecimals(this._rpc, pool.tokenYMint);
     const priceRange = getStrategyPriceRangeMeteora(
       priceLower,
       priceUpper,
@@ -212,14 +284,14 @@ export class MeteoraService {
     };
   }
 
-  async getGenericPoolInfo(poolPubkey: PublicKey): Promise<GenericPoolInfo> {
+  async getGenericPoolInfo(poolPubkey: Address): Promise<GenericPoolInfo> {
     const pool = await this.getPool(poolPubkey);
     if (!pool) {
       return {
         dex: 'METEORA',
-        address: new PublicKey(0),
-        tokenMintA: new PublicKey(0),
-        tokenMintB: new PublicKey(0),
+        address: DEFAULT_PUBLIC_KEY,
+        tokenMintA: DEFAULT_PUBLIC_KEY,
+        tokenMintB: DEFAULT_PUBLIC_KEY,
         price: new Decimal(0),
         feeRate: new Decimal(0),
         volumeOnLast7d: new Decimal(0),
@@ -228,13 +300,13 @@ export class MeteoraService {
         positions: new Decimal(0),
       };
     }
-    const tokenXDecimals = await getMintDecimals(this._connection, pool.tokenXMint);
-    const tokenYDecimals = await getMintDecimals(this._connection, pool.tokenYMint);
+    const tokenXDecimals = await getMintDecimals(this._rpc, pool.tokenXMint);
+    const tokenYDecimals = await getMintDecimals(this._rpc, pool.tokenYMint);
     const price = getPriceOfBinByBinIdWithDecimals(pool.activeId, pool.binStep, tokenXDecimals, tokenYDecimals);
 
     const poolInfo: GenericPoolInfo = {
       dex: 'METEORA',
-      address: new PublicKey(poolPubkey),
+      address: address(poolPubkey),
       tokenMintA: pool.tokenXMint,
       tokenMintB: pool.tokenYMint,
       price,
@@ -249,11 +321,16 @@ export class MeteoraService {
     return poolInfo;
   }
 
-  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 } }],
-    });
+  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();
 
     return rawPositions.length;
   }