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

package/src/services/OrcaService.ts

@@ -1,109 +1,50 @@
-import { address, Address, Base58EncodedBytes, Rpc, SolanaRpcApi } from '@solana/kit';
+import { Connection, PublicKey } from '@solana/web3.js';
 import Decimal from 'decimal.js';
+import {
+  estimateAprsForPriceRange,
+  OrcaNetwork,
+  OrcaWhirlpoolClient,
+  getNearestValidTickIndexFromTickIndex,
+  priceToTickIndex,
+  PoolData,
+} from '@orca-so/whirlpool-sdk';
 import axios from 'axios';
-import { OrcaWhirlpoolsResponse, Whirlpool as WhirlpoolAPIResponse } from './OrcaWhirlpoolsResponse';
-import { WhirlpoolStrategy } from '../@codegen/kliquidity/accounts';
-import { Position } from '../@codegen/whirlpools/accounts';
+import { OrcaWhirlpoolsResponse, Whirlpool } from './OrcaWhirlpoolsResponse';
+import { SolanaCluster } from '@hubbleprotocol/hubble-config';
+import { WhirlpoolStrategy } from '../kamino-client/accounts';
+import { Position } from '../whirlpools-client';
 import { WhirlpoolAprApy } from './WhirlpoolAprApy';
 import {
   aprToApy,
-  estimateAprsForPriceRange,
   GenericPoolInfo,
-  getHighestInitializedTickArrayTickIndex,
-  getLiquidityDistribution,
-  getLowestInitializedTickArrayTickIndex,
-  getNearestValidTickIndexFromTickIndex,
   getStrategyPriceRangeOrca,
   LiquidityDistribution,
   LiquidityForPrice,
   ZERO,
 } from '../utils';
-import { PROGRAM_ID as WHIRLPOOLS_PROGRAM_ID } from '../@codegen/whirlpools/programId';
-import { CollateralInfo } from '../@codegen/kliquidity/types';
+import { WHIRLPOOL_PROGRAM_ID } from '../whirlpools-client/programId';
+import { CollateralInfo } from '../kamino-client/types';
 import { KaminoPrices } from '../models';
