viem 2.56.9 → 2.57.0

package/tempo/internal/relay/cache.ts

@@ -0,0 +1,82 @@
+import { withTimeout } from '../../../utils/promise/withTimeout.js'
+import type * as Store_ from '../../Store.js'
+
+export type Store = Store_.Store
+
+// Scope in-flight work to one request so Workers never share request-owned I/O.
+const flights = new WeakMap<Store, Map<string, Promise<unknown>>>()
+const prefix = 'viem:relay:cache:'
+
+export function scoped(store: Store | undefined): Store | undefined {
+  if (!store) return undefined
+  return {
+    getItem: (key) => store.getItem(key),
+    setItem: (key, value) => store.setItem(key, value),
+    removeItem: (key) => store.removeItem(key),
+  }
+}
+
+export async function memoize<value>(
+  fetch: () => Promise<value>,
+  options: { key: string; store: Store; ttl: number },
+): Promise<value> {
+  const { store, ttl } = options
+  const key = `${prefix}${options.key}`
+  let active = true
+  const timeoutError = new Error('Relay cache operation timed out.')
+  return withTimeout(
+    async () => {
+      const raw = await store.getItem(key)
+      if (!active) throw timeoutError
+      if (raw) {
+        try {
+          const entry = JSON.parse(raw, (_key, item) => {
+            if (typeof item !== 'string' || !item.startsWith(prefix))
+              return item
+            if (item.startsWith(`${prefix}string:`))
+              return item.slice(`${prefix}string:`.length)
+            if (item.startsWith(`${prefix}bigint:`))
+              return BigInt(item.slice(`${prefix}bigint:`.length))
+            throw new TypeError('Invalid relay cache value.')
+          }) as { value: value; expiresAt: number }
+          if (entry.expiresAt > Date.now()) return entry.value
+        } catch {
+          // Refresh malformed or older entries.
+        }
+      }
+      let pending = flights.get(store)
+      if (!pending) {
+        pending = new Map()
+        flights.set(store, pending)
+      }
+      const existing = pending.get(key)
+      if (existing) return existing as Promise<value>
+      const result = (async () => {
+        const value = await fetch()
+        if (!active) throw timeoutError
+        if (value !== undefined)
+          await store.setItem(
+            key,
+            JSON.stringify(
+              { value, expiresAt: Date.now() + ttl },
+              (_key, item) => {
+                if (typeof item === 'bigint') return `${prefix}bigint:${item}`
+                if (typeof item === 'string' && item.startsWith(prefix))
+                  return `${prefix}string:${item}`
+                return item
+              },
+            ),
+          )
+        return value
+      })().finally(() => pending.delete(key))
+      pending.set(key, result)
+      return result
+    },
+    {
+      timeout: 30_000,
+      errorInstance: timeoutError,
+    },
+  ).finally(() => {
+    active = false
+  })
+}

package/tempo/internal/relay/deadline.ts

@@ -0,0 +1,45 @@
+import { RpcResponse } from 'ox'
+import type * as Relay from '../../Relay.js'
+
+/** Bounds the complete fill, including callbacks that do not observe abort signals. */
+export async function run(
+  handler: Relay.handleRequest.Handler,
+  request: Relay.handleRequest.Request,
+  options: Relay.handleRequest.RequestOptions,
+  config: Relay.handleRequest.Options,
+) {
+  const controller = new AbortController()
+  const abort = () => controller.abort(options.signal?.reason)
+  options.signal?.addEventListener('abort', abort, { once: true })
+  if (options.signal?.aborted) abort()
+  const timeout = setTimeout(
+    () =>
+      controller.abort(
+        new RpcResponse.LimitExceededError({
+          message: 'Relay fill exceeded its deadline.',
+        }),
+      ),
+    config.timeout ?? 10_000,
+  )
+  const signal = controller.signal
+
+  let rejectAbort!: (reason: unknown) => void
+  const aborted = new Promise<never>((_, reject) => {
+    rejectAbort = reject
+  })
+  const onAbort = () => rejectAbort(signal.reason)
+  signal.addEventListener('abort', onAbort, { once: true })
+  try {
+    signal.throwIfAborted()
+    return await Promise.race([
+      handler(request, { ...options, signal }),
+      aborted,
+    ])
+  } finally {
+    clearTimeout(timeout)
+    options.signal?.removeEventListener('abort', abort)
+    signal.removeEventListener('abort', onAbort)
+    // Prevent timed-out hooks from dispatching additional I/O after the response completes.
+    controller.abort()
+  }
+}

