Pancakeswap

// 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))

// discover-pools.mjs
// Single script that discovers PancakeSwap pools and fetches all APR data.
//
// Environment variables:
//   CHAIN      — chain string (required): bsc, eth, arb, base, zksync, linea, opbnb, monad, sol
//   TOKEN0     — EVM address, Solana pubkey, or native alias (bnb/eth/sol) (optional)
//   TOKEN1     — same as TOKEN0 (optional)
//   ORDER_BY   — tvlUSD (default), apr24h, volumeUSD24h

import {
  BinPoolManagerAbi,
  CLPoolManagerAbi,
  INFI_BIN_POOL_MANAGER_ADDRESSES,
  INFI_CL_POOL_MANAGER_ADDRESSES,
} from '@pancakeswap/infinity-sdk'
import { createPublicClient, http } from 'viem'
import { base, bsc } from 'viem/chains'

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

const CHAIN_STRING_TO_ID = {
  bsc: 56,
  eth: 1,
  arb: 42161,
  base: 8453,
  zksync: 324,
  linea: 59144,
  opbnb: 204,
  monad: 143,
  sol: 8000001001,
}

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

const CHAIN_RPC = {
  56: 'https://bsc-dataseed1.binance.org',
  8453: 'https://mainnet.base.org',
}

const MASTERCHEF_V3 = {
  56: '0x556B9306565093C855AEA9AE92A594704c2Cd59e',
  1: '0x556B9306565093C855AEA9AE92A594704c2Cd59e',
  42161: '0x5e09ACf80C0296740eC5d6F643005a4ef8DaA694',
  8453: '0xC6A2Db661D5a5690172d8eB0a7DEA2d3008665A3',
  324: '0x4c615E78c5fCA1Ad31e4d66eb0D8688d84307463',
}

const MC_V3_RPC = {
  56: 'https://bsc-rpc.publicnode.com',
  1: 'https://ethereum-rpc.publicnode.com',
  42161: 'https://arbitrum-one-rpc.publicnode.com',
  8453: 'https://base-rpc.publicnode.com',
  324: 'https://zksync-era-rpc.publicnode.com',
}

const WBNB_BSC = '0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c'
const ZERO_ADDR = '0x0000000000000000000000000000000000000000'
const INCENTRA_API = 'https://incentra-prd.brevis.network/sdk/v1'
const INCENTRA_CAMPAIGN_TYPES = [3, 4, 8]
const MERKL_CHAIN_IDS = [1, 56, 8453, 42161, 324, 59144, 143]
const SECONDS_PER_YEAR = 31_536_000
const FEE_BASE = 10_000

// ─── Input parsing ─────────────────────────────────────────────────────────────

const CHAIN = (process.env.CHAIN || '').toLowerCase()
const TOKEN0_RAW = (process.env.TOKEN0 || '').toLowerCase()
const TOKEN1_RAW = (process.env.TOKEN1 || '').toLowerCase()
const ORDER_BY = process.env.ORDER_BY || 'tvlUSD'

const ALL_PROTOCOLS = ['v2', 'v3', 'stable', 'infinityCl', 'infinityBin', 'infinityStable']
const PROTOCOLS_INPUT = process.env.PROTOCOLS
  ? process.env.PROTOCOLS.split(',')
      .map((p) => p.trim())
      .filter(Boolean)
  : ALL_PROTOCOLS

if (!CHAIN_STRING_TO_ID[CHAIN]) {
  throw new Error(
    `Unsupported CHAIN: "${CHAIN}". Supported: ${Object.keys(CHAIN_STRING_TO_ID).join(', ')}`,
  )
}

const ORDER = ['tvlUSD', 'apr24h', 'volumeUSD24h']
if (!ORDER.includes(ORDER_BY)) {
  throw new Error(`Unsupported ORDER_BY: "${ORDER_BY}". Supported: ${ORDER.join(', ')}`)
}

const invalidProtocols = PROTOCOLS_INPUT.filter((p) => !ALL_PROTOCOLS.includes(p))
if (invalidProtocols.length > 0) {
  throw new Error(
    `Unsupported PROTOCOLS: "${invalidProtocols.join(', ')}". Supported: ${ALL_PROTOCOLS.join(
      ', ',
    )}`,
  )
}

const chainId = CHAIN_STRING_TO_ID[CHAIN]
const isSolana = CHAIN === 'sol'

