@kamino-finance/kliquidity-sdk 6.2.2 → 6.3.0

package/src/services/OrcaService.ts

@@ -0,0 +1,383 @@
+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 } 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,
+  GenericPoolInfo,
+  getStrategyPriceRangeOrca,
+  LiquidityDistribution,
+  LiquidityForPrice,
+  ZERO,
+} from '../utils';
+import { WHIRLPOOL_PROGRAM_ID } from '../whirlpools-client/programId';
+import { CollateralInfo } from '../kamino-client/types';
+import { KaminoPrices } from '../models';
+import { PROGRAM_ID } from '../kamino-client/programId';
+
+export class OrcaService {
+  private readonly _connection: Connection;
+  private readonly _cluster: SolanaCluster;
+  private readonly _orcaNetwork: OrcaNetwork;
+  private readonly _orcaApiUrl: string;
+  private readonly _globalConfig: PublicKey;
+  private readonly _kaminoProgramId: PublicKey;
+
+  constructor(
+    connection: Connection,
+    cluster: SolanaCluster,
+    globalConfig: PublicKey,
+    kaminoProgramId: PublicKey = PROGRAM_ID
+  ) {
+    this._connection = connection;
+    this._cluster = cluster;
+    this._globalConfig = globalConfig;
+    this._orcaNetwork = cluster === 'mainnet-beta' ? OrcaNetwork.MAINNET : OrcaNetwork.DEVNET;
+    this._orcaApiUrl = `https://api.${cluster === 'mainnet-beta' ? 'mainnet' : 'devnet'}.orca.so`;
+    this._kaminoProgramId = kaminoProgramId;
+  }
+
+  async getOrcaWhirlpools() {
+    return (await axios.get<OrcaWhirlpoolsResponse>(`${this._orcaApiUrl}/v1/whirlpool/list`)).data;
+  }
+
+  /**
+   * Get token prices for a strategy - for use with orca sdk
+   * @param strategy
+   * @param prices
+   * @param collateralInfos
+   * @returns {Record<string, Decimal>} - token prices by mint string
+   * @private
+   */
+  private getTokenPrices(
+    strategy: WhirlpoolStrategy,
+    prices: KaminoPrices,
+    collateralInfos: CollateralInfo[]
+  ): Record<string, Decimal> {
+    const tokensPrices: Record<string, Decimal> = {};
+
+    const tokenA = collateralInfos[strategy.tokenACollateralId.toNumber()];
+    const tokenB = collateralInfos[strategy.tokenBCollateralId.toNumber()];
+    const rewardToken0 = collateralInfos[strategy.reward0CollateralId.toNumber()];
+    const rewardToken1 = collateralInfos[strategy.reward1CollateralId.toNumber()];
+    const rewardToken2 = collateralInfos[strategy.reward2CollateralId.toNumber()];
+
+    const aPrice = prices.spot[tokenA.mint.toString()];
+    const bPrice = prices.spot[tokenB.mint.toString()];
+    const reward0Price = strategy.reward0Decimals.toNumber() !== 0 ? prices.spot[rewardToken0.mint.toString()] : null;
+    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] = [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[mintA] = aPrice.price;
+    tokensPrices[mintB] = bPrice.price;
+    if (reward0Price !== null) {
+      tokensPrices[reward0] = reward0Price.price;
+    }
+    if (reward1Price !== null) {
+      tokensPrices[reward1] = reward1Price.price;
+    }
+    if (reward2Price !== null) {
+      tokensPrices[reward2] = reward2Price.price;
+    }
+
+    return tokensPrices;
+  }
+
+  private getPoolTokensPrices(pool: PoolData, prices: KaminoPrices) {
+    const tokensPrices: Record<string, Decimal> = {};
+    const tokens = [
+      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) {
+        const price = prices.spot[mint]?.price;
+        if (!price) {
+          throw new Error(`Could not get token ${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,
+    whirlpools?: Whirlpool[]
+  ): Promise<WhirlpoolAprApy> {
+    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 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,
+      strategy,
+      new Decimal(pool.price.toString())
+    );
+    if (priceRange.strategyOutOfRange) {
+      return {
+        ...priceRange,
+        rewardsApy: [],
+        rewardsApr: [],
+        feeApy: ZERO,
+        feeApr: ZERO,
+        totalApy: ZERO,
+        totalApr: ZERO,
+      };
+    }
+
+    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 apr = estimateAprsForPriceRange(
+      pool,
+      tokensPrices,
+      fee24Usd,
+      position.tickLowerIndex,
+      position.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);
+    const rewardsApr = apr.rewards.map((r) => new Decimal(r));
+    return {
+      totalApr,
+      totalApy: aprToApy(totalApr, 365),
+      feeApr,
+      feeApy: aprToApy(feeApr, 365),
+      rewardsApr,
+      rewardsApy: rewardsApr.map((x) => aprToApy(x, 365)),
+      ...priceRange,
+    };
+  }
+
+  // strongly recommended to pass lowestTick and highestTick because fetching the lowest and highest existent takes very long
+  async getWhirlpoolLiquidityDistribution(
+    pool: PublicKey,
+    keepOrder: boolean = true,
+    lowestTick?: number,
+    highestTick?: number
+  ): Promise<LiquidityDistribution> {
+    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}`);
+    }
+
+    let lowestInitializedTick: number;
+    if (lowestTick) {
+      lowestInitializedTick = lowestTick;
+    } else {
+      lowestInitializedTick = await orca.pool.getLowestInitializedTickArrayTickIndex(pool, poolData.tickSpacing);
+    }
+
+    let highestInitializedTick: number;
+    if (highestTick) {
+      highestInitializedTick = highestTick;
+    } else {
+      highestInitializedTick = await orca.pool.getHighestInitializedTickArrayTickIndex(pool, poolData.tickSpacing);
+    }
+
+    const orcaLiqDistribution = await orca.pool.getLiquidityDistribution(
+      pool,
+      lowestInitializedTick,
+      highestInitializedTick
+    );
+
+    const liqDistribution: LiquidityDistribution = {
+      currentPrice: poolData.price,
+      currentTickIndex: poolData.tickCurrentIndex,
+      distribution: [],
+    };
+
+    orcaLiqDistribution.datapoints.forEach((entry) => {
+      let priceWithOrder = new Decimal(entry.price);
+      if (!keepOrder) {
+        priceWithOrder = new Decimal(1).div(priceWithOrder);
+      }
+      const liq: LiquidityForPrice = {
+        price: priceWithOrder,
+        liquidity: entry.liquidity,
+        tickIndex: entry.tickIndex,
+      };
+
+      liqDistribution.distribution.push(liq);
+    });
+
+    return liqDistribution;
+  }
+
+  async getWhirlpoolPositionAprApy(
+    poolPubkey: PublicKey,
+    priceLower: Decimal,
+    priceUpper: Decimal,
+    prices: KaminoPrices,
+    whirlpools?: Whirlpool[]
+  ): Promise<WhirlpoolAprApy> {
+    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(pool.price) || priceUpper.lt(pool.price)) {
+      strategyOutOfRange = true;
+    }
+    if (strategyOutOfRange) {
+      return {
+        priceLower,
+        priceUpper,
+        strategyOutOfRange,
+        poolPrice: pool.price,
+        rewardsApy: [],
+        rewardsApr: [],
+        feeApy: ZERO,
+        feeApr: ZERO,
+        totalApy: ZERO,
+        totalApr: ZERO,
+      };
+    }
+
+    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, pool.tokenDecimalsA, pool.tokenDecimalsB),
+      whirlpool.tickSpacing
+    );
+    const tickUpperIndex = getNearestValidTickIndexFromTickIndex(
+      priceToTickIndex(priceUpper, pool.tokenDecimalsA, pool.tokenDecimalsB),
+      whirlpool.tickSpacing
+    );
+
+    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);
+    const rewardsApr = apr.rewards.map((r) => new Decimal(r));
+    return {
+      totalApr,
+      totalApy: aprToApy(totalApr, 365),
+      feeApr,
+      feeApy: aprToApy(feeApr, 365),
+      rewardsApr,
+      rewardsApy: rewardsApr.map((x) => aprToApy(x, 365)),
+      priceLower,
+      priceUpper,
+      poolPrice: pool.price,
+      strategyOutOfRange,
+    };
+  }
+
+  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: 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),
+    };
+    return poolInfo;
+  }
+
+  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;
+  }
+}