-import { priceToTickIndex } from '@orca-so/whirlpools-core';
 
 export class OrcaService {
-  private readonly _rpc: Rpc<SolanaRpcApi>;
-  private readonly _whirlpoolProgramId: Address;
+  private readonly _connection: Connection;
+  private readonly _whirilpoolProgramId: PublicKey;
+  private readonly _orcaNetwork: OrcaNetwork;
   private readonly _orcaApiUrl: string;
 
-  constructor(
-    rpc: Rpc<SolanaRpcApi>,
-    whirlpoolProgramId: Address = WHIRLPOOLS_PROGRAM_ID
-  ) {
-    this._rpc = rpc;
-    this._whirlpoolProgramId = whirlpoolProgramId;
-    this._orcaApiUrl = `https://api.orca.so/v2/solana`;
-  }
-
-  getWhirlpoolProgramId(): Address {
-    return this._whirlpoolProgramId;
+  constructor(connection: Connection, cluster: SolanaCluster, whirlpoolProgramId: PublicKey = WHIRLPOOL_PROGRAM_ID) {
+    this._connection = connection;
+    this._whirilpoolProgramId = whirlpoolProgramId;
+    this._orcaNetwork = cluster === 'mainnet-beta' ? OrcaNetwork.MAINNET : OrcaNetwork.DEVNET;
+    this._orcaApiUrl = `https://api.${cluster === 'mainnet-beta' ? 'mainnet' : 'devnet'}.orca.so`;
   }
 
-  // Fetch all Orca whirlpools with pagination support (note there are over 20 pages so it may take a while)
-  async getOrcaWhirlpools(tokens: Address[] = []): Promise<WhirlpoolAPIResponse[]> {
-    const maxPageSize = 1000;
-    const maxPages = 100; // Safety limit to prevent infinite loops
-    const allWhirlpools: WhirlpoolAPIResponse[] = [];
-    let after: string | undefined = undefined;
-    let hasMore = true;
-    let pageCount = 0;
-
-    while (hasMore && pageCount < maxPages) {
-      pageCount++;
-      const url = new URL(`${this._orcaApiUrl}/pools`);
-      url.searchParams.set('size', maxPageSize.toString());
-
-      if (after) {
-        url.searchParams.set('after', after);
-      }
-
-      // Add token filtering parameters based on the number of tokens provided
-      if (tokens.length === 1) {
-        url.searchParams.set('token', tokens[0]);
-      } else if (tokens.length === 2) {
-        url.searchParams.set('tokensBothOf', tokens.join(','));
-      }
-
-      try {
-        const response = await axios.get<OrcaWhirlpoolsResponse>(url.toString());
-        const data = response.data;
-
-        // Add whirlpools from this page to our collection
-        if (data.data && data.data.length > 0) {
-          allWhirlpools.push(...data.data);
-        }
-
-        // Check if there are more pages using the meta.cursor.next field
-        if (data.meta?.cursor?.next) {
-          after = data.meta.cursor.next;
-          hasMore = true;
-        } else {
-          hasMore = false;
-        }
-      } catch (error) {
-        console.error('Error fetching Orca whirlpools page:', error);
-        throw error;
-      }
-    }
-
-    if (pageCount >= maxPages) {
-      console.warn(`Reached maximum page limit (${maxPages}). There might be more whirlpools available.`);
-    }
-
-    return allWhirlpools;
+  getWhirlpoolProgramId(): PublicKey {
+    return this._whirilpoolProgramId;
   }
 
-  async getOrcaWhirlpool(poolAddress: Address): Promise<WhirlpoolAPIResponse> {
-    const response = await axios.get(`${this._orcaApiUrl}/pools/${poolAddress}`);
-
-    // If the API response has a nested data field that contains the actual pool data
-    if (response.data.data && typeof response.data.data === 'object') {
-      return response.data.data;
-    }
-
-    return response.data;
+  async getOrcaWhirlpools() {
+    return (await axios.get<OrcaWhirlpoolsResponse>(`${this._orcaApiUrl}/v1/whirlpool/list`)).data;
   }
 
   /**
@@ -118,8 +59,8 @@ export class OrcaService {
     strategy: WhirlpoolStrategy,
     prices: KaminoPrices,
     collateralInfos: CollateralInfo[]
-  ): Map<Address, Decimal> {
-    const tokensPrices: Map<Address, Decimal> = new Map();
+  ): Record<string, Decimal> {
+    const tokensPrices: Record<string, Decimal> = {};
 
     const tokenA = collateralInfos[strategy.tokenACollateralId.toNumber()];
     const tokenB = collateralInfos[strategy.tokenBCollateralId.toNumber()];
@@ -133,34 +74,34 @@ export class OrcaService {
     const reward1Price = strategy.reward1Decimals.toNumber() !== 0 ? prices.spot[rewardToken1.mint.toString()] : null;
     const reward2Price = strategy.reward2Decimals.toNumber() !== 0 ? prices.spot[rewardToken2.mint.toString()] : null;
 
-    const [mintA, mintB] = [address(strategy.tokenAMint.toString()), address(strategy.tokenBMint.toString())];
-    const reward0 = address(collateralInfos[strategy.reward0CollateralId.toNumber()]?.mint?.toString());
-    const reward1 = address(collateralInfos[strategy.reward1CollateralId.toNumber()]?.mint?.toString());
-    const reward2 = address(collateralInfos[strategy.reward2CollateralId.toNumber()]?.mint?.toString());
+    const [mintA, mintB] = [strategy.tokenAMint.toString(), strategy.tokenBMint.toString()];
+    const reward0 = collateralInfos[strategy.reward0CollateralId.toNumber()]?.mint?.toString();
+    const reward1 = collateralInfos[strategy.reward1CollateralId.toNumber()]?.mint?.toString();
+    const reward2 = collateralInfos[strategy.reward2CollateralId.toNumber()]?.mint?.toString();
 
-    tokensPrices.set(mintA, aPrice.price);
-    tokensPrices.set(mintB, bPrice.price);
+    tokensPrices[mintA] = aPrice.price;
+    tokensPrices[mintB] = bPrice.price;
     if (reward0Price !== null) {
-      tokensPrices.set(reward0, reward0Price.price);
+      tokensPrices[reward0] = reward0Price.price;
     }
     if (reward1Price !== null) {
-      tokensPrices.set(reward1, reward1Price.price);
+      tokensPrices[reward1] = reward1Price.price;
     }
     if (reward2Price !== null) {
-      tokensPrices.set(reward2, reward2Price.price);
+      tokensPrices[reward2] = reward2Price.price;
     }
 
     return tokensPrices;
   }
 
-  private getPoolTokensPrices(pool: WhirlpoolAPIResponse, prices: KaminoPrices): Map<Address, Decimal> {
-    const tokensPrices: Map<Address, Decimal> = new Map();
+  private getPoolTokensPrices(pool: PoolData, prices: KaminoPrices) {
+    const tokensPrices: Record<string, Decimal> = {};
     const tokens = [
-      address(pool.tokenMintA.toString()),
-      address(pool.tokenMintB.toString()),
-      address(pool.rewards[0]?.mint.toString()),
-      address(pool.rewards[1]?.mint.toString()),
-      address(pool.rewards[2]?.mint.toString()),
+      pool.tokenMintA.toString(),
+      pool.tokenMintB.toString(),
+      pool.rewards[0].mint.toString(),
+      pool.rewards[1].mint.toString(),
+      pool.rewards[2].mint.toString(),
     ];
     for (const mint of tokens) {
       if (mint) {
@@ -168,28 +109,46 @@ export class OrcaService {
         if (!price) {
           throw new Error(`Could not get token ${mint} price`);
         }
-        tokensPrices.set(mint, price);
+        tokensPrices[mint] = price;
       }
     }
 
     return tokensPrices;
   }
 
+  async getPool(poolAddress: PublicKey) {
+    const orca = new OrcaWhirlpoolClient({
+      connection: this._connection,
+      network: this._orcaNetwork,
+    });
+    return await orca.getPool(poolAddress);
+  }
+
   async getStrategyWhirlpoolPoolAprApy(
     strategy: WhirlpoolStrategy,
     collateralInfos: CollateralInfo[],
-    prices: KaminoPrices
+    prices: KaminoPrices,
+    whirlpools?: Whirlpool[]
   ): Promise<WhirlpoolAprApy> {
-    const position = await Position.fetch(this._rpc, strategy.position);
+    const orca = new OrcaWhirlpoolClient({
+      connection: this._connection,
+      network: this._orcaNetwork,
+    });
+    const position = await Position.fetch(this._connection, strategy.position);
     if (!position) {
       throw new Error(`Position ${strategy.position.toString()} does not exist`);
     }
 
-    const pool = await this.getOrcaWhirlpool(strategy.pool);
-    if (!pool) {
-      throw Error(`Could not get orca pool data for ${strategy.pool.toString()}`);
+    const pool = await orca.getPool(strategy.pool);
+    if (!whirlpools) {
+      ({ whirlpools } = await this.getOrcaWhirlpools());
     }
 
+    const whirlpool = whirlpools?.find((x) => x.address === strategy.pool.toString());
+
+    if (!pool || !whirlpool) {
+      throw Error(`Could not get orca pool data for ${strategy.pool.toString()}`);
+    }
     const priceRange = getStrategyPriceRangeOrca(
       position.tickLowerIndex,
       position.tickUpperIndex,
@@ -198,10 +157,7 @@ export class OrcaService {
     );
     if (priceRange.strategyOutOfRange) {
       return {
-        priceLower: new Decimal(priceRange.priceLower),
-        priceUpper: new Decimal(priceRange.priceUpper),
-        poolPrice: new Decimal(pool.price),
-        strategyOutOfRange: priceRange.strategyOutOfRange,
+        ...priceRange,
         rewardsApy: [],
         rewardsApr: [],
         feeApy: ZERO,
@@ -211,34 +167,20 @@ export class OrcaService {
       };
     }
 
-    const lpFeeRate = new Decimal(pool.feeRate);
-    const volume24hUsd = pool.stats['24h']?.volume ?? new Decimal(0);
+    const lpFeeRate = pool.feePercentage;
+    const volume24hUsd = whirlpool?.volume?.day ?? new Decimal(0);
     const fee24Usd = new Decimal(volume24hUsd).mul(lpFeeRate).toNumber();
     const tokensPrices = this.getTokenPrices(strategy, prices, collateralInfos);
 
-    const rewardsDecimals = new Map<Address, number>();
-    if (strategy.reward0Decimals.toNumber() !== 0) {
-      rewardsDecimals.set(address(pool.rewards[0]?.mint), strategy.reward0Decimals.toNumber());
-    }
-    if (strategy.reward1Decimals.toNumber() !== 0) {
-      rewardsDecimals.set(address(pool.rewards[1]?.mint), strategy.reward1Decimals.toNumber());
-    }
-    if (strategy.reward2Decimals.toNumber() !== 0) {
-      rewardsDecimals.set(address(pool.rewards[2]?.mint), strategy.reward2Decimals.toNumber());
-    }
     const apr = estimateAprsForPriceRange(
       pool,
       tokensPrices,
       fee24Usd,
       position.tickLowerIndex,
-      position.tickUpperIndex,
-      rewardsDecimals
+      position.tickUpperIndex
     );
 
-    let totalApr = new Decimal(apr.fee);
-    for (const reward of apr.rewards) {
-      totalApr = totalApr.add(reward);
-    }
+    const totalApr = new Decimal(apr.fee).add(apr.rewards[0]).add(apr.rewards[1]).add(apr.rewards[2]);
     const feeApr = new Decimal(apr.fee);
     const rewardsApr = apr.rewards.map((r) => new Decimal(r));
     return {
@@ -248,22 +190,23 @@ export class OrcaService {
       feeApy: aprToApy(feeApr, 365),
       rewardsApr,
       rewardsApy: rewardsApr.map((x) => aprToApy(x, 365)),
-      priceLower: new Decimal(priceRange.priceLower),
-      priceUpper: new Decimal(priceRange.priceUpper),
-      poolPrice: new Decimal(pool.price),
-      strategyOutOfRange: priceRange.strategyOutOfRange,
+      ...priceRange,
     };
   }
 
   // strongly recommended to pass lowestTick and highestTick because fetching the lowest and highest existent takes very long
   async getWhirlpoolLiquidityDistribution(
-    pool: Address,
+    pool: PublicKey,
     keepOrder: boolean = true,
     lowestTick?: number,
     highestTick?: number
   ): Promise<LiquidityDistribution> {
-    const whirlpool = await this.getOrcaWhirlpool(pool);
-    if (!whirlpool) {
+    const orca = new OrcaWhirlpoolClient({
+      connection: this._connection,
+      network: this._orcaNetwork,
+    });
+    const poolData = await orca.getPool(pool);
+    if (!poolData) {
       throw new Error(`Could not get pool data for Whirlpool ${pool}`);
     }
 
@@ -271,28 +214,25 @@ export class OrcaService {
     if (lowestTick) {
       lowestInitializedTick = lowestTick;
     } else {
-      lowestInitializedTick = await getLowestInitializedTickArrayTickIndex(this._rpc, pool, whirlpool.tickSpacing);
+      lowestInitializedTick = await orca.pool.getLowestInitializedTickArrayTickIndex(pool, poolData.tickSpacing);
     }
 
     let highestInitializedTick: number;
     if (highestTick) {
       highestInitializedTick = highestTick;
     } else {
-      highestInitializedTick = await getHighestInitializedTickArrayTickIndex(this._rpc, pool, whirlpool.tickSpacing);
+      highestInitializedTick = await orca.pool.getHighestInitializedTickArrayTickIndex(pool, poolData.tickSpacing);
     }
 
-    const orcaLiqDistribution = await getLiquidityDistribution(
-      this._rpc,
+    const orcaLiqDistribution = await orca.pool.getLiquidityDistribution(
       pool,
-      whirlpool,
       lowestInitializedTick,
-      highestInitializedTick,
-      this._whirlpoolProgramId
+      highestInitializedTick
     );
 
     const liqDistribution: LiquidityDistribution = {
-      currentPrice: new Decimal(whirlpool.price),
-      currentTickIndex: whirlpool.tickCurrentIndex,
+      currentPrice: poolData.price,
+      currentTickIndex: poolData.tickCurrentIndex,
       distribution: [],
     };
 
@@ -314,19 +254,30 @@ export class OrcaService {
   }
 
   async getWhirlpoolPositionAprApy(
-    poolPubkey: Address,
+    poolPubkey: PublicKey,
     priceLower: Decimal,
     priceUpper: Decimal,
     prices: KaminoPrices,
-    rewardsDecimals: Map<Address, number>
+    whirlpools?: Whirlpool[]
   ): Promise<WhirlpoolAprApy> {
-    const pool = await this.getOrcaWhirlpool(poolPubkey);
-    if (!pool) {
+    const orca = new OrcaWhirlpoolClient({
+      connection: this._connection,
+      network: this._orcaNetwork,
+    });
+
+    const pool = await orca.getPool(poolPubkey);
+    if (!whirlpools) {
+      ({ whirlpools } = await this.getOrcaWhirlpools());
+    }
+
+    const whirlpool = whirlpools?.find((x) => x.address === poolPubkey.toString());
+
+    if (!pool || !whirlpool) {
       throw Error(`Could not get orca pool data for ${poolPubkey}`);
     }
 
     let strategyOutOfRange = false;
-    if (priceLower.gt(new Decimal(pool.price)) || priceUpper.lt(new Decimal(pool.price))) {
+    if (priceLower.gt(pool.price) || priceUpper.lt(pool.price)) {
       strategyOutOfRange = true;
     }
     if (strategyOutOfRange) {
@@ -334,7 +285,7 @@ export class OrcaService {
         priceLower,
         priceUpper,
         strategyOutOfRange,
-        poolPrice: new Decimal(pool.price),
+        poolPrice: pool.price,
         rewardsApy: [],
         rewardsApr: [],
         feeApy: ZERO,
@@ -344,28 +295,21 @@ export class OrcaService {
       };
     }
 
-    const lpFeeRate = pool.feeRate;
-    const volume24hUsd = pool?.stats?.['24h']?.volume ?? new Decimal(0);
+    const lpFeeRate = pool.feePercentage;
+    const volume24hUsd = whirlpool?.volume?.day ?? new Decimal(0);
     const fee24Usd = new Decimal(volume24hUsd).mul(lpFeeRate).toNumber();
     const tokensPrices = this.getPoolTokensPrices(pool, prices);
 
     const tickLowerIndex = getNearestValidTickIndexFromTickIndex(
-      priceToTickIndex(priceLower.toNumber(), pool.tokenA.decimals, pool.tokenB.decimals),
-      pool.tickSpacing
+      priceToTickIndex(priceLower, pool.tokenDecimalsA, pool.tokenDecimalsB),
+      whirlpool.tickSpacing
     );
     const tickUpperIndex = getNearestValidTickIndexFromTickIndex(
-      priceToTickIndex(priceUpper.toNumber(), pool.tokenA.decimals, pool.tokenB.decimals),
-      pool.tickSpacing
+      priceToTickIndex(priceUpper, pool.tokenDecimalsA, pool.tokenDecimalsB),
+      whirlpool.tickSpacing
     );
 
-    const apr = estimateAprsForPriceRange(
-      pool,
-      tokensPrices,
-      fee24Usd,
-      tickLowerIndex,
-      tickUpperIndex,
-      rewardsDecimals
-    );
+    const apr = estimateAprsForPriceRange(pool, tokensPrices, fee24Usd, tickLowerIndex, tickUpperIndex);
 
     const totalApr = new Decimal(apr.fee).add(apr.rewards[0]).add(apr.rewards[1]).add(apr.rewards[2]);
     const feeApr = new Decimal(apr.fee);
@@ -379,26 +323,38 @@ export class OrcaService {
       rewardsApy: rewardsApr.map((x) => aprToApy(x, 365)),
       priceLower,
       priceUpper,
-      poolPrice: new Decimal(pool.price),
+      poolPrice: pool.price,
       strategyOutOfRange,
     };
   }
 
-  async getGenericPoolInfo(poolPubkey: Address) {
-    const pool = await this.getOrcaWhirlpool(poolPubkey);
-    if (!pool) {
-      throw Error(`Could not get orca pool data for ${poolPubkey.toString()}`);
+  async getGenericPoolInfo(poolPubkey: PublicKey, whirlpools?: Whirlpool[]) {
+    const orca = new OrcaWhirlpoolClient({
+      connection: this._connection,
+      network: this._orcaNetwork,
+    });
+
+    const poolString = poolPubkey.toString();
+    const pool = await orca.getPool(poolPubkey);
+    if (!whirlpools) {
+      ({ whirlpools } = await this.getOrcaWhirlpools());
+    }
+
+    const whirlpool = whirlpools?.find((x) => x.address === poolString);
+
+    if (!pool || !whirlpool) {
+      throw Error(`Could not get orca pool data for ${poolString}`);
     }
 
     const poolInfo: GenericPoolInfo = {
       dex: 'ORCA',
-      address: poolPubkey,
-      tokenMintA: address(pool.tokenMintA),
-      tokenMintB: address(pool.tokenMintB),
-      price: new Decimal(pool.price),
-      feeRate: new Decimal(pool.feeRate),
-      volumeOnLast7d: pool.stats['7d'] ? new Decimal(pool.stats['7d'].volume) : undefined,
-      tvl: pool.tvlUsdc ? new Decimal(pool.tvlUsdc) : undefined,
+      address: new PublicKey(poolPubkey),
+      tokenMintA: pool.tokenMintA,
+      tokenMintB: pool.tokenMintB,
+      price: pool.price,
+      feeRate: pool.feePercentage,
+      volumeOnLast7d: whirlpool.volume ? new Decimal(whirlpool.volume?.week) : undefined,
+      tvl: whirlpool.tvl ? new Decimal(whirlpool.tvl) : undefined,
       tickSpacing: new Decimal(pool.tickSpacing),
       // todo(Silviu): get real amount of positions
       positions: new Decimal(0),
@@ -406,17 +362,15 @@ export class OrcaService {
     return poolInfo;
   }
 
-  async getPositionsCountByPool(pool: Address): Promise<number> {
-    const rawPositions = await this._rpc
-      .getProgramAccounts(WHIRLPOOLS_PROGRAM_ID, {
-        commitment: 'confirmed',
-        filters: [
-          // account LAYOUT: https://github.com/orca-so/whirlpools/blob/main/programs/whirlpool/src/state/position.rs#L20
-          { dataSize: 216n },
-          { memcmp: { bytes: pool.toString() as Base58EncodedBytes, offset: 8n, encoding: 'base58' } },
-        ],
-      })
-      .send();
+  async getPositionsCountByPool(pool: PublicKey): Promise<number> {
+    const rawPositions = await this._connection.getProgramAccounts(WHIRLPOOL_PROGRAM_ID, {
+      commitment: 'confirmed',
+      filters: [
+        // account LAYOUT: https://github.com/orca-so/whirlpools/blob/main/programs/whirlpool/src/state/position.rs#L20
+        { dataSize: 216 },
+        { memcmp: { bytes: pool.toBase58(), offset: 8 } },
+      ],
+    });
 
     return rawPositions.length;
   }