const EVM_ADDR_RE = /^0x[0-9a-fA-F]{40}$/
const SOL_ADDR_RE = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/
const INF_POOL_ID_RE = /^0x[0-9a-fA-F]{64}$/

// Resolve native aliases to their canonical forms for API queries
function resolveToken(raw) {
  if (!raw) return null
  if (raw === 'bnb') return { native: true, aliases: [ZERO_ADDR, WBNB_BSC] }
  if (raw === 'eth') return { native: true, aliases: [] } // omit from token filter
  if (raw === 'sol') return { native: true, aliases: [] }
  return { native: false, address: raw }
}

const token0 = resolveToken(TOKEN0_RAW)
const token1 = resolveToken(TOKEN1_RAW)

// ─── Explorer API helpers ──────────────────────────────────────────────────────

const EXPLORER_BASE = 'https://explorer.pancakeswap.com/api/cached/pools'
const PROTOCOLS = PROTOCOLS_INPUT.map((p) => `protocols=${p}`).join('&')

function feeTierPct(pool) {
  if (pool.protocol === 'stable') return '0.01%'
  if (pool.isDynamicFee) return '0%'
  if (pool.protocol === 'infinityStable') return `${(pool.feeTier / 100_000_000).toPrecision(4)}%`
  return `${pool.feeTier / 10_000}%`
}

const GET_FEE_ABI = [
  {
    name: 'getFee',
    type: 'function',
    stateMutability: 'view',
    inputs: [{ name: '', type: 'address' }],
    outputs: [{ name: '', type: 'uint24' }],
  },
]

function apr24hPct(pool) {
  const v = parseFloat(pool.apr24h || '0')
  return `${(v * 100).toFixed(2)}%`
}

async function fetchExplorerPair(t0addr, t1addr) {
  const url = `${EXPLORER_BASE}/list/pair/${t0addr}/${t1addr}?chains=${CHAIN}&${PROTOCOLS}&orderBy=${ORDER_BY}`
  const r = await fetch(url)
  const data = await r.json()
  return data.rows || []
}

async function fetchExplorerList(tokenParams) {
  const base = `${EXPLORER_BASE}/list?chains=${CHAIN}&${PROTOCOLS}&orderBy=${ORDER_BY}`
  const qs = tokenParams.map((t) => `tokens=${t}`).join('&')
  const url = qs ? `${base}&${qs}` : base
  const r = await fetch(url)
  const data = await r.json()
  return data.rows || []
}

function normalizePool(row) {
  const lpFeeApr = apr24hPct(row)
  return {
    id: row.id,
    protocol: row.protocol,
    feeTierPct: feeTierPct(row),
    isDynamicFee: row.isDynamicFee || false,
    hookAddress: row.hookAddress || null,
    tvlUSD: row.tvlUSD,
    volumeUSD24h: row.volumeUSD24h,
    lpFeeApr,
    token0: row.token0?.symbol || '',
    token1: row.token1?.symbol || '',
    token0Address: row.token0?.id || row.token0?.address || '',
    token1Address: row.token1?.id || row.token1?.address || '',
    cakePerYear: 0,
    cakeAprPct: '—',
    totalAprPct: lpFeeApr,
    merklApr: [],
    incentraApr: [],
    protocolFeePercent: null,
  }
}

// ─── Pool discovery ────────────────────────────────────────────────────────────

async function discoverPools() {
  if (isSolana) {
    return fetchSolanaPools()
  }

  const bothKnown = token0 && !token0.native && token1 && !token1.native

  const bnbToken = [token0, token1].find((t) => t?.native && t.aliases?.length > 0)

  if (bothKnown) {
    const rows = await fetchExplorerPair(token0.address, token1.address)
    return filterMinTvl(dedupe(rows.map(normalizePool)))
  }

  if (bnbToken) {
    // BNB special case: query both zero address and WBNB
    const otherToken = token0 === bnbToken ? token1 : token0
    const [rows0, rows1] = await Promise.all(
      bnbToken.aliases.map((alias) => {
        if (otherToken && !otherToken.native) {
          return fetchExplorerPair(alias, otherToken.address)
        }
        return fetchExplorerList([`${chainId}:${alias}`])
      }),
    )
    return filterMinTvl(dedupe([...rows0, ...rows1].map(normalizePool)))
  }

  // Build token params for list endpoint
  const tokenParams = []
  for (const t of [token0, token1]) {
    if (t && !t.native && EVM_ADDR_RE.test(t.address)) {
      tokenParams.push(`${chainId}:${t.address}`)
    }
  }
  const rows = await fetchExplorerList(tokenParams)
  return filterMinTvl(dedupe(rows.map(normalizePool)))
}

