@w3lib/evm-batch-call 0.5.0 → 0.7.0

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]]
+}

package/src/multicall.ts

@@ -81,6 +81,9 @@ const MULTICALL3: Record<number, Multicall> = {
   80094: { address: CANONICAL, block: 0 }, // Berachain，创世预置
   534352: { address: CANONICAL, block: 14 }, // Scroll
   86233268: { address: CANONICAL, block: 10854614 }, // Winchain，部署区块未查到
+  1030: { address: CANONICAL, block: 159584122 }, // Conflux eSpace，部署区块未查到
+  1672: { address: CANONICAL, block: 20812125 }, // Pharos，部署区块未查到
+  1776: { address: CANONICAL, block: 188237272 }, // Injective EVM，部署区块未查到
   // 以下两条链不支持 deployless（合约创建式 eth_call 返回空 / 格式不对），只能用 Multicall3；
   // 早于部署区块的历史查询会失败
   42262: { address: CANONICAL, block: 22380155 }, // Oasis Emerald，部署区块未查到

package/src/names.ts

@@ -0,0 +1,141 @@
+/**
+ * 域名解析（子路径 `@w3lib/evm-batch-call/names`）：ENS（Ethereum）、SPACE ID（BSC 的 .bnb）、Basenames（Base 的 .base.eth），
+ * 名字 → 地址、地址 → 名字（反查后再正查核对）。都是 ENS 式的注册表合约，读取合成几次 multicall
+ */
+import { ensNormalize, namehash } from 'ethers'
+
+import type { Provider } from './provider.js'
+import { isTronChain } from './tron.js'
+
+export interface NameService {
+  id: string
+  name: string
+  chainId: number
+  /** ENS 式的注册表合约（resolver(node)） */
+  registry: string
+  /** 这个服务的名字后缀（如 ['bnb']）；null 表示任意名字都交给它（ENS 还支持导入的 DNS 域名） */
+  suffixes: readonly string[] | null
+  /** 反查用的节点后缀：ENS 是 addr.reverse，L2 上按 ENSIP-19 是 <coinType 十六进制>.reverse */
+  reverseSuffix: string
+}
+
+/** 内置的域名服务（2026-10 在链上核对过注册表和正查 / 反查） */
+export const NAME_SERVICES: readonly NameService[] = [
+  { id: 'ens', name: 'ENS', chainId: 1, registry: '0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e', suffixes: null, reverseSuffix: 'addr.reverse' },
+  { id: 'spaceid', name: 'SPACE ID', chainId: 56, registry: '0x08CEd32a7f3eeC915Ba84415e9C07a7286977956', suffixes: ['bnb'], reverseSuffix: 'addr.reverse' },
+  { id: 'basenames', name: 'Basenames', chainId: 8453, registry: '0xb94704422c2a1e396835a571837aa5ae53285a95', suffixes: ['base.eth'], reverseSuffix: '80002105.reverse' },
+]
+
+export interface NamesOptions {
+  /** 用哪些域名服务，默认 NAME_SERVICES 里 Provider 这条链的 */
+  services?: readonly NameService[]
+}
+
+export interface ResolvedName {
+  /** 传入的名字（原样） */
+  name: string
+  /** 规范化后的名字（ENSIP-15）；名字不合法时为 null */
+  normalized: string | null
+  /** 解析出的地址；没有注册、没有设置地址、名字不合法时为 null */
+  address: string | null
+  /** 解析这个名字的服务 id；没有服务认这个后缀时为 null */
+  service: string | null
+}
+
+export interface AddressName {
+  /** 传入的地址（原样） */
+  address: string
+  /** 反查到、并且正查回到同一个地址的名字；没有时为 null */
+  name: string | null
+  service: string | null
+}
+
+const REGISTRY_ABI = ['function resolver(bytes32 node) view returns (address)']
+const RESOLVER_ABI = ['function addr(bytes32 node) view returns (address)', 'function name(bytes32 node) view returns (string)']
+const ZERO = '0x0000000000000000000000000000000000000000'
+const present = (a: string | null | undefined): a is string => !!a && a.toLowerCase() !== ZERO
+
+function servicesOf(chainId: number, options: NamesOptions): readonly NameService[] {
+  return options.services ?? NAME_SERVICES.filter((s) => s.chainId === chainId)
+}
+
+/** 名字归哪个服务：后缀最长的匹配优先，其次是不限后缀的服务 */
+function serviceFor(name: string, services: readonly NameService[]): NameService | null {
+  let best: { s: NameService; len: number } | null = null
+  for (const s of services) {
+    for (const suffix of s.suffixes ?? []) {
+      if ((name === suffix || name.endsWith(`.${suffix}`)) && (!best || suffix.length > best.len)) best = { s, len: suffix.length }
+    }
+  }
+  return best?.s ?? services.find((s) => s.suffixes === null) ?? null
+}
+
+function normalize(name: string): string | null {
+  try {
+    const n = ensNormalize(name.trim())
+    return n.includes('.') ? n : null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 名字 → 地址（读注册表的 resolver，再读 resolver 的 addr，两次 multicall）。
+ * 不支持通配解析（ENSIP-10）和链下解析（CCIP-Read，如 cb.id 等子域名），这些名字返回 null
+ *
+ * ```ts
+ * await resolveNames(new Provider(1), ['vitalik.eth', 'nick.eth'])
+ * // [{ name: 'vitalik.eth', normalized: 'vitalik.eth', address: '0xd8dA…6045', service: 'ens' }, …]
+ * ```
+ */
+export async function resolveNames(provider: Provider, names: readonly string[], options: NamesOptions = {}): Promise<ResolvedName[]> {
+  const chainId = await provider.getChainId()
+  const services = isTronChain(chainId) ? [] : servicesOf(chainId, options)
+  const items = names.map((name) => {
+    const normalized = normalize(name)
+    const service = normalized ? serviceFor(normalized, services) : null
+    return { name, normalized, service, node: normalized && service ? namehash(normalized) : null }
+  })
+  const todo = items.filter((x) => x.node && x.service)
+  const resolvers = todo.length ? await provider.tryAll<string>(todo.map((x) => provider.contract((x.service as NameService).registry, REGISTRY_ABI).resolver(x.node as string))) : []
+  const withResolver = todo.flatMap((x, i) => (present(resolvers[i]) ? [{ x, resolver: resolvers[i] as string }] : []))
+  const addresses = withResolver.length ? await provider.tryAll<string>(withResolver.map(({ x, resolver }) => provider.contract(resolver, RESOLVER_ABI).addr(x.node as string))) : []
+  const found = new Map(withResolver.map(({ x }, i) => [x, present(addresses[i]) ? (addresses[i] as string) : null]))
+  return items.map((x) => ({ name: x.name, normalized: x.normalized, address: found.get(x) ?? null, service: x.service?.id ?? null }))
+}
+
+/**
+ * 地址 → 名字：读反查记录（主名字），再正查核对名字确实指回这个地址（没有核对的反查记录可以随便设置，不能信）。
+ * 共四次 multicall；Tron 上没有域名服务，都返回 null
+ *
+ * ```ts
+ * await lookupAddresses(new Provider(56), [user])   // [{ address: user, name: 'alice.bnb', service: 'spaceid' }]
+ * ```
+ */
+export async function lookupAddresses(provider: Provider, addresses: readonly string[], options: NamesOptions = {}): Promise<AddressName[]> {
+  const chainId = await provider.getChainId()
+  const services = isTronChain(chainId) ? [] : servicesOf(chainId, options)
+  const queries = addresses.flatMap((address, i) =>
+    /^0x[0-9a-fA-F]{40}$/.test(address) ? services.map((s) => ({ i, s, node: namehash(`${address.slice(2).toLowerCase()}.${s.reverseSuffix}`) })) : [],
+  )
+  const resolvers = queries.length ? await provider.tryAll<string>(queries.map((q) => provider.contract(q.s.registry, REGISTRY_ABI).resolver(q.node))) : []
+  const withResolver = queries.flatMap((q, j) => (present(resolvers[j]) ? [{ q, resolver: resolvers[j] as string }] : []))
+  const names = withResolver.length ? await provider.tryAll<string>(withResolver.map(({ q, resolver }) => provider.contract(resolver, RESOLVER_ABI).name(q.node))) : []
+  const claimed = withResolver.flatMap(({ q }, j) => (typeof names[j] === 'string' && names[j] ? [{ q, name: names[j] as string }] : []))
+  // 正查核对：名字要由同一个服务解析回这个地址
+  const forward = await resolveNames(
+    provider,
+    claimed.map((c) => c.name),
+    { services },
+  )
+  const result: AddressName[] = addresses.map((address) => ({ address, name: null, service: null }))
+  claimed.forEach((c, j) => {
+    const f = forward[j]
+    const out = result[c.q.i] as AddressName
+    if (out.name === null && f?.address && f.service === c.q.s.id && f.address.toLowerCase() === out.address.toLowerCase()) {
+      out.name = f.normalized
+      out.service = c.q.s.id
+    }
+  })
+  return result
+}

package/src/owner.ts

@@ -1,8 +1,10 @@
 import type { CallOverrides } from './aggregate.js'
 import { NATIVE_TOKEN, formatUnits, type BalanceToken } from './erc20.js'
 import type { Provider } from './provider.js'
+import { HttpStatusError, fetchJson } from './http.js'
+import { defillamaPrices, type PriceSource } from './price.js'
 import { transferScan, type TransferScanOptions } from './scan.js'
-import { TRON_CHAIN_ID, isTronAddress, isTronChain, toTronAddress } from './tron.js'
+import { isTronAddress, isTronChain, toTronAddress } from './tron.js'
 
 // ---------------------------------------------------------------------------
 // 代币来源：负责“这个地址可能持有哪些代币”。余额和精度一律由本库用 multicall 在链上核对。
@@ -31,41 +33,10 @@ export interface TokenSource {
   discover(ctx: TokenSourceContext): Promise<DiscoveredToken[] | null>
 }
 
-const REQUEST_TIMEOUT = 20_000
 const LIST_TTL = 60 * 60 * 1000
 const MAX_CACHED_LISTS = 16
 const ZERO_ADDRESS = '0x0000000000000000000000000000000000000000'
 
-export class HttpStatusError extends Error {
-  constructor(
-    readonly status: number,
-    target: string,
-  ) {
-    super(`HTTP ${status} from ${target}`)
-    this.name = 'HttpStatusError'
-  }
-}
-
-/**
- * @param secret 请求里带的 Key：出错时错误信息只写域名，不写完整地址，避免 Key 出现在日志里
- */
-function fetchJson<T>(fetchFn: typeof fetch, url: string, init?: RequestInit, secret?: string): Promise<T> {
-  return fetchFn(url, { ...init, signal: AbortSignal.timeout(REQUEST_TIMEOUT) }).then(async (res) => {
-    if (!res.ok) {
-      throw new HttpStatusError(res.status, secret ? safeHost(url) : url)
-    }
-    return (await res.json()) as T
-  })
-}
-
-function safeHost(url: string): string {
-  try {
-    return new URL(url).host
-  } catch {
-    return 'request'
-  }
-}
-
 // 公开代币列表：缓存“按链过滤、转换后”的结果（不缓存原始 JSON），1 小时；缓存 Promise，同时发起的请求共用，失败不缓存。
 // 公开列表与使用哪个 fetch 无关，所以缓存键只看列表和链
 const listCache = new Map<string, { at: number; promise: Promise<DiscoveredToken[] | null> }>()
@@ -410,111 +381,9 @@ function dedupe<T extends DiscoveredToken>(tokens: T[]): T[] {
   return [...seen.values()]
 }
 
-// ---------------------------------------------------------------------------
-// 价格来源
-// ---------------------------------------------------------------------------
-
-export interface PriceSourceContext {
-  chainId: number
-  /** 代币地址（不含主币） */
-  tokens: readonly string[]
-  /** 主币 symbol（需要主币价格时）；不需要时为 null */
-  nativeSymbol: string | null
-  fetch: typeof fetch
-}
-
-export interface PriceSource {
-  readonly name: string
-  /** 返回 去重键 → 美元价格：EVM 是小写 0x 地址；Tron 是 T 开头的 base58 地址（区分大小写）；主币用键 'native'。没有价格的不返回 */
-  prices(ctx: PriceSourceContext): Promise<Map<string, number>>
-}
-
-/** DefiLlama 的链标识：chainId → slug（2026-10 实测可用） */
-export const DEFILLAMA_CHAINS: Readonly<Record<number, string>> = {
-  1: 'ethereum',
-  10: 'optimism',
-  56: 'bsc',
-  130: 'unichain',
-  137: 'polygon',
-  143: 'monad',
-  196: 'xlayer',
-  204: 'op_bnb',
-  324: 'era',
-  999: 'hyperliquid',
-  1116: 'core',
-  2818: 'morph',
-  5000: 'mantle',
-  8453: 'base',
-  9745: 'plasma',
-  34443: 'mode',
-  42161: 'arbitrum',
-  43114: 'avax',
-  57073: 'ink',
-  59144: 'linea',
-  80094: 'berachain',
-  81457: 'blast',
-  534352: 'scroll',
-  [TRON_CHAIN_ID.mainnet]: 'tron',
-}
-
-/** 主币价格：按主币 symbol 对应 CoinGecko 的币种 id（DefiLlama 用 coingecko:<id> 查） */
-const NATIVE_PRICE_IDS: Readonly<Record<string, string>> = {
-  ETH: 'ethereum',
-  BNB: 'binancecoin',
-  POL: 'polygon-ecosystem-token',
-  AVAX: 'avalanche-2',
-  MNT: 'mantle',
-  OKB: 'okb',
-  HYPE: 'hyperliquid',
-  BERA: 'berachain-bera',
-  CORE: 'coredaoorg',
-  MON: 'monad',
-  XPL: 'plasma',
-  TRX: 'tron',
-}
-
-/**
- * DefiLlama 价格（免费、不需要 Key）。minConfidence：DefiLlama 给出的置信度下限（0~1），低于它视为没有价格，默认 0.9。
- * 注意：流动性很差的代币价格可能虚高，展示总资产时建议配合 minUsd 或自己的价格源。
- */
-export function defillamaPrices(options: { minConfidence?: number } = {}): PriceSource {
-  const minConfidence = options.minConfidence ?? 0.9
-  return {
-    name: 'defillama',
-    async prices({ chainId, tokens, nativeSymbol, fetch: fetchFn }) {
-      const result = new Map<string, number>()
-      const slug = DEFILLAMA_CHAINS[chainId]
-      const nativeId = nativeSymbol ? NATIVE_PRICE_IDS[nativeSymbol.toUpperCase()] : undefined
-      // 查询键 → 结果里用的去重键：EVM 地址小写；Tron 地址区分大小写，DefiLlama 要用原样的 base58（T…）地址
-      const resultKey = new Map<string, string>()
-      const tokenKeys = slug
-        ? tokens.map((t) => {
-            const tron = slug === 'tron'
-            const query = `${slug}:${tron ? toTronAddress(t) : t.toLowerCase()}`
-            resultKey.set(query.toLowerCase(), tron ? toTronAddress(t) : t.toLowerCase())
-            return query
-          })
-        : []
-      const keys = [...(nativeId ? [`coingecko:${nativeId}`] : []), ...tokenKeys]
-      const batches: string[][] = []
-      for (let i = 0; i < keys.length; i += 100) {
-        batches.push(keys.slice(i, i + 100))
-      }
-      const responses = await Promise.all(
-        batches.map((batch) => fetchJson<{ coins?: Record<string, { price?: number; confidence?: number }> }>(fetchFn, `https://coins.llama.fi/prices/current/${batch.join(',')}`)),
-      )
-      for (const res of responses) {
-        for (const [key, coin] of Object.entries(res.coins ?? {})) {
-          if (typeof coin.price !== 'number' || !Number.isFinite(coin.price) || (coin.confidence !== undefined && coin.confidence < minConfidence)) {
-            continue
-          }
-          result.set(key.startsWith('coingecko:') ? 'native' : (resultKey.get(key.toLowerCase()) ?? key.slice(key.indexOf(':') + 1).toLowerCase()), coin.price)
-        }
-      }
-      return result
-    },
-  }
-}
+// 价格来源在 price.ts（子路径 /price）；这里继续导出，旧的 import 不受影响
+export { DEFILLAMA_CHAINS, defillamaPrices, type PriceSource, type PriceSourceContext } from './price.js'
+export { HttpStatusError }
 
 // ---------------------------------------------------------------------------
 // ownerTokens
@@ -617,7 +486,7 @@ export async function ownerTokens(provider: Provider, owner: string, options: Ow
   // 价格源的键：Tron 上统一用 T 地址（代币来源给的可能是 0x 格式）
   const priceKey = (address: string) => (isTronChain(chainId) ? toTronAddress(address) : addressKey(address))
   const priceMap = priceSource
-    ? await priceSource.prices({ chainId, tokens: held.map((x) => (isTronChain(chainId) ? toTronAddress(x.meta.address) : x.meta.address)), nativeSymbol: nativeAddress ? (nativeInfo?.symbol ?? null) : null, fetch: fetchFn })
+    ? await priceSource.prices({ chainId, tokens: held.map((x) => (isTronChain(chainId) ? toTronAddress(x.meta.address) : x.meta.address)), nativeSymbol: nativeAddress ? (nativeInfo?.symbol ?? null) : null, fetch: fetchFn, provider })
     : new Map<string, number>()
   const valueOf = (formatted: string, price: number | undefined) => (price === undefined ? null : Number(formatted) * price)
 

package/src/portfolio.ts

@@ -0,0 +1,91 @@
+/**
+ * 资产总值（子路径 `@w3lib/evm-batch-call/price`）：已知代币的余额 × 价格，可选加上 LP 仓位的价值
+ */
+import { lpPositions, type LpPosition, type LpPositionsOptions } from './lp.js'
+import { combinePrices, defillamaPrices, onchainPrices, tokenPrices, type PriceSource } from './price.js'
+import type { Provider } from './provider.js'
+
+export interface PortfolioOptions {
+  /** 要计入的代币（含主币：NATIVE_TOKEN），余额用 multicall 一次读出 */
+  tokens: readonly string[]
+  /** 价格源，依次使用，默认 [defillamaPrices(), onchainPrices()] */
+  sources?: readonly PriceSource[]
+  /** 同时计入 LP 仓位（V2 LP 代币、V3 仓位 NFT；参数同 lpPositions，价格源用上面的 sources），默认不计入 */
+  lp?: boolean | Omit<LpPositionsOptions, 'prices'>
+  /** 价值低于它的代币不列出（不影响合计）；大于 0 时没有价格的代币也不列出（计入 unpriced），默认 0 */
+  minUsd?: number
+  /** 某个价格源出错时调用 */
+  onPriceError?: (err: unknown) => void
+  fetch?: typeof fetch
+}
+
+export interface PortfolioToken {
+  token: string
+  native: boolean
+  symbol: string | null
+  balance: string
+  decimals: number
+  formatted: string
+  price: number | null
+  /** 美元价值；没有价格时为 null */
+  value: number | null
+  /** 给出价格的价格源 */
+  priceSource: string | null
+}
+
+export interface Portfolio {
+  /** 合计（代币 + LP；没有价格的不计入） */
+  totalUsd: number
+  tokensUsd: number
+  lpUsd: number
+  /** 有余额的代币，按价值从高到低 */
+  tokens: PortfolioToken[]
+  /** LP 仓位（开启 lp 时） */
+  lp: LpPosition[]
+  /** 有余额但没有价格的代币数（LP 仓位里缺价格的也算） */
+  unpriced: number
+}
+
+/**
+ * 一个地址的资产总值：代币余额（只看传入的代币，EVM 不能只靠节点列出持仓）× 价格，可选加上 LP 仓位。
+ *
+ * ```ts
+ * const p = await portfolio(provider, user, { tokens: [NATIVE_TOKEN, USDT, USDC], lp: true })
+ * p.totalUsd  // 1234.5
+ * ```
+ */
+export async function portfolio(provider: Provider, owner: string, options: PortfolioOptions): Promise<Portfolio> {
+  const { tokens, sources = [defillamaPrices(), onchainPrices()], lp, minUsd = 0, onPriceError, fetch: fetchFn } = options
+  const onError = onPriceError ? (_: PriceSource, err: unknown) => onPriceError(err) : undefined
+  const [balances, positions] = await Promise.all([
+    tokens.length ? provider.balances(owner, tokens, { symbol: true }) : Promise.resolve([]),
+    lp ? lpPositions(provider, owner, { ...(lp === true ? {} : lp), prices: combinePrices(sources, { onError }), ...(fetchFn ? { fetch: fetchFn } : {}), ...(onPriceError ? { onPriceError } : {}) }) : Promise.resolve([]),
+  ])
+  const held = balances.filter((b) => b.success && BigInt(b.balance) > 0n)
+  const prices = held.length ? await tokenPrices(provider, held.map((b) => b.token), { sources, ...(onError ? { onError } : {}), ...(fetchFn ? { fetch: fetchFn } : {}) }) : []
+  const list: PortfolioToken[] = held.map((b, i) => {
+    const p = prices[i]
+    const price = p?.price ?? null
+    return {
+      token: b.token,
+      native: b.native,
+      symbol: b.symbol ?? null,
+      balance: b.balance,
+      decimals: b.decimals,
+      formatted: b.formatted,
+      price,
+      value: price === null ? null : Number(b.formatted) * price,
+      priceSource: p?.source ?? null,
+    }
+  })
+  const tokensUsd = list.reduce((sum, t) => sum + (t.value ?? 0), 0)
+  const lpUsd = positions.reduce((sum, p) => sum + (p.valueUsd ?? 0), 0)
+  return {
+    totalUsd: tokensUsd + lpUsd,
+    tokensUsd,
+    lpUsd,
+    tokens: list.filter((t) => (t.value ?? 0) >= minUsd || (minUsd === 0 && t.value === null)).sort((a, b) => (b.value ?? -1) - (a.value ?? -1)),
+    lp: positions,
+    unpriced: list.filter((t) => t.price === null).length + positions.filter((p) => p.valueUsd === null).length,
+  }
+}