Get wallet's open positions from AMM protocols

package.json

@@ -25,10 +25,15 @@
     "@jup-ag/api": "^6.0.6",
     "@jup-ag/react-hook": "^6.0.0-beta.2",
     "@ladderlabs/buddy-sdk": "0.2.17",
+    "@mercurial-finance/dynamic-amm-sdk": "^1.1.2",
+    "@meteora-ag/dlmm": "^1.2.2",
     "@moongate/moongate-adapter": "^0.0.99",
+    "@orca-so/common-sdk": "^0.6.3",
+    "@orca-so/whirlpools-sdk": "^0.13.5",
     "@project-serum/anchor": "^0.17.1-beta.1",
     "@project-serum/borsh": "^0.2.5",
     "@pythnetwork/client": "^2.2.0",
+    "@raydium-io/raydium-sdk-v2": "^0.1.68-alpha",
     "@rive-app/react-canvas": "^4.2.1",
     "@solana-mobile/wallet-adapter-mobile": "^2.0.1",
     "@solana/buffer-layout": "^4.0.0",
@@ -48,7 +53,8 @@
     "borsh": "^0.6.0",
     "bs58": "^4.0.1",
     "coingecko-api": "^1.0.10",
-    "gfx-component-lib": "^1.12.25",
+    "decimal.js": "^10.4.3",
+    "gfx-component-lib": "^1.13.0",
     "gfx-perp-sdk": "https://github.com/GooseFX1/gfx-perp-ts-sdk/releases/download/5/gfx-perp-sdk.tar.gz",
     "gfx_stocks_pool": "file:./wasm",
     "goosefx-ssl-sdk": "latest",

src/web3/migration/example.ts

@@ -0,0 +1,45 @@
+
+import { Connection, PublicKey } from "@solana/web3.js";
+import { getRaydiumCLMMPositions } from "./getPositions/raydium";
+import { getMeteoraDynamicCLMMPositions } from "./getPositions/meteora";
+import { getOrcaCLMMPositionsForUser } from "./getPositions/orca";
+import { MigratePosition, prettifyPositions } from "./getPositions/common";
+
+const RPC_URL = process.env.RPC_URL ?? `https://api.mainnet-beta.solana.com`
+const WHIRLPOOL_PROGRAM_ID = new PublicKey(`whirLbMiicVdio4qvUfM5KAg6Ct8VwpYzGff3uctyCc`);
+const USER_ADDRESS = new PublicKey(`2EFe8wtnTFTfsXaTdg76GsqXFuoYsWXXYtQsZboncaJN`);
+
+export const getAllPositions = async() => {
+  const connection = new Connection(RPC_URL, 'confirmed');
+  const epochInfo = await connection.getEpochInfo();
+
+  const positions = new Array<MigratePosition>();
+
+  // Get Raydium positions
+  positions.push(...await getRaydiumCLMMPositions(
+    connection,
+    USER_ADDRESS,
+    {},
+    false,
+    epochInfo
+  ));
+
+  // Get Meteora positions
+  positions.push(...await getMeteoraDynamicCLMMPositions(
+    connection,
+    USER_ADDRESS,
+  ));
+
+  // Get Orca positions
+  positions.push(...await getOrcaCLMMPositionsForUser(
+    connection,
+    USER_ADDRESS,
+    WHIRLPOOL_PROGRAM_ID
+  ))
+
+  console.log("Positions", prettifyPositions(positions));
+}
+
+if (require.main === module) {
+  getAllPositions().catch(console.error)
+}

src/web3/migration/getPositions/common.ts

@@ -0,0 +1,26 @@
+import { PublicKey } from "@solana/web3.js"
+import * as anchor from "@project-serum/anchor"
+
+export type Source = 'RaydiumCLMM' | `MeteoraCLMM` | 'OrcaCLMM'
+
+export type MigratePosition = {
+  source: Source,
+  tokenA: PublicKey,
+  tokenB: PublicKey,
+  amountTokenA: anchor.BN,
+  amountTokenB: anchor.BN,
+}
+
+export const prettifyPositions = (positions: MigratePosition[]): {
+  [K in keyof MigratePosition]: string;
+}[] => {
+  return positions.map(pos => {
+    return {
+      source: pos.source,
+      tokenA: pos.tokenA.toString(),
+      tokenB: pos.tokenB.toString(),
+      amountTokenA: pos.amountTokenA.toString(),
+      amountTokenB: pos.amountTokenB.toString(),
+    }
+  })
+}

