viem 2.56.9 → 2.57.0

package/tempo/internal/relay/preflight.ts

@@ -0,0 +1,81 @@
+import type { Address } from 'abitype'
+import { VirtualAddress } from 'ox/tempo'
+import { call } from '../../../actions/public/call.js'
+import type { Client } from '../../../clients/createClient.js'
+import { zeroAddress } from '../../../constants/address.js'
+import { decodeAbiParameters } from '../../../utils/abi/decodeAbiParameters.js'
+import { encodeAbiParameters } from '../../../utils/abi/encodeAbiParameters.js'
+import { concat } from '../../../utils/data/concat.js'
+import * as Addresses from '../../Addresses.js'
+
+/** Reads fee preferences, balances, and virtual masters without dependent RPC requests. */
+export async function read(
+  client: Client,
+  options: {
+    account?: Address | undefined
+    tokens?: readonly Address[] | undefined
+    targets?: readonly Address[] | undefined
+  },
+) {
+  const { account = zeroAddress, tokens = [], targets = [] } = options
+  const masterIds = [
+    ...new Set(targets.map((target) => VirtualAddress.parse(target).masterId)),
+  ]
+  const { data } = await call(client, {
+    batch: false,
+    data: concat([
+      bytecode,
+      encodeAbiParameters(
+        [
+          { type: 'address' },
+          { type: 'address' },
+          { type: 'address[]' },
+          { type: 'address' },
+          { type: 'bytes4[]' },
+        ],
+        [
+          account,
+          Addresses.feeManager,
+          tokens,
+          Addresses.addressRegistry,
+          masterIds,
+        ],
+      ),
+    ]),
+  })
+  const [preferredToken, preferredBalance, balances, resolved, masters] =
+    decodeAbiParameters(
+      [
+        { type: 'address' },
+        { type: 'uint256' },
+        { type: 'uint256[]' },
+        { type: 'bool' },
+        { type: 'address[]' },
+      ],
+      data ?? '0x',
+    )
+  return {
+    preferredToken,
+    preferredBalance,
+    balances: tokens.map((address, index) => ({
+      address,
+      balance: balances[index]!,
+    })),
+    virtualAddresses:
+      resolved && targets.length > 0
+        ? (Object.fromEntries(
+            targets.map((target) => {
+              const master =
+                masters[
+                  masterIds.indexOf(VirtualAddress.parse(target).masterId)
+                ]!
+              return [target, master === zeroAddress ? null : master]
+            }),
+          ) as Record<Address, Address | null>)
+        : undefined,
+  }
+}
+
+// forge inspect contracts/src/deployless/RelayPreflight.sol:RelayPreflight bytecode --optimize --evm-version paris
+const bytecode =
+  '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'

package/tempo/internal/relay/request.ts

