@w3lib/evm-batch-call 0.5.0 → 0.6.0

package/src/liquidity/v4.ts

@@ -0,0 +1,348 @@
+import { AbiCoder, Interface, hexlify } from 'ethers'
+
+import type { LpPosition, LpProtocol, LpToken } from '../lp.js'
+import { getAmountsForLiquidity, getFeesEarned, getMaxAmounts, getMinAmounts, getMintAmounts, getSqrtRatioAtTick, getTickAtSqrtRatio } from '../lpMath.js'
+import { decodePositionInfo, poolIdOf } from '../lpV4.js'
+import { liquidityFor, resolveRange, sqrtPriceOf } from './concentrated.js'
+import {
+  ZERO_ADDRESS,
+  concentratedProtocol,
+  evm,
+  isNative,
+  makePlan,
+  parseAmount,
+  permit2Approvals,
+  priceFields,
+  removeAmount,
+  tokenIdOf,
+  tokenInfo,
+  type Ctx,
+} from './common.js'
+import type { IncreaseLiquidityParams, LiquidityPlan, NewPositionParams, PositionRef, RemoveLiquidityParams } from './types.js'
+
+const pmInterface = new Interface([
+  'function ownerOf(uint256 tokenId) view returns (address)',
+  'function getApproved(uint256 tokenId) view returns (address)',
+  'function isApprovedForAll(address owner, address operator) view returns (bool)',
+  'function getPoolAndPositionInfo(uint256 tokenId) view returns ((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) poolKey, uint256 info)',
+  'function getPositionLiquidity(uint256 tokenId) view returns (uint128)',
+  'function modifyLiquidities(bytes unlockData, uint256 deadline) payable',
+  'function initializePool((address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks) key, uint160 sqrtPriceX96) payable returns (int24)',
+  'function multicall(bytes[] data) payable returns (bytes[] results)',
+])
+const stateViewInterface = new Interface([
+  'function getSlot0(bytes32 poolId) view returns (uint160 sqrtPriceX96, int24 tick, uint24 protocolFee, uint24 lpFee)',
+  'function getFeeGrowthInside(bytes32 poolId, int24 tickLower, int24 tickUpper) view returns (uint256 feeGrowthInside0X128, uint256 feeGrowthInside1X128)',
+  'function getPositionInfo(bytes32 poolId, address owner, int24 tickLower, int24 tickUpper, bytes32 salt) view returns (uint128 liquidity, uint256 feeGrowthInside0LastX128, uint256 feeGrowthInside1LastX128)',
+])
+
+/** v4-periphery 的 Actions */
+const Actions = {
+  INCREASE_LIQUIDITY: 0x00,
+  DECREASE_LIQUIDITY: 0x01,
+  MINT_POSITION: 0x02,
+  BURN_POSITION: 0x03,
+  SETTLE_PAIR: 0x0d,
+  TAKE_PAIR: 0x11,
+  CLOSE_CURRENCY: 0x12,
+  SWEEP: 0x14,
+} as const
+
+/** 标准手续费档位对应的 tick 间距（与 Uniswap 网页一致） */
+const DEFAULT_TICK_SPACING: Readonly<Record<number, number>> = { 100: 1, 500: 10, 3000: 60, 10000: 200 }
+
+const coder = AbiCoder.defaultAbiCoder()
+const POOL_KEY = 'tuple(address currency0, address currency1, uint24 fee, int24 tickSpacing, address hooks)'
+
+interface PoolKey {
+  currency0: string
+  currency1: string
+  fee: number
+  tickSpacing: number
+  hooks: string
+}
+
+const keyTuple = (k: PoolKey) => [k.currency0, k.currency1, k.fee, k.tickSpacing, k.hooks]
+
+/** 依次执行的 action 列表 → modifyLiquidities 的 unlockData */
+class Planner {
+  readonly actions: number[] = []
+  readonly params: string[] = []
+
+  add(action: number, types: string[], values: unknown[]): this {
+    this.actions.push(action)
+    this.params.push(coder.encode(types, values))
+    return this
+  }
+
+  encode(): string {
+    return coder.encode(['bytes', 'bytes[]'], [hexlify(new Uint8Array(this.actions)), this.params])
+  }
+}
+
+interface V4Pool {
+  key: PoolKey
+  poolId: string
+  sqrtPriceX96: bigint
+  tick: number
+}
+
+interface V4Position {
+  protocol: LpProtocol
+  pm: string
+  stateView: string
+  tokenId: bigint
+  owner: string
+  /** 发送者能不能管理这个仓位（所有者或被授权） */
+  canManage: boolean
+  pool: V4Pool
+  tickLower: number
+  tickUpper: number
+  liquidity: bigint
+  fees0: bigint
+  fees1: bigint
+}
+
+function addresses(ctx: Ctx, protocol: LpProtocol): { pm: string; stateView: string } {
+  if (ctx.tron) {
+    throw new Error('Uniswap V4 is not supported on Tron')
+  }
+  if (!protocol.positionManager || !protocol.stateView) {
+    throw new Error(`Protocol ${protocol.id} needs positionManager and stateView`)
+  }
+  return { pm: evm(protocol.positionManager), stateView: evm(protocol.stateView) }
+}
+
+async function readPosition(ctx: Ctx, ref: PositionRef | LpPosition): Promise<V4Position> {
+  const protocol = concentratedProtocol(ctx, ref)
+  const { pm, stateView } = addresses(ctx, protocol)
+  const tokenId = tokenIdOf(ref)
+  const c = ctx.provider.contract(pm, pmInterface)
+  const [owner, info, liquidity] = (await ctx.provider.all([c.ownerOf(tokenId), c.getPoolAndPositionInfo(tokenId), c.getPositionLiquidity(tokenId)])) as [
+    string,
+    { 0: { currency0: string; currency1: string; fee: bigint; tickSpacing: bigint; hooks: string }; 1: bigint },
+    bigint,
+  ]
+  const raw = info[0]
+  const key: PoolKey = { currency0: evm(raw.currency0), currency1: evm(raw.currency1), fee: Number(raw.fee), tickSpacing: Number(raw.tickSpacing), hooks: evm(raw.hooks) }
+  const poolId = poolIdOf(key)
+  const { tickLower, tickUpper } = decodePositionInfo(info[1])
+  const sv = ctx.provider.contract(stateView, stateViewInterface)
+  const salt = `0x${tokenId.toString(16).padStart(64, '0')}`
+  const [slot0, inside, last, approved, approvedForAll] = (await ctx.provider.all([
+    sv.getSlot0(poolId),
+    sv.getFeeGrowthInside(poolId, tickLower, tickUpper),
+    sv.getPositionInfo(poolId, pm, tickLower, tickUpper, salt),
+    c.getApproved(tokenId),
+    c.isApprovedForAll(owner, ctx.owner),
+  ])) as [{ 0: bigint; 1: bigint }, { 0: bigint; 1: bigint }, { 1: bigint; 2: bigint }, string, boolean]
+  return {
+    protocol,
+    pm,
+    stateView,
+    tokenId,
+    owner: evm(owner),
+    // 与 PositionManager 的 onlyIfApproved 一致：所有者、单个仓位的 approve、setApprovalForAll 都可以
+    canManage: evm(owner) === ctx.owner || evm(approved) === ctx.owner || approvedForAll,
+    pool: { key, poolId, sqrtPriceX96: slot0[0], tick: Number(slot0[1]) },
+    tickLower,
+    tickUpper,
+    liquidity,
+    fees0: getFeesEarned(liquidity, inside[0], last[1]),
+    fees1: getFeesEarned(liquidity, inside[1], last[2]),
+  }
+}
+
+function assertOwner(ctx: Ctx, position: V4Position): void {
+  if (!position.canManage) {
+    throw new Error(`${ctx.owner} is not the owner of position ${position.tokenId} (owner: ${position.owner})`)
+  }
+}
+
+const hookData = (ctx: Ctx) => (ctx.options.hookData ? hexlify(ctx.options.hookData) : '0x')
+
+export async function v4Add(ctx: Ctx, params: IncreaseLiquidityParams | NewPositionParams): Promise<LiquidityPlan> {
+  let protocol: LpProtocol
+  let pm: string
+  let pool: V4Pool
+  let tickLower: number
+  let tickUpper: number
+  let tokenId: bigint | null = null
+  let createPrice: bigint | null = null
+  let fees: [bigint, bigint] = [0n, 0n]
+  let t0: LpToken
+  let t1: LpToken
+  let given0: bigint | undefined
+  let given1: bigint | undefined
+
+  if ('position' in params) {
+    const position = await readPosition(ctx, params.position)
+    assertOwner(ctx, position)
+    ;({ protocol, pm, pool, tickLower, tickUpper } = position)
+    tokenId = position.tokenId
+    fees = [position.fees0, position.fees1]
+    ;[t0, t1] = (await tokenInfo(ctx, [pool.key.currency0, pool.key.currency1])) as [LpToken, LpToken]
+    given0 = parseAmount(params.amount0, params.amount0Formatted, t0, 'amount0')
+    given1 = parseAmount(params.amount1, params.amount1Formatted, t1, 'amount1')
+  } else {
+    protocol = params.protocol as LpProtocol
+    const { pm: positionManager, stateView } = addresses(ctx, protocol)
+    pm = positionManager
+    if (params.fee === undefined) {
+      throw new Error('fee is required for V4 (e.g. 500, 3000, 10000)')
+    }
+    const tickSpacing = params.tickSpacing ?? DEFAULT_TICK_SPACING[params.fee]
+    if (tickSpacing === undefined) {
+      throw new Error(`Pass tickSpacing: there is no default for fee ${params.fee}`)
+    }
+    // 主币是零地址，排在前面
+    const a = isNative(ctx, params.tokenA) ? ZERO_ADDRESS : evm(params.tokenA)
+    const b = isNative(ctx, params.tokenB) ? ZERO_ADDRESS : evm(params.tokenB)
+    if (a === b) {
+      throw new Error('tokenA and tokenB must be different')
+    }
+    const aIs0 = BigInt(a) < BigInt(b)
+    const key: PoolKey = { currency0: aIs0 ? a : b, currency1: aIs0 ? b : a, fee: params.fee, tickSpacing, hooks: params.hooks ? evm(params.hooks) : ZERO_ADDRESS }
+    const poolId = poolIdOf(key)
+    const slot0 = (await ctx.provider.call(ctx.provider.contract(stateView, stateViewInterface).getSlot0(poolId))) as { 0: bigint; 1: bigint }
+    pool = { key, poolId, sqrtPriceX96: slot0[0], tick: Number(slot0[1]) }
+    ;[t0, t1] = (await tokenInfo(ctx, [key.currency0, key.currency1])) as [LpToken, LpToken]
+    if (pool.sqrtPriceX96 === 0n) {
+      if (params.initialPrice === undefined) {
+        throw new Error('This V4 pool (currencies, fee, tickSpacing, hooks) is not initialized yet; pass initialPrice to create it')
+      }
+      createPrice = sqrtPriceOf(params.initialPrice, aIs0, t0, t1, 'initialPrice')
+      pool = { ...pool, sqrtPriceX96: createPrice, tick: getTickAtSqrtRatio(createPrice) }
+    }
+    ;[tickLower, tickUpper] = resolveRange(params, aIs0, t0, t1, tickSpacing)
+    const amountA = parseAmount(params.amountA, params.amountAFormatted, aIs0 ? t0 : t1, 'amountA')
+    const amountB = parseAmount(params.amountB, params.amountBFormatted, aIs0 ? t1 : t0, 'amountB')
+    ;[given0, given1] = aIs0 ? [amountA, amountB] : [amountB, amountA]
+  }
+
+  const { key } = pool
+  const sqrtA = getSqrtRatioAtTick(tickLower)
+  const sqrtB = getSqrtRatioAtTick(tickUpper)
+  const liquidity = liquidityFor(pool.sqrtPriceX96, tickLower, tickUpper, given0, given1, t0, t1)
+  const [amount0, amount1] = getMintAmounts(pool.sqrtPriceX96, sqrtA, sqrtB, liquidity)
+  // V4 直接指定流动性，价格变动时需要的数量随之变化：按滑点给出上限
+  const [max0, max1] = getMaxAmounts(pool.sqrtPriceX96, sqrtA, sqrtB, liquidity, ctx.slippage)
+  const native = key.currency0 === ZERO_ADDRESS
+  const planner = new Planner()
+  if (tokenId === null) {
+    planner.add(
+      Actions.MINT_POSITION,
+      [POOL_KEY, 'int24', 'int24', 'uint256', 'uint128', 'uint128', 'address', 'bytes'],
+      [keyTuple(key), tickLower, tickUpper, liquidity, max0, max1, ctx.recipient, hookData(ctx)],
+    )
+    planner.add(Actions.SETTLE_PAIR, ['address', 'address'], [key.currency0, key.currency1])
+  } else {
+    planner.add(Actions.INCREASE_LIQUIDITY, ['uint256', 'uint256', 'uint128', 'uint128', 'bytes'], [tokenId, liquidity, max0, max1, hookData(ctx)])
+    // 追加时会自动领取手续费：手续费可能比要存入的多（差额为正），CLOSE_CURRENCY 按差额的正负自动付款或收款
+    planner.add(Actions.CLOSE_CURRENCY, ['address'], [key.currency0])
+    planner.add(Actions.CLOSE_CURRENCY, ['address'], [key.currency1])
+  }
+  if (native) {
+    // 附带的主币按上限给，多余的退回
+    planner.add(Actions.SWEEP, ['address', 'address'], [ZERO_ADDRESS, ctx.owner])
+  }
+  const modify = pmInterface.encodeFunctionData('modifyLiquidities', [planner.encode(), ctx.deadline])
+  const data = createPrice === null ? modify : pmInterface.encodeFunctionData('multicall', [[pmInterface.encodeFunctionData('initializePool', [keyTuple(key), createPrice]), modify]])
+  const value = native ? max0 : 0n
+  const approve = await permit2Approvals(
+    ctx,
+    pm,
+    [
+      { token: key.currency0, amount: max0 },
+      { token: key.currency1, amount: max1 },
+    ].filter((i) => i.token !== ZERO_ADDRESS),
+  )
+  return makePlan(ctx, {
+    action: 'add',
+    version: 'v4',
+    protocol: protocol.id,
+    protocolName: protocol.name,
+    pool: pool.poolId,
+    createPool: createPrice !== null,
+    token0: t0,
+    token1: t1,
+    tokenId: tokenId === null ? null : tokenId.toString(),
+    tickLower,
+    tickUpper,
+    tick: pool.tick,
+    ...priceFields(t0, t1, pool.sqrtPriceX96, tickLower, tickUpper),
+    liquidity: liquidity.toString(),
+    amount0: amount0.toString(),
+    amount1: amount1.toString(),
+    amount0Max: max0.toString(),
+    amount1Max: max1.toString(),
+    amount0Min: null,
+    amount1Min: null,
+    fees0: fees[0].toString(),
+    fees1: fees[1].toString(),
+    native: native ? 'token0' : null,
+    value: value.toString(),
+    transactions: [...approve, { kind: 'add', to: pm, data, value: value.toString() }],
+  })
+}
+
+export async function v4Remove(ctx: Ctx, params: RemoveLiquidityParams, collectOnly = false): Promise<LiquidityPlan> {
+  const position = await readPosition(ctx, params.position)
+  assertOwner(ctx, position)
+  const { pm, pool, tickLower, tickUpper, tokenId } = position
+  const { key } = pool
+  let liquidity = 0n
+  if (!collectOnly) {
+    if (position.liquidity === 0n) {
+      throw new Error(`Position ${tokenId} has no liquidity`)
+    }
+    liquidity = removeAmount(position.liquidity, params.percent, params.liquidity)
+  } else if (position.fees0 === 0n && position.fees1 === 0n) {
+    throw new Error(`Position ${tokenId} has no fees to collect`)
+  }
+  const burn = !collectOnly && !!params.burn
+  if (burn && liquidity !== position.liquidity) {
+    throw new Error('burn: true needs the whole position to be removed')
+  }
+  const [t0, t1] = (await tokenInfo(ctx, [key.currency0, key.currency1])) as [LpToken, LpToken]
+  const sqrtA = getSqrtRatioAtTick(tickLower)
+  const sqrtB = getSqrtRatioAtTick(tickUpper)
+  const [amount0, amount1] = getAmountsForLiquidity(pool.sqrtPriceX96, sqrtA, sqrtB, liquidity)
+  const [min0, min1] = getMinAmounts(pool.sqrtPriceX96, sqrtA, sqrtB, liquidity, ctx.slippage)
+  const planner = new Planner()
+  if (burn) {
+    planner.add(Actions.BURN_POSITION, ['uint256', 'uint128', 'uint128', 'bytes'], [tokenId, min0, min1, hookData(ctx)])
+  } else {
+    // 流动性为 0 时只领取手续费
+    planner.add(Actions.DECREASE_LIQUIDITY, ['uint256', 'uint256', 'uint128', 'uint128', 'bytes'], [tokenId, liquidity, min0, min1, hookData(ctx)])
+  }
+  planner.add(Actions.TAKE_PAIR, ['address', 'address', 'address'], [key.currency0, key.currency1, ctx.recipient])
+  const data = pmInterface.encodeFunctionData('modifyLiquidities', [planner.encode(), ctx.deadline])
+  return makePlan(ctx, {
+    action: collectOnly ? 'collect' : 'remove',
+    version: 'v4',
+    protocol: position.protocol.id,
+    protocolName: position.protocol.name,
+    pool: pool.poolId,
+    createPool: false,
+    token0: t0,
+    token1: t1,
+    tokenId: tokenId.toString(),
+    tickLower,
+    tickUpper,
+    tick: pool.tick,
+    ...priceFields(t0, t1, pool.sqrtPriceX96, tickLower, tickUpper),
+    liquidity: liquidity.toString(),
+    amount0: amount0.toString(),
+    amount1: amount1.toString(),
+    amount0Max: null,
+    amount1Max: null,
+    amount0Min: min0.toString(),
+    amount1Min: min1.toString(),
+    fees0: position.fees0.toString(),
+    fees1: position.fees1.toString(),
+    native: key.currency0 === ZERO_ADDRESS ? 'token0' : null,
+    value: '0',
+    transactions: [{ kind: collectOnly ? 'collect' : 'remove', to: pm, data, value: '0' }],
+  })
+}

