viem 3.0.0-next.12 → 3.0.0-next.13

package/src/tempo/actions/token/burn.ts

@@ -1,5 +1,6 @@
 import { AbiEvent, Hex as Hex_ } from 'ox'
-import type { Errors, Hex } from 'ox'
+import type { Address, Errors, Hex } from 'ox'
+import type { OneOf } from '../../../core/internal/types.js'
 
 import type * as Account from '../../../core/Account.js'
 import type * as Chain from '../../../core/Chain.js'
@@ -25,7 +26,7 @@ import {
 } from '../../internal/utils.js'
 
 /**
- * Burns TIP-20 tokens from the caller's balance.
+ * Burns TIP-20 tokens from the caller's balance or a specified account with `BURN_AT_ROLE`.
  *
  * @example
  * ```ts
@@ -60,9 +61,13 @@ export namespace burn {
   export type Args = {
     /** Amount of tokens to burn, in base units or formatted decimal form. */
     amount: AmountInput
-    /** Memo to include in the burn. */
-    memo?: Hex.Hex | undefined
-  } & TokenParameter
+  } & TokenParameter &
+    OneOf<
+      | { /** Memo to include in the burn. */ memo?: Hex.Hex | undefined }
+      | {
+          /** Address to burn from. Requires BURN_AT_ROLE. */ from: Address.Address
+        }
+    >
   export type Options = WriteParameters & Args
   export type ReturnType = write.ReturnType
   // TODO: exhaustive error type
@@ -85,7 +90,7 @@ export namespace burn {
   }
 
   /**
-   * Defines a call to the `burn` or `burnWithMemo` function.
+   * Defines a call to the `burn`, `burnWithMemo`, or `burnAt` function.
    *
    * Can be passed to any action that accepts a contract call. The token is
    * selected by `token`; `amount.decimals` is inferred from the client's
@@ -98,9 +103,16 @@ export namespace burn {
     ...parameters: CallParameters<Args, Client.Client<chain>>
   ) {
     const [client, args] = resolveCallParameters(parameters)
-    const { amount, memo, token } = args
+    const { amount, from, memo, token } = args
     const { address, decimals } = resolveToken(client, { token })
     const value = toBaseUnits(amount, decimals)
+    if (from)
+      return defineCall({
+        abi: Abis.tip20,
+        address,
+        functionName: 'burnAt',
+        args: [from, value],
+      })
     const callArgs = memo
       ? ({
           args: [value, Hex_.padLeft(memo, 32)],
@@ -169,10 +181,10 @@ export namespace burn {
     const logs extends readonly AbiEvent.extractLogs.Log[],
   >(logs: logs) {
     const [log] = AbiEvent.extractLogs(Abis.tip20, logs, {
-      eventName: 'Burn',
+      eventName: ['Burn', 'BurnAt'],
       strict: true,
     })
-    if (!log) throw new Error('`Burn` event not found.')
+    if (!log) throw new Error('`Burn` or `BurnAt` event not found.')
     return log
   }
 }

package/src/tempo/actions/token/burnSync.ts

@@ -65,6 +65,8 @@ export namespace burnSync {
   export type Args = burn.Args
   export type Options = burn.Options & WriteSyncParameters
   export type ReturnType = {
+    /** BURN_AT_ROLE holder that performed the burn. */
+    burner?: Address.Address | undefined
     /** Address tokens were burned from. */
     from: Address.Address
     /** Burned amount, in base units. */

package/src/tempo/chainConfig.ts

@@ -58,11 +58,10 @@ export type TransactionRequest = Omit<
   /** Capabilities to pass to `eth_fillTransaction`. */
   capabilities?: Capabilities.FillTransactionRequestCapabilities | undefined
   /**
-   * Fee payer of the transaction (TIP-1 gas sponsorship). Pass `true` to defer the fee
-   * token to an external fee payer (e.g. a relay), or a local Account to
-   * co-sign the transaction as the fee payer.
+   * Fee payer for TIP-1 gas sponsorship. Pass `true` for relay sponsorship,
+   * an Account to co-sign locally, or an external sponsor URL allowed by the relay.
    */
-  feePayer?: viem_Account.Account | boolean | undefined
+  feePayer?: viem_Account.Account | boolean | string | undefined
   /** Stored multisig operation to approve. */
   hash?: Hex.Hex | undefined
   /** Owner signing a multisig approval. */
