@w3lib/evm-batch-call 0.5.0 → 0.6.0

package/src/liquidity/types.ts

@@ -0,0 +1,194 @@
+import type { BigNumberish } from 'ethers'
+
+import type { LpPosition, LpProtocol, LpToken, LpVersion } from '../lp.js'
+import type { SendOptions, TronSendOptions, WriteResult, WriteStatus } from '../write/send.js'
+
+/**
+ * 已有的仓位：直接传 getLpPositions 查到的 LpPosition，或者只传能定位仓位的字段。
+ * - V2：pool（LP 代币地址）
+ * - V3 / V4：tokenId，加上 positionManager 或 protocol（协议 id / LpProtocol）
+ */
+export interface PositionRef {
+  pool?: string
+  tokenId?: string | number | bigint
+  positionManager?: string
+  protocol?: string | LpProtocol
+}
+
+/** 往已有仓位追加流动性：两边数量给一边即可（另一边按当前价格算），也可以都给（按较少的一边） */
+export interface IncreaseLiquidityParams {
+  position: PositionRef | LpPosition
+  /** token0 的数量：amount0（最小单位）和 amount0Formatted（按精度换算，如 '1.5'）二选一 */
+  amount0?: BigNumberish
+  amount0Formatted?: string
+  amount1?: BigNumberish
+  amount1Formatted?: string
+}
+
+/**
+ * 新建仓位（V3 / V4：一个新的仓位 NFT；V2：往 tokenA / tokenB 的池子里加，池子不存在时创建）。
+ * 两个代币不分顺序，价格都是“1 个 tokenA 值多少个 tokenB”
+ */
+export interface NewPositionParams {
+  /** 协议 id（如 'uniswap-v3'）或自己的 LpProtocol */
+  protocol: string | LpProtocol
+  /** 代币地址；主币用 NATIVE_TOKEN 或零地址（V2 / V3 换成包装币、用主币支付；V4 是主币池子） */
+  tokenA: string
+  tokenB: string
+  /** V3 / V4：手续费档位（百万分之一：500 = 0.05%） */
+  fee?: number
+  /** V4：tick 间距，默认按手续费档位（100 → 1、500 → 10、3000 → 60、10000 → 200） */
+  tickSpacing?: number
+  /** V4：池子的 hooks 合约，默认零地址 */
+  hooks?: string
+  /** V3 / V4：价格区间（tokenB / tokenA，取最近的可用 tick）；或直接给 tickLower / tickUpper；或 fullRange */
+  priceLower?: string | number
+  priceUpper?: string | number
+  /** 池子里的 tick（token1 / token0 方向），必须是 tickSpacing 的整数倍 */
+  tickLower?: number
+  tickUpper?: number
+  /** 全区间（最小到最大的可用 tick） */
+  fullRange?: boolean
+  /** tokenA / tokenB 的数量：amount（最小单位）和 formatted 二选一；两边给一边即可，V2 新池子两边都要给 */
+  amountA?: BigNumberish
+  amountAFormatted?: string
+  amountB?: BigNumberish
+  amountBFormatted?: string
+  /** 池子不存在（或还没初始化）时用这个价格创建（tokenB / tokenA）。不传时池子不存在会报错 */
+  initialPrice?: string | number
+}
+
+export type AddLiquidityParams = IncreaseLiquidityParams | NewPositionParams
+
+export interface RemoveLiquidityParams {
+  position: PositionRef | LpPosition
+  /** 移除的比例（百分数，(0, 100]），默认 100 */
+  percent?: number
+  /** 或者直接给移除的流动性：V3 / V4 是 L，V2 是 LP 代币数量（最小单位） */
+  liquidity?: BigNumberish
+  /** V3 / V4：全部移除后销毁仓位 NFT，默认 false */
+  burn?: boolean
+}
+
+export interface CollectFeesParams {
+  /** V3 / V4 的仓位（V2 的手续费已经计入 LP 份额，没有单独领取） */
+  position: PositionRef | LpPosition
+}
+
+export interface LiquidityOptions {
+  /** 价格滑点（比例，0.005 = 0.5%），默认 0.005 */
+  slippage?: number
+  /** 交易的有效期（秒），默认 1200 */
+  deadline?: number
+  /** 收到 LP 代币 / 仓位 NFT / 移除的代币的地址，默认 owner */
+  recipient?: string
+  /**
+   * V2 / V3：包装币（WETH / WBNB …）那一边用主币支付 / 收取。
+   * 新建仓位时 tokenA / tokenB 传主币地址会自动开启；往已有仓位追加、移除、领取时默认 false（收到包装币）。V4 的主币池子不需要
+   */
+  native?: boolean
+  /** 授权额度：'exact'（默认，本次需要的数量）或 'max'（无限额度，之后不用再授权） */
+  approve?: 'exact' | 'max'
+  /** 内置表里没有的协议（自己的 LpProtocol），定位仓位时也会用到 */
+  protocols?: readonly LpProtocol[]
+  /** V4：传给 hooks 的 hookData，默认 '0x' */
+  hookData?: string
+}
+
+/** 一笔要发送的交易 */
+export interface LiquidityTx {
+  /**
+   * - approve：代币授权给 Router / 仓位合约 / Permit2
+   * - permit2：Permit2 授权给 V4 的仓位合约
+   * - add / remove / collect：添加 / 移除流动性、领取手续费
+   */
+  kind: 'approve' | 'permit2' | 'add' | 'remove' | 'collect'
+  to: string
+  data: string
+  /** 附带的主币（最小单位） */
+  value: string
+  /** approve / permit2：授权的代币、被授权方、额度 */
+  token?: string
+  spender?: string
+  amount?: string
+}
+
+/**
+ * 添加 / 移除流动性的计划：预计的数量 + 要按顺序发送的交易（授权在前）。
+ * 只做读取、不签名，可以当作报价用（输入一边数量，看另一边要多少）
+ */
+export interface LiquidityPlan {
+  action: 'add' | 'remove' | 'collect'
+  chainId: number
+  version: LpVersion
+  /** 协议 id / 显示名 */
+  protocol: string
+  protocolName: string
+  /** 池子地址（V4 为 poolId）；V2 / V3 的池子还不存在时为 null */
+  pool: string | null
+  /** 这次会创建（初始化）池子 */
+  createPool: boolean
+  owner: string
+  recipient: string
+  token0: LpToken
+  token1: LpToken
+  /** 已有仓位的 tokenId；新建 V3 / V4 仓位、V2 为 null */
+  tokenId: string | null
+  /** V3 / V4：仓位的 tick 区间、池子当前的 tick 和价格（token1 / token0，按精度换算，只用于展示） */
+  tickLower: number | null
+  tickUpper: number | null
+  tick: number | null
+  price: number | null
+  priceLower: number | null
+  priceUpper: number | null
+  /** 添加 / 移除的流动性：V3 / V4 是 L；V2 是 LP 代币数量（添加时为预计） */
+  liquidity: string
+  /** 按当前价格预计存入 / 取出的数量（不含手续费） */
+  amount0: string
+  amount1: string
+  amount0Formatted: string | null
+  amount1Formatted: string | null
+  /** 添加：最多会用掉的数量（V4 按滑点上浮；V2 / V3 即传给合约的数量）；移除：为 null */
+  amount0Max: string | null
+  amount1Max: string | null
+  /** 移除：至少会拿到的数量（价格在滑点范围外时交易失败）；添加：为 null */
+  amount0Min: string | null
+  amount1Min: string | null
+  /**
+   * 一并领取的未领取手续费（V3 移除 / 领取；V4 修改流动性时自动领取）。V2 没有单独的手续费，为 '0'
+   */
+  fees0: string
+  fees1: string
+  fees0Formatted: string | null
+  fees1Formatted: string | null
+  /** 哪一边用主币支付 / 收取（V2 / V3 的包装币那一边开启 native 时；V4 主币池子的 token0）；都不是时为 null */
+  native: 'token0' | 'token1' | null
+  /** 主交易附带的主币 */
+  value: string
+  /** 交易的截止时间（秒级时间戳） */
+  deadline: number
+  /** 按顺序发送；不需要授权时只有一笔 */
+  transactions: LiquidityTx[]
+}
+
+export interface LiquiditySendOptions extends LiquidityOptions, Omit<SendOptions, 'onUpdate'>, TronSendOptions {
+  /** 发送前检查余额够不够（添加时），默认 true */
+  checkBalance?: boolean
+  /** 每笔交易状态变化时回调（index 是在 plan.transactions 里的下标） */
+  onUpdate?: (result: LiquidityTxResult) => void
+}
+
+export interface LiquidityTxResult extends WriteResult {
+  kind: LiquidityTx['kind']
+}
+
+export interface LiquidityResult {
+  plan: LiquidityPlan
+  /** 与 plan.transactions 一一对应 */
+  results: LiquidityTxResult[]
+  /** 主交易（最后一笔）的状态和哈希 */
+  status: WriteStatus
+  hash: string | null
+  /** 新建的 V3 / V4 仓位的 tokenId（EVM 上主交易 confirmed 后从回执里读；其他情况为 null） */
+  tokenId: string | null
+}

