viem 3.0.0-next.10 → 3.0.0-next.13

package/src/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/src/tempo/internal/relay/error.ts

@@ -0,0 +1,129 @@
+import type { Address } from 'abitype'
+import { Hex } from 'ox'
+import type { Client } from '../../../core/Client.js'
+import { format as formatUnits } from 'ox/Value'
+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
+}
+
+const zeroAddress = '0x0000000000000000000000000000000000000000'
+
+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 } : {}),
+    },
+  }
+}