@@ -90,7 +89,7 @@ export type TransactionRequestRpc = TransactionRequestTempo.Rpc
  */
 export type Envelope = TxEnvelopeTempo.TxEnvelopeTempo & {
   /** Fee payer of the transaction (TIP-1 gas sponsorship). */
-  feePayer?: viem_Account.Account | boolean | undefined
+  feePayer?: viem_Account.Account | boolean | string | undefined
   /** Owner signing a multisig approval. */
   owner?: RootAccount | undefined
   /** Multisig account, config, and modeled approvals for gas estimation. */
@@ -293,6 +292,9 @@ export const chainConfig = {
             )
           Object.assign(request, {
             ...storedTransaction,
+            gas: storedTransaction.gas ?? 0n,
+            maxFeePerGas: storedTransaction.maxFeePerGas ?? 0n,
+            maxPriorityFeePerGas: storedTransaction.maxPriorityFeePerGas ?? 0n,
             nonce: Number(storedTransaction.nonce ?? 0n),
             account: request.account,
             from: operation.account,
@@ -436,7 +438,7 @@ export const chainConfig = {
           request.nonce = 0
         } else if (useExpiringNonce) {
           request.nonceKey = maxUint256
-          request.nonce = 0
+          request.nonce ??= 0
           if (typeof request.validAfter === 'undefined')
             request.validAfter = randomValidAfter()
           if (typeof request.validBefore === 'undefined')
@@ -765,6 +767,7 @@ function encodeRequest(
   // fee payer commits to it when co-signing. (ox withholds `feeToken` only
   // for external sponsorship, where the fee payer picks the token.)
   if (typeof feePayer === 'object') rpc.feePayer = true
+  if (typeof feePayer === 'string') Object.assign(rpc, { feePayer })
 
   return rpc
 }

package/src/tempo/index.ts

@@ -58,6 +58,9 @@ export { tempoActions, type Decorator as TempoActions } from './Decorator.js'
 /** Tempo errors. */
 export * from './errors.js'
 
+/** Decodes Tempo precompile reverts into readable execution errors. */
+export * as ExecutionError from './ExecutionError.js'
+
 /** Helpers producing unix timestamps for key expiries. */
 export * as Expiry from './Expiry.js'
 
@@ -70,6 +73,9 @@ export * as KeyAuthorizationManager from './KeyAuthorizationManager.js'
 /** P256 (secp256r1) key utilities. Re-exports `ox/P256`. */
 export * as P256 from './P256.js'
 
+/** Composable relay request handlers. */
+export * as Relay from './Relay.js'
+
 /** Call scopes restricting access keys to targets & selectors. */
 export * as Scopes from './Scopes.js'
 
@@ -80,7 +86,7 @@ export * as Selectors from './Selectors.js'
 export * as Store from './Store.js'
 
 /** Relay transport: routes fee sponsorship traffic to a fee payer service. */
-export { withMultisig, withRelay, type Relay } from './Transport.js'
+export { withRelay } from './Transport.js'
 
 /** WebAuthn P256 credential creation & signing. */
 export * as WebAuthnP256 from './WebAuthnP256.js'
@@ -93,8 +99,5 @@ export * as WebCryptoP256 from './WebCryptoP256.js'
 // `viem/tempo` never imports `viem`. See `internal/inference.ts`.
 export type * from '../internal/inference.js'
 
-/** Coordinates native multisig approvals over JSON-RPC. */
-export * as Multisig from './Multisig.js'
-
 /** Tempo Zone chains. */
 export * as Zone from './Zone.js'

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

@@ -0,0 +1,82 @@
+import { withTimeout } from '../../../core/internal/promise.js'
+import type * as Store_ from '../../Store.js'
+
+export type Store = Store_.Store
+
+// Scope in-flight work to one request so Workers never share request-owned I/O.
+const flights = new WeakMap<Store, Map<string, Promise<unknown>>>()
+const prefix = 'viem:relay:cache:'
+
+export function scoped(store: Store | undefined): Store | undefined {
+  if (!store) return undefined
+  return {
+    getItem: (key) => store.getItem(key),
+    setItem: (key, value) => store.setItem(key, value),
+    removeItem: (key) => store.removeItem(key),
+  }
+}
+
+export async function memoize<value>(
+  fetch: () => Promise<value>,
+  options: { key: string; store: Store; ttl: number },
+): Promise<value> {
+  const { store, ttl } = options
+  const key = `${prefix}${options.key}`
+  let active = true
+  const timeoutError = new Error('Relay cache operation timed out.')
+  return withTimeout(
+    async () => {
+      const raw = await store.getItem(key)
+      if (!active) throw timeoutError
+      if (raw) {
+        try {
+          const entry = JSON.parse(raw, (_key, item) => {
+            if (typeof item !== 'string' || !item.startsWith(prefix))
+              return item
+            if (item.startsWith(`${prefix}string:`))
+              return item.slice(`${prefix}string:`.length)
+            if (item.startsWith(`${prefix}bigint:`))
+              return BigInt(item.slice(`${prefix}bigint:`.length))
+            throw new TypeError('Invalid relay cache value.')
+          }) as { value: value; expiresAt: number }
+          if (entry.expiresAt > Date.now()) return entry.value
+        } catch {
+          // Refresh malformed or older entries.
+        }
+      }
+      let pending = flights.get(store)
+      if (!pending) {
+        pending = new Map()
+        flights.set(store, pending)
+      }
+      const existing = pending.get(key)
+      if (existing) return existing as Promise<value>
+      const result = (async () => {
+        const value = await fetch()
+        if (!active) throw timeoutError
+        if (value !== undefined)
+          await store.setItem(
+            key,
+            JSON.stringify(
+              { value, expiresAt: Date.now() + ttl },
+              (_key, item) => {
+                if (typeof item === 'bigint') return `${prefix}bigint:${item}`
+                if (typeof item === 'string' && item.startsWith(prefix))
+                  return `${prefix}string:${item}`
+                return item
+              },
+            ),
+          )
+        return value
+      })().finally(() => pending.delete(key))
+      pending.set(key, result)
+      return result
+    },
+    {
+      timeout: 30_000,
+      errorInstance: timeoutError,
+    },
+  ).finally(() => {
+    active = false
+  })
+}

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 } : {}),
+    },
+  }
+}