function dedupe(pools) {
  const seen = new Set()
  return pools.filter((p) => {
    if (seen.has(p.id)) return false
    seen.add(p.id)
    return true
  })
}

function filterMinTvl(pools) {
  return pools.filter((p) => parseFloat(p.tvlUSD) >= 100)
}

// ─── Solana pool discovery + APR ──────────────────────────────────────────────

async function fetchSolanaPools() {
  const tokenParams = []
  for (const t of [token0, token1]) {
    if (t && !t.native && SOL_ADDR_RE.test(t.address)) {
      tokenParams.push(`${chainId}:${t.address}`)
    }
  }
  const rows = await fetchExplorerList(tokenParams)
  const pools = filterMinTvl(dedupe(rows.map(normalizePool)))

  if (pools.length === 0) return pools

  // Fetch sol-explorer APR data for all pools at once
  const ids = pools.map((p) => p.id).join(',')
  try {
    const r = await fetch(
      `https://sol-explorer.pancakeswap.com/api/cached/v1/pools/info/ids?ids=${ids}`,
    )
    const data = await r.json()
    const byId = {}
    for (const entry of data.data || []) {
      byId[entry.id] = entry
    }
    for (const pool of pools) {
      const info = byId[pool.id]
      if (!info) continue
      const feeApr = info.day?.feeApr ?? 0
      const cakeFarmApr = info.day?.rewardApr?.[0] ?? 0
      pool.apr24hPct = `${feeApr.toFixed(2)}%`
      if (cakeFarmApr > 0) {
        pool.cakeAprPct = `${cakeFarmApr.toFixed(2)}%`
      }
    }
  } catch (_) {
    // sol-explorer unavailable — continue with Explorer API APR only
  }

  return pools
}

// ─── Merkl + Incentra APRs ─────────────────────────────────────────────────────

async function fetchIncentraApr() {
  try {
    const r = await fetch(`${INCENTRA_API}/liquidityCampaigns`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ campaign_type: INCENTRA_CAMPAIGN_TYPES, status: [4] }),
    })
    const data = await r.json()
    if (data.err) return []

    return data.campaigns.map((c) => ({
      chainId: c.chainId,
      campaignId: c.campaignId,
      poolId: c.pools.poolId,
      poolName: c.pools.poolName,
      apr: c.rewardInfo.apr * 100,
      status: c.status,
    }))
  } catch (_) {
    return []
  }
}

async function fetchMerklApr() {
  try {
    const r = await fetch(
      `https://api.merkl.xyz/v4/opportunities/?chainId=${MERKL_CHAIN_IDS.join(
        ',',
      )}&test=false&mainProtocolId=pancake-swap&action=POOL,HOLD&status=LIVE&items=100`,
    )
    const result = await r.json()
    const pancake = result?.filter(
      (o) =>
        o?.tokens?.[0]?.symbol?.toLowerCase().startsWith('cake-lp') ||
        o?.protocol?.id?.toLowerCase().startsWith('pancake-swap') ||
        o?.protocol?.id?.toLowerCase().startsWith('pancakeswap'),
    )
    return pancake.map((c) => ({
      chainId: c.chainId,
      campaignId: c.identifier,
      poolId: c.identifier,
      poolName: c.name,
      apr: c.apr / 100,
      status: c.status,
    }))
  } catch (_) {
    return []
  }
}

function matchExtraAprs(pools, merklApr, incentraApr) {
  for (const pool of pools) {
    const id = pool.id.toLowerCase()
    pool.merklApr = merklApr.filter(
      (m) => m.chainId.toString() === chainId.toString() && m.poolId.toLowerCase() === id,
    )
    pool.incentraApr = incentraApr.filter(
      (i) => i.chainId.toString() === chainId.toString() && i.poolId.toLowerCase() === id,
    )
    if (pool.incentraApr.length) {
      pool.totalAprPct = `${
        pool.incentraApr[0].apr + (parseFloat(pool.totalAprPct.replace('%', '')) || 0)
      }%`
    }
    if (pool.merklApr.length) {
      pool.totalAprPct = `${
        pool.merklApr[0].apr * 100 + (parseFloat(pool.totalAprPct.replace('%', '')) || 0)
      }%`
    }
  }
}

