@w3lib/evm-batch-call 0.1.0 → 0.3.0

package/src/source.ts

@@ -1,6 +1,7 @@
-import { BrowserProvider, FetchRequest, JsonRpcProvider, type Eip1193Provider } from 'ethers'
+import { BrowserProvider, FetchRequest, JsonRpcProvider, makeError, type Eip1193Provider, type TransactionRequest } from 'ethers'
 
 import type { EthersLikeProvider } from './aggregate.js'
+import { canDetectChainId, detectChainId, detectChainIdCached } from './detect.js'
 import { FallbackRpc, type FallbackOptions } from './fallback.js'
 import { DEFAULT_RPC_URLS, DEFAULT_TRON_HOSTS } from './rpcNodes.js'
 import { TRON_CHAIN_ID, TronProvider, type TronProviderOptions, type TronWebLike } from './tron.js'
@@ -50,10 +51,118 @@ export function resolveSource(
   }
   // 多节点时 Tron 节点不在单节点内重试 429，直接切到下一个节点
   const multiple = list.length > 1
-  const nodes = list.map((item) => toEthersLike(chainId, item, options, multiple))
+  const timeout = options.fallback?.timeout ?? 10_000
+  const nodes = list.map((item) => {
+    const node = toEthersLike(chainId, item, options, multiple)
+    // 内置公共节点本来就是按 chainId 选出来的，不需要再校验
+    return source === undefined ? node : withChainCheck(chainId, item, node, timeout)
+  })
   return multiple ? new FallbackRpc(nodes, options.fallback) : (nodes[0] as EthersLikeProvider)
 }
 
