@w3lib/evm-batch-call 0.6.0 → 0.8.0

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)