@@ -0,0 +1,391 @@
+import type { Address } from 'abitype'
+import { RpcResponse } from 'ox'
+import type { Transaction as core_Transaction } from 'ox/tempo'
+import { tempo } from '../../../chains/index.js'
+import { type Client, createClient } from '../../../clients/createClient.js'
+import { custom } from '../../../clients/transports/custom.js'
+import type * as Relay from '../../Relay.js'
+import * as Transaction from '../../Transaction.js'
+import * as Store from './cache.js'
+import * as Deadline from './deadline.js'
+import { formatError, isExecutionError } from './error.js'
+import { getDefaultTokens } from './feeToken.js'
+import * as Utils from './utils.js'
+import {
+  extractCalls,
+  getVirtualAddressTargets,
+  resolveVirtualAddresses,
+} from './virtualAddress.js'
+
+export type Result = {
+  tx: Record<string, unknown>
+  capabilities?: Record<string, unknown> | undefined
+  sponsor?: unknown
+}
+
+/** Compose middleware and execute post-fill hooks once for the selected result. */
+export function compose(
+  downstream: Relay.handleRequest.Handler,
+  options: Relay.handleRequest.Options = {},
+  resolveClient?: ((chainId: number) => { chain: { id: number } }) | undefined,
+): Relay.handleRequest.Handler {
+  const options_ = options
+  const plugins = options.plugins ?? []
+  if (plugins.length === 0) return downstream
+  if (plugins.filter((plugin) => plugin.signTransaction).length > 1)
+    throw new Error('Only one relay transaction signer may be configured.')
+
+  const handle: Relay.handleRequest.Handler = async (
+    request,
+    requestOptions = {},
+  ) => {
+    const stores = new Map<Store.Store, Store.Store>()
+    const tokens = new Map<number, Promise<readonly Address[]>>()
+    const scoped = (store: Store.Store | undefined) => {
+      if (!store) return undefined
+      let result = stores.get(store)
+      if (!result) {
+        result = Store.scoped(store)!
+        stores.set(store, result)
+      }
+      return result
+    }
+
+    const execute = async (
+      start: number,
+      request: Relay.handleRequest.Request,
+      options: Relay.handleRequest.RequestOptions,
+    ) => {
+      const state = {
+        request,
+        options: { ...options },
+        result: undefined as unknown,
+      }
+      const contexts = new Map<number, Relay.Plugin.Context>()
+      const contextAt = (index: number): Relay.Plugin.Context => {
+        const existing = contexts.get(index)
+        if (existing) return existing
+        const clients = new Map<number, Client>()
+        const chainId = (id = state.options.chainId) => {
+          if (id === undefined || !Number.isSafeInteger(id) || id <= 0)
+            throw new RpcResponse.InvalidParamsError({
+              message:
+                'A chain ID is required to resolve the downstream client.',
+            })
+          return id
+        }
+        const context: Relay.Plugin.Context = {
+          get request() {
+            return state.request
+          },
+          set request(value) {
+            state.request = value
+          },
+          get result() {
+            return state.result
+          },
+          set result(value) {
+            state.result = value
+          },
+          get options() {
+            return state.options
+          },
+          set options(value) {
+            state.options = value
+          },
+          get client() {
+            return context.getClient()
+          },
+          getClient(id_) {
+            const id = chainId(id_)
+            let client = clients.get(id)
+            if (client) return client
+            const upstream = resolveClient?.(id)
+            if (upstream?.chain && upstream.chain.id !== id)
+              throw new RpcResponse.InvalidParamsError({
+                message: 'Conflicting chain ids.',
+              })
+            client = createClient({
+              chain: { ...tempo, ...upstream?.chain, id },
+              batch: { multicall: { deployless: true } },
+              transport: (config) => {
+                const transport = custom(
+                  {
+                    request: async (request, options) => {
+                      const child = await execute(index + 1, request, {
+                        ...state.options,
+                        ...options,
+                        chainId: id,
+                      })
+                      return child.state.result
+                    },
+                  },
+                  { retryCount: 0 },
+                )(config)
+                // Forward request options without adding a retry loop around downstream I/O.
+                return { ...transport, request: transport.config.request }
+              },
+            })
+            clients.set(id, client)
+            return client
+          },
+          async resolveTokens(id_) {
+            const id = chainId(id_)
+            let result = tokens.get(id)
+            if (!result) {
+              result = Promise.resolve().then(() =>
+                (options_.resolveTokens ?? getDefaultTokens)(id),
+              )
+              tokens.set(id, result)
+            }
+            return result
+          },
+          getStore: scoped,
+        }
+        contexts.set(index, context)
+        return context
+      }
+      const dispatch = async (index: number): Promise<void> => {
+        if (index === plugins.length) {
+          const parameters = state.request.params?.[0] as
+            | Record<string, unknown>
+            | undefined
+          // The node must estimate unsigned sponsorship independently of the sender's fee-token balance.
+          const request =
+            state.request.method === 'eth_fillTransaction' &&
+            parameters?.feePayer === true &&
+            !parameters.feePayerSignature
+              ? {
+                  ...state.request,
+                  params: [{ ...parameters, feeToken: undefined }],
+                }
+              : state.request
+          requestOptions.signal?.throwIfAborted()
+          state.result = await downstream(request, {
+            ...state.options,
+            ...(isFill ? { signal: requestOptions.signal } : {}),
+          })
+          return
+        }
+        const plugin = plugins[index]!
+        const context = contextAt(index)
+        if (!plugin.handleRequest) return dispatch(index + 1)
+        let called = false
+        const result = await plugin.handleRequest(context, async () => {
+          if (called)
+            throw new Error(
+              'next() may only be called once per middleware invocation.',
+            )
+          called = true
+          await dispatch(index + 1)
+        })
+        if (result !== undefined) state.result = result
+      }
+      await dispatch(start)
+      return { state, contextAt }
+    }
+
+    const isFill = request.method === 'eth_fillTransaction'
+    const isRaw = [
+      'eth_signRawTransaction',
+      'eth_sendRawTransaction',
+      'eth_sendRawTransactionSync',
+    ].includes(request.method)
+    const parameters = request.params?.[0] as Record<string, unknown>
+    let root: Awaited<ReturnType<typeof execute>> | undefined
+    try {
+      requestOptions.signal?.throwIfAborted()
+      if (
+        isFill &&
+        (!parameters ||
+          typeof parameters !== 'object' ||
+          Array.isArray(parameters))
+      )
+        throw new RpcResponse.InvalidParamsError({
+          message: 'Expected a transaction object.',
+        })
+      if (isFill) Utils.normalizeFillTransactionRequest(parameters)
+      const bodyChainId = (() => {
+        if (isRaw && Utils.isSerializedTempoTransaction(request.params?.[0])) {
+          try {
+            return Transaction.deserialize(request.params[0]).chainId
+          } catch {
+            throw new RpcResponse.InvalidParamsError({
+              message: 'Invalid serialized Tempo transaction.',
+            })
+          }
+        }
+        if (!isFill || parameters.chainId === undefined) return undefined
+        const id = Utils.resolveChainId(parameters.chainId)
+        if (id === undefined || !Number.isSafeInteger(id) || id <= 0)
+          throw new RpcResponse.InvalidParamsError({
+            message: 'Invalid transaction chain ID.',
+          })
+        return id
+      })()
+      if (
+        bodyChainId !== undefined &&
+        requestOptions.chainId !== undefined &&
+        bodyChainId !== requestOptions.chainId
+      )
+        throw new RpcResponse.InvalidParamsError({
+          message: 'Conflicting chain ids.',
+        })
+      root = await execute(0, request, {
+        ...requestOptions,
+        ...((requestOptions.chainId ?? bodyChainId) !== undefined
+          ? { chainId: requestOptions.chainId ?? bodyChainId }
+          : {}),
+      })
+      if (!isFill) return root.state.result
+      const filled = root.state.result as Result
+      if (filled.capabilities?.error) return filled
+      const transaction = Utils.normalizeTempoTransaction(
+        Utils.mergeCallsFromRequest(
+          filled.tx,
+          Utils.normalizeFillTransactionRequest(parameters),
+        ),
+      )
+      const final: Result = {
+        ...filled,
+        tx: Utils.formatTempoTransaction(
+          transaction as core_Transaction.Transaction,
+        ),
+      }
+      const snapshot = freeze(structuredClone(final))
+      const targets = getVirtualAddressTargets(extractCalls(transaction))
+      const resolved = final.capabilities?.virtualAddresses as
+        | Record<Address, Address | null>
+        | undefined
+      const [patches, signatures, virtualAddresses] = await Promise.all([
+        Promise.all(
+          plugins.map((plugin, index) =>
+            plugin.afterFill?.(snapshot, root!.contextAt(index)),
+          ),
+        ),
+        Promise.all(
+          plugins.map((plugin, index) =>
+            plugin.signTransaction?.(snapshot, root!.contextAt(index)),
+          ),
+        ),
+        targets.length > 0 &&
+        !targets.every((target) => resolved && target in resolved)
+          ? resolveVirtualAddresses(root.contextAt(-1).client, {
+              calls: extractCalls(transaction),
+            }).catch(() => {
+              requestOptions.signal?.throwIfAborted()
+              return undefined
+            })
+          : undefined,
+      ])
+      requestOptions.signal?.throwIfAborted()
+      const capabilities = { ...final.capabilities }
+      const keys = new Set<string>()
+      for (const patch of patches) {
+        for (const [key, value] of Object.entries(patch?.capabilities ?? {})) {
+          if (keys.has(key))
+            throw new Error(`Conflicting relay capability: ${key}.`)
+          keys.add(key)
+          capabilities[key] = value
+        }
+      }
+      const signature = signatures.find((signature) => signature !== undefined)
+      if (signature) {
+        delete final.tx.signature
+        final.tx.feePayerSignature = signature
+      }
+      const sponsor = capabilities.sponsor ?? final.sponsor
+      return {
+        ...final,
+        capabilities: {
+          sponsored: !!sponsor,
+          ...capabilities,
+          ...(virtualAddresses ? { virtualAddresses } : {}),
+        },
+      }
+    } catch (error) {
+      requestOptions.signal?.throwIfAborted()
+      if (
+        isFill &&
+        isExecutionError(error) &&
+        (parameters.capabilities as Record<string, unknown> | undefined)
+          ?.errors === true
+      ) {
+        // Resolve errors through a downstream-only client; never restart the plugin pipeline.
+        const id =
+          requestOptions.chainId ?? Utils.resolveChainId(parameters.chainId)
+        const client = createClient({
+          chain: { ...tempo, id: id ?? tempo.id },
+          transport: custom(
+            {
+              request: (request, options) =>
+                downstream(request, {
+                  ...requestOptions,
+                  ...options,
+                  chainId: id,
+                  signal: requestOptions.signal,
+                }),
+            },
+            { retryCount: 0 },
+          ),
+        })
+        return formatError(error, parameters, client)
+      }
+      if (!isFill && !isRaw) throw error
+      throw Utils.toRpcError(error)
+    }
+  }
+  if (
+    options.timeout !== undefined &&
+    (!Number.isSafeInteger(options.timeout) || options.timeout <= 0)
+  )
+    throw new RpcResponse.InvalidParamsError({
+      message: 'Expected a positive integer for timeout.',
+    })
+  if (options.timeout !== undefined && options.timeout > 2_147_483_647)
+    throw new RpcResponse.InvalidParamsError({
+      message: 'The fill timeout cannot exceed 2147483647 milliseconds.',
+    })
+  return (request, requestOptions = {}) =>
+    request.method === 'eth_fillTransaction'
+      ? Deadline.run(handle, request, requestOptions, options)
+      : handle(request, requestOptions)
+}
+
+/** Prevent hooks from mutating the transaction another hook signs. */
+function freeze<value>(value: value): value {
+  if (value && typeof value === 'object') {
+    for (const child of Object.values(value)) freeze(child)
+    Object.freeze(value)
+  }
+  return value
+}
+
+/** Normalize a downstream fill without discarding capabilities added by other plugins. */
+export async function fill(
+  client: Client,
+  transaction: Record<string, unknown>,
+  options: Relay.handleRequest.RequestOptions = {},
+): Promise<Result> {
+  const formatted = Utils.formatFillTransactionRequest(client, transaction)
+  const result = (await client.request(
+    {
+      method: 'eth_fillTransaction',
+      params: [formatted as never],
+    },
+    options,
+  )) as unknown as Result
+
+  const error = result.capabilities?.error as
+    | { message?: string; errorName?: string; data?: `0x${string}` }
+    | undefined
+  if (error) {
+    const cause = new Error(
+      error.message ?? error.errorName ?? 'UpstreamRevert',
+    )
+    Object.assign(cause, { name: 'UpstreamRevertError', data: error.data })
+    throw cause
+  }
+
+  return { ...result, tx: Utils.mergeCallsFromRequest(result.tx, transaction) }
+}