+/** 识别失败后多久内不再重试识别（期间请求照常发出，不做校验） */
+const CHECK_RETRY_INTERVAL = 60_000
+
+/**
+ * 校验节点所在的链与 Provider 的 chainId 一致，避免把另一条链的数据当成这条链的返回：
+ * 比如 [钱包, 公共节点] 自动识别出钱包的链后，公共节点其实在另一条链上；或者配错了节点 URL。
+ *
+ * - 不一致时抛 NETWORK_ERROR（多节点时 FallbackRpc 会换下一个节点）
+ * - 通过已配置好的节点连接识别（带 Tron apiKey / 限流等），结果按来源缓存，每个节点只多一次请求
+ * - 识别与实际请求并行发出，不增加延迟；不一致时丢弃请求结果
+ * - 识别本身失败时不拦截（交给实际请求去报错），并在一段时间内不再重试，避免每次请求都多一次识别
+ */
+export class ChainCheckedProvider implements EthersLikeProvider {
+  #checkFailedAt = 0
+
+  constructor(
+    readonly inner: EthersLikeProvider,
+    readonly chainId: number,
+    readonly source: ProviderSource,
+    readonly timeout: number,
+  ) {}
+
+  async #check(): Promise<void> {
+    if (this.#checkFailedAt && Date.now() - this.#checkFailedAt < CHECK_RETRY_INTERVAL) {
+      return
+    }
+    let actual: number
+    try {
+      actual = await detectChainIdCached(this.source, () => detectViaNode(this.inner, this.source), this.timeout)
+    } catch {
+      this.#checkFailedAt = Date.now()
+      return
+    }
+    this.#checkFailedAt = 0
+    if (actual !== this.chainId) {
+      throw makeError(`chainId mismatch: expected ${this.chainId}, but the node is on ${actual}`, 'NETWORK_ERROR', {
+        event: 'chainIdMismatch',
+      })
+    }
+  }
+
+  async #run<T>(request: () => Promise<T>): Promise<T> {
+    const [checked, result] = await Promise.allSettled([this.#check(), request()])
+    if (checked.status === 'rejected') {
+      throw checked.reason
+    }
+    if (result.status === 'rejected') {
+      throw result.reason
+    }
+    return result.value
+  }
+
+  call(tx: TransactionRequest): Promise<string> {
+    return this.#run(() => this.inner.call(tx))
+  }
+
+  getBalance(...args: Parameters<EthersLikeProvider['getBalance']>): Promise<bigint> {
+    return this.#run(() => this.inner.getBalance(...args))
+  }
+
+  getBlockNumber(): Promise<number> {
+    const inner = this.inner
+    if (!inner.getBlockNumber) {
+      return Promise.reject(new Error('getBlockNumber is not supported by this node'))
+    }
+    return this.#run(() => (inner.getBlockNumber as () => Promise<number>)())
+  }
+
+  getLogs(filter: Parameters<NonNullable<EthersLikeProvider['getLogs']>>[0]): Promise<Awaited<ReturnType<NonNullable<EthersLikeProvider['getLogs']>>>> {
+    const inner = this.inner
+    if (!inner.getLogs) {
+      return Promise.reject(new Error('getLogs is not supported by this node'))
+    }
+    return this.#run(() => (inner.getLogs as NonNullable<EthersLikeProvider['getLogs']>)(filter))
+  }
+
+  async getChainId(): Promise<number> {
+    return this.chainId
+  }
+}
+
+/** 通过已创建的节点连接识别它实际所在的链 */
+function detectViaNode(node: EthersLikeProvider, source: ProviderSource): Promise<number> {
+  if (node instanceof TronProvider) {
+    return node.getChainId()
+  }
+  // JsonRpcProvider（staticNetwork）/ BrowserProvider（'any' 网络）的 getNetwork 不反映节点实际的链，直接问节点
+  if (node instanceof JsonRpcProvider) {
+    return node.send('eth_chainId', []).then(Number)
+  }
+  return detectChainId(source, Number.POSITIVE_INFINITY)
+}
+
+function withChainCheck(chainId: number, source: ProviderSource, node: EthersLikeProvider, timeout: number): EthersLikeProvider {
+  if (!Number.isFinite(chainId) || !canDetectChainId(source) || pinnedWallets.has(node)) {
+    return node
+  }
+  return new ChainCheckedProvider(node, chainId, source, timeout)
+}
+
+/** 由 EIP-1193 钱包创建、已固定在 chainId 上的 BrowserProvider（每次请求 ethers 都会校验链），不需要再包一层 */
+const pinnedWallets = new WeakSet<EthersLikeProvider>()
+
 function toEthersLike(chainId: number, source: ProviderSource, options: SourceOptions, multiple: boolean): EthersLikeProvider {
   if (typeof source === 'string') {
     if (isTronChain(chainId)) {
@@ -78,7 +187,13 @@ function toEthersLike(chainId: number, source: ProviderSource, options: SourceOp
     return TronProvider.fromTronWeb(source as TronWebLike, options.tron)
   }
   if (typeof value.request === 'function') {
-    return new BrowserProvider(source as Eip1193Provider)
+    // 传入 chainId：钱包当前所在的链与之不符时请求报 NETWORK_ERROR（network changed），
+    // 而不是静默返回另一条链的数据；在多节点列表里会据此自动切到下一个节点
+    const wallet = new BrowserProvider(source as Eip1193Provider, Number.isFinite(chainId) ? chainId : undefined)
+    if (Number.isFinite(chainId)) {
+      pinnedWallets.add(wallet)
+    }
+    return wallet
   }
   throw new Error('Unsupported provider: expected an RPC URL, an ethers Provider, an EIP-1193 provider or a tronWeb instance')
 }

package/src/tron.ts

@@ -62,7 +62,8 @@ function toTronHex(address: string): string {
 
 /** 只用到 tronWeb 的这几个字段，兼容 tronweb v5/v6 及钱包注入的实例 */
 export interface TronWebLike {
-  fullNode: { request: (url: string, payload: Record<string, unknown>, method: string) => Promise<any> }
+  /** host 是当前连接的全节点地址，TronLink 切换网络时会变，用于区分 chainId 缓存 */
+  fullNode: { request: (url: string, payload: Record<string, unknown>, method: string) => Promise<any>; host?: string }
   defaultAddress?: { base58?: string | false }
 }
 
@@ -85,6 +86,8 @@ export interface TronProviderOptions {
   minInterval?: number
   /** 遇到 HTTP 429 时的重试次数（指数退避，从 1s 开始）。默认 3 */
   retries?: number
+  /** 单次 HTTP 请求超时（毫秒，仅对内置 fetch 生效，自定义 request 自行处理）。默认 10000；<= 0 不限制 */
+  timeout?: number
   /** 不传 from 时使用的调用者地址；传函数则每次调用时取值（钱包切换账号后自动跟随） */
   defaultFrom?: string | (() => string | null | undefined)
 }
@@ -131,8 +134,14 @@ export class TronProvider implements EthersLikeProvider {
       if (options.apiKey) {
         headers['TRON-PRO-API-KEY'] = options.apiKey
       }
+      const timeout = options.timeout ?? 10_000
       this.#request = async (path, body) => {
-        const res = await fetch(`${host}/${path}`, { method: 'POST', headers, body: JSON.stringify(body) })
+        const res = await fetch(`${host}/${path}`, {
+          method: 'POST',
+          headers,
+          body: JSON.stringify(body),
+          signal: timeout > 0 && Number.isFinite(timeout) ? AbortSignal.timeout(timeout) : undefined,
+        })
         if (!res.ok) {
           throw new HttpError(`Tron request ${path} failed: HTTP ${res.status}`, res.status)
         }
@@ -202,6 +211,16 @@ export class TronProvider implements EthersLikeProvider {
     return output
   }
 
+  /** chainId = 创世区块哈希的最后 4 字节（与 TronGrid /jsonrpc 的 eth_chainId 一致，主网 728126428） */
+  async getChainId(): Promise<number> {
+    const res = await this.#limit(() => this.#request('wallet/getblockbynum', { num: 0 }))
+    const blockId = String(res?.blockID ?? '')
+    if (!/^[0-9a-f]{64}$/i.test(blockId)) {
+      throw new Error('Unable to detect Tron chainId: unexpected genesis block response')
+    }
+    return Number.parseInt(blockId.slice(-8), 16)
+  }
+
   async getBalance(address: unknown, blockTag?: unknown): Promise<bigint> {
     assertLatest(blockTag)
     const res = await this.#limit(() => this.#request('wallet/getaccount', { address: toTronHex(String(address)) }))

package/src/util.ts

@@ -0,0 +1,20 @@
+export class TimeoutError extends Error {
+  constructor(ms: number) {
+    super(`RPC request timed out after ${ms}ms`)
+    this.name = 'TimeoutError'
+  }
+}
+
+/** ms <= 0 或非有限值表示不限制 */
+export function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T> {
+  if (!Number.isFinite(ms) || ms <= 0) {
+    return promise
+  }
+  let timer: ReturnType<typeof setTimeout>
+  return Promise.race([
+    promise,
+    new Promise<never>((_, reject) => {
+      timer = setTimeout(() => reject(new TimeoutError(ms)), ms)
+    }),
+  ]).finally(() => clearTimeout(timer))
+}