package/tempo/internal/relay/error.ts

@@ -0,0 +1,128 @@
+import type { Address } from 'abitype'
+import { Hex } from 'ox'
+import type { Client } from '../../../clients/createClient.js'
+import { zeroAddress } from '../../../constants/address.js'
+import { formatUnits } from '../../../utils/unit/formatUnits.js'
+import * as ExecutionError from '../../ExecutionError.js'
+import type * as Store from './cache.js'
+import { resolveTokenMetadata } from './feeToken.js'
+import { simulateAndParseDiffs } from './simulate.js'
+import * as Utils from './utils.js'
+import { extractCalls, resolveVirtualAddresses } from './virtualAddress.js'
+
+/** Distinguishes execution reverts from transport and plugin failures. */
+export function isExecutionError(error: unknown): error is Error {
+  if (!(error instanceof Error)) return false
+
+  const seen = new Set<unknown>()
+  const pending: unknown[] = [error]
+  while (pending.length) {
+    const current = pending.pop()
+    if (!current || typeof current !== 'object' || seen.has(current)) continue
+    seen.add(current)
+
+    const candidate = current as Record<string, unknown>
+    if (
+      candidate.code === 3 ||
+      candidate.name === 'UpstreamRevertError' ||
+      candidate.name === 'ExecutionRevertedError' ||
+      candidate.name === 'ContractFunctionRevertedError' ||
+      [candidate.message, candidate.details].some(
+        (message) =>
+          typeof message === 'string' && /^execution reverted\b/i.test(message),
+      )
+    )
+      return true
+
+    pending.push(candidate.cause, candidate.error)
+  }
+  return false
+}
+
+export async function formatError(
+  error: Error,
+  parameters: Record<string, unknown>,
+  client: Client,
+  simulateStore?: Store.Store,
+) {
+  const revert = ExecutionError.from(error)
+
+  const stub = {
+    from: parameters.from,
+    to: parameters.to ?? null,
+    gas: '0x0',
+    nonce: '0x0',
+    value: '0x0',
+    maxFeePerGas: '0x0',
+    maxPriorityFeePerGas: '0x0',
+  }
+
+  if (revert.errorName === 'InsufficientBalance' && revert.args?.length === 3) {
+    const [available, required, token] = revert.args
+
+    const normalized = Utils.normalizeFillTransactionRequest(parameters)
+
+    // Simulate from zero address for optimistic balance diffs.
+    const optimisticCalls = normalized ? extractCalls(normalized) : undefined
+    const [{ balanceDiffs, tokenMetadata }, virtualAddresses] = optimisticCalls
+      ? await Promise.all([
+          simulateAndParseDiffs(client, {
+            account: zeroAddress,
+            calls: optimisticCalls,
+            store: simulateStore,
+          }),
+          resolveVirtualAddresses(client, { calls: optimisticCalls }).catch(
+            () => undefined,
+          ),
+        ])
+      : [{ balanceDiffs: undefined, tokenMetadata: undefined }, undefined]
+
+    // Re-key balance diffs from zero address to the real sender.
+    const senderDiffs =
+      parameters.from && balanceDiffs
+        ? { [parameters.from as Address]: balanceDiffs[zeroAddress] ?? [] }
+        : balanceDiffs
+
+    const metadata = await resolveTokenMetadata(client, {
+      token,
+      tokenMetadata,
+      store: simulateStore,
+    }).catch(() => undefined)
+    const deficit = required - available
+
+    return {
+      tx: stub,
+      capabilities: {
+        balanceDiffs: senderDiffs,
+        error: ExecutionError.serialize(revert),
+        insufficientFunds: metadata
+          ? {
+              amount: Hex.fromNumber(deficit) as `0x${string}`,
+              decimals: metadata.decimals,
+              formatted: formatUnits(deficit, metadata.decimals),
+              token,
+              symbol: metadata.symbol,
+            }
+          : undefined,
+        sponsored: false,
+        ...(virtualAddresses ? { virtualAddresses } : {}),
+      },
+    }
+  }
+
+  const normalized = Utils.normalizeFillTransactionRequest(parameters)
+  const virtualAddresses = normalized
+    ? await resolveVirtualAddresses(client, {
+        calls: extractCalls(normalized),
+      }).catch(() => undefined)
+    : undefined
+
+  return {
+    tx: stub,
+    capabilities: {
+      error: ExecutionError.serialize(revert),
+      sponsored: false,
+      ...(virtualAddresses ? { virtualAddresses } : {}),
+    },
+  }
+}