viem 2.57.5 → 2.57.6

package/tempo/internal/errors.ts

@@ -0,0 +1,110 @@
+import type { Address } from 'abitype'
+import { TokenId } from 'ox/tempo'
+import type {
+  MulticallParameters,
+  MulticallReturnType,
+} from '../../actions/public/multicall.js'
+import type { Client } from '../../clients/createClient.js'
+import { formatUnits } from '../../utils/unit/formatUnits.js'
+import type * as ExecutionError from '../ExecutionError.js'
+import type { TempoExecutionError } from '../errors.js'
+
+/** Action-specific steps to resolve errors, keyed by error name. Listed before the default steps. */
+export type Hints = {
+  [name in TempoExecutionError.ErrorName]?: readonly string[]
+}
+
+/** Builds a specific error for a decoded Tempo error, or returns `undefined` when it does not apply. */
+type Resolver = (
+  context: Context,
+) => Promise<TempoExecutionError | undefined> | TempoExecutionError | undefined
+
+/** Resolvers keyed by error signature. */
+export type Resolvers = {
+  [signature in keyof typeof ExecutionError.messages]?: Resolver
+}
+
+export type Context = {
+  /** Parameters for the base `TempoExecutionError`. */
+  base: TempoExecutionError.Parameters
+  client: Client
+  /** Signer, with its access key when signing with one. */
+  signer: { address: Address; accessKey: Address | undefined } | undefined
+  /** Contract call that failed, when the action made one. */
+  call:
+    | {
+        address: Address
+        args: readonly unknown[]
+        functionName: string
+        /** Reads an argument by its ABI input name. */
+        arg: <type = unknown>(name: string) => type | undefined
+      }
+    | undefined
+  /** Whether the error came from transaction validation or fee payment rather than a revert. */
+  validation: boolean
+  /** Raw node message. */
+  details: string
+  parameters: Record<string, any>
+  /** Multicall with `allowFailure: true`. Resolves an empty array when the request fails. */
+  read: <const contracts extends readonly unknown[]>(
+    contracts: MulticallParameters<contracts>['contracts'],
+  ) => Promise<Partial<MulticallReturnType<contracts, true>>>
+}
+
+/**
+ * Wraps an action so failures with a decoded Tempo error throw a {@link TempoExecutionError}.
+ * Other errors are rethrown unchanged.
+ *
+ * @internal
+ */
+export function withExecutionError<
+  action extends (client: any, parameters: any) => Promise<any>,
+>(action: action, options: { hints?: Hints | undefined } = {}): action {
+  return (async (client: Client, parameters: Record<string, any>) => {
+    try {
+      return await action(client, parameters)
+    } catch (error) {
+      // Loaded on failure only, so resolvers and error tables stay out of the success path.
+      const { toExecutionError } = await import('./resolveError.js')
+      throw await toExecutionError(error, { ...options, client, parameters })
+    }
+  }) as action
+}
+
+/** Fee token from the action parameters or chain, when set. */
+export function getFeeToken(context: Context) {
+  const feeToken =
+    context.parameters.feeToken ??
+    (
+      context.client.chain as
+        | { feeToken?: TokenId.TokenIdOrAddress }
+        | undefined
+    )?.feeToken
+  return feeToken === undefined || feeToken === null
+    ? undefined
+    : TokenId.toAddress(feeToken)
+}
+
+/** Whether `address` is a TIP-20 token. */
+export function isTip20(address: Address | undefined): address is Address {
+  return !!address?.toLowerCase().startsWith('0x20c0')
+}
+
+/** Formats an amount as `formatted (raw)` when decimals are known. */
+export function formatAmount(
+  value: bigint | undefined,
+  decimals: number | undefined,
+) {
+  if (value === undefined) return undefined
+  if (decimals === undefined) return value.toString()
+  return `${formatUnits(value, decimals)} (${value})`
+}
+
+/** Formats Unix seconds as an ISO 8601 string. */
+export function formatTime(seconds: bigint | number | undefined) {
+  if (!seconds) return undefined
+  const milliseconds = Number(seconds) * 1000
+  // `Date` cannot represent times past ±8.64e15 milliseconds.
+  if (!(Math.abs(milliseconds) <= 8.64e15)) return seconds.toString()
+  return new Date(milliseconds).toISOString()
+}

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