package/src/services/OrcaWhirlpoolsResponse.ts

@@ -0,0 +1,120 @@
+export interface OrcaWhirlpoolsResponse {
+  whirlpools: Whirlpool[];
+  hasMore: boolean;
+}
+
+export interface Whirlpool {
+  address: string;
+  tokenA: TokenA;
+  tokenB: TokenB;
+  whitelisted: boolean;
+  tickSpacing: number;
+  price: number;
+  lpFeeRate: number;
+  protocolFeeRate: number;
+  whirlpoolsConfig: string;
+  modifiedTimeMs?: number;
+  tvl?: number;
+  volume?: Volume;
+  volumeDenominatedA?: VolumeDenominatedA;
+  volumeDenominatedB?: VolumeDenominatedB;
+  priceRange?: PriceRange;
+  feeApr?: FeeApr;
+  reward0Apr?: Reward0Apr;
+  reward1Apr?: Reward1Apr;
+  reward2Apr?: Reward2Apr;
+  totalApr?: TotalApr;
+}
+
+export interface TokenA {
+  mint: string;
+  symbol: string;
+  name: string;
+  decimals: number;
+  logoURI?: string;
+  coingeckoId?: string;
+  whitelisted: boolean;
+  poolToken: boolean;
+  wrapper?: string;
+}
+
+export interface TokenB {
+  mint: string;
+  symbol: string;
+  name: string;
+  decimals: number;
+  logoURI: string;
+  coingeckoId?: string;
+  whitelisted: boolean;
+  poolToken: boolean;
+  wrapper?: string;
+}
+
+export interface Volume {
+  day: number;
+  week: number;
+  month: number;
+}
+
+export interface VolumeDenominatedA {
+  day: number;
+  week: number;
+  month: number;
+}
+
+export interface VolumeDenominatedB {
+  day: number;
+  week: number;
+  month: number;
+}
+
+export interface PriceRange {
+  day: Day;
+  week: Week;
+  month: Month;
+}
+
+export interface Day {
+  min: number;
+  max: number;
+}
+
+export interface Week {
+  min: number;
+  max: number;
+}
+
+export interface Month {
+  min: number;
+  max: number;
+}
+
+export interface FeeApr {
+  day: number;
+  week: number;
+  month: number;
+}
+
+export interface Reward0Apr {
+  day: number;
+  week?: number;
+  month?: number;
+}
+
+export interface Reward1Apr {
+  day: number;
+  week: number;
+  month: number;
+}
+
+export interface Reward2Apr {
+  day: number;
+  week: number;
+  month: number;
+}
+
+export interface TotalApr {
+  day: number;
+  week?: number;
+  month?: number;
+}