package/src/liquidity/v2.ts

@@ -0,0 +1,371 @@
+import { Interface } from 'ethers'
+
+import { LP_PROTOCOLS, type LpPosition, type LpProtocol, type LpToken } from '../lp.js'
+import { sqrtBigInt } from '../lpMath.js'
+import { ZERO_ADDRESS, approvals, evm, isNative, makePlan, minus, out, parseAmount, protocolById, removeAmount, same, tokenInfo, type Ctx } from './common.js'
+import type { IncreaseLiquidityParams, LiquidityPlan, LiquidityTx, NewPositionParams, PositionRef, RemoveLiquidityParams } from './types.js'
+
+const routerInterface = new Interface([
+  'function WETH() view returns (address)',
+  'function addLiquidity(address tokenA, address tokenB, uint256 amountADesired, uint256 amountBDesired, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) returns (uint256 amountA, uint256 amountB, uint256 liquidity)',
+  'function addLiquidityETH(address token, uint256 amountTokenDesired, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) payable returns (uint256 amountToken, uint256 amountETH, uint256 liquidity)',
+  'function removeLiquidity(address tokenA, address tokenB, uint256 liquidity, uint256 amountAMin, uint256 amountBMin, address to, uint256 deadline) returns (uint256 amountA, uint256 amountB)',
+  'function removeLiquidityETH(address token, uint256 liquidity, uint256 amountTokenMin, uint256 amountETHMin, address to, uint256 deadline) returns (uint256 amountToken, uint256 amountETH)',
+])
+const factoryInterface = new Interface(['function getPair(address tokenA, address tokenB) view returns (address)', 'function feeTo() view returns (address)'])
+const pairInterface = new Interface([
+  'function token0() view returns (address)',
+  'function token1() view returns (address)',
+  'function factory() view returns (address)',
+  'function getReserves() view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast)',
+  'function totalSupply() view returns (uint256)',
+  'function balanceOf(address owner) view returns (uint256)',
+  'function kLast() view returns (uint256)',
+])
+
+/** UniswapV2Pair.MINIMUM_LIQUIDITY：第一次添加时锁定的 LP 代币 */
+const MINIMUM_LIQUIDITY = 1000n
+
+interface PairState {
+  protocol: LpProtocol
+  router: string
+  pair: string | null
+  token0: string
+  token1: string
+  reserve0: bigint
+  reserve1: bigint
+  /** LP 总量，已加上下一次添加 / 移除前会先给 feeTo 增发的协议手续费（_mintFee） */
+  totalSupply: bigint
+  balance: bigint
+}
+
+/**
+ * UniswapV2Pair._mintFee：协议手续费开启（factory.feeTo 不为零）时，每次添加 / 移除前先按 √k 的增长给 feeTo 增发 LP，
+ * 按份额算数量时要用增发后的总量。比例按 LpProtocol.protocolFee，没填时按 8/25（增发得多、算出的数量偏少，最小值更宽松，不会因此 revert）
+ */
+function protocolFeeMint(protocol: LpProtocol, totalSupply: bigint, reserve0: bigint, reserve1: bigint, kLast: bigint): bigint {
+  if (kLast === 0n || totalSupply === 0n) {
+    return 0n
+  }
+  const rootK = sqrtBigInt(reserve0 * reserve1)
+  const rootKLast = sqrtBigInt(kLast)
+  if (rootK <= rootKLast) {
+    return 0n
+  }
+  return protocol.protocolFee === '1/6'
+    ? (totalSupply * (rootK - rootKLast)) / (rootK * 5n + rootKLast)
+    : (totalSupply * (rootK - rootKLast) * 8n) / (rootK * 17n + rootKLast * 8n)
+}
+
+function routerOf(protocol: LpProtocol): string {
+  if (!protocol.router) {
+    throw new Error(`Protocol ${protocol.id} has no router; set router on its LpProtocol`)
+  }
+  return evm(protocol.router)
+}
+
+/** 读池子：储备、总量、owner 持有的 LP；协议没给时按池子的 factory 找（Router）。已知协议时协议手续费的状态一并读 */
+async function readPair(ctx: Ctx, pair: string, protocol?: LpProtocol): Promise<PairState> {
+  const c = ctx.provider.contract(pair, pairInterface)
+  const feeToCall = (factory: string) => ctx.provider.contract(factory, factoryInterface).feeTo()
+  // kLast / feeTo 有的分叉没有：一起用 tryAll 读，读不到按没开启协议手续费
+  const first = (await ctx.provider.tryAll([
+    c.token0(),
+    c.token1(),
+    c.factory(),
+    c.getReserves(),
+    c.totalSupply(),
+    c.balanceOf(ctx.owner),
+    c.kLast(),
+    ...(protocol?.factory ? [feeToCall(protocol.factory)] : []),
+  ])) as [string | null, string | null, string | null, { 0: bigint; 1: bigint } | null, bigint | null, bigint | null, bigint | null, (string | null)?]
+  const [token0, token1, factory, reserves, totalSupply, balance, kLast] = first
+  if (!token0 || !token1 || !factory || !reserves || totalSupply === null || balance === null) {
+    throw new Error(`${out(ctx, pair)} is not a V2 pool`)
+  }
+  const found =
+    protocol ??
+    [...(ctx.options.protocols ?? []), ...LP_PROTOCOLS].find((p) => p.chainId === ctx.chainId && p.version === 'v2' && p.factory && same(p.factory, factory))
+  if (!found) {
+    throw new Error(`Unknown V2 factory ${out(ctx, evm(factory))} of pool ${out(ctx, pair)}; pass its LpProtocol (with router) in options.protocols`)
+  }
+  if (protocol?.factory && !same(protocol.factory, factory)) {
+    throw new Error(`Pool ${out(ctx, pair)} does not belong to ${protocol.id}`)
+  }
+  const feeTo = protocol?.factory ? (first[7] ?? null) : ((await ctx.provider.tryAll([feeToCall(factory)])) as [string | null])[0]
+  const feeOn = feeTo !== null && evm(feeTo) !== ZERO_ADDRESS
+  const minted = feeOn ? protocolFeeMint(found, totalSupply, reserves[0], reserves[1], kLast ?? 0n) : 0n
+  return {
+    protocol: found,
+    router: routerOf(found),
+    pair,
+    token0: evm(token0),
+    token1: evm(token1),
+    reserve0: reserves[0],
+    reserve1: reserves[1],
+    totalSupply: totalSupply + minted,
+    balance,
+  }
+}
+
+/** 仓位上带的协议：LpProtocol 对象直接用；协议 id 按内置表 / options.protocols 找（getLpPositions 里不认识的工厂是 'v2:<工厂>'，按工厂找） */
+function refProtocol(ctx: Ctx, ref: PositionRef | LpPosition): LpProtocol | undefined {
+  if (!ref.protocol || (typeof ref.protocol === 'string' && ref.protocol.startsWith('v2:'))) {
+    return undefined
+  }
+  const protocol = protocolById(ctx, ref.protocol)
+  if (protocol.version !== 'v2') {
+    throw new Error(`${protocol.id} is not a V2 protocol`)
+  }
+  return protocol
+}
+
+const wethOf = async (ctx: Ctx, router: string) => evm((await ctx.provider.call(ctx.provider.contract(router, routerInterface).WETH())) as string)
+
+/** UniswapV2Library.quote：按储备比例换算 */
+const quote = (amountA: bigint, reserveA: bigint, reserveB: bigint) => (amountA * reserveB) / reserveA
+
+export async function v2Add(ctx: Ctx, params: IncreaseLiquidityParams | NewPositionParams): Promise<LiquidityPlan> {
+  let state: PairState
+  /** 新建时 tokenA 是不是 token0；往已有仓位追加时为 null（数量直接按 token0 / token1） */
+  let aIs0: boolean | null = null
+  let native = ctx.options.native ?? false
+  /** Router 的包装币（用主币时才读） */
+  let weth: string | null = null
+
+  if ('position' in params) {
+    const ref = params.position as PositionRef | LpPosition
+    if (!ref.pool) {
+      throw new Error('V2 position needs pool')
+    }
+    state = await readPair(ctx, evm(ref.pool), refProtocol(ctx, ref))
+  } else {
+    const protocol = params.protocol as LpProtocol
+    const router = routerOf(protocol)
+    let a = evm(params.tokenA)
+    let b = evm(params.tokenB)
+    if (isNative(ctx, a) || isNative(ctx, b)) {
+      // 主币：换成 Router 的包装币，用主币支付
+      const wrapped = await wethOf(ctx, router)
+      a = isNative(ctx, a) ? wrapped : a
+      b = isNative(ctx, b) ? wrapped : b
+      weth = wrapped
+      native = true
+    }
+    if (a === b) {
+      throw new Error('tokenA and tokenB must be different')
+    }
+    if (!protocol.factory) {
+      throw new Error(`Protocol ${protocol.id} has no factory; set factory on its LpProtocol`)
+    }
+    const pair = evm((await ctx.provider.call(ctx.provider.contract(protocol.factory, factoryInterface).getPair(a, b))) as string)
+    if (pair === ZERO_ADDRESS) {
+      // 池子还不存在：Router 添加时会创建
+      const [token0, token1] = BigInt(a) < BigInt(b) ? [a, b] : [b, a]
+      state = { protocol, router, pair: null, token0, token1, reserve0: 0n, reserve1: 0n, totalSupply: 0n, balance: 0n }
+    } else {
+      state = await readPair(ctx, pair, protocol)
+    }
+    aIs0 = a === state.token0
+  }
+
+  const { router, token0, token1, reserve0, reserve1, totalSupply } = state
+  // 代币信息和（往已有仓位用主币追加时）包装币地址互不依赖，一起读
+  const [tokens, wrapped] = await Promise.all([tokenInfo(ctx, [token0, token1]), native && !weth ? wethOf(ctx, router) : Promise.resolve(weth)])
+  const [t0, t1] = tokens as [LpToken, LpToken]
+  weth = wrapped
+  let given0: bigint | undefined
+  let given1: bigint | undefined
+  if (aIs0 === null) {
+    const p = params as IncreaseLiquidityParams
+    given0 = parseAmount(p.amount0, p.amount0Formatted, t0, 'amount0')
+    given1 = parseAmount(p.amount1, p.amount1Formatted, t1, 'amount1')
+  } else {
+    const p = params as NewPositionParams
+    const amountA = parseAmount(p.amountA, p.amountAFormatted, aIs0 ? t0 : t1, 'amountA')
+    const amountB = parseAmount(p.amountB, p.amountBFormatted, aIs0 ? t1 : t0, 'amountB')
+    ;[given0, given1] = aIs0 ? [amountA, amountB] : [amountB, amountA]
+  }
+  if (given0 === undefined && given1 === undefined) {
+    throw new Error('Pass the amount of at least one token')
+  }
+
+  // 主币：其中一边必须是包装币
+  if (native) {
+    weth ??= await wethOf(ctx, router)
+    if (weth !== token0 && weth !== token1) {
+      throw new Error('native: true needs one side of the pool to be the wrapped native token')
+    }
+  }
+
+  // 传给 Router 的数量（desired）：给了的按给的，另一边按储备比例
+  let desired0: bigint
+  let desired1: bigint
+  const empty = reserve0 === 0n && reserve1 === 0n
+  if (!empty && (reserve0 === 0n || reserve1 === 0n)) {
+    throw new Error(`Pool ${out(ctx, state.pair as string)} has one empty reserve; liquidity cannot be added at a meaningful price`)
+  }
+  if (empty) {
+    if (!given0 || !given1) {
+      throw new Error('The pool is empty: pass the amounts of both tokens (they set the initial price)')
+    }
+    ;[desired0, desired1] = [given0, given1]
+  } else {
+    desired0 = given0 ?? quote(given1 as bigint, reserve1, reserve0)
+    desired1 = given1 ?? quote(given0 as bigint, reserve0, reserve1)
+  }
+  // 实际用掉的数量：与 Router 的 _addLiquidity 一致（A 是 addLiquidity 的第一个代币；addLiquidityETH 的 A 是非包装币那一边）。
+  // 先按 A 算 B 的最优数量，超出 B 的 desired 时反过来按 B 算 A
+  let amount0 = desired0
+  let amount1 = desired1
+  if (!empty) {
+    const aIsToken0 = weth !== token0
+    const [dA, dB, rA, rB] = aIsToken0 ? [desired0, desired1, reserve0, reserve1] : [desired1, desired0, reserve1, reserve0]
+    const optimalB = quote(dA, rA, rB)
+    const [amountA, amountB] = optimalB <= dB ? [dA, optimalB] : [quote(dB, rB, rA), dB]
+    ;[amount0, amount1] = aIsToken0 ? [amountA, amountB] : [amountB, amountA]
+  }
+  if (amount0 === 0n || amount1 === 0n) {
+    throw new Error('Amount too small: one side rounds to 0')
+  }
+  const liquidity = totalSupply === 0n ? sqrtBigInt(amount0 * amount1) - MINIMUM_LIQUIDITY : minBig((amount0 * totalSupply) / reserve0, (amount1 * totalSupply) / reserve1)
+  if (liquidity <= 0n) {
+    throw new Error('Amount too small: no LP tokens would be minted')
+  }
+
+  // 最小值按实际会用掉的数量算（两边都给、比例与池子不同时，Router 会按较少的一边收取，那一边的最小值不能按给的数量算）
+  const min0 = empty ? desired0 : minus(amount0, ctx.slippage)
+  const min1 = empty ? desired1 : minus(amount1, ctx.slippage)
+  let main: LiquidityTx
+  let value = 0n
+  if (weth) {
+    const tokenIs0 = weth === token1
+    const token = tokenIs0 ? token0 : token1
+    // 附带的主币按 desired 给，没用完的 Router 会退回
+    value = tokenIs0 ? desired1 : desired0
+    main = {
+      kind: 'add',
+      to: out(ctx, router),
+      data: routerInterface.encodeFunctionData('addLiquidityETH', [
+        token,
+        tokenIs0 ? desired0 : desired1,
+        tokenIs0 ? min0 : min1,
+        tokenIs0 ? min1 : min0,
+        ctx.recipient,
+        ctx.deadline,
+      ]),
+      value: value.toString(),
+    }
+  } else {
+    main = {
+      kind: 'add',
+      to: out(ctx, router),
+      data: routerInterface.encodeFunctionData('addLiquidity', [token0, token1, desired0, desired1, min0, min1, ctx.recipient, ctx.deadline]),
+      value: '0',
+    }
+  }
+  const approve = await approvals(
+    ctx,
+    [
+      { token: token0, spender: router, amount: desired0 },
+      { token: token1, spender: router, amount: desired1 },
+    ].filter((i) => i.token !== weth),
+  )
+  return makePlan(ctx, {
+    action: 'add',
+    version: 'v2',
+    protocol: state.protocol.id,
+    protocolName: state.protocol.name,
+    pool: state.pair,
+    createPool: state.pair === null,
+    token0: t0,
+    token1: t1,
+    tokenId: null,
+    tickLower: null,
+    tickUpper: null,
+    tick: null,
+    price: null,
+    priceLower: null,
+    priceUpper: null,
+    liquidity: liquidity.toString(),
+    amount0: amount0.toString(),
+    amount1: amount1.toString(),
+    amount0Max: desired0.toString(),
+    amount1Max: desired1.toString(),
+    amount0Min: null,
+    amount1Min: null,
+    fees0: '0',
+    fees1: '0',
+    native: weth === null ? null : weth === token0 ? 'token0' : 'token1',
+    value: value.toString(),
+    transactions: [...approve, main],
+  })
+}
+
+export async function v2Remove(ctx: Ctx, params: RemoveLiquidityParams): Promise<LiquidityPlan> {
+  const ref = params.position
+  if (!ref.pool) {
+    throw new Error('V2 position needs pool')
+  }
+  const state = await readPair(ctx, evm(ref.pool), refProtocol(ctx, ref))
+  const { router, token0, token1, reserve0, reserve1, totalSupply, balance } = state
+  if (balance === 0n) {
+    throw new Error(`${out(ctx, ctx.owner)} holds no LP tokens of ${out(ctx, state.pair as string)}`)
+  }
+  const liquidity = removeAmount(balance, params.percent, params.liquidity)
+  const [t0, t1] = (await tokenInfo(ctx, [token0, token1])) as [LpToken, LpToken]
+  // 按份额取出（与 pair.burn 一致；总量已含先给 feeTo 增发的协议手续费）
+  const amount0 = (liquidity * reserve0) / totalSupply
+  const amount1 = (liquidity * reserve1) / totalSupply
+  const min0 = minus(amount0, ctx.slippage)
+  const min1 = minus(amount1, ctx.slippage)
+
+  let weth: string | null = null
+  if (ctx.options.native) {
+    weth = await wethOf(ctx, router)
+    if (weth !== token0 && weth !== token1) {
+      throw new Error('native: true needs one side of the pool to be the wrapped native token')
+    }
+  }
+  const tokenIs0 = weth === token1
+  const main: LiquidityTx = {
+    kind: 'remove',
+    to: out(ctx, router),
+    data: weth
+      ? routerInterface.encodeFunctionData('removeLiquidityETH', [tokenIs0 ? token0 : token1, liquidity, tokenIs0 ? min0 : min1, tokenIs0 ? min1 : min0, ctx.recipient, ctx.deadline])
+      : routerInterface.encodeFunctionData('removeLiquidity', [token0, token1, liquidity, min0, min1, ctx.recipient, ctx.deadline]),
+    value: '0',
+  }
+  const approve = await approvals(ctx, [{ token: state.pair as string, spender: router, amount: liquidity }])
+  return makePlan(ctx, {
+    action: 'remove',
+    version: 'v2',
+    protocol: state.protocol.id,
+    protocolName: state.protocol.name,
+    pool: state.pair,
+    createPool: false,
+    token0: t0,
+    token1: t1,
+    tokenId: null,
+    tickLower: null,
+    tickUpper: null,
+    tick: null,
+    price: null,
+    priceLower: null,
+    priceUpper: null,
+    liquidity: liquidity.toString(),
+    amount0: amount0.toString(),
+    amount1: amount1.toString(),
+    amount0Max: null,
+    amount1Max: null,
+    amount0Min: min0.toString(),
+    amount1Min: min1.toString(),
+    fees0: '0',
+    fees1: '0',
+    native: weth === null ? null : weth === token0 ? 'token0' : 'token1',
+    value: '0',
+    transactions: [...approve, main],
+  })
+}
+
+const minBig = (a: bigint, b: bigint) => (a < b ? a : b)