src/web3/migration/getPositions/meteora.ts

@@ -0,0 +1,29 @@
+import { Connection, PublicKey } from "@solana/web3.js"
+import DLMM from "@meteora-ag/dlmm"
+import { MigratePosition, Source } from "./common";
+import { BN } from "bn.js";
+import Decimal from "decimal.js";
+
+// "DLMM"
+// https://github.com/MeteoraAg/dlmm-sdk
+// programId = LBUZKhRxPF3XUpBCjp4YzTKgLccjZhTSDM9YuVaPwxo
+export const getMeteoraDynamicCLMMPositions = async (
+  connection: Connection, 
+  user: PublicKey
+): Promise<Array<MigratePosition>> => {
+  DLMM.migratePosition
+  return DLMM.getAllLbPairPositionsByUser(connection, user).then(
+    info => Array.from(info.values()).map(info => {
+    return info.lbPairPositionsData.map(position => {
+      const amountTokenA = new BN(new Decimal(position.positionData.totalXAmount).floor().toString());
+      const amountTokenB = new BN(new Decimal(position.positionData.totalYAmount).floor().toString());
+      return {
+        source: 'MeteoraCLMM' as Source,
+        tokenA: info.tokenX.publicKey,
+        tokenB: info.tokenY.publicKey,
+        amountTokenA,
+        amountTokenB,
+      }
+    })
+  }).flat())
+}

src/web3/migration/getPositions/orca.ts