// ─── CAKE farm APR (V3 on-chain MasterChef + Infinity REST) ───────────────────

async function rpcBatch(rpcUrl, calls) {
  const CHUNK = 8
  const results = new Array(calls.length).fill('0x')
  for (let i = 0; i < calls.length; i += CHUNK) {
    const chunk = calls.slice(i, i + CHUNK)
    const batch = chunk.map(([to, data], idx) => ({
      jsonrpc: '2.0',
      id: idx,
      method: 'eth_call',
      params: [{ to, data }, 'latest'],
    }))
    try {
      const r = await fetch(rpcUrl, {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify(batch),
      })
      const raw = await r.json()
      if (Array.isArray(raw)) {
        raw.sort((a, b) => a.id - b.id)
        for (let j = 0; j < raw.length; j++) {
          results[i + j] = raw[j]?.result || '0x'
        }
      }
    } catch (_) {
      // leave as '0x'
    }
  }
  return results
}

function decodeUint(hex) {
  if (!hex || hex === '0x') return 0n
  return BigInt(hex)
}

function padAddress(addr) {
  return addr.toLowerCase().replace('0x', '').padStart(64, '0')
}

function padUint(val) {
  return BigInt(val).toString(16).padStart(64, '0')
}

const SIG_CAKE_PER_SEC = '0xc4f6a8ce'
const SIG_TOTAL_ALLOC = '0x17caf6f1'
const SIG_POOL_ADDR_PID = '0x0743384d'
const SIG_POOL_INFO = '0x1526fe27'

async function fetchV3CakePerYear(poolAddresses) {
  const mc = MASTERCHEF_V3[chainId]
  const rpc = MC_V3_RPC[chainId]
  if (!mc || !rpc || poolAddresses.length === 0) return {}

  const calls = [
    [mc, SIG_CAKE_PER_SEC],
    [mc, SIG_TOTAL_ALLOC],
    ...poolAddresses.map((a) => [mc, SIG_POOL_ADDR_PID + padAddress(a)]),
  ]

  const results = await rpcBatch(rpc, calls)
  const cakePerSecRaw = decodeUint(results[0])
  const totalAlloc = decodeUint(results[1])
  if (totalAlloc === 0n || cakePerSecRaw === 0n) return {}

  const cakePerSec = Number(cakePerSecRaw) / 1e12 / 1e18

  const pids = poolAddresses.map((_, i) => decodeUint(results[2 + i]))
  const infoCalls = pids.map((pid) => [mc, SIG_POOL_INFO + padUint(pid)])
  const infoResults = await rpcBatch(rpc, infoCalls)

  const out = {}
  for (let i = 0; i < poolAddresses.length; i++) {
    const hex = infoResults[i]
    if (!hex || hex === '0x' || hex.length < 66) {
      out[poolAddresses[i].toLowerCase()] = 0
      continue
    }
    const allocPoint = Number(BigInt('0x' + hex.slice(2, 66)))
    if (poolAddresses.length > 0 && hex.length >= 130) {
      const returnedPool = '0x' + hex.slice(90, 130).toLowerCase()
      if (returnedPool !== poolAddresses[i].toLowerCase()) {
        out[poolAddresses[i].toLowerCase()] = 0
        continue
      }
    }
    if (allocPoint === 0) {
      out[poolAddresses[i].toLowerCase()] = 0
      continue
    }
    const poolCakePerSec = cakePerSec * (allocPoint / Number(totalAlloc))
    out[poolAddresses[i].toLowerCase()] = poolCakePerSec * SECONDS_PER_YEAR
  }
  return out
}

async function fetchInfinityCakePerYear(infinityPoolIds) {
  if (infinityPoolIds.length === 0) return {}
  const out = {}
  try {
    const r = await fetch(
      `https://infinity.pancakeswap.com/farms/campaigns/${chainId}/false?limit=100&page=1`,
    )
    const data = await r.json()
    for (const c of data.campaigns || []) {
      const pid = c.poolId.toLowerCase()
      if (!infinityPoolIds.includes(pid)) continue
      const rewardRaw = Number(c.totalRewardAmount || 0)
      const duration = Number(c.duration || 0)
      if (duration <= 0 || rewardRaw <= 0) continue
      const yearlyReward = (rewardRaw / 1e18 / duration) * SECONDS_PER_YEAR
      out[pid] = (out[pid] || 0) + yearlyReward
    }
  } catch (_) {
    // continue without infinity farm data
  }
  return out
}