package/src/lp.ts

@@ -24,6 +24,13 @@ export interface LpProtocol {
   chainId: number
   /** V2：工厂合约（getPair、识别 LP 代币属于哪个协议）；V3：池子的工厂合约（getPool） */
   factory?: string
+  /** V2：Router 合约（添加 / 移除流动性用，见子路径 `/liquidity`） */
+  router?: string
+  /**
+   * V2：协议手续费开启（factory.feeTo 不为零）时，每次添加 / 移除前给 feeTo 增发的 LP 占 √k 增长的比例：
+   * Uniswap 及大多数分叉是 '1/6'，PancakeSwap 是 '8/25'。不填时按 '8/25'（增发得多，算出的移除数量偏少，最小值更宽松）
+   */
+  protocolFee?: '1/6' | '8/25'
   /** V3 / V4：仓位 NFT 合约（NonfungiblePositionManager / PositionManager） */
   positionManager?: string
   /** V4：StateView（读池子和仓位的状态） */
@@ -32,7 +39,15 @@ export interface LpProtocol {
   deployBlock?: number
 }
 
-const v2 = (id: string, name: string, chainId: number, factory: string): LpProtocol => ({ id, name, version: 'v2', chainId, factory })
+const v2 = (id: string, name: string, chainId: number, factory: string, router: string, protocolFee: '1/6' | '8/25'): LpProtocol => ({
+  id,
+  name,
+  version: 'v2',
+  chainId,
+  factory,
+  router,
+  protocolFee,
+})
 const v3 = (id: string, name: string, chainId: number, positionManager: string, factory: string): LpProtocol => ({ id, name, version: 'v3', chainId, positionManager, factory })
 const v4 = (chainId: number, positionManager: string, stateView: string, deployBlock?: number): LpProtocol => ({
   id: 'uniswap-v4',
@@ -49,41 +64,44 @@ const UNI_V3_FACTORY = '0x1F98431c8aD98523631AE4a59f267346ea31F984'
 const CAKE_V3_NPM = '0x46A15B0b27311cedF172AB29E4f4766fbE7F4364'
 const CAKE_V3_FACTORY = '0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865'
 const SUSHI_V2_FACTORY = '0xc35DADB65012eC5796536bD9864eD8773aBc74C4'
+const SUSHI_V2_ROUTER = '0x1b02dA8Cb0d097eB8D57A175b88c7D8b47997506'
+const UNI_V2_ROUTER_L2 = '0x4752ba5DBc23f44D87826276BF6Fd6b1C372aD24'
+const CAKE_V2_ROUTER_L2 = '0x8cFe327CEc66d1C090Dd72bd0FF11d690C33a2Eb'
 
 /**
- * 内置的 DEX 部署（2026-10 在链上逐个核对：V3 的 name / factory、V2 的 allPairsLength）。
+ * 内置的 DEX 部署（2026-10 在链上逐个核对：V3 的 name / factory、V2 的 allPairsLength、V2 Router 的 factory / WETH）。
  * 不在表里的 DEX / 链可以通过 `protocols` 选项传入自己的 LpProtocol。
  */
 export const LP_PROTOCOLS: readonly LpProtocol[] = [
   // Ethereum
-  v2('uniswap-v2', 'Uniswap V2', 1, '0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f'),
-  v2('sushiswap-v2', 'SushiSwap', 1, '0xC0AEe478e3658e2610c5F7A4A2E1777cE9e4f2Ac'),
-  v2('pancakeswap-v2', 'PancakeSwap V2', 1, '0x1097053Fd2ea711dad45caCcc45EfF7548fCB362'),
+  v2('uniswap-v2', 'Uniswap V2', 1, '0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f', '0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D', '1/6'),
+  v2('sushiswap-v2', 'SushiSwap', 1, '0xC0AEe478e3658e2610c5F7A4A2E1777cE9e4f2Ac', '0xd9e1cE17f2641f24aE83637ab66a2cca9C378B9F', '1/6'),
+  v2('pancakeswap-v2', 'PancakeSwap V2', 1, '0x1097053Fd2ea711dad45caCcc45EfF7548fCB362', '0xEfF92A263d31888d860bD50809A8D171709b7b1c', '8/25'),
   v3('uniswap-v3', 'Uniswap V3', 1, UNI_V3_NPM, UNI_V3_FACTORY),
   v3('pancakeswap-v3', 'PancakeSwap V3', 1, CAKE_V3_NPM, CAKE_V3_FACTORY),
   // BSC
-  v2('pancakeswap-v2', 'PancakeSwap V2', 56, '0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73'),
-  v2('uniswap-v2', 'Uniswap V2', 56, '0x8909Dc15e40173Ff4699343b6eB8132c65e18eC6'),
-  v2('sushiswap-v2', 'SushiSwap', 56, SUSHI_V2_FACTORY),
+  v2('pancakeswap-v2', 'PancakeSwap V2', 56, '0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73', '0x10ED43C718714eb63d5aA57B78B54704E256024E', '8/25'),
+  v2('uniswap-v2', 'Uniswap V2', 56, '0x8909Dc15e40173Ff4699343b6eB8132c65e18eC6', UNI_V2_ROUTER_L2, '1/6'),
+  v2('sushiswap-v2', 'SushiSwap', 56, SUSHI_V2_FACTORY, SUSHI_V2_ROUTER, '1/6'),
   v3('pancakeswap-v3', 'PancakeSwap V3', 56, CAKE_V3_NPM, CAKE_V3_FACTORY),
   v3('uniswap-v3', 'Uniswap V3', 56, '0x7b8A01B39D58278b5DE7e48c8449c9f4F5170613', '0xdB1d10011AD0Ff90774D0C6Bb92e5C5c8b4461F7'),
   // Base
-  v2('uniswap-v2', 'Uniswap V2', 8453, '0x8909Dc15e40173Ff4699343b6eB8132c65e18eC6'),
-  v2('pancakeswap-v2', 'PancakeSwap V2', 8453, '0x02a84c1b3BBD7401a5f7fa98a384EBC70bB5749E'),
+  v2('uniswap-v2', 'Uniswap V2', 8453, '0x8909Dc15e40173Ff4699343b6eB8132c65e18eC6', UNI_V2_ROUTER_L2, '1/6'),
+  v2('pancakeswap-v2', 'PancakeSwap V2', 8453, '0x02a84c1b3BBD7401a5f7fa98a384EBC70bB5749E', CAKE_V2_ROUTER_L2, '8/25'),
   v3('uniswap-v3', 'Uniswap V3', 8453, '0x03a520b32C04BF3bEEf7BEb72E919cf822Ed34f1', '0x33128a8fC17869897dcE68Ed026d694621f6FDfD'),
   v3('pancakeswap-v3', 'PancakeSwap V3', 8453, CAKE_V3_NPM, CAKE_V3_FACTORY),
   // Arbitrum
-  v2('uniswap-v2', 'Uniswap V2', 42161, '0xf1D7CC64Fb4452F05c498126312eBE29f30Fbcf9'),
-  v2('sushiswap-v2', 'SushiSwap', 42161, SUSHI_V2_FACTORY),
-  v2('pancakeswap-v2', 'PancakeSwap V2', 42161, '0x02a84c1b3BBD7401a5f7fa98a384EBC70bB5749E'),
+  v2('uniswap-v2', 'Uniswap V2', 42161, '0xf1D7CC64Fb4452F05c498126312eBE29f30Fbcf9', UNI_V2_ROUTER_L2, '1/6'),
+  v2('sushiswap-v2', 'SushiSwap', 42161, SUSHI_V2_FACTORY, SUSHI_V2_ROUTER, '1/6'),
+  v2('pancakeswap-v2', 'PancakeSwap V2', 42161, '0x02a84c1b3BBD7401a5f7fa98a384EBC70bB5749E', CAKE_V2_ROUTER_L2, '8/25'),
   v3('uniswap-v3', 'Uniswap V3', 42161, UNI_V3_NPM, UNI_V3_FACTORY),
   v3('pancakeswap-v3', 'PancakeSwap V3', 42161, CAKE_V3_NPM, CAKE_V3_FACTORY),
   // Optimism
-  v2('uniswap-v2', 'Uniswap V2', 10, '0x0c3c1c532F1e39EdF36BE9Fe0bE1410313E074Bf'),
+  v2('uniswap-v2', 'Uniswap V2', 10, '0x0c3c1c532F1e39EdF36BE9Fe0bE1410313E074Bf', '0x4A7b5Da61326A6379179b40d00F57E5bbDC962c2', '1/6'),
   v3('uniswap-v3', 'Uniswap V3', 10, UNI_V3_NPM, UNI_V3_FACTORY),
   // Polygon
-  v2('uniswap-v2', 'Uniswap V2', 137, '0x9e5A52f57b3038F1B8EeE45F28b3C1967e22799C'),
-  v2('sushiswap-v2', 'SushiSwap', 137, SUSHI_V2_FACTORY),
+  v2('uniswap-v2', 'Uniswap V2', 137, '0x9e5A52f57b3038F1B8EeE45F28b3C1967e22799C', '0xedf6066a2b290C185783862C7F4776A2C8077AD1', '1/6'),
+  v2('sushiswap-v2', 'SushiSwap', 137, SUSHI_V2_FACTORY, SUSHI_V2_ROUTER, '1/6'),
   v3('uniswap-v3', 'Uniswap V3', 137, UNI_V3_NPM, UNI_V3_FACTORY),
   // Avalanche
   v3('uniswap-v3', 'Uniswap V3', 43114, '0x655C406EBFa14EE2006250925e54ec43AD184f8B', '0x740b1c1de25031C31FF4fC9A62f554A55cdC1baD'),
@@ -94,8 +112,8 @@ export const LP_PROTOCOLS: readonly LpProtocol[] = [
   v4(42161, '0xd88f38f930b7952f2db2432cb002e7abbf3dd869', '0x76fd297e2d437cd7f76d50f01afe6160f86e9990', 297842893),
   v4(10, '0x3c3ea4b57a46241e54610e5f022e5c45859a1017', '0xc18a3169788f4f75a170290584eca6395c75ecdb', 130947681),
   v4(137, '0x1ec2ebf4f37e7363fdfe3551602425af0b3ceef9', '0x5ea1bd7974c8a611cbab0bdcafcb1d9cc9b3ba5a', 66980394),
-  // Tron：SunSwap（V2 工厂的 allPairsLength、V3 仓位合约的 name / factory 在链上核对过）
-  v2('sunswap-v2', 'SunSwap V2', TRON_CHAIN_ID.mainnet, 'TKWJdrQkqHisa1X8HUdHEfREvTzw4pMAaY'),
+  // Tron：SunSwap（协议手续费与 Uniswap 相同，1/6，用主网数据核对过；V2 工厂的 allPairsLength、V3 仓位合约的 name / factory 在链上核对过）
+  v2('sunswap-v2', 'SunSwap V2', TRON_CHAIN_ID.mainnet, 'TKWJdrQkqHisa1X8HUdHEfREvTzw4pMAaY', 'TNJVzGqKBWkJxJB5XYSqGAwUTV15U24pPq', '1/6'),
   v3('sunswap-v3', 'SunSwap V3', TRON_CHAIN_ID.mainnet, 'TLSWrv7eC1AZCXkRjpqMZUmvgd99cj7pPF', 'TThJt8zaJzJMhCEScH7zWKnp5buVZqys9x'),
 ]
 

package/src/lpMath.ts

@@ -111,3 +111,226 @@ export function sqrtPriceToPrice(sqrtPriceX96: bigint, decimals0: number, decima
 export function tickToPrice(tick: number, decimals0: number, decimals1: number): number {
   return 1.0001 ** tick * 10 ** (decimals0 - decimals1)
 }
+
+// ---------------------------------------------------------------------------
+// 添加 / 移除流动性用到的计算
+// ---------------------------------------------------------------------------
+
+/** getSqrtRatioAtTick(MIN_TICK) / getSqrtRatioAtTick(MAX_TICK)：池子价格的上下限（价格必须在 [MIN, MAX) 内） */
+export const MIN_SQRT_RATIO = 4295128739n
+export const MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342n
+export const MAX_UINT128 = 2n ** 128n - 1n
+
+const divUp = (a: bigint, b: bigint) => (a + b - 1n) / b
+
+/** SqrtPriceMath.getAmount0Delta：区间 [a, b] 内 L 对应的 token0，roundUp 时向上取整（添加流动性时池子收取的数量） */
+export function getAmount0Delta(sqrtA: bigint, sqrtB: bigint, liquidity: bigint, roundUp: boolean): bigint {
+  if (sqrtA > sqrtB) {
+    ;[sqrtA, sqrtB] = [sqrtB, sqrtA]
+  }
+  const n1 = liquidity << 96n
+  const n2 = sqrtB - sqrtA
+  return roundUp ? divUp(divUp(n1 * n2, sqrtB), sqrtA) : (n1 * n2) / sqrtB / sqrtA
+}
+
+/** SqrtPriceMath.getAmount1Delta：区间 [a, b] 内 L 对应的 token1，roundUp 时向上取整 */
+export function getAmount1Delta(sqrtA: bigint, sqrtB: bigint, liquidity: bigint, roundUp: boolean): bigint {
+  if (sqrtA > sqrtB) {
+    ;[sqrtA, sqrtB] = [sqrtB, sqrtA]
+  }
+  return roundUp ? divUp(liquidity * (sqrtB - sqrtA), Q96) : (liquidity * (sqrtB - sqrtA)) / Q96
+}
+
+/** 添加流动性 L 时池子收取的两种代币数量（向上取整，与池子的 modifyPosition 一致） */
+export function getMintAmounts(sqrtPrice: bigint, sqrtA: bigint, sqrtB: bigint, liquidity: bigint): [bigint, bigint] {
+  if (sqrtA > sqrtB) {
+    ;[sqrtA, sqrtB] = [sqrtB, sqrtA]
+  }
+  if (sqrtPrice <= sqrtA) {
+    return [getAmount0Delta(sqrtA, sqrtB, liquidity, true), 0n]
+  }
+  if (sqrtPrice < sqrtB) {
+    return [getAmount0Delta(sqrtPrice, sqrtB, liquidity, true), getAmount1Delta(sqrtA, sqrtPrice, liquidity, true)]
+  }
+  return [0n, getAmount1Delta(sqrtA, sqrtB, liquidity, true)]
+}
+
+/** LiquidityAmounts.getLiquidityForAmount0：区间 [a, b] 内 amount0 个 token0 对应的流动性（向下取整） */
+export function getLiquidityForAmount0(sqrtA: bigint, sqrtB: bigint, amount0: bigint): bigint {
+  if (sqrtA > sqrtB) {
+    ;[sqrtA, sqrtB] = [sqrtB, sqrtA]
+  }
+  return (amount0 * ((sqrtA * sqrtB) / Q96)) / (sqrtB - sqrtA)
+}
+
+/** LiquidityAmounts.getLiquidityForAmount1：区间 [a, b] 内 amount1 个 token1 对应的流动性（向下取整） */
+export function getLiquidityForAmount1(sqrtA: bigint, sqrtB: bigint, amount1: bigint): bigint {
+  if (sqrtA > sqrtB) {
+    ;[sqrtA, sqrtB] = [sqrtB, sqrtA]
+  }
+  return (amount1 * Q96) / (sqrtB - sqrtA)
+}
+
+/**
+ * LiquidityAmounts.getLiquidityForAmounts：最多用 amount0 / amount1 时能添加的流动性（取两边较小的，与 V3 仓位合约一致）。
+ * 价格在区间下方只用 token0，上方只用 token1
+ */
+export function getLiquidityForAmounts(sqrtPrice: bigint, sqrtA: bigint, sqrtB: bigint, amount0: bigint, amount1: bigint): bigint {
+  if (sqrtA > sqrtB) {
+    ;[sqrtA, sqrtB] = [sqrtB, sqrtA]
+  }
+  if (sqrtPrice <= sqrtA) {
+    return getLiquidityForAmount0(sqrtA, sqrtB, amount0)
+  }
+  if (sqrtPrice < sqrtB) {
+    const l0 = getLiquidityForAmount0(sqrtPrice, sqrtB, amount0)
+    const l1 = getLiquidityForAmount1(sqrtA, sqrtPrice, amount1)
+    return l0 < l1 ? l0 : l1
+  }
+  return getLiquidityForAmount1(sqrtA, sqrtB, amount1)
+}
+
+/** 流动性是 uint128：超出时报错（合约里同样会 revert） */
+export function toUint128(liquidity: bigint): bigint {
+  if (liquidity < 0n || liquidity > MAX_UINT128) {
+    throw new RangeError(`liquidity out of uint128 range: ${liquidity}`)
+  }
+  return liquidity
+}
+
+/** TickMath.getTickAtSqrtRatio：满足 getSqrtRatioAtTick(tick) <= sqrtPrice 的最大 tick（精确，二分查找） */
+export function getTickAtSqrtRatio(sqrtPriceX96: bigint): number {
+  if (sqrtPriceX96 < MIN_SQRT_RATIO || sqrtPriceX96 >= MAX_SQRT_RATIO) {
+    throw new RangeError(`sqrtPriceX96 out of range: ${sqrtPriceX96}`)
+  }
+  let lo = MIN_TICK
+  let hi = MAX_TICK
+  while (lo < hi) {
+    const mid = Math.floor((lo + hi + 1) / 2)
+    if (getSqrtRatioAtTick(mid) <= sqrtPriceX96) {
+      lo = mid
+    } else {
+      hi = mid - 1
+    }
+  }
+  return lo
+}
+
+/** 整数平方根（向下取整） */
+export function sqrtBigInt(value: bigint): bigint {
+  if (value < 0n) {
+    throw new RangeError('square root of a negative number')
+  }
+  if (value < 2n) {
+    return value
+  }
+  // 牛顿迭代：从不小于平方根的 2^ceil(位数 / 2) 开始单调递减，收敛到向下取整的平方根
+  let x = 1n << BigInt((value.toString(2).length + 1) >> 1)
+  for (;;) {
+    const y = (x + value / x) >> 1n
+    if (y >= x) {
+      break
+    }
+    x = y
+  }
+  return x
+}
+
+/** 十进制数（'1.5'、'2e-7'、1.5）→ 分子 / 分母，精确，不经过浮点 */
+export function parseDecimal(value: string | number): { num: bigint; den: bigint } {
+  const text = typeof value === 'number' ? (Number.isFinite(value) ? String(value) : '') : value.trim()
+  const m = /^\+?(\d*)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/.exec(text)
+  if (!m || (!m[1] && !m[2])) {
+    throw new Error(`Invalid number: ${String(value)}`)
+  }
+  const frac = m[2] ?? ''
+  const exp = Number(m[3] ?? 0) - frac.length
+  if (Math.abs(exp) > 400) {
+    throw new RangeError(`Number out of range: ${String(value)}`)
+  }
+  const digits = BigInt(`${m[1] ?? ''}${frac}` || '0')
+  return exp >= 0 ? { num: digits * 10n ** BigInt(exp), den: 1n } : { num: digits, den: 10n ** BigInt(-exp) }
+}
+
+/**
+ * 价格（token1 / token0，按精度换算后的人类可读数字，如 600 表示 1 个 token0 值 600 个 token1）→ sqrtPriceX96。
+ * 精确计算（字符串不经过浮点），结果向下取整；价格必须大于 0
+ */
+export function priceToSqrtPriceX96(price: string | number, decimals0: number, decimals1: number): bigint {
+  const { num, den } = parseDecimal(price)
+  return ratioToSqrtPriceX96(num, den, decimals0, decimals1)
+}
+
+/** 价格（分数 num / den，token1 / token0，按精度换算）→ sqrtPriceX96，向下取整；价格必须大于 0 */
+export function ratioToSqrtPriceX96(num: bigint, den: bigint, decimals0: number, decimals1: number): bigint {
+  if (num <= 0n || den <= 0n) {
+    throw new RangeError('price must be greater than 0')
+  }
+  // raw = price × 10^(d1 − d0)；sqrtPriceX96 = sqrt(raw × 2^192)
+  const scale = decimals1 - decimals0
+  const n = num * (scale > 0 ? 10n ** BigInt(scale) : 1n) * 2n ** 192n
+  const d = den * (scale < 0 ? 10n ** BigInt(-scale) : 1n)
+  return sqrtBigInt(n / d)
+}
+
+/** sqrtPriceX96 → tick（getTickAtSqrtRatio），超出池子价格范围时取 MIN_TICK / MAX_TICK */
+export function clampedTickAtSqrtRatio(sqrtPrice: bigint): number {
+  if (sqrtPrice < MIN_SQRT_RATIO) {
+    return MIN_TICK
+  }
+  if (sqrtPrice >= MAX_SQRT_RATIO) {
+    return MAX_TICK
+  }
+  return getTickAtSqrtRatio(sqrtPrice)
+}
+
+/** 价格（token1 / token0，按精度换算）→ tick：满足 tickToPrice(tick) <= price 的最大 tick，限制在 [MIN_TICK, MAX_TICK] 内 */
+export function priceToTick(price: string | number, decimals0: number, decimals1: number): number {
+  return clampedTickAtSqrtRatio(priceToSqrtPriceX96(price, decimals0, decimals1))
+}
+
+/** 最近的可用 tick（tickSpacing 的整数倍），限制在 [MIN_TICK, MAX_TICK] 内 */
+export function nearestUsableTick(tick: number, tickSpacing: number): number {
+  if (!Number.isInteger(tickSpacing) || tickSpacing <= 0) {
+    throw new RangeError(`invalid tickSpacing: ${tickSpacing}`)
+  }
+  const rounded = Math.round(tick / tickSpacing) * tickSpacing
+  if (rounded < MIN_TICK) {
+    return rounded + tickSpacing
+  }
+  if (rounded > MAX_TICK) {
+    return rounded - tickSpacing
+  }
+  return rounded
+}
+
+/**
+ * 价格按 slippage 上下浮动后的 sqrtPrice：[sqrtPrice × sqrt(1 − s), sqrtPrice × sqrt(1 + s)]，限制在池子允许的价格范围内。
+ * slippage 是比例（0.005 = 0.5%），精确到百万分之一
+ */
+export function sqrtPriceBounds(sqrtPriceX96: bigint, slippage: number): [bigint, bigint] {
+  if (!(slippage >= 0 && slippage < 1)) {
+    throw new RangeError(`slippage must be in [0, 1): ${slippage}`)
+  }
+  const ppm = BigInt(Math.round(slippage * 1e6))
+  const square = sqrtPriceX96 * sqrtPriceX96
+  const lower = sqrtBigInt((square * (1_000_000n - ppm)) / 1_000_000n)
+  const upper = sqrtBigInt((square * (1_000_000n + ppm)) / 1_000_000n)
+  const clamp = (x: bigint) => (x <= MIN_SQRT_RATIO ? MIN_SQRT_RATIO + 1n : x >= MAX_SQRT_RATIO ? MAX_SQRT_RATIO - 1n : x)
+  return [clamp(lower), clamp(upper)]
+}
+
+/**
+ * 价格在 slippage 范围内变动时，流动性 L 至少对应多少代币（移除流动性 / V3 添加时的最小数量，向下取整）。
+ * token0 随价格上涨而减少，取上限价格时的数量；token1 取下限价格时的
+ */
+export function getMinAmounts(sqrtPriceX96: bigint, sqrtA: bigint, sqrtB: bigint, liquidity: bigint, slippage: number): [bigint, bigint] {
+  const [lower, upper] = sqrtPriceBounds(sqrtPriceX96, slippage)
+  return [getAmountsForLiquidity(upper, sqrtA, sqrtB, liquidity)[0], getAmountsForLiquidity(lower, sqrtA, sqrtB, liquidity)[1]]
+}
+
+/** 价格在 slippage 范围内变动时，添加流动性 L 最多需要多少代币（V4 的 amountMax，向上取整） */
+export function getMaxAmounts(sqrtPriceX96: bigint, sqrtA: bigint, sqrtB: bigint, liquidity: bigint, slippage: number): [bigint, bigint] {
+  const [lower, upper] = sqrtPriceBounds(sqrtPriceX96, slippage)
+  return [getMintAmounts(lower, sqrtA, sqrtB, liquidity)[0], getMintAmounts(upper, sqrtA, sqrtB, liquidity)[1]]
+}