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

package/src/services/RaydiumService.ts

@@ -1,64 +1,84 @@
-import { Connection, PublicKey } from '@solana/web3.js';
+import {
+  Account,
+  address,
+  Address,
+  Base58EncodedBytes,
+  getAddressEncoder,
+  getProgramDerivedAddress,
+  ProgramDerivedAddress,
+  Rpc,
+  SolanaRpcApi,
+} from '@solana/kit';
 import {
   LiquidityDistribution as RaydiumLiquidityDistribuion,
   Pool,
   RaydiumPoolsResponse,
 } from './RaydiumPoolsResponse';
-import { PersonalPositionState, PoolState } from '../raydium_client';
+import { PersonalPositionState, PoolState } from '../@codegen/raydium/accounts';
 import Decimal from 'decimal.js';
 import { WhirlpoolAprApy } from './WhirlpoolAprApy';
-import { WhirlpoolStrategy } from '../kamino-client/accounts';
+import { WhirlpoolStrategy } from '../@codegen/kliquidity/accounts';
 import {
   aprToApy,
   GenericPoolInfo,
   getStrategyPriceRangeRaydium,
+  getTokenAccountBalanceLamports,
   LiquidityDistribution,
   LiquidityForPrice,
+  optionGetValue,
+  optionGetValueOrUndefined,
+  solToWSol,
+  toLegacyPublicKey,
+  WSOL_MINT,
   ZERO,
 } from '../utils';
 import axios from 'axios';
 import { FullPercentage } from '../utils/CreationParameters';