@@ -0,0 +1,106 @@
+
+import { 
+  decreaseLiquidityQuoteByLiquidityWithParams,
+  WhirlpoolContext, 
+  PDAUtil,
+  TokenExtensionUtil,
+  IGNORE_CACHE,
+} from "@orca-so/whirlpools-sdk"
+import { BN } from "bn.js"
+import { Percentage, ReadOnlyWallet } from "@orca-so/common-sdk"
+import { Connection, Keypair, PublicKey } from "@solana/web3.js"
+import { TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID, AccountLayout } from "@solana/spl-token"
+import { MigratePosition } from "./common"
+import { IAccounts } from "@/context"
+
+// Token amount is exactly 1 for both Orca and Raydium
+const getLikelyPositionMintsForUser = async (
+  connection: Connection, 
+  user: PublicKey
+): Promise<PublicKey[]> => {
+  const tokenAccounts = await connection
+    .getTokenAccountsByOwner(user, { programId: TOKEN_PROGRAM_ID }, 'confirmed');
+  const token2022Accounts = await connection
+    .getTokenAccountsByOwner(user, { programId: TOKEN_2022_PROGRAM_ID }, 'confirmed');
+  const accountInfos = tokenAccounts.value.concat(token2022Accounts.value);
+  const mints = accountInfos.map(info => {
+    return {
+      pubkey: info.pubkey,
+      account: AccountLayout.decode(Uint8Array.from(info.account.data))
+    }
+  }).filter(data => data.account.amount === BigInt(1))
+  .map(data => data.account.mint);
+
+  return mints
+}
+
+const getOrcaPositionAccountsForMints = async (
+  whirlpoolCtx: WhirlpoolContext,
+  mints: PublicKey[], 
+): Promise<Array<MigratePosition>> => {
+  const addresses = mints.map(mint => PDAUtil.getPosition(whirlpoolCtx.program.programId, mint).publicKey);
+  const positions = Array.from((
+    await whirlpoolCtx.fetcher.getPositions(addresses, IGNORE_CACHE)).values())
+    .filter(position => position !== null)
+  const whirlpoolAddresses = Array.from(positions.values()).map(pos => pos.whirlpool);
+  const whirlpools = await whirlpoolCtx.fetcher.getPools(whirlpoolAddresses, IGNORE_CACHE); 
+
+  const allPositions = new Array<MigratePosition>();
+  for (const position of positions) {
+    let whirlpool = whirlpools.get(position.whirlpool.toString());
+    if (whirlpool === null || whirlpool === undefined) {
+      continue;
+    }
+
+    const tokenExtensionCtx =
+      await TokenExtensionUtil.buildTokenExtensionContext(
+        whirlpoolCtx.fetcher,
+        whirlpool,
+        IGNORE_CACHE
+      );
+
+    const positionInfo = decreaseLiquidityQuoteByLiquidityWithParams({
+      liquidity: position.liquidity,
+      tickCurrentIndex: whirlpool.tickCurrentIndex,
+      sqrtPrice: whirlpool.sqrtPrice,
+      tickLowerIndex: position.tickLowerIndex,
+      tickUpperIndex: position.tickUpperIndex,
+      tokenExtensionCtx,
+      slippageTolerance: new Percentage(new BN(0), new BN(100))
+    });
+
+    allPositions.push({
+      source: 'OrcaCLMM',
+      tokenA: whirlpool.tokenMintA,
+      tokenB: whirlpool.tokenMintB,
+      amountTokenA: positionInfo.tokenEstA,
+      amountTokenB: positionInfo.tokenEstB
+    })
+  }
+
+  return allPositions;
+}
+
+export const getOrcaCLMMPositionsForUser = async (
+  connection: Connection, 
+  user: PublicKey,
+  programId: PublicKey,
+  userTokenAccounts?: IAccounts
+): Promise<MigratePosition[]> => {
+  const whirlpoolCtx = WhirlpoolContext.from(
+    connection, 
+    new ReadOnlyWallet(Keypair.generate().publicKey),
+    programId
+  );
+
+  let positionMints: PublicKey[];
+  if (!userTokenAccounts) {
+    positionMints = await getLikelyPositionMintsForUser(connection, user);
+  } else {
+    positionMints = Object.entries(userTokenAccounts)
+    .filter(([_, accountInfo]) => accountInfo.amount === '1')
+    .map(([mint, _]) => new PublicKey(mint))
+  }
+
+  return await getOrcaPositionAccountsForMints(whirlpoolCtx, positionMints);
+}

src/web3/migration/getPositions/raydium.ts

