Collect Fees

// fetch-infinity-positions.mjs
// Fetch all PancakeSwap Infinity (v4) CL and Bin positions for a wallet,
// compute pending fees for CL positions, and compute token amounts for Bin positions.
//
// Environment variables:
//   WALLET    — 0x wallet address (required)
//   CHAIN_ID  — numeric chain ID (required)
//   RPC       — JSON-RPC endpoint URL (required)

import {
  CLPoolManagerAbi,
  CLPositionManagerAbi,
  INFI_CL_POOL_MANAGER_ADDRESSES,
  INFI_CL_POSITION_MANAGER_ADDRESSES,
} from '@pancakeswap/infinity-sdk'
import { createPublicClient, encodeAbiParameters, http, keccak256 } from 'viem'
import { base, bsc } from 'viem/chains'

// ─── Chain config ────────────────────────────────────────────────────────────

const CHAIN_MAP = {
  56: bsc,
  8453: base,
}

const CHAIN_NAME_MAP = {
  56: 'bsc',
  8453: 'base',
}

const chainId = Number(process.env.CHAIN_ID)
const chain = CHAIN_MAP[chainId]
if (!chain) {
  const supported = Object.keys(CHAIN_MAP).join(', ')
  throw new Error(`Unsupported CHAIN_ID: ${chainId}. Supported chain IDs: ${supported}`)
}

const chainName = CHAIN_NAME_MAP[chainId]

const WALLET = process.env.WALLET
if (!/^0x[0-9a-fA-F]{40}$/.test(WALLET)) {
  throw new Error(`Invalid WALLET address: ${WALLET}`)
}

const RPC = process.env.RPC

// ─── Contract addresses (same on BSC and Base) ────────────────────────────────

const CL_POSITION_MANAGER = INFI_CL_POSITION_MANAGER_ADDRESSES[chainId]
const CL_POOL_MANAGER = INFI_CL_POOL_MANAGER_ADDRESSES[chainId]

// ─── Utilities ────────────────────────────────────────────────────────────────

const Q128 = 2n ** 128n
const MOD = 2n ** 256n

function computePoolId(poolKey) {
  // keccak256 of ABI-encoded poolKey (6 slots: currency0, currency1, hooks, poolManager, fee, bytes32 parameters)
  return keccak256(
    encodeAbiParameters(
      [
        { name: 'currency0', type: 'address' },
        { name: 'currency1', type: 'address' },
        { name: 'hooks', type: 'address' },
        { name: 'poolManager', type: 'address' },
        { name: 'fee', type: 'uint24' },
        { name: 'parameters', type: 'bytes32' },
      ],
      [
        poolKey.currency0,
        poolKey.currency1,
        poolKey.hooks,
        poolKey.poolManager,
        poolKey.fee,
        poolKey.parameters,
      ],
    ),
  )
}

function feeGrowthInside(fgGlobal, fgOutLower, fgOutUpper, tickLower, tickUpper, currentTick) {
  const fgBelow = currentTick >= tickLower ? fgOutLower : (fgGlobal - fgOutLower + MOD) % MOD
  const fgAbove = currentTick < tickUpper ? fgOutUpper : (fgGlobal - fgOutUpper + MOD) % MOD
  return (fgGlobal - fgBelow - fgAbove + MOD * 2n) % MOD
}

// ─── Explorer API pagination ──────────────────────────────────────────────────

async function fetchAllPages(urlBase) {
  const rows = []
  let after = ''
  do {
    const url = `${urlBase}?before=&after=${after}`
    const res = await fetch(url)
    if (!res.ok) throw new Error(`Explorer API error ${res.status}: ${url}`)
    const data = await res.json()
    rows.push(...(data.rows ?? []))
    if (!data.hasNextPage) break
    after = data.endCursor ?? ''
  } while (true)
  return rows
}

// ─── Main ─────────────────────────────────────────────────────────────────────

const client = createPublicClient({ chain, transport: http(RPC) })
const EXPLORER = 'https://explorer.pancakeswap.com/api/cached/pools/positions'

// ── Part 1: CL Positions ──────────────────────────────────────────────────────

const clRows = await fetchAllPages(`${EXPLORER}/infinityCl/${chainName}/${WALLET}`)
const activeCLRows = clRows.filter((r) => r.liquidity !== '0')

const clPositions = []