-import { PROGRAM_ID as RAYDIUM_PROGRAM_ID } from '../raydium_client/programId';
+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 { fromLegacyPublicKey } from '@solana/compat';
+import { fetchAllMint, Mint } from '@solana-program/token-2022';
+import { DEFAULT_PUBLIC_KEY } from '../constants/pubkeys';
 
 export class RaydiumService {
-  private readonly _connection: Connection;
-  private readonly _raydiumProgramId: PublicKey;
+  private readonly _rpc: Rpc<SolanaRpcApi>;
+  private readonly _raydiumProgramId: Address;
 
-  constructor(connection: Connection, raydiumProgramId: PublicKey = RAYDIUM_PROGRAM_ID) {
+  constructor(rpc: Rpc<SolanaRpcApi>, raydiumProgramId: Address = RAYDIUM_PROGRAM_ID) {
+    this._rpc = rpc;
     this._raydiumProgramId = raydiumProgramId;
-    this._connection = connection;
   }
 
-  getRaydiumProgramId(): PublicKey {
+  getRaydiumProgramId(): Address {
     return this._raydiumProgramId;
   }
 
   async getRaydiumWhirlpools(): Promise<RaydiumPoolsResponse> {
     return (await axios.get<RaydiumPoolsResponse>(`https://api.kamino.finance/v2/raydium/ammPools`)).data;
   }
-  
-  async getRaydiumPoolInfo(poolPubkey: PublicKey): Promise<ApiV3PoolInfoConcentratedItem> {
-    const raydiumLoadParams: RaydiumLoadParams = { connection: this._connection };
-    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;
+
+  async getRaydiumPoolInfo(poolPubkey: Address): Promise<ApiV3PoolInfoConcentratedItem> {
+    return this.getPoolInfoFromRpc(poolPubkey.toString());
   }
 
   async getRaydiumPoolLiquidityDistribution(
-    pool: PublicKey,
+    pool: Address,
     keepOrder: boolean = true,
     lowestTick?: number,
     highestTick?: number
@@ -69,7 +89,7 @@ export class RaydiumService {
       )
     ).data;
 
-    const poolState = await PoolState.fetch(this._connection, pool);
+    const poolState = await PoolState.fetch(this._rpc, pool);
     if (!poolState) {
       throw Error(`Raydium pool state ${pool} does not exist`);
     }
@@ -118,11 +138,11 @@ export class RaydiumService {
   }
 
   getStrategyWhirlpoolPoolAprApy = async (strategy: WhirlpoolStrategy, pools?: Pool[]): Promise<WhirlpoolAprApy> => {
-    const position = await PersonalPositionState.fetch(this._connection, strategy.position);
+    const position = await PersonalPositionState.fetch(this._rpc, strategy.position);
     if (!position) {
       throw Error(`Position ${strategy.position} does not exist`);
     }
-    const poolState = await PoolState.fetch(this._connection, strategy.pool);
+    const poolState = await PoolState.fetch(this._rpc, strategy.pool);
     if (!poolState) {
       throw Error(`Raydium pool state ${strategy.pool} does not exist`);
     }
@@ -176,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,
@@ -184,18 +204,18 @@ 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,
     };
   };
 
   getRaydiumPositionAprApy = async (
-    poolPubkey: PublicKey,
+    poolPubkey: Address,
     priceLower: Decimal,
     priceUpper: Decimal,
     pools?: Pool[]
   ): Promise<WhirlpoolAprApy> => {
-    const poolState = await PoolState.fetch(this._connection, poolPubkey);
+    const poolState = await PoolState.fetch(this._rpc, poolPubkey);
     if (!poolState) {
       throw Error(`Raydium pool state ${poolPubkey} does not exist`);
     }
@@ -262,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,
@@ -270,13 +290,13 @@ 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,
     };
   };
 
-  async getGenericPoolInfo(poolPubkey: PublicKey, pools?: Pool[]): Promise<GenericPoolInfo> {
-    const poolState = await PoolState.fetch(this._connection, poolPubkey);
+  async getGenericPoolInfo(poolPubkey: Address, pools?: Pool[]): Promise<GenericPoolInfo> {
+    const poolState = await PoolState.fetch(this._rpc, poolPubkey);
     if (!poolState) {
       throw Error(`Raydium pool state ${poolPubkey} does not exist`);
     }
@@ -296,7 +316,7 @@ export class RaydiumService {
 
     const poolInfo: GenericPoolInfo = {
       dex: 'RAYDIUM',
-      address: new PublicKey(poolPubkey),
+      address: poolPubkey,
       tokenMintA: poolState.tokenMint0,
       tokenMintB: poolState.tokenMint1,
       price: new Decimal(raydiumPool.price),
@@ -310,15 +330,322 @@ export class RaydiumService {
     return poolInfo;
   }
 
-  async getPositionsCountByPool(pool: PublicKey): Promise<number> {
-    const positions = await this._connection.getProgramAccounts(this._raydiumProgramId, {
-      commitment: 'confirmed',
-      filters: [
-        { dataSize: PositionInfoLayout.span },
-        { memcmp: { bytes: pool.toBase58(), offset: PositionInfoLayout.offsetOf('poolId') } },
-      ],
-    });
+  async getPositionsCountByPool(pool: Address): Promise<number> {
+    const positions = await this._rpc
+      .getProgramAccounts(this._raydiumProgramId, {
+        commitment: 'confirmed',
+        filters: [
+          { dataSize: BigInt(PositionInfoLayout.span) },
+          {
+            memcmp: {
+              bytes: pool.toString() as Base58EncodedBytes,
+              offset: BigInt(PositionInfoLayout.offsetOf('poolId')),
+              encoding: 'base58',
+            },
+          },
+        ],
+      })
+      .send();
 
     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/CreationParameters.ts

@@ -1,4 +1,4 @@
-import { PublicKey } from '@solana/web3.js';
+import { address, Address } from '@solana/kit';
 import {
   Autodrift,
   Drift,
@@ -8,7 +8,7 @@ import {
   PricePercentage,
   PricePercentageWithReset,
   TakeProfit,
-} from '../kamino-client/types/RebalanceType';
+} from '../@codegen/kliquidity/types/RebalanceType';
 import Decimal from 'decimal.js';
 import { Dex } from './utils';
 
@@ -25,8 +25,8 @@ export const DefaultUpperPercentageBPSDecimal: Decimal = new Decimal(DefaultUppe
 export const DefaultLowerPriceDifferenceBPS: number = 500;
 export const DefaultUpperPriceDifferenceBPS: number = 500;
 
-export const DefaultMintTokenA: PublicKey = new PublicKey('So11111111111111111111111111111111111111112');
-export const DefaultMintTokenB: PublicKey = new PublicKey('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
+export const DefaultMintTokenA: Address = address('So11111111111111111111111111111111111111112');
+export const DefaultMintTokenB: Address = address('EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v');
 export const DefaultFeeTierOrca: Decimal = new Decimal(0.0005);
 export const DefaultTickSpacing: number = 1;
 export const DefaultDex: Dex = 'ORCA';

package/src/utils/compat.ts

@@ -0,0 +1,6 @@
+import { PublicKey } from '@solana/web3.js';
+import { Address } from '@solana/kit';
+
+export function toLegacyPublicKey(address: Address): PublicKey {
+  return new PublicKey(address.toString());
+}

package/src/utils/index.ts

@@ -1,8 +1,7 @@
-export * from './anchorUtils';
 export * from './batch';
 export * from './tokenUtils';
 export * from './utils';
 export * from './math';
 export * from './types';
 export * from './orca';
-export * from './instructions';
+export * from './compat';

package/src/utils/jupiter.ts

@@ -0,0 +1,30 @@
+import { Instruction } from '@jup-ag/api';
+import { AccountRole, address, Instruction as SolanaInstruction } from '@solana/kit';
+
+export function jupInstructionToSolanaInstruction(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 }),
+    })),
+  };
+}
+
+export function jupInstructionsToSolanaInstructions(ixs: Instruction[]): SolanaInstruction[] {
+  return ixs.map((ix) => jupInstructionToSolanaInstruction(ix));
+}
+
+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;
+}