async function fetchCakePrice() {
  try {
    const r = await fetch(
      'https://api.coingecko.com/api/v3/simple/price?ids=pancakeswap-token&vs_currencies=usd',
    )
    const data = await r.json()
    return data?.['pancakeswap-token']?.usd || 0
  } catch (_) {
    return 0
  }
}

async function fetchCakeFarmAprs(pools) {
  const v3Addresses = pools
    .filter((p) => p.protocol === 'v3' && EVM_ADDR_RE.test(p.id))
    .map((p) => p.id.toLowerCase())

  const infinityIds = pools
    .filter(
      (p) =>
        (p.protocol === 'infinityCl' || p.protocol === 'infinityBin') && INF_POOL_ID_RE.test(p.id),
    )
    .map((p) => p.id.toLowerCase())

  const [cakePrice, v3Data, infData] = await Promise.all([
    fetchCakePrice(),
    fetchV3CakePerYear(v3Addresses),
    fetchInfinityCakePerYear(infinityIds),
  ])

  const cakePerYear = { ...v3Data, ...infData }

  for (const pool of pools) {
    const id = pool.id.toLowerCase()
    if (id in cakePerYear) {
      pool.cakePerYear = cakePerYear[id]
      const tvl = parseFloat(pool.tvlUSD) || 0
      if (cakePerYear[id] > 0 && cakePrice > 0 && tvl > 0) {
        const apr = (cakePerYear[id] * cakePrice) / tvl
        pool.cakeAprPct = `${(apr * 100).toFixed(2)}%`
        pool.totalAprPct = `${apr * 100 + (parseFloat(pool.totalAprPct.replace('%', '')) || 0)}%`
      }
    }
  }

  return cakePrice
}

// ─── Infinity protocol fees ────────────────────────────────────────────────────

function parseProtocolFee(packed) {
  const token0Fee = Number(packed) % 2 ** 12
  return token0Fee / FEE_BASE
}

async function fetchProtocolFees(pools) {
  const viemChain = CHAIN_VIEM_MAP[chainId]
  const rpcUrl = CHAIN_RPC[chainId]
  if (!viemChain || !rpcUrl) return

  const infinityPools = pools.filter(
    (p) =>
      (p.protocol === 'infinityCl' || p.protocol === 'infinityBin') && INF_POOL_ID_RE.test(p.id),
  )
  if (infinityPools.length === 0) return

  const client = createPublicClient({ chain: viemChain, transport: http(rpcUrl) })

  const slot0Calls = infinityPools.flatMap((p) => [
    {
      address: INFI_CL_POOL_MANAGER_ADDRESSES[chainId],
      abi: CLPoolManagerAbi,
      functionName: 'getSlot0',
      args: [p.id],
    },
    {
      address: INFI_BIN_POOL_MANAGER_ADDRESSES[chainId],
      abi: BinPoolManagerAbi,
      functionName: 'getSlot0',
      args: [p.id],
    },
  ])

  let slot0Results = []
  try {
    slot0Results = await client.multicall({ contracts: slot0Calls })
  } catch (_) {
    // leave protocolFeePercent as null for all pools
  }

  const dynamicPools = []

  for (let i = 0; i < infinityPools.length; i++) {
    const pool = infinityPools[i]
    const clResult = slot0Results[i * 2]
    const binResult = slot0Results[i * 2 + 1]

    let feePercent = 0
    if (clResult?.status === 'success' && clResult.result[0] !== 0n) {
      feePercent = parseProtocolFee(clResult.result[2])
    } else if (binResult?.status === 'success' && binResult.result[0] !== 0n) {
      feePercent = parseProtocolFee(binResult.result[1])
    }

    pool.protocolFeePercent = `${feePercent}%`

    if (pool.isDynamicFee && pool.hookAddress) {
      dynamicPools.push({ pool, feePercent })
    } else {
      // Incorporate protocol fee into feeTierPct for fixed-fee pools
      const baseFee = parseFloat(pool.feeTierPct)
      pool.feeTierPct = `${(baseFee + feePercent).toFixed(4).replace(/\.?0+$/, '')}%`
    }
  }

  await fetchDynamicFees(client, dynamicPools)
}

