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

package/src/tempo/internal/relay/plugin.ts

@@ -0,0 +1,13 @@
+import type * as Relay from '../../Relay.js'
+
+const multisigPlugins = new WeakSet<Relay.Plugin>()
+
+/** Registers the built-in multisig plugin for transport capability detection. */
+export function multisig(plugin: Relay.Plugin): Relay.multisig.ReturnType {
+  multisigPlugins.add(plugin)
+  return plugin as Relay.multisig.ReturnType
+}
+
+export function isMultisig(plugin: Relay.Plugin): boolean {
+  return multisigPlugins.has(plugin)
+}

package/src/tempo/internal/relay/preflight.ts

@@ -0,0 +1,83 @@
+import type { Address } from 'abitype'
+import { VirtualAddress } from 'ox/tempo'
+import { call } from '../../../core/actions/call.js'
+import type { Client } from '../../../core/Client.js'
+const zeroAddress = '0x0000000000000000000000000000000000000000'
+import {
+  decode as decodeAbiParameters,
+  encode as encodeAbiParameters,
+} from 'ox/AbiParameters'
+import * as Hex from 'ox/Hex'
+import * as Addresses from '../../Addresses.js'
+
+/** Reads fee preferences, liquid fee-token balances, and virtual masters in one RPC request. */
+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: Hex.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 --root contracts src/deployless/RelayPreflight.sol:RelayPreflight bytecode --optimize --evm-version paris
+const bytecode =
+  '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'

package/src/tempo/internal/relay/request.ts

@@ -0,0 +1,401 @@
+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, create as createClient } from '../../../core/Client.js'
+import type * as Relay from '../../Relay.js'
+import * as Transaction from 'ox/tempo/TxEnvelopeTempo'
+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: {
+                key: 'relay-forward',
+                name: 'Relay Forwarding',
+                type: 'relay-forward',
+                setup: () => ({
+                  retryCount: 0,
+                  request: (async (
+                    request: Relay.handleRequest.Request,
+                    options?: Relay.handleRequest.RequestOptions,
+                  ) => {
+                    const child = await execute(
+                      index + 1,
+                      request as Relay.handleRequest.Request,
+                      {
+                        ...state.options,
+                        ...options,
+                        chainId: id,
+                      },
+                    )
+                    return child.state.result
+                  }) as Client['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: {
+            key: 'relay-error',
+            name: 'Relay Error Enrichment',
+            type: 'relay-error',
+            setup: () => ({
+              request: ((
+                request: Relay.handleRequest.Request,
+                options?: Relay.handleRequest.RequestOptions,
+              ) =>
+                downstream(request, {
+                  ...requestOptions,
+                  ...options,
+                  chainId: id,
+                  signal: requestOptions.signal,
+                })) as Client['request'],
+            }),
+          },
+        })
+        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) }
+}