package/src/services/PoolSimulationService.ts

@@ -0,0 +1,42 @@
+import axios, { AxiosResponse } from 'axios';
+import { PoolSimulationResponse } from '../models/PoolSimulationResponseData';
+import Decimal from 'decimal.js';
+import { PublicKey } from '@solana/web3.js';
+
+export type SimulationParameters = {
+  poolAddress: PublicKey;
+  depositDate: string;
+  endDate: string;
+};
+
+export type SimulationManualPoolParameters = SimulationParameters & {
+  priceLower: Decimal;
+  priceUpper: Decimal;
+};
+
+export type SimulationPercentagePoolParameters = SimulationParameters & {
+  rangeWidthPriceLower: number;
+  rangeWidthPriceUpper: number;
+  resetRangeWidthPercUpper?: number;
+  resetRangeWidthPercLower?: number;
+};
+
+export async function simulateManualPool(params: SimulationManualPoolParameters): Promise<PoolSimulationResponse> {
+  const response: AxiosResponse<PoolSimulationResponse> = await axios.get(
+    `https://api.kamino.finance/simulate/${params.poolAddress}?strategy_type=Fixed&deposit_date=${
+      params.depositDate
+    }&end_date=${
+      params.endDate
+    }&price_lower=${params.priceLower.toString()}&price_upper=${params.priceUpper.toString()}`
+  );
+  return response.data;
+}
+
+export async function simulatePercentagePool(
+  params: SimulationPercentagePoolParameters
+): Promise<PoolSimulationResponse> {
+  const response: AxiosResponse<PoolSimulationResponse> = await axios.get(
+    `https://api.kamino.finance/simulate/${params.poolAddress}?strategy_type=Tracker&deposit_date=${params.depositDate}&end_date=${params.endDate}&range_width_perc_lower=${params.rangeWidthPriceLower}&range_width_perc_upper=${params.rangeWidthPriceUpper}&reset_range_width_perc_upper=${params.resetRangeWidthPercUpper}&reset_range_width_perc_lower=${params.resetRangeWidthPercLower}`
+  );
+  return response.data;
+}

package/src/services/RaydiumPoolsResponse.ts

@@ -0,0 +1,96 @@
+import { AmmV3ConfigInfo } from '@raydium-io/raydium-sdk';
+
+export interface RaydiumPoolsResponse {
+  data: Pool[];
+}
+
+export interface Pool {
+  id: string;
+  mintA: string;
+  mintB: string;
+  vaultA: string;
+  vaultB: string;
+  mintDecimalsA: number;
+  mintDecimalsB: number;
+  ammConfig: AmmV3ConfigInfo;
+  tvl: number;
+  day: Day;
+  week: Week;
+  month: Month;
+  lookupTableAccount: string;
+  price: number;
+}
+
+export interface AmmConfig {
+  id: string;
+  index: number;
+  protocolFeeRate: number;
+  tradeFeeRate: number;
+  tickSpacing: number;
+  fundFeeRate: number;
+  fundOwner: string;
+  description: string;
+}
+
+export interface Day {
+  volume: number;
+  volumeFee: number;
+  feeA: number;
+  feeB: number;
+  feeApr: number;
+  rewardApr: RewardApr;
+  apr: number;
+  priceMin: number;
+  priceMax: number;
+}
+
+export interface RewardApr {
+  A: number;
+  B: number;
+  C: number;
+}
+
+export interface Week {
+  volume: number;
+  volumeFee: number;
+  feeA: number;
+  feeB: number;
+  feeApr: number;
+  rewardApr: RewardApr2;
+  apr: number;
+  priceMin: number;
+  priceMax: number;
+}
+
+export interface RewardApr2 {
+  A: number;
+  B: number;
+  C: number;
+}
+
+export interface Month {
+  volume: number;
+  volumeFee: number;
+  feeA: number;
+  feeB: number;
+  feeApr: number;
+  rewardApr: RewardApr3;
+  apr: number;
+  priceMin: number;
+  priceMax: number;
+}
+
+export interface RewardApr3 {
+  A: number;
+  B: number;
+  C: number;
+}
+
+export interface LiquidityDistribution {
+  data: LiquidityForPrice[];
+}
+
+export interface LiquidityForPrice {
+  price: number;
+  liquidity: number;
+}