@kamino-finance/kliquidity-sdk 8.4.5 → 8.4.6

package/src/services/RaydiumService.ts

@@ -1,4 +1,14 @@
-import { Address, Base58EncodedBytes, Rpc, SolanaRpcApi } from '@solana/kit';
+import {
+  Account,
+  address,
+  Address,
+  Base58EncodedBytes,
+  getAddressEncoder,
+  getProgramDerivedAddress,
+  ProgramDerivedAddress,
+  Rpc,
+  SolanaRpcApi,
+} from '@solana/kit';
 import {
   LiquidityDistribution as RaydiumLiquidityDistribuion,
   Pool,
@@ -12,8 +22,14 @@ import {
   aprToApy,
   GenericPoolInfo,
   getStrategyPriceRangeRaydium,
+  getTokenAccountBalanceLamports,
   LiquidityDistribution,
   LiquidityForPrice,
+  optionGetValue,
+  optionGetValueOrUndefined,
+  solToWSol,
+  toLegacyPublicKey,
+  WSOL_MINT,
   ZERO,
 } from '../utils';
 import axios from 'axios';
@@ -22,24 +38,30 @@ import { PROGRAM_ID as RAYDIUM_PROGRAM_ID } from '../@codegen/raydium/programId'
 import { priceToTickIndexWithRounding } from '../utils/raydium';
 import {
   ApiV3PoolInfoConcentratedItem,
-  Clmm,
+  ClmmConfigLayout,
+  ClmmRpcData,
+  ComputeClmmPoolInfo,
+  POOL_TICK_ARRAY_BITMAP_SEED,
+  PoolInfoLayout,
   PoolUtils,
   PositionInfoLayout,
-  Raydium,
-  RaydiumLoadParams,
+  ReturnTypeFetchExBitmaps,
+  ReturnTypeFetchMultipleMintInfos,
+  ReturnTypeGetTickPrice,
   SqrtPriceMath,
+  TickArrayBitmapExtensionLayout,
   TickMath,
 } from '@raydium-io/raydium-sdk-v2/lib';
-import { Connection } from '@solana/web3.js';
+import { fromLegacyPublicKey } from '@solana/compat';
+import { fetchAllMint, Mint } from '@solana-program/token-2022';
+import { DEFAULT_PUBLIC_KEY } from '../constants/pubkeys';
 
 export class RaydiumService {
   private readonly _rpc: Rpc<SolanaRpcApi>;
-  private readonly _legacyConnection: Connection;
   private readonly _raydiumProgramId: Address;
 
-  constructor(rpc: Rpc<SolanaRpcApi>, legacyConnection: Connection, raydiumProgramId: Address = RAYDIUM_PROGRAM_ID) {
+  constructor(rpc: Rpc<SolanaRpcApi>, raydiumProgramId: Address = RAYDIUM_PROGRAM_ID) {
     this._rpc = rpc;
-    this._legacyConnection = legacyConnection;
     this._raydiumProgramId = raydiumProgramId;
   }
 
@@ -52,12 +74,7 @@ export class RaydiumService {
   }
 
   async getRaydiumPoolInfo(poolPubkey: Address): Promise<ApiV3PoolInfoConcentratedItem> {
-    const raydiumLoadParams: RaydiumLoadParams = { connection: this._legacyConnection };
-    const raydium = await Raydium.load(raydiumLoadParams);
-    const rayClmm = new Clmm({ scope: raydium, moduleName: '' });
-    const otherPoolInfo = await rayClmm.getPoolInfoFromRpc(poolPubkey.toString());
-    console.log('otherPoolInfo', otherPoolInfo);
-    return otherPoolInfo.poolInfo;
+    return this.getPoolInfoFromRpc(poolPubkey.toString());
   }
 
   async getRaydiumPoolLiquidityDistribution(
@@ -179,7 +196,7 @@ export class RaydiumService {
     const { apr, feeApr, rewardsApr } = PoolUtils.estimateAprsForPriceRangeMultiplier(params);
     const totalApr = new Decimal(apr).div(100);
     const fee = new Decimal(feeApr).div(100);
-    const rewards = rewardsApr.map((reward) => new Decimal(reward).div(100));
+    const rewards = rewardsApr.map((reward: number) => new Decimal(reward).div(100));
 
     return {
       totalApr,
@@ -187,7 +204,7 @@ export class RaydiumService {
       feeApr: fee,
       feeApy: aprToApy(fee, 365),
       rewardsApr: rewards,
-      rewardsApy: rewards.map((x) => aprToApy(x, 365)),
+      rewardsApy: rewards.map((x: Decimal) => aprToApy(x, 365)),
       ...priceRange,
     };
   };
@@ -265,7 +282,7 @@ export class RaydiumService {
     const { apr, feeApr, rewardsApr } = PoolUtils.estimateAprsForPriceRangeMultiplier(params);
     const totalApr = new Decimal(apr).div(100);
     const fee = new Decimal(feeApr).div(100);
-    const rewards = rewardsApr.map((reward) => new Decimal(reward).div(100));
+    const rewards = rewardsApr.map((reward: number) => new Decimal(reward).div(100));
 
     return {
       totalApr,
@@ -273,7 +290,7 @@ export class RaydiumService {
       feeApr: fee,
       feeApy: aprToApy(fee, 365),
       rewardsApr: rewards,
-      rewardsApy: rewards.map((x) => aprToApy(x, 365)),
+      rewardsApy: rewards.map((x: Decimal) => aprToApy(x, 365)),
       ...priceRange,
     };
   };
@@ -332,4 +349,303 @@ export class RaydiumService {
 
     return positions.length;
   }
+
+  getTickPrice(
+    tick: number,
+    tokenADecimals: number,
+    tokenBDecimals: number,
+    baseIn: boolean = true
+  ): ReturnTypeGetTickPrice {
+    const tickSqrtPriceX64 = SqrtPriceMath.getSqrtPriceX64FromTick(tick);
+    const tickPrice = SqrtPriceMath.sqrtPriceX64ToPrice(tickSqrtPriceX64, tokenADecimals, tokenBDecimals);
+
+    return baseIn
+      ? { tick, price: tickPrice, tickSqrtPriceX64 }
+      : { tick, price: new Decimal(1).div(tickPrice), tickSqrtPriceX64 };
+  }
+
+  async getRpcClmmPoolInfo(poolId: string): Promise<ClmmRpcData> {
+    const poolAccountInfo = await this._rpc
+      .getAccountInfo(address(poolId), { commitment: 'confirmed', encoding: 'base64' })
+      .send();
+    if (!poolAccountInfo.value) {
+      throw Error(`Raydium pool state ${poolId} does not exist`);
+    }
+
+    const poolState = await PoolState.fetch(this._rpc, address(poolId));
+    if (!poolState) {
+      throw Error(`Raydium pool state ${poolId} does not exist`);
+    }
+
+    const rpc = PoolInfoLayout.decode(Buffer.from(poolAccountInfo.value.data[0], 'base64'));
+    const currentPrice = SqrtPriceMath.sqrtPriceX64ToPrice(
+      poolState.sqrtPriceX64,
+      poolState.mintDecimals0,
+      poolState.mintDecimals1
+    ).toNumber();
+
+    const data: ClmmRpcData = {
+      ...rpc,
+      currentPrice,
+      programId: toLegacyPublicKey(this._raydiumProgramId),
+    };
+
+    return data;
+  }
+
+  async fetchComputeClmmInfo(poolInfoWithAddress: ClmmRpcDataWithAddress): Promise<ComputeClmmPoolInfo> {
+    const { address: poolAddress } = poolInfoWithAddress;
+    return (await this.fetchComputeMultipleClmmInfo([poolInfoWithAddress]))[poolAddress.toString()];
+  }
+
+  async fetchExBitmaps(exBitmapAddress: Address[]): Promise<ReturnTypeFetchExBitmaps> {
+    const fetchedBitmapAccount = await this._rpc
+      .getMultipleAccounts(exBitmapAddress, { commitment: 'confirmed', encoding: 'base64' })
+      .send();
+    const fetchedBitmapAccountWithAddress = exBitmapAddress.map((address, index) => ({
+      address,
+      data: fetchedBitmapAccount.value[index]?.data,
+    }));
+
+    const returnTypeFetchExBitmaps: ReturnTypeFetchExBitmaps = {};
+    for (const { address, data } of fetchedBitmapAccountWithAddress) {
+      if (!data) continue;
+      returnTypeFetchExBitmaps[address.toString()] = TickArrayBitmapExtensionLayout.decode(
+        Buffer.from(data[0], 'base64')
+      );
+    }
+    return returnTypeFetchExBitmaps;
+  }
+
+  async fetchComputeMultipleClmmInfo(poolList: ClmmRpcDataWithAddress[]): Promise<Record<string, ComputeClmmPoolInfo>> {
+    const fetchRpcList = poolList.map((p) => p.address);
+    const rpcRes = await this._rpc
+      .getMultipleAccounts(fetchRpcList, { commitment: 'confirmed', encoding: 'base64' })
+      .send();
+    const rpcResWithAddress = fetchRpcList.map((address, index) => ({
+      address,
+      data: rpcRes.value[index]?.data,
+    }));
+
+    const rpcDataMap: Record<string, ReturnType<typeof PoolInfoLayout.decode>> = {};
+    for (const { address, data } of rpcResWithAddress) {
+      if (!data) continue;
+      rpcDataMap[address.toString()] = PoolInfoLayout.decode(Buffer.from(data[0], 'base64'));
+    }
+
+    // Fetch amm configs
+    const configSet = Array.from(new Set(poolList.map((p) => p.clmmPoolRpcInfo.ammConfig.toBase58())));
+    const configRes = await this._rpc
+      .getMultipleAccounts(
+        configSet.map((s) => address(s)),
+        { commitment: 'confirmed', encoding: 'base64' }
+      )
+      .send();
+
+    const clmmConfigs: Record<string, ReturnType<typeof ClmmConfigLayout.decode>> = {};
+    configSet.forEach((configAddress, index) => {
+      const data = configRes.value[index]?.data;
+      if (data) {
+        clmmConfigs[configAddress] = ClmmConfigLayout.decode(Buffer.from(data[0], 'base64'));
+      }
+    });
+
+    // Fetch mint infos
+    const allMints = Array.from(
+      new Set(poolList.flatMap((p) => [p.clmmPoolRpcInfo.mintA.toBase58(), p.clmmPoolRpcInfo.mintB.toBase58()]))
+    );
+    const mintInfos = await this.fetchMultipleMintInfos(allMints.map((m) => address(m)));
+
+    const pdaList = await Promise.all(
+      poolList.map(async (poolInfo) => {
+        const pda = await getPdaExBitmapAccount(
+          fromLegacyPublicKey(poolInfo.clmmPoolRpcInfo.programId),
+          poolInfo.address
+        );
+        return address(pda[0]);
+      })
+    );
+
+    const exBitData = await this.fetchExBitmaps(pdaList);
+
+    const result: Record<string, ComputeClmmPoolInfo> = {};
+    for (let i = 0; i < poolList.length; i++) {
+      const cur = poolList[i];
+      const pda = await getPdaExBitmapAccount(fromLegacyPublicKey(cur.clmmPoolRpcInfo.programId), cur.address);
+
+      const ammConfigKey = cur.clmmPoolRpcInfo.ammConfig.toBase58();
+      const ammConfigData = clmmConfigs[ammConfigKey];
+      const mintAKey = cur.clmmPoolRpcInfo.mintA.toBase58();
+      const mintBKey = cur.clmmPoolRpcInfo.mintB.toBase58();
+
+      result[cur.address.toString()] = {
+        ...rpcDataMap[cur.address.toString()],
+        id: toLegacyPublicKey(cur.address),
+        version: 6,
+        programId: fromLegacyPublicKey(cur.clmmPoolRpcInfo.programId),
+        mintA: {
+          chainId: 101,
+          address: mintAKey,
+          programId: mintInfos[mintAKey]?.programId.toBase58() || 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
+          logoURI: '',
+          symbol: '',
+          name: '',
+          decimals: cur.clmmPoolRpcInfo.mintDecimalsA,
+          tags: [],
+          extensions: { feeConfig: mintInfos[mintAKey]?.feeConfig },
+        },
+        mintB: {
+          chainId: 101,
+          address: mintBKey,
+          programId: mintInfos[mintBKey]?.programId.toBase58() || 'TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA',
+          logoURI: '',
+          symbol: '',
+          name: '',
+          decimals: cur.clmmPoolRpcInfo.mintDecimalsB,
+          tags: [],
+          extensions: { feeConfig: mintInfos[mintBKey]?.feeConfig },
+        },
+        ammConfig: {
+          ...ammConfigData,
+          id: toLegacyPublicKey(address(ammConfigKey)),
+          fundFeeRate: 0,
+          description: '',
+          defaultRange: 0,
+          defaultRangePoint: [],
+          fundOwner: '',
+        },
+        currentPrice: new Decimal(cur.clmmPoolRpcInfo.currentPrice),
+        exBitmapAccount: toLegacyPublicKey(pda[0]),
+        exBitmapInfo: exBitData[pda[0].toString()],
+        startTime: rpcDataMap[cur.address.toString()].startTime.toNumber(),
+        rewardInfos: rpcDataMap[cur.address.toString()].rewardInfos,
+      } as any;
+    }
+    return result;
+  }
+
+  async fetchMultipleMintInfos(mints: Address[]): Promise<ReturnTypeFetchMultipleMintInfos> {
+    if (mints.length === 0) return {};
+
+    const cleanedMints = mints.map((i) => solToWSol(i));
+    // fetch in chunks of 100
+    const mintInfos: Account<Mint>[] = [];
+    for (let i = 0; i < cleanedMints.length; i += 100) {
+      const chunk = cleanedMints.slice(i, i + 100);
+      const chunkMintInfos = await fetchAllMint(this._rpc, chunk);
+      mintInfos.push(...chunkMintInfos);
+    }
+
+    const mintInfosWithAddress = cleanedMints.map((mint, index) => ({
+      address: mint,
+      data: mintInfos[index],
+    }));
+
+    const mintK: ReturnTypeFetchMultipleMintInfos = {};
+    for (const { address, data } of mintInfosWithAddress) {
+      if (!data) {
+        console.log('invalid mint account', address.toString());
+        continue;
+      }
+      mintK[address] = {
+        mintAuthority: optionGetValueOrUndefined(data.data.mintAuthority)
+          ? toLegacyPublicKey(optionGetValue(data.data.mintAuthority)!)
+          : null,
+        programId: toLegacyPublicKey(data.programAddress),
+        feeConfig: undefined,
+        address: toLegacyPublicKey(address),
+        isInitialized: true,
+        tlvData: Buffer.from([]),
+        supply: data.data.supply,
+        decimals: data.data.decimals,
+        freezeAuthority: optionGetValueOrUndefined(data.data.freezeAuthority)
+          ? toLegacyPublicKey(optionGetValue(data.data.freezeAuthority)!)
+          : null,
+      };
+    }
+    mintK[DEFAULT_PUBLIC_KEY.toString()] = mintK[WSOL_MINT.toString()];
+
+    return mintK;
+  }
+
+  public async getComputeClmmPoolInfo(
+    clmmPoolRpcInfoWithAddress: ClmmRpcDataWithAddress
+  ): Promise<ComputeClmmPoolInfo> {
+    const computeClmmPoolInfo = await this.fetchComputeClmmInfo(clmmPoolRpcInfoWithAddress);
+    return computeClmmPoolInfo;
+  }
+
+  async getPoolInfoFromRpc(poolId: string): Promise<ApiV3PoolInfoConcentratedItem> {
+    const rpcData = await this.getRpcClmmPoolInfo(poolId);
+
+    const poolInfoWithAddress = {
+      address: address(poolId),
+      clmmPoolRpcInfo: rpcData,
+    };
+    const computeClmmPoolInfo = await this.getComputeClmmPoolInfo(poolInfoWithAddress);
+
+    const poolInfo = this.clmmComputeInfoToApiInfo(computeClmmPoolInfo);
+
+    poolInfo.mintAmountA = await getTokenAccountBalanceLamports(this._rpc, fromLegacyPublicKey(rpcData.vaultA));
+    poolInfo.mintAmountB = await getTokenAccountBalanceLamports(this._rpc, fromLegacyPublicKey(rpcData.vaultB));
+
+    return poolInfo;
+  }
+
+  clmmComputeInfoToApiInfo(pool: ComputeClmmPoolInfo): ApiV3PoolInfoConcentratedItem {
+    return {
+      ...pool,
+      type: 'Concentrated',
+      programId: pool.programId.toString(),
+      id: pool.id.toString(),
+      rewardDefaultInfos: [],
+      rewardDefaultPoolInfos: 'Clmm',
+      price: pool.currentPrice.toNumber(),
+      mintAmountA: 0,
+      mintAmountB: 0,
+      feeRate: pool.ammConfig.tradeFeeRate,
+      openTime: pool.startTime.toString(),
+      tvl: 0,
+
+      day: mockRewardData,
+      week: mockRewardData,
+      month: mockRewardData,
+      pooltype: [],
+
+      farmUpcomingCount: 0,
+      farmOngoingCount: 0,
+      farmFinishedCount: 0,
+      burnPercent: 0,
+      config: {
+        ...pool.ammConfig,
+        id: pool.ammConfig.id.toString(),
+        defaultRange: 0,
+        defaultRangePoint: [],
+      },
+    };
+  }
+}
+
+export interface ClmmRpcDataWithAddress {
+  address: Address;
+  clmmPoolRpcInfo: ClmmRpcData;
+}
+
+export async function getPdaExBitmapAccount(programId: Address, poolId: Address): Promise<ProgramDerivedAddress> {
+  const addressEncoder = getAddressEncoder();
+  return getProgramDerivedAddress({
+    seeds: [POOL_TICK_ARRAY_BITMAP_SEED, addressEncoder.encode(poolId)],
+    programAddress: programId,
+  });
 }
+
+const mockRewardData = {
+  volume: 0,
+  volumeQuote: 0,
+  volumeFee: 0,
+  apr: 0,
+  feeApr: 0,
+  priceMin: 0,
+  priceMax: 0,
+  rewardApr: [],
+};

package/src/services/index.ts

@@ -3,3 +3,5 @@ export * from './OrcaService';
 export * from './OrcaWhirlpoolsResponse';
 export * from './RaydiumService';
 export * from './JupService';
+export * from './MeteoraService';
+export * from './MeteoraPoolsResponse';

package/src/utils/jupiter.ts

@@ -1,7 +1,7 @@
 import { Instruction } from '@jup-ag/api';
-import { AccountRole, address, IInstruction } from '@solana/kit';
+import { AccountRole, address, Instruction as SolanaInstruction } from '@solana/kit';
 
-export function instructionToIInstruction(ix: Instruction): IInstruction {
+export function jupInstructionToSolanaInstruction(ix: Instruction): SolanaInstruction {
   return {
     data: ix.data ? Buffer.from(ix.data, 'base64') : undefined,
     programAddress: address(ix.programId),
@@ -12,8 +12,8 @@ export function instructionToIInstruction(ix: Instruction): IInstruction {
   };
 }
 
-export function instructionsToIInstructions(ixs: Instruction[]): IInstruction[] {
-  return ixs.map((ix) => instructionToIInstruction(ix));
+export function jupInstructionsToSolanaInstructions(ixs: Instruction[]): SolanaInstruction[] {
+  return ixs.map((ix) => jupInstructionToSolanaInstruction(ix));
 }
 
 export function getAccountRole({ isSigner, isMut }: { isSigner: boolean; isMut: boolean }): AccountRole {

package/src/utils/tokenUtils.ts

@@ -1,4 +1,13 @@
-import { Address, IInstruction, address, TransactionSigner, Rpc, GetAccountInfoApi, Account } from '@solana/kit';
+import {
+  Address,
+  Instruction,
+  address,
+  TransactionSigner,
+  Rpc,
+  GetAccountInfoApi,
+  Account,
+  SolanaRpcApi,
+} from '@solana/kit';
 import { WhirlpoolStrategy } from '../@codegen/kliquidity/accounts';
 import Decimal from 'decimal.js';
 import { CollateralInfo } from '../@codegen/kliquidity/types';
@@ -16,10 +25,10 @@ import { SYSTEM_PROGRAM_ADDRESS } from '@solana-program/system';
 import { getSetComputeUnitLimitInstruction } from '@solana-program/compute-budget';
 import { tickIndexToPrice } from '@orca-so/whirlpools-core';
 
-export const SOL_MINTS = [
-  address('So11111111111111111111111111111111111111111'),
-  address('So11111111111111111111111111111111111111112'),
-];
+export const SOL_MINT = address('So11111111111111111111111111111111111111111');
+export const WSOL_MINT = address('So11111111111111111111111111111111111111112');
+
+export const SOL_MINTS = [SOL_MINT, WSOL_MINT];
 export const DECIMALS_SOL = 9;
 
 export async function getAssociatedTokenAddressAndAccount(
@@ -57,7 +66,7 @@ export function createAssociatedTokenAccountInstruction(
   mint: Address,
   programId: Address = TOKEN_PROGRAM_ADDRESS,
   associatedTokenProgramId: Address = ASSOCIATED_TOKEN_PROGRAM_ADDRESS
-): IInstruction {
+): Instruction {
   return getCreateAssociatedTokenInstruction(
     {
       mint,
@@ -71,7 +80,7 @@ export function createAssociatedTokenAccountInstruction(
   );
 }
 
-export function createComputeUnitLimitIx(units: number = 400000): IInstruction {
+export function createComputeUnitLimitIx(units: number = 400000): Instruction {
   return getSetComputeUnitLimitInstruction({ units });
 }
 
@@ -166,3 +175,26 @@ export async function getMintDecimals(rpc: Rpc<GetAccountInfoApi>, mint: Address
   }
   return acc.data.decimals;
 }
+
+export function solToWSol(mint: Address): Address {
+  if (mint === SOL_MINT) {
+    return WSOL_MINT;
+  }
+  return mint;
+}
+
+export async function getTokenAccountBalance(rpc: Rpc<SolanaRpcApi>, tokenAccount: Address): Promise<Decimal> {
+  const tokenAccountBalance = await rpc.getTokenAccountBalance(tokenAccount).send();
+  if (!tokenAccountBalance.value) {
+    throw new Error(`Could not get token account balance for ${tokenAccount.toString()}.`);
+  }
+  return new Decimal(tokenAccountBalance.value.uiAmountString!);
+}
+
+export async function getTokenAccountBalanceLamports(rpc: Rpc<SolanaRpcApi>, tokenAccount: Address): Promise<number> {
+  const tokenAccountBalance = await rpc.getTokenAccountBalance(tokenAccount).send();
+  if (!tokenAccountBalance.value) {
+    throw new Error(`Could not get token account balance for ${tokenAccount.toString()}.`);
+  }
+  return Number(tokenAccountBalance.value.amount);
+}

package/src/utils/transactions.ts

@@ -2,7 +2,7 @@ import {
   Address,
   GetAccountInfoApi,
   GetTokenAccountBalanceApi,
-  IInstruction,
+  Instruction,
   Rpc,
   TransactionSigner,
 } from '@solana/kit';
@@ -27,8 +27,8 @@ import { getTransferSolInstruction } from '@solana-program/system';
 
 export const MAX_ACCOUNTS_PER_TRANSACTION = 64;
 
-export const getComputeBudgetAndPriorityFeeIxns = (units: number, priorityFeeLamports?: Decimal): IInstruction[] => {
-  const ixns: IInstruction[] = [];
+export const getComputeBudgetAndPriorityFeeIxns = (units: number, priorityFeeLamports?: Decimal): Instruction[] => {
+  const ixns: Instruction[] = [];
 
   ixns.push(getSetComputeUnitLimitInstruction({ units }));
 
@@ -45,7 +45,7 @@ export const createAtaIfMissingIx = async (
   mint: Address,
   owner: TransactionSigner,
   programId: Address
-): Promise<IInstruction | undefined> => {
+): Promise<Instruction | undefined> => {
   const ata = await getAssociatedTokenAddress(mint, owner.address, programId);
   const doesAtaExist = Boolean(await checkIfAccountExists(connection, ata));
   const createIxn = !doesAtaExist
@@ -58,7 +58,7 @@ export const getAtasWithCreateIxnsIfMissing = async (
   connection: Rpc<any>,
   mints: [Address, Address][],
   owner: TransactionSigner
-): Promise<IInstruction[]> => {
+): Promise<Instruction[]> => {
   const requests = mints.map(async ([mint, tokenProgram]) => {
     const createAtaIx = await createAtaIfMissingIx(connection, mint, owner, tokenProgram);
     if (createAtaIx) {
@@ -68,7 +68,7 @@ export const getAtasWithCreateIxnsIfMissing = async (
   });
   const result = (await Promise.all(requests.filter((x) => x !== undefined))).filter(
     (ix) => ix !== undefined
-  ) as IInstruction[];
+  ) as Instruction[];
 
   return result;
 };
@@ -79,8 +79,8 @@ export const createWsolAtaIfMissing = async (
   owner: TransactionSigner,
   method: 'deposit' | 'withdraw' = 'deposit'
 ): Promise<CreateAta> => {
-  const createIxns: IInstruction[] = [];
-  const closeIxns: IInstruction[] = [];
+  const createIxns: Instruction[] = [];
+  const closeIxns: Instruction[] = [];
 
   const wsolAta: Address = await getAssociatedTokenAddress(WRAPPED_SOL_MINT, owner.address);
 
@@ -157,7 +157,7 @@ export async function checkIfAccountExists(connection: Rpc<GetAccountInfoApi>, a
   return (await connection.getAccountInfo(account, { encoding: 'base64' }).send()).value != null;
 }
 
-export function removeBudgetAndAtaIxns(ixns: IInstruction[], mints: Address[]): IInstruction[] {
+export function removeBudgetAndAtaIxns(ixns: Instruction[], mints: Address[]): Instruction[] {
   return ixns.filter((ixn) => {
     const { programAddress, accounts } = ixn;
 

package/src/utils/types.ts

@@ -1,6 +1,6 @@
 import { BN } from '@coral-xyz/anchor';
 
-import { address, Address, IInstruction, TransactionMessage, TransactionSigner } from '@solana/kit';
+import { address, Address, Instruction, TransactionMessage, TransactionSigner } from '@solana/kit';
 import { WhirlpoolStrategy } from '../@codegen/kliquidity/accounts';
 import { Dex, collToLamportsDecimal } from './utils';
 import Decimal from 'decimal.js';
@@ -214,7 +214,7 @@ export interface SwapperIxBuilder {
     owner: TransactionSigner,
     slippage: Decimal,
     allKeys: Address[]
-  ): Promise<[IInstruction[], Address[]]>;
+  ): Promise<[Instruction[], Address[]]>;
 }
 
 export interface ProfiledFunctionExecution {
@@ -227,8 +227,8 @@ export function noopProfiledFunctionExecution(promise: Promise<any>): Promise<an
 
 export interface CreateAta {
   ata: Address;
-  createIxns: IInstruction[];
-  closeIxns: IInstruction[];
+  createIxns: Instruction[];
+  closeIxns: Instruction[];
 }
 
 export interface DeserializedVersionedTransaction {
@@ -237,7 +237,7 @@ export interface DeserializedVersionedTransaction {
 }
 
 export interface InstructionsWithLookupTables {
-  instructions: IInstruction[];
+  instructions: Instruction[];
   lookupTablesAddresses: Address[];
 }
 
@@ -269,16 +269,16 @@ export interface InputRebalanceFieldInfo {
 }
 
 export interface InitStrategyIxs {
-  initStrategyIx: IInstruction;
-  updateStrategyParamsIxs: IInstruction[];
-  updateRebalanceParamsIx: IInstruction;
-  openPositionIxs: IInstruction[];
+  initStrategyIx: Instruction;
+  updateStrategyParamsIxs: Instruction[];
+  updateRebalanceParamsIx: Instruction;
+  openPositionIxs: Instruction[];
 }
 
 export interface WithdrawShares {
-  prerequisiteIxs: IInstruction[];
-  withdrawIx: IInstruction;
-  closeSharesAtaIx?: IInstruction;
+  prerequisiteIxs: Instruction[];
+  withdrawIx: Instruction;
+  closeSharesAtaIx?: Instruction;
 }
 
 export interface MetadataProgramAddressesOrca {
@@ -304,13 +304,13 @@ export interface LowerAndUpperTickPubkeys {
   upperTickBump: number;
 }
 export interface WithdrawAllAndCloseIxns {
-  withdrawIxns: IInstruction[];
-  closeIxn: IInstruction;
+  withdrawIxns: Instruction[];
+  closeIxn: Instruction;
 }
 
 export interface InitPoolTickIfNeeded {
   tick: Address;
-  initTickIx: IInstruction | undefined;
+  initTickIx: Instruction | undefined;
 }
 
 export type Percentage = {