async function fetchDynamicFees(client, dynamicPools) {
  if (dynamicPools.length === 0) return


  const calls = dynamicPools.map(({ pool }) => ({
    address: pool.hookAddress,
    abi: GET_FEE_ABI,
    functionName: 'getFee',
    args: [ZERO_ADDR],
  }))

  try {
    const results = await client.multicall({ contracts: calls })
    for (let i = 0; i < dynamicPools.length; i++) {
      const { pool, feePercent } = dynamicPools[i]
      const r = results[i]
      if (r?.status === 'success') {
        const dynamicLpFee = Number(r.result) / FEE_BASE
        pool.feeTierPct = `${(dynamicLpFee + feePercent).toString().replace(/\.?0+$/, '')}%`
      }
    }
  } catch (_) {
    // leave feeTierPct as placeholder
  }
}

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

const [pools, [merklApr, incentraApr]] = await Promise.all([
  discoverPools(),
  Promise.all([fetchMerklApr(), fetchIncentraApr()]),
])

matchExtraAprs(pools, merklApr, incentraApr)

let cakePrice = 0
if (!isSolana) {
  const [price] = await Promise.all([fetchCakeFarmAprs(pools), fetchProtocolFees(pools)])
  cakePrice = price
}

console.log(
  JSON.stringify(
    {
      chain: CHAIN,
      chainId,
      cakePrice,
      pools,
    },
    null,
    2,
  ),
)

import json, sys, os, time, re
try:
    import requests
except ImportError:
    import subprocess
    subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', 'requests'])
    import requests

MASTERCHEF_V3 = {
    56:    '0x556B9306565093C855AEA9AE92A594704c2Cd59e',
    1:     '0x556B9306565093C855AEA9AE92A594704c2Cd59e',
    42161: '0x5e09ACf80C0296740eC5d6F643005a4ef8DaA694',
    8453:  '0xC6A2Db661D5a5690172d8eB0a7DEA2d3008665A3',
    324:   '0x4c615E78c5fCA1Ad31e4d66eb0D8688d84307463',
}
RPC_URLS = {
    56:    'https://bsc-rpc.publicnode.com',
    1:     'https://ethereum-rpc.publicnode.com',
    42161: 'https://arbitrum-one-rpc.publicnode.com',
    8453:  'https://base-rpc.publicnode.com',
    324:   'https://zksync-era-rpc.publicnode.com',
}
BATCH_CHUNK = 8
SIG_CAKE_PER_SEC  = '0xc4f6a8ce'
SIG_TOTAL_ALLOC   = '0x17caf6f1'
SIG_POOL_ADDR_PID = '0x0743384d'
SIG_POOL_INFO     = '0x1526fe27'

ADDR_RE    = re.compile(r'^0x[0-9a-fA-F]{40}$')
POOL_ID_RE = re.compile(r'^0x[0-9a-fA-F]{64}$')

def _rpc_batch(rpc, batch, retries=2):
    for attempt in range(retries + 1):
        try:
            resp = requests.post(rpc, json=batch, timeout=15)
            raw = resp.json()
            if isinstance(raw, dict):
                if attempt < retries:
                    time.sleep(1.0 * (attempt + 1))
                    continue
                return [{'result': '0x'}] * len(batch)
            has_err = any(r.get('error', {}).get('code') in (-32016, -32014) for r in raw)
            if has_err and attempt < retries:
                time.sleep(1.0 * (attempt + 1))
                continue
            return raw
        except Exception:
            if attempt < retries:
                time.sleep(1.0 * (attempt + 1))
            else:
                return [{'result': '0x'}] * len(batch)
    return [{'result': '0x'}] * len(batch)

def eth_call_batch(rpc, calls):
    if not calls:
        return []
    all_results = [None] * len(calls)
    for cs in range(0, len(calls), BATCH_CHUNK):
        chunk = calls[cs:cs + BATCH_CHUNK]
        batch = [{'jsonrpc': '2.0', 'id': i, 'method': 'eth_call',
                  'params': [{'to': to, 'data': data}, 'latest']}
                 for i, (to, data) in enumerate(chunk)]
        raw = _rpc_batch(rpc, batch)
        if isinstance(raw, list):
            raw.sort(key=lambda r: r.get('id', 0))
            for i, r in enumerate(raw):
                all_results[cs + i] = r.get('result', '0x')
        else:
            for i in range(len(chunk)):
                all_results[cs + i] = '0x'
        if cs + BATCH_CHUNK < len(calls):
            time.sleep(0.3)
    return all_results