@@ -0,0 +1,146 @@
+import { Connection, EpochInfo, PublicKey } from "@solana/web3.js"
+import { MigratePosition } from "./common";
+import { 
+  Clmm, 
+  clmmComputeInfoToApiInfo, 
+  CLMM_PROGRAM_ID, 
+  fetchMultipleMintInfos, 
+  PoolFetchType,
+  PositionUtils, 
+  Raydium, 
+  TokenAccount, 
+  TokenAccountRaw, 
+  ApiV3PoolInfoConcentratedItem,
+  ApiV3PoolInfoItem
+} from "@raydium-io/raydium-sdk-v2"
+
+const getAllCLMMPoolsFromAPI = async(raydium: Raydium): Promise<Array<ApiV3PoolInfoConcentratedItem>> => {
+  const pools = new Array<ApiV3PoolInfoItem>();
+  let page = 1;
+  while (true) {
+    const response = await raydium.api.getPoolList({
+      type: PoolFetchType.Concentrated,
+      sort: 'liquidity',
+      order: 'desc',
+      pageSize: 100,
+      page,
+    });
+    pools.push(...response.data);
+    if (!response.hasNextPage) {
+      break;
+    }
+    page += 1;
+  }
+
+  return pools as ApiV3PoolInfoConcentratedItem[]
+}
+
+const getCLMMPoolInfosFromAPI = async (
+  raydium: Raydium, 
+  poolIds: string[]
+): Promise<Array<ApiV3PoolInfoConcentratedItem>> => {
+  return await Promise.all(chunks(poolIds, 100).map(async (ids) => {
+    return ((await raydium.api.fetchPoolById({ ids: ids.join(',') })) as ApiV3PoolInfoConcentratedItem[]) 
+  })).then(pools => pools.flat())
+}
+
+const getCLMMPoolInfosFromRPC = async (
+  raydium: Raydium, 
+  poolIds: (string | PublicKey)[]
+): Promise<Array<ApiV3PoolInfoConcentratedItem>> => {
+  const clmm = new Clmm({
+    scope: raydium,
+    moduleName: "gfxMigrate",
+  });
+  const rpcPools = await clmm.getRpcClmmPoolInfos({poolIds, config: {
+    batchRequest: true,
+    chunkCount: 99,
+  }});
+  const mints = new Set<PublicKey>();
+
+  Object.values(rpcPools).forEach((p) => {
+    mints.add(p.mintA);
+    mints.add(p.mintB)
+  });
+  const fetchMintInfoRes = await fetchMultipleMintInfos({
+    connection: raydium.connection,
+    mints: Array.from(mints)
+  }); 
+
+  const { computeClmmPoolInfo } = await clmm.getComputeClmmPoolInfos({
+    clmmPoolsRpcInfo: rpcPools,
+    mintInfos: fetchMintInfoRes
+  });
+  return Object.values(computeClmmPoolInfo).map(p => clmmComputeInfoToApiInfo(p))
+}
+
+export const getRaydiumCLMMPositions = async (
+  connection: Connection,
+  user: PublicKey,
+  poolMap: Record<string, ApiV3PoolInfoConcentratedItem> = {},
+  useRpc = true,
+  epochInfo?: EpochInfo,
+  tokenAccounts?: TokenAccount[],
+  tokenAccountRawInfos?: TokenAccountRaw[]
+): Promise<Array<MigratePosition>> => {
+  const raydium = await Raydium.load({
+    connection,
+    owner: user,
+    signAllTransactions: undefined,
+    tokenAccounts,
+    tokenAccountRawInfos, 
+    disableLoadToken: true,
+    disableFeatureCheck: true
+  });
+  const ownerPositions = await raydium.clmm.getOwnerPositionInfo({ programId: CLMM_PROGRAM_ID });
+  const poolsToFetch = ownerPositions.map(position => position.poolId.toString())
+    .filter(poolId => !poolMap[poolId]);
+
+  if (!epochInfo) {
+    epochInfo = await raydium.connection.getEpochInfo();
+  }
+
+  let pools: Array<ApiV3PoolInfoConcentratedItem>;
+  if (poolsToFetch.length != 0) {
+    if (useRpc) {
+      pools = await getCLMMPoolInfosFromRPC(raydium, poolsToFetch);
+    } else {
+      pools = await getCLMMPoolInfosFromAPI(raydium, poolsToFetch);
+    }
+    pools.forEach(pool => {
+      if (!pool) return;
+      poolMap[pool.id] = pool;
+    });
+  }
+
+  const migratePositions = new Array<MigratePosition>();
+  for (const ownerPosition of ownerPositions) {
+    let poolInfo = poolMap[ownerPosition.poolId.toString()];
+    if (!poolInfo) {
+      continue;
+    }
+    const position = PositionUtils.getAmountsFromLiquidity({
+      poolInfo,
+      ownerPosition,
+      liquidity: ownerPosition.liquidity,
+      slippage: 0,
+      add: false,
+      epochInfo
+    })
+    migratePositions.push({
+      source: 'RaydiumCLMM',
+      tokenA: new PublicKey(poolInfo.mintA.address),
+      tokenB: new PublicKey(poolInfo.mintB.address),
+      amountTokenA: position.amountSlippageA.amount,
+      amountTokenB: position.amountSlippageB.amount,
+    });
+  }
+
+  return migratePositions
+}
+
+function chunks<T>(array: T[], size: number): T[][] {
+  return Array.apply(0, new Array(Math.ceil(array.length / size))).map((_, index) =>
+    array.slice(index * size, (index + 1) * size)
+  )
+}