if (activeCLRows.length > 0) {
  // Fetch on-chain position data for each tokenId
  const posResults = await client.multicall({
    contracts: activeCLRows.map((row) => ({
      address: CL_POSITION_MANAGER,
      abi: CLPositionManagerAbi,
      functionName: 'positions',
      args: [BigInt(row.id)],
    })),
  })

  // Collect unique pool IDs and their positions data
  const poolIdToPositions = new Map() // poolId -> [{ rowIdx, posData }]
  const positionData = []

  for (let i = 0; i < posResults.length; i++) {
    const result = posResults[i]
    if (result.status !== 'success') continue
    const pos = result.result
    const poolKey = pos[0]
    const poolId = computePoolId(poolKey)
    positionData.push({ rowIdx: i, pos, poolId, poolKey })
    if (!poolIdToPositions.has(poolId)) {
      poolIdToPositions.set(poolId, [])
    }
    poolIdToPositions.get(poolId).push(positionData.length - 1)
  }

  // Batch pool-level reads per unique pool (getFeeGrowthGlobals, getSlot0)
  // plus per-position tick reads (getPoolTickInfo for tickLower and tickUpper)
  const uniquePoolIds = [...poolIdToPositions.keys()]

  const poolCalls = uniquePoolIds.flatMap((poolId) => [
    {
      address: CL_POOL_MANAGER,
      abi: CLPoolManagerAbi,
      functionName: 'getFeeGrowthGlobals',
      args: [poolId],
    },
    {
      address: CL_POOL_MANAGER,
      abi: CLPoolManagerAbi,
      functionName: 'getSlot0',
      args: [poolId],
    },
  ])

  const tickCalls = positionData.flatMap((pd) => [
    {
      address: CL_POOL_MANAGER,
      abi: CLPoolManagerAbi,
      functionName: 'getPoolTickInfo',
      args: [pd.poolId, pd.pos[1]], // tickLower
    },
    {
      address: CL_POOL_MANAGER,
      abi: CLPoolManagerAbi,
      functionName: 'getPoolTickInfo',
      args: [pd.poolId, pd.pos[2]], // tickUpper
    },
  ])

  const [poolResults, tickResults] = await Promise.all([
    client.multicall({ contracts: poolCalls }),
    client.multicall({ contracts: tickCalls }),
  ])

  // Build poolId -> { fgGlobal0, fgGlobal1, currentTick } map
  const poolState = new Map()
  for (let i = 0; i < uniquePoolIds.length; i++) {
    const fgResult = poolResults[i * 2]
    const slot0Result = poolResults[i * 2 + 1]
    if (fgResult.status !== 'success' || slot0Result.status !== 'success') continue
    const [fg0, fg1] = fgResult.result
    const currentTick = slot0Result.result[1]
    poolState.set(uniquePoolIds[i], { fg0, fg1, currentTick })
  }

  // Compute pending fees for each position
  for (let i = 0; i < positionData.length; i++) {
    const { rowIdx, pos, poolId } = positionData[i]
    const state = poolState.get(poolId)
    if (!state) continue

    const tickLowerResult = tickResults[i * 2]
    const tickUpperResult = tickResults[i * 2 + 1]
    if (tickLowerResult.status !== 'success' || tickUpperResult.status !== 'success') continue

    console.log('tick results', tickLowerResult, tickUpperResult)

    const { feeGrowthOutside0X128: fgOutLower0, feeGrowthOutside1X128: fgOutLower1 } =
      tickLowerResult.result
    const { feeGrowthOutside0X128: fgOutUpper0, feeGrowthOutside1X128: fgOutUpper1 } =
      tickUpperResult.result

    const poolKey = pos[0]
    const tickLower = pos[1]
    const tickUpper = pos[2]
    const liquidity = pos[3]
    const fg0InsideLast = pos[4]
    const fg1InsideLast = pos[5]

    const fg0Inside = feeGrowthInside(
      state.fg0,
      fgOutLower0,
      fgOutUpper0,
      tickLower,
      tickUpper,
      state.currentTick,
    )
    const fg1Inside = feeGrowthInside(
      state.fg1,
      fgOutLower1,
      fgOutUpper1,
      tickLower,
      tickUpper,
      state.currentTick,
    )

    const pending0 = (((fg0Inside - fg0InsideLast + MOD) % MOD) * liquidity) / Q128
    const pending1 = (((fg1Inside - fg1InsideLast + MOD) % MOD) * liquidity) / Q128

    const row = activeCLRows[rowIdx]
    clPositions.push({
      id: row.id,
      token0: poolKey.currency0,
      token1: poolKey.currency1,
      tickLower: Number(tickLower),
      tickUpper: Number(tickUpper),
      liquidity: liquidity.toString(),
      pending0: pending0.toString(),
      pending1: pending1.toString(),
    })
  }
}

