viem 2.57.4 → 2.57.6

package/tempo/internal/relay/feePayer.ts

@@ -419,7 +419,7 @@ async function handleRawTransaction(options: handleRawTransaction.Options) {
     })
 
   const transaction = Transaction.deserialize(serialized)
-  // Prefer sender recovered from raw envelope; multisig finalize path supplies fallback sender.
+  // Prefer sender recovered from raw envelope; configurable account finalize path supplies fallback sender.
   const sender = transaction.from ?? options.sender
 
   // Sponsorship only applies after sender has signed original transaction.

package/tempo/internal/relay/keyAuthorization.ts

@@ -0,0 +1,415 @@
+import type { Address } from 'abitype'
+import * as RpcResponse from 'ox/RpcResponse'
+import {
+  AccountConfig,
+  AccountOperation,
+  KeyAuthorization,
+  SignatureEnvelope,
+} from 'ox/tempo'
+import { getBlockNumber } from '../../../actions/public/getBlockNumber.js'
+import type { Client } from '../../../clients/createClient.js'
+import { BaseError } from '../../../errors/base.js'
+import { isAddressEqual } from '../../../utils/address/isAddressEqual.js'
+import * as Actions from '../../actions/index.js'
+import type * as Relay from '../../Relay.js'
+import * as Store from '../../Store.js'
+import { selectApprovals, validateConfig } from './accounts.js'
+import * as Plugin from './plugin.js'
+
+/** Creates middleware that stores pending key authorizations and attaches them to fills. @internal */
+export function create(
+  options: Relay.keyAuthorization.Options = {},
+): Relay.keyAuthorization.ReturnType {
+  const { store = Store.memory() } = options
+  if (!store.compareAndSet)
+    throw new RpcResponse.InvalidParamsError({
+      message:
+        'Key authorization storage requires a store with atomic `compareAndSet`.',
+    })
+  return Plugin.keyAuthorization({
+    async handleRequest(context, next) {
+      const { request } = context
+
+      if (request.method === 'relay_saveKeyAuthorization') {
+        const keyAuthorization = parse(request.params?.[0])
+        const chainId = Number(keyAuthorization.chainId)
+        if (
+          context.options.chainId !== undefined &&
+          context.options.chainId !== chainId
+        )
+          throw new RpcResponse.InvalidParamsError({
+            message: 'Conflicting chain ids.',
+          })
+        const client = context.getClient(chainId)
+        const account = await check(client, keyAuthorization)
+        if (!account) return null
+        // Drop an unusable pending authorization so it cannot block this one.
+        await read(client, store, {
+          account,
+          accessKey: keyAuthorization.address,
+          chainId,
+        })
+        if (!(await write(store, { account, keyAuthorization })))
+          throw new RpcResponse.InvalidParamsError({
+            message:
+              'A pending key authorization for this access key expires later.',
+          })
+        return null
+      }
+
+      if (request.method === 'account_approveKeyAuthorization') {
+        await next()
+        const operation = AccountOperation.fromRpc(
+          context.result as AccountOperation.Rpc,
+        ) as AccountOperation.KeyAuthorizationOperation
+        if (operation.status !== 'success') return
+        const keyAuthorization = KeyAuthorization.deserialize(
+          operation.keyAuthorization,
+        ) as KeyAuthorization.Signed
+        // Re-check completed operations: quorum may land after expiry, and a
+        // stored success may predate a config rotation. The approval itself
+        // succeeded, so an authorization that fails these checks, or loses to a
+        // newer pending one, is skipped rather than reported. Operational
+        // failures propagate so callers know storage did not complete.
+        const chainId = Number(keyAuthorization.chainId)
+        const client = context.getClient(chainId)
+        const account = await check(client, keyAuthorization).catch((error) => {
+          if (error instanceof RpcResponse.InvalidParamsError) return undefined
+          throw error
+        })
+        if (!account) return
+        await read(client, store, {
+          account,
+          accessKey: keyAuthorization.address,
+          chainId,
+        })
+        await write(store, { account, keyAuthorization })
+        return
+      }
+
+      if (request.method !== 'eth_fillTransaction') return next()
+
+      const parameters = request.params?.[0] as Record<string, unknown>
+      const { from: account, keyId: accessKey } = parameters
+      if (
+        parameters.keyAuthorization ||
+        typeof account !== 'string' ||
+        typeof accessKey !== 'string'
+      )
+        return next()
+
+      const pending = await read(context.client, store, {
+        account: account as Address,
+        accessKey: accessKey as Address,
+        chainId: context.options.chainId!,
+      })
+      if (!pending) return next()
+      const metadata = await Actions.accessKey.getMetadata(context.client, {
+        account: account as Address,
+        accessKey: accessKey as Address,
+      })
+      // The key already landed onchain, so the authorization is spent.
+      if (isActive(metadata, accessKey as Address)) {
+        await remove(store, pending)
+        return next()
+      }
+      const keyAuthorization = KeyAuthorization.toRpc(pending.keyAuthorization)
+
+      // Attach before forwarding so gas estimation and later plugins see the authorization.
+      context.request = {
+        ...request,
+        params: [{ ...parameters, keyAuthorization }],
+      }
+      return next()
+    },
+  })
+}
+
+/** Parses a signed key authorization from RPC parameters. */
+function parse(value: unknown) {
+  const keyAuthorization = (() => {
+    try {
+      if (typeof value === 'string')
+        return KeyAuthorization.deserialize(value as `0x${string}`)
+      return KeyAuthorization.fromRpc(value as KeyAuthorization.Rpc)
+    } catch {
+      return undefined
+    }
+  })()
+  if (!keyAuthorization?.signature)
+    throw new RpcResponse.InvalidParamsError({
+      message: 'Expected a signed key authorization.',
+    })
+  return keyAuthorization as KeyAuthorization.Signed
+}
+
+/**
+ * Validates an authorization and returns the account it authorizes, or `undefined`
+ * when the access key is already active onchain.
+ */
+async function check(
+  client: Client,
+  keyAuthorization: KeyAuthorization.Signed,
+): Promise<Address | undefined> {
+  if (isExpired(keyAuthorization))
+    throw new RpcResponse.InvalidParamsError({
+      message: 'Key authorization has expired.',
+    })
+  const account = await verify(client, keyAuthorization)
+  if (await isBurned(client, { account, keyAuthorization }))
+    throw new RpcResponse.InvalidParamsError({
+      message: 'Key authorization witness has been burned.',
+    })
+  // Authorizations for keys that are already active would only be removed on the next fill.
+  const metadata = await Actions.accessKey.getMetadata(client, {
+    account,
+    accessKey: keyAuthorization.address,
+  })
+  if (isActive(metadata, keyAuthorization.address)) return undefined
+  return account
+}
+
+/** Verifies the authorization signature and returns the account it authorizes. */
+async function verify(
+  client: Client,
+  keyAuthorization: KeyAuthorization.Signed,
+): Promise<Address> {
+  const { signature, ...unsigned } = keyAuthorization
+  const payload = KeyAuthorization.getSignPayload(unsigned)
+
+  if (signature.type === 'configurable') {
+    if (
+      !keyAuthorization.account ||
+      !isAddressEqual(keyAuthorization.account, signature.account)
+    )
+      throw new RpcResponse.InvalidParamsError({
+        message:
+          'Configurable account key authorization account does not match its signature.',
+      })
+    const config = AccountConfig.from(signature.config)
+    await validateConfig({
+      account: signature.account,
+      blockNumber: await getBlockNumber(client, { cacheTime: 0 }),
+      client: client as never,
+      config,
+    })
+    const approvals = await selectApprovals({
+      account: signature.account,
+      approvals: signature.signatures.map((signature) =>
+        SignatureEnvelope.serialize(signature),
+      ),
+      config,
+      hash: AccountConfig.getSignPayload({
+        account: signature.account,
+        config,
+        payload,
+      }),
+    })
+    if (approvals.weight < approvals.threshold)
+      throw new RpcResponse.InvalidParamsError({
+        message:
+          'Configurable account key authorization has not reached quorum.',
+      })
+    return signature.account
+  }
+
+  const signer = (() => {
+    try {
+      const signer = SignatureEnvelope.extractAddress({ payload, signature })
+      if (SignatureEnvelope.verify(signature, { address: signer, payload }))
+        return signer
+    } catch {}
+    throw new RpcResponse.InvalidParamsError({
+      message: 'Invalid key authorization signature.',
+    })
+  })()
+
+  // Admin-signed authorizations can only be submitted by the admin key itself,
+  // so only authorizations signed by the account can be attached for the new key.
+  if (
+    keyAuthorization.account &&
+    !isAddressEqual(keyAuthorization.account, signer)
+  )
+    throw new RpcResponse.InvalidParamsError({
+      message: 'Key authorization must be signed by its account.',
+    })
+  return signer
+}
+
+/**
+ * Reads the pending authorization for an access key. Entries that are malformed,
+ * expired, or whose witness has been burned are removed.
+ */
+async function read(
+  client: Client,
+  store: Store.Atomic,
+  options: { account: Address; accessKey: Address; chainId: number },
+) {
+  const { account } = options
+  const key = getKey(options)
+  const value = await store.getItem(key)
+  if (!value) return undefined
+  const keyAuthorization = (() => {
+    try {
+      return KeyAuthorization.deserialize(
+        value as `0x${string}`,
+      ) as KeyAuthorization.Signed
+    } catch {
+      return undefined
+    }
+  })()
+  if (
+    keyAuthorization &&
+    !isExpired(keyAuthorization) &&
+    (await isVerified(client, keyAuthorization)) &&
+    !(await isBurned(client, { account, keyAuthorization }))
+  )
+    return { key, keyAuthorization, value }
+  await remove(store, { key, value })
+  return undefined
+}
+
+/**
+ * Removes a stored authorization only while it still holds the value that was read,
+ * so a concurrently saved replacement survives. The empty value expires immediately.
+ * @internal
+ */
+export async function remove(
+  store: Store.Atomic,
+  options: { key: string; value: string },
+) {
+  const { key, value } = options
+  await store.compareAndSet(key, value, '', { expiresAt: Date.now() })
+}
+
+/**
+ * Returns whether the authorization still verifies, such as after a configurable
+ * account rotates its config. Operational failures propagate.
+ */
+async function isVerified(
+  client: Client,
+  keyAuthorization: KeyAuthorization.Signed,
+) {
+  try {
+    await verify(client, keyAuthorization)
+    return true
+  } catch (error) {
+    if (error instanceof RpcResponse.InvalidParamsError) return false
+    throw error
+  }
+}
+
+/** Returns whether the authorization's witness has been burned onchain. */
+async function isBurned(
+  client: Client,
+  options: { account: Address; keyAuthorization: KeyAuthorization.Signed },
+) {
+  const { account, keyAuthorization } = options
+  if (!keyAuthorization.witness) return false
+  return Actions.accessKey.isWitnessBurned(client, {
+    account,
+    witness: keyAuthorization.witness,
+  })
+}
+
+/**
+ * Stores an authorization unless a pending authorization for the same key expires
+ * later, so a replayed older authorization cannot replace a newer one.
+ * @internal
+ */
+export async function write(
+  store: Store.Atomic,
+  options: {
+    account: Address
+    keyAuthorization: KeyAuthorization.Signed
+  },
+): Promise<boolean> {
+  const { account, keyAuthorization } = options
+  const key = getKey({
+    account,
+    accessKey: keyAuthorization.address,
+    chainId: Number(keyAuthorization.chainId),
+  })
+  const value = KeyAuthorization.serialize(keyAuthorization)
+  const expiresAt = Math.min(
+    Date.now() + maxTtl,
+    getExpiry(keyAuthorization) * 1_000,
+  )
+  for (let attempt = 0; attempt < maxWriteAttempts; attempt++) {
+    const current = (await store.getItem(key)) ?? null
+    const existing = (() => {
+      if (!current) return undefined
+      try {
+        return KeyAuthorization.deserialize(current as `0x${string}`)
+      } catch {
+        return undefined
+      }
+    })()
+    if (existing && current!.toLowerCase() === value.toLowerCase()) return true
+    if (existing && getExpiry(existing) >= getExpiry(keyAuthorization))
+      return false
+    // A lost compare-and-set means another writer replaced the value, so compare again.
+    if (await store.compareAndSet(key, current, value, { expiresAt }))
+      return true
+  }
+  throw new StoreConflictError()
+}
+
+/** Maximum compare-and-set attempts before a write is abandoned. */
+const maxWriteAttempts = 32
+
+/** Maximum time a pending key authorization is kept. */
+const maxTtl = 30 * 24 * 60 * 60 * 1_000
+
+/** Returns the authorization expiry in seconds, treating no expiry as unbounded. */
+function getExpiry(keyAuthorization: KeyAuthorization.KeyAuthorization) {
+  const { expiry } = keyAuthorization
+  return expiry === undefined || expiry === null
+    ? Number.POSITIVE_INFINITY
+    : Number(expiry)
+}
+
+/** Returns whether the access key is active onchain. */
+function isActive(
+  metadata: Actions.accessKey.getMetadata.ReturnValue,
+  accessKey: Address,
+) {
+  return (
+    isAddressEqual(metadata.address, accessKey) &&
+    !metadata.isRevoked &&
+    metadata.expiry > BigInt(Math.floor(Date.now() / 1000))
+  )
+}
+
+function isExpired(keyAuthorization: KeyAuthorization.KeyAuthorization) {
+  const { expiry } = keyAuthorization
+  return (
+    expiry !== undefined &&
+    expiry !== null &&
+    BigInt(expiry) <= BigInt(Math.floor(Date.now() / 1000))
+  )
+}
+
+function getKey(options: {
+  account: Address
+  accessKey: Address
+  chainId: number
+}) {
+  const { account, accessKey, chainId } = options
+  return [
+    'keyAuthorization',
+    chainId,
+    account.toLowerCase(),
+    accessKey.toLowerCase(),
+  ].join(':')
+}
+
+/** Thrown when a pending key authorization cannot be written after repeated conflicts. */
+class StoreConflictError extends BaseError {
+  constructor() {
+    super(
+      'Pending key authorization could not be written after repeated conflicts.',
+      { name: 'Relay.KeyAuthorization.StoreConflictError' },
+    )
+  }
+}