def decode_uint(h):
    if not h or h == '0x': return 0
    return int(h, 16)

def pad_address(addr):
    return addr.lower().replace('0x', '').zfill(64)

def pad_uint(val):
    return hex(val).replace('0x', '').zfill(64)

def get_cake_price():
    try:
        r = requests.get(
            'https://api.coingecko.com/api/v3/simple/price?ids=pancakeswap-token&vs_currencies=usd',
            timeout=5)
        return r.json().get('pancakeswap-token', {}).get('usd', 0)
    except Exception:
        return 0

def get_v3_cake_data(chain_id, pool_addresses):
    mc = MASTERCHEF_V3.get(chain_id)
    rpc = RPC_URLS.get(chain_id)
    if not mc or not rpc or not pool_addresses:
        return {}
    try:
        calls = [(mc, SIG_CAKE_PER_SEC), (mc, SIG_TOTAL_ALLOC)]
        for a in pool_addresses:
            calls.append((mc, SIG_POOL_ADDR_PID + pad_address(a)))
        results = eth_call_batch(rpc, calls)
        cake_per_sec_raw = decode_uint(results[0])
        total_alloc = decode_uint(results[1])
        if total_alloc == 0 or cake_per_sec_raw == 0:
            return {}
        cake_per_sec = cake_per_sec_raw / 1e12 / 1e18
        pids = [decode_uint(results[2 + i]) for i in range(len(pool_addresses))]
        time.sleep(0.5)
        info_calls = [(mc, SIG_POOL_INFO + pad_uint(pid)) for pid in pids]
        info_results = eth_call_batch(rpc, info_calls)
        result = {}
        for i, addr in enumerate(pool_addresses):
            info_hex = info_results[i]
            if not info_hex or info_hex == '0x' or len(info_hex) < 66:
                result[addr.lower()] = 0
                continue
            alloc_point = int(info_hex[2:66], 16)
            if len(info_hex) >= 130:
                returned_pool = '0x' + info_hex[90:130].lower()
                if returned_pool != addr.lower():
                    result[addr.lower()] = 0
                    continue
            if alloc_point == 0:
                result[addr.lower()] = 0
                continue
            pool_cake_per_sec = cake_per_sec * (alloc_point / total_alloc)
            result[addr.lower()] = pool_cake_per_sec * 31_536_000
        return result
    except Exception:
        return {}

def main():
    try:
        if len(sys.argv) < 2:
            print(json.dumps({'chainId': 0, 'cakePrice': 0, 'cakePerYear': {}}))
            sys.exit(0)

        chain_id = int(sys.argv[1])
        pool_ids = [p.lower() for p in sys.argv[2:]]

        v3_addrs = [p for p in pool_ids if ADDR_RE.match(p)]
        inf_ids   = [p for p in pool_ids if POOL_ID_RE.match(p)]

        cake_price = get_cake_price()
        cake_per_year = {}

        # V3: on-chain MasterChef lookup
        if v3_addrs:
            v3_data = get_v3_cake_data(chain_id, v3_addrs)
            cake_per_year.update(v3_data)

        # Infinity: REST campaign API
        if inf_ids:
            try:
                r = requests.get(
                    f'https://infinity.pancakeswap.com/farms/campaigns/{chain_id}/false?limit=100&page=1',
                    timeout=10)
                campaigns = r.json().get('campaigns', [])
                SECONDS_PER_YEAR = 31_536_000
                for c in campaigns:
                    pid = c['poolId'].lower()
                    if pid not in inf_ids:
                        continue
                    reward_raw = int(c.get('totalRewardAmount', 0))
                    duration = int(c.get('duration', 0))
                    if duration <= 0 or reward_raw <= 0:
                        continue
                    yearly_reward = (reward_raw / 1e18) / duration * SECONDS_PER_YEAR
                    cake_per_year[pid] = cake_per_year.get(pid, 0) + yearly_reward
            except Exception:
                pass

        print(json.dumps({
            'chainId': chain_id,
            'cakePrice': cake_price,
            'cakePerYear': cake_per_year,
        }))
    except Exception:
        chain_id = int(sys.argv[1]) if len(sys.argv) >= 2 else 0
        print(json.dumps({'chainId': chain_id, 'cakePrice': 0, 'cakePerYear': {}}))
        sys.exit(0)

main()