// ── Part 2: Bin Positions ─────────────────────────────────────────────────────
// The Explorer API returns per-bin reserve and share data directly — no on-chain
// calls are needed. Each row represents one pool; reserveOfBins[] contains the
// per-bin breakdown including userSharesOfBin.

const binRows = await fetchAllPages(`${EXPLORER}/infinityBin/${chainName}/poolsByOwner/${WALLET}`)

// Fetch pool metadata (token0/token1) for each unique poolId in parallel
const uniqueBinPoolIds = [...new Set(binRows.map((r) => r.poolId))]
const poolMetaResults = await Promise.all(
  uniqueBinPoolIds.map((poolId) =>
    fetch(`https://explorer.pancakeswap.com/api/cached/pools/infinityBin/${chainName}/${poolId}`)
      .then((r) => (r.ok ? r.json() : null))
      .catch(() => null),
  ),
)
const binPoolMeta = new Map()
for (let i = 0; i < uniqueBinPoolIds.length; i++) {
  const meta = poolMetaResults[i]
  binPoolMeta.set(uniqueBinPoolIds[i], {
    token0: meta?.token0?.id ?? null,
    token1: meta?.token1?.id ?? null,
  })
}

const binPositions = []

for (const row of binRows) {
  const poolId = row.poolId
  const { token0, token1 } = binPoolMeta.get(poolId) ?? {
    token0: null,
    token1: null,
  }

  for (const bin of row.reserveOfBins ?? []) {
    const userShares = BigInt(bin.userSharesOfBin ?? '0')
    if (userShares === 0n) continue

    const totalShares = BigInt(bin.totalShares)
    const reserveX = BigInt(bin.reserveX)
    const reserveY = BigInt(bin.reserveY)

    const amountX = totalShares > 0n ? (userShares * reserveX) / totalShares : 0n
    const amountY = totalShares > 0n ? (userShares * reserveY) / totalShares : 0n

    binPositions.push({
      poolId,
      token0,
      token1,
      binId: bin.binId,
      share: userShares.toString(),
      amountX: amountX.toString(),
      amountY: amountY.toString(),
    })
  }
}

// ── Output ────────────────────────────────────────────────────────────────────

console.log(JSON.stringify({ clPositions, binPositions }))

// fetch-solana.cjs
// Discover PancakeSwap Solana CLMM positions and farm positions, output pending rewards.
//
// Environment variables:
//   SOL_WALLET  — base58 Solana public key (required)

'use strict'

const {
  getMultipleAccountsInfo,
  PositionInfoLayout,
  parseTokenAccountResp,
  PositionUtils,
  Raydium,
  JupTokenType,
  TickUtils,
  TickArrayLayout,
  API_URLS,
} = require('@pancakeswap/solana-core-sdk')
const { Connection, PublicKey } = require('@solana/web3.js')
const { TOKEN_PROGRAM_ID, TOKEN_2022_PROGRAM_ID } = require('@solana/spl-token')
const BN = require('bn.js')

const address = process.env.SOL_WALLET
const PANCAKE_CLMM_PROGRAM_ID = new PublicKey('HpNfyc2Saw7RKkQd8nEL4khUcuPhQ7WwY1B2qjx8jxFq')
const POSITION_SEED = Buffer.from('position', 'utf8')
const urlConfigs = {
  ...API_URLS,
  BASE_HOST: process.env.NEXT_PUBLIC_EXPLORE_API_ENDPOINT ?? API_URLS.BASE_HOST,
  POOL_LIST: '/cached/v1/pools/info/list',
  MINT_PRICE: '/cached/v1/tokens/price',
  INFO: '/cached/v1/pools/stats/overview',
  POOL_SEARCH_BY_ID: '/cached/v1/pools/info/ids',
  POOL_POSITION_LINE: '/cached/v1/pools/line/position',
  POOL_LIQUIDITY_LINE: '/cached/v1/pools/line/liquidity',
  POOL_TVL_LINE: '/cached/v1/pools/line/tvl',
  POOL_KEY_BY_ID: '/cached/v1/pools/info/ids',
  BIRDEYE_TOKEN_PRICE: '/cached/v1/tokens/birdeye/defi/multi_price',
  TOKEN_LIST: 'https://api-v3.raydium.io/mint/list',
  PCS_TOKEN_LIST: 'https://tokens.pancakeswap.finance/pancakeswap-solana-default.json',
}

async function getTokenBalances(connection, owner) {
  const [solAccountResp, tokenAccountResp, token2022Resp] = await Promise.all([
    connection.getAccountInfo(owner),
    connection.getTokenAccountsByOwner(owner, { programId: TOKEN_PROGRAM_ID }),
    connection.getTokenAccountsByOwner(owner, {
      programId: TOKEN_2022_PROGRAM_ID,
    }),
  ])

  const tokenAccountData = parseTokenAccountResp({
    owner,
    solAccountResp,
    tokenAccountResp: {
      context: tokenAccountResp.context,
      value: [...tokenAccountResp.value, ...token2022Resp.value],
    },
  })

  const tokenAccountMap = new Map()
  tokenAccountData.tokenAccounts.forEach((tokenAccount) => {
    const mintStr = tokenAccount.mint?.toBase58()
    if (!tokenAccountMap.has(mintStr)) {
      tokenAccountMap.set(mintStr, [tokenAccount])
      return
    }
    tokenAccountMap.get(mintStr).push(tokenAccount)
  })

  tokenAccountMap.forEach((tokenAccount) => {
    tokenAccount.sort((a, b) => (a.amount.lt(b.amount) ? 1 : -1))
  })

  return tokenAccountMap
}

async function fetchPoolInfos(poolIds) {
  const timestamp = Date.now()

  const apiBaseUrl = 'https://sol-explorer.pancakeswap.com/api'
  const searchUrl = '/cached/v1/pools/info/ids'
  const response = await fetch(`${apiBaseUrl}${searchUrl}?ids=${poolIds.join(',')}`)

  const poolInfo = await response.json()

  return poolInfo.data.map((pool) => {
    let isFarming = false
    if (pool.rewardDefaultInfos && pool.rewardDefaultInfos.length > 0) {
      isFarming = pool.rewardDefaultInfos.some(
        (reward) => Number(reward.endTime ?? 0) * 1000 > timestamp && reward.perSecond > 0,
      )
    }
    return { ...pool, isFarming }
  })
}

const getTickArrayAddress = (props) =>
  TickUtils.getTickArrayAddressByTick(
    new PublicKey(props.pool.programId),
    new PublicKey(props.pool.id),
    props.tickNumber,
    props.pool.config.tickSpacing,
  )

async function getRewardInfo(connection, raydium, position) {
  const result = await raydium.clmm.getPoolInfoFromRpc(position.poolId)

  const tickArrayLowerAddress = getTickArrayAddress({
    pool: result.poolInfo,
    tickNumber: position.tickLower,
  })
  const tickArrayUpperAddress = getTickArrayAddress({
    pool: result.poolInfo,
    tickNumber: position.tickUpper,
  })

  const tickLowerData = await connection.getAccountInfo(tickArrayLowerAddress)
  const tickUpperData = await connection.getAccountInfo(tickArrayUpperAddress)
  if (!tickLowerData || !tickUpperData) {
    throw new Error('Tick array account not found')
  }

  const tickArrayLower = TickArrayLayout.decode(tickLowerData.data)
  const tickArrayUpper = TickArrayLayout.decode(tickUpperData.data)

  const tickLowerState =
    tickArrayLower.ticks[
      TickUtils.getTickOffsetInArray(position.tickLower, result.computePoolInfo.tickSpacing)
    ]
  const tickUpperState =
    tickArrayUpper.ticks[
      TickUtils.getTickOffsetInArray(position.tickUpper, result.computePoolInfo.tickSpacing)
    ]

  const fees = PositionUtils.GetPositionFeesV2(
    result.computePoolInfo,
    position,
    tickLowerState,
    tickUpperState,
  )
  const rewards = PositionUtils.GetPositionRewardsV2(
    result.computePoolInfo,
    position,
    tickLowerState,
    tickUpperState,
  )

  return {
    feeAmount0: fees.tokenFeeAmountA,
    feeAmount1: fees.tokenFeeAmountB,
    rewardAmounts: rewards,
  }
}

async function main() {
  const owner = new PublicKey(address)
  const connection = new Connection('https://api.mainnet-beta.solana.com', 'confirmed')

  const raydium = await Raydium.load({
    connection,
    owner,
    urlConfigs,
    jupTokenType: JupTokenType.Strict,
    logRequests: false,
    disableFeatureCheck: true,
    disableLoadToken: true,
    loopMultiTxStatus: true,
    blockhashCommitment: 'finalized',
  })

  const tokenAccountData = await getTokenBalances(connection, owner)

  const tokensData = Array.from(tokenAccountData.values())
    .flat()
    .filter((token) => token.amount.eq(new BN(1)))

  const keys = tokensData.map((token) => {
    const [publicKey] = PublicKey.findProgramAddressSync(
      [POSITION_SEED, token.mint.toBuffer()],
      PANCAKE_CLMM_PROGRAM_ID,
    )
    return publicKey
  })

  const res = await getMultipleAccountsInfo(connection, keys)

  const parsedInfo = res
    // .flat()
    .map((info) => {
      if (!info) return null
      return PositionInfoLayout.decode(info.data)
    })
    .filter((info) => !!info)

  const poolInfos = await fetchPoolInfos(parsedInfo.map((i) => i.poolId.toBase58()))

  // Dont parallelize because of rate limits
  const rewardInfos = []
  for (let i = 0; i < parsedInfo.length; i++) {
    const rewardInfo = await getRewardInfo(connection, raydium, parsedInfo[i])
    rewardInfos.push(rewardInfo)
  }

  const positions = parsedInfo
    .map((pos, i) => {
      const poolInfo = poolInfos.find((p) => p.id === pos.poolId.toBase58())
      const rewardInfo = rewardInfos[i]

      // if (rewardInfo.feeAmount0.isZero() && rewardInfo.feeAmount1.isZero()) {
      //   return null;
      // }

      return {
        poolId: pos.poolId.toBase58(),
        token0: poolInfo.mintA.address,
        token1: poolInfo.mintB.address,
        fee: poolInfo.feeRate,
        tokensOwed0: rewardInfo.feeAmount0.toString(),
        tokensOwed1: rewardInfo.feeAmount1.toString(),
        farmReward: rewardInfo.rewardAmounts[0].toString(),
        tickLower: pos.tickLower,
        tickUpper: pos.tickUpper,
        liquidity: pos.liquidity.toString(),
      }
    })
    .filter(Boolean) // Only positions with non-zero amounts

  console.log(JSON.stringify(positions, null, 2))
}

main().catch((err) => {
  console.error(err)
  process.exit(1)
})

// fetch-v3-positions.mjs
// Fetch all V3 NonfungiblePositionManager positions for a wallet across all supported chains.
//
// Environment variables:
//   CHAIN_ID          — numeric chain ID (required)
//   WALLET            — 0x wallet address (required)
//   RPC               — JSON-RPC endpoint URL (required)

// import { masterChefV3Addresses } from "@pancakeswap/farms";
import {
  masterChefV3ABI,
  NFT_POSITION_MANAGER_ADDRESSES,
  nonfungiblePositionManagerABI,
} from '@pancakeswap/v3-sdk'
import { createPublicClient, http } from 'viem'
import { arbitrum, base, bsc, linea, mainnet, monad, opBNB, zksync } from 'viem/chains'

const CHAIN_MAP = {
  56: bsc,
  1: mainnet,
  42161: arbitrum,
  8453: base,
  324: zksync,
  59144: linea,
  204: opBNB,
  143: monad,
}

const masterChefV3Addresses = {
  1: '0x556B9306565093C855AEA9AE92A594704c2Cd59e',
  56: '0x556B9306565093C855AEA9AE92A594704c2Cd59e',
  324: '0x4c615E78c5fCA1Ad31e4d66eb0D8688d84307463',
  42161: '0x5e09ACf80C0296740eC5d6F643005a4ef8DaA694',
  59144: '0x22E2f236065B780FA33EC8C4E58b99ebc8B55c57',
  8453: '0xC6A2Db661D5a5690172d8eB0a7DEA2d3008665A3',
  204: '0x05ddEDd07C51739d2aE21F6A9d97a8d69C2C3aaA',
}

const chainId = Number(process.env.CHAIN_ID)
const chain = CHAIN_MAP[chainId]
if (!chain) {
  const supported = Object.keys(CHAIN_MAP).join(', ')
  throw new Error(`Unsupported CHAIN_ID: ${chainId}. Supported chain IDs: ${supported}`)
}

const WALLET = process.env.WALLET
const POSITION_MANAGER = NFT_POSITION_MANAGER_ADDRESSES[chainId]
const masterchefAddress = masterChefV3Addresses[chainId]

const client = createPublicClient({ chain, transport: http(process.env.RPC) })

const MAX_UINT128 = 2n ** 128n - 1n
const CONCURRENCY = Number(process.env.CONCURRENCY ?? 5)

async function mapWithConcurrency(items, limit, fn) {
  const results = []
  for (let i = 0; i < items.length; i += limit) {
    results.push(...(await Promise.all(items.slice(i, i + limit).map(fn))))
    // Delay to avoid rate limits
    await new Promise((resolve) => setTimeout(resolve, 500))
  }
  return results
}

async function getFarmingPositions() {
  const balance = await client.readContract({
    address: masterchefAddress,
    abi: masterChefV3ABI,
    functionName: 'balanceOf',
    args: [WALLET],
  })

  const tokenIdResults = await client.multicall({
    contracts: Array.from({ length: Number(balance) }, (_, i) => ({
      address: masterchefAddress,
      abi: masterChefV3ABI,
      functionName: 'tokenOfOwnerByIndex',
      args: [WALLET, BigInt(i)],
    })),
  })
  const tokenIds = tokenIdResults.filter((r) => r.status === 'success').map((r) => r.result)

  return tokenIds
}

const balance = await client.readContract({
  address: POSITION_MANAGER,
  abi: nonfungiblePositionManagerABI,
  functionName: 'balanceOf',
  args: [WALLET],
})

const tokenIdResults = await client.multicall({
  contracts: Array.from({ length: Number(balance) }, (_, i) => ({
    address: POSITION_MANAGER,
    abi: nonfungiblePositionManagerABI,
    functionName: 'tokenOfOwnerByIndex',
    args: [WALLET, BigInt(i)],
  })),
})
const tokenIds = tokenIdResults.filter((r) => r.status === 'success').map((r) => r.result)

const collectResults = await mapWithConcurrency(tokenIds, CONCURRENCY, (id) =>
  client
    .simulateContract({
      address: POSITION_MANAGER,
      abi: nonfungiblePositionManagerABI,
      functionName: 'collect',
      args: [
        {
          tokenId: id,
          recipient: WALLET,
          amount0Max: MAX_UINT128,
          amount1Max: MAX_UINT128,
        },
      ],
      account: WALLET,
    })
    .then((r) => [r.result[0].toString(), r.result[1].toString()]),
)

const farmingTokenIds = await getFarmingPositions()
tokenIds.push(...farmingTokenIds)

const collectFarmingResults = await mapWithConcurrency(farmingTokenIds, CONCURRENCY, (id) =>
  client
    .simulateContract({
      address: masterchefAddress,
      abi: masterChefV3ABI,
      functionName: 'collect',
      args: [
        {
          tokenId: id,
          recipient: WALLET,
          amount0Max: MAX_UINT128,
          amount1Max: MAX_UINT128,
        },
      ],
      account: WALLET,
    })
    .then((r) => [r.result[0].toString(), r.result[1].toString()]),
)

collectResults.push(...collectFarmingResults)

const posResults = await client.multicall({
  contracts: tokenIds.map((id) => ({
    address: POSITION_MANAGER,
    abi: nonfungiblePositionManagerABI,
    functionName: 'positions',
    args: [id],
  })),
})

const positions = posResults
  .filter((r) => r.status === 'success')
  .map((r, i) => {
    const p = r.result

    // Differs from tokensOwed via position result
    const [tokensOwed0, tokensOwed1] = collectResults[i]

    return {
      tokenId: tokenIds[i].toString(),
      token0: p[2],
      token1: p[3],
      fee: p[4],
      tokensOwed0,
      tokensOwed1,
      tickLower: p[5],
      tickUpper: p[6],
      liquidity: p[7].toString(),
      farming: farmingTokenIds.includes(tokenIds[i]),
    }
  })

console.log(JSON.stringify(positions))