package/tempo/internal/relay/plugin.ts

@@ -1,13 +1,26 @@
 import type * as Relay from '../../Relay.js'
 
-const multisigPlugins = new WeakSet<Relay.Plugin>()
+const accountsPlugins = new WeakSet<Relay.Plugin>()
+const keyAuthorizationPlugins = 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
+/** Registers the built-in accounts plugin for transport capability detection. */
+export function accounts(plugin: Relay.Plugin): Relay.accounts.ReturnType {
+  accountsPlugins.add(plugin)
+  return plugin as Relay.accounts.ReturnType
 }
 
-export function isMultisig(plugin: Relay.Plugin): boolean {
-  return multisigPlugins.has(plugin)
+export function isAccounts(plugin: Relay.Plugin): boolean {
+  return accountsPlugins.has(plugin)
+}
+
+/** Registers the built-in key authorization plugin for transport capability detection. */
+export function keyAuthorization(
+  plugin: Relay.Plugin,
+): Relay.keyAuthorization.ReturnType {
+  keyAuthorizationPlugins.add(plugin)
+  return plugin as Relay.keyAuthorization.ReturnType
+}
+
+export function isKeyAuthorization(plugin: Relay.Plugin): boolean {
+  return keyAuthorizationPlugins.has(plugin)
 }

package/tempo/internal/resolveError.ts

@@ -0,0 +1,169 @@
+import type { Abi, Address } from 'abitype'
+import { parseAccount } from '../../accounts/utils/parseAccount.js'
+import { call } from '../../actions/public/call.js'
+import { multicall } from '../../actions/public/multicall.js'
+import type { Client } from '../../clients/createClient.js'
+import { BaseError } from '../../errors/base.js'
+import { TransactionReceiptRevertedError } from '../../errors/transaction.js'
+import type { ContractFunctionParameters } from '../../types/contract.js'
+import { encodeFunctionData } from '../../utils/abi/encodeFunctionData.js'
+import { formatAbiItem } from '../../utils/abi/formatAbiItem.js'
+import { toFunctionSelector } from '../../utils/hash/toFunctionSelector.js'
+import { errorResolvers as accessKeyResolvers } from '../actions/accessKey.js'
+import { errorResolvers as ammResolvers } from '../actions/amm.js'
+import { errorResolvers as channelResolvers } from '../actions/channel.js'
+import { errorResolvers as dexResolvers } from '../actions/dex.js'
+import { errorResolvers as feeResolvers } from '../actions/fee.js'
+import { errorResolvers as nonceResolvers } from '../actions/nonce.js'
+import { errorResolvers as policyResolvers } from '../actions/policy.js'
+import { errorResolvers as tokenResolvers } from '../actions/token.js'
+import * as ExecutionError from '../ExecutionError.js'
+import { TempoExecutionError } from '../errors.js'
+import type { Context, Hints, Resolvers } from './errors.js'
+
+/** Node messages that carry no revert data, mapped to the error they describe. */
+const messages = [
+  [/Access key expired: expiry \d+ <= min allowed \d+/, 'ExpiryInPast()'],
+] as const
+
+export async function toExecutionError(
+  cause: unknown,
+  options: {
+    client: Client
+    hints?: Hints | undefined
+    parameters: Record<string, any>
+  },
+) {
+  if (!(cause instanceof BaseError)) return cause
+  const { client, parameters } = options
+  const source = (await replay(cause, client, parameters)) ?? cause
+  const details = source.details ?? ''
+  let error: ExecutionError.ExecutionError = ExecutionError.from(source)
+  if (error.errorName === 'unknown') {
+    const signature = messages.find(([pattern]) => pattern.test(details))?.[1]
+    if (!signature) return cause
+    error = ExecutionError.from(toFunctionSelector(signature))
+  }
+  if (error.errorName === 'unknown') return cause
+
+  const signature = formatAbiItem(
+    error.abiItem,
+  ) as keyof typeof ExecutionError.messages
+  // Solidity `Error(string)` and `Panic(uint256)` are not Tempo errors.
+  if (!(signature in ExecutionError.messages)) return cause
+  const hints = [
+    ...(options.hints?.[error.errorName] ?? []),
+    ...(ExecutionError.hints[signature] ?? []),
+  ]
+  const base = { cause, error, hints } as TempoExecutionError.Parameters
+
+  const account_ = parameters.account ?? client.account
+  const account = account_ ? parseAccount(account_) : undefined
+  const context: Context = {
+    base,
+    call: getCall(parameters),
+    client,
+    details,
+    parameters,
+    read: (contracts) =>
+      multicall(client, {
+        allowFailure: true,
+        contracts: contracts as readonly ContractFunctionParameters[],
+        deployless: true,
+      }).catch(() => []) as never,
+    signer: account && {
+      address: account.address,
+      accessKey:
+        account.source === 'accessKey' && 'accessKeyAddress' in account
+          ? (account.accessKeyAddress as Address)
+          : undefined,
+    },
+    validation: !hasRevertData(source),
+  }
+
+  for (const resolvers of [
+    accessKeyResolvers,
+    ammResolvers,
+    channelResolvers,
+    dexResolvers,
+    feeResolvers,
+    nonceResolvers,
+    policyResolvers,
+    tokenResolvers,
+  ] as readonly Resolvers[]) {
+    const result = await resolvers[signature]?.(context)
+    if (result) return result
+  }
+  return new TempoExecutionError(base)
+}
+
+/** Replays a call whose receipt reverted, to recover its revert data. */
+async function replay(
+  cause: BaseError,
+  client: Client,
+  parameters: Record<string, any>,
+) {
+  const reverted = cause.walk(
+    (error) => error instanceof TransactionReceiptRevertedError,
+  ) as TransactionReceiptRevertedError | null
+  const to = parameters.to ?? parameters.address
+  const data =
+    parameters.data ??
+    (parameters.abi && parameters.functionName
+      ? encodeFunctionData({
+          abi: parameters.abi,
+          args: parameters.args,
+          functionName: parameters.functionName,
+        })
+      : undefined)
+  if (!reverted || !to || !data) return undefined
+  // ponytail: replays on the parent block, so earlier transactions in the same block are not applied.
+  return call(client, {
+    account: parameters.account ?? client.account,
+    blockNumber: reverted.receipt.blockNumber - 1n,
+    data,
+    to,
+    value: parameters.value,
+  }).then(
+    () => undefined,
+    (error) => (error instanceof BaseError ? error : undefined),
+  )
+}
+
+/** Whether an error carries revert data, which only execution reverts have. */
+function hasRevertData(error: BaseError) {
+  return !!error.walk((error) => {
+    const { data, raw } = error as { data?: unknown; raw?: unknown }
+    const hex =
+      typeof data === 'object' && data !== null
+        ? (data as { data?: unknown }).data
+        : (data ?? raw)
+    return typeof hex === 'string' && hex.length >= 10
+  })
+}
+
+function getCall(parameters: Record<string, any>): Context['call'] {
+  const {
+    abi,
+    address,
+    args = [],
+    functionName,
+  } = parameters as {
+    abi?: Abi
+    address?: Address
+    args?: readonly unknown[]
+    functionName?: string
+  }
+  if (!address || !functionName) return undefined
+  const item = abi?.find(
+    (item) => item.type === 'function' && item.name === functionName,
+  )
+  const inputs = item?.type === 'function' ? item.inputs : []
+  return {
+    address,
+    args,
+    functionName,
+    arg: (name) =>
+      args[inputs.findIndex((input) => input.name === name)] as never,
+  }
+}

package/tempo/internal/utils.ts

@@ -279,6 +279,8 @@ export function defineCall<
 } {
   return {
     ...(call as any),
+    // Precompile errors bubble up across contracts (e.g. `AccountKeychain` errors from a TIP-20 `transfer`).
+    abi: [...call.abi, ...Abis.coreErrors],
     data: encodeFunctionData(call as never),
     to: call.address,
   } as const

package/utils/hash/normalizeSignature.ts

@@ -46,8 +46,9 @@ export function normalizeSignature(
 
     // Ignore spaces
     if (char === ' ') {
-      // If the previous character is a separator, and the current section isn't empty, we want to deactivate.
-      if (signature[i - 1] !== ',' && current !== ',' && current !== ',(') {
+      // A space directly after a `(` or `,` separator is leading whitespace.
+      // Otherwise, it ends the type, so we want to deactivate.
+      if (!current.endsWith(',') && !current.endsWith('(')) {
         current = ''
         active = false
       }