viem 3.0.0-next.13 → 3.0.0-next.14

package/src/tempo/Addresses.ts

@@ -47,6 +47,8 @@ export const validator = '0xcccccccc00000000000000000000000000000000'
 export const validatorV2 = '0xcccccccc00000000000000000000000000000001'
 export const zoneFactory = '0x5aF2000000000000000000000000000000000000'
 export const zoneMessenger = '0x5A4d000000000000000000000000000000000000'
+/** Address of the zone inbox precompile. */
+export const zoneInbox = '0x1c00000000000000000000000000000000000001'
 /** Address of the zone outbox precompile. */
 export const zoneOutbox = '0x1c00000000000000000000000000000000000002'
 export const zonePortalImplementation =

package/src/tempo/Decorator.ts

@@ -3,13 +3,13 @@ import type * as Chain from '../core/Chain.js'
 import type * as Client from '../core/Client.js'
 import type * as Transport from '../core/Transport.js'
 import * as accessKey from './actions/accessKey/index.js'
+import * as accounts from './actions/accounts/index.js'
 import * as amm from './actions/amm/index.js'
 import * as channel from './actions/channel/index.js'
 import * as dex from './actions/dex/index.js'
 import * as earn from './actions/earn.js'
 import * as faucet from './actions/faucet/index.js'
 import * as fee from './actions/fee/index.js'
-import * as multisig from './actions/multisig/index.js'
 import * as nonce from './actions/nonce/index.js'
 import * as policy from './actions/policy/index.js'
 import * as propAmmActions from './actions/propAmm.js'
@@ -55,6 +55,8 @@ export function tempoActions() {
       isWitnessBurned: (options) => accessKey.isWitnessBurned(client, options),
       revoke: (options) => accessKey.revoke(client, options),
       revokeSync: (options) => accessKey.revokeSync(client, options),
+      saveAuthorization: (options) =>
+        accessKey.saveAuthorization(client, options),
       signAuthorization: ((options: accessKey.signAuthorization.Options) =>
         accessKey.signAuthorization(
           client,
@@ -71,6 +73,14 @@ export function tempoActions() {
       watchWitnessBurned: (options) =>
         accessKey.watchWitnessBurned(client, options),
     },
+    accounts: {
+      getConfig: (options) => accounts.getConfig(client, options),
+      getConfigCommitment: (options) =>
+        accounts.getConfigCommitment(client, options),
+      getOperation: (options) => accounts.getOperation(client, options),
+      updateConfig: (options) => accounts.updateConfig(client, options),
+      updateConfigSync: (options) => accounts.updateConfigSync(client, options),
+    },
     amm: {
       burn: (options) => amm.burn(client, options),
       burnSync: (options) => amm.burnSync(client, options),
@@ -289,14 +299,6 @@ export function tempoActions() {
       get: (options) => nonce.get(client, options),
       watchIncremented: (options) => nonce.watchIncremented(client, options),
     },
-    multisig: {
-      getConfig: (options) => multisig.getConfig(client, options),
-      getConfigCommitment: (options) =>
-        multisig.getConfigCommitment(client, options),
-      getOperation: (options) => multisig.getOperation(client, options),
-      updateConfig: (options) => multisig.updateConfig(client, options),
-      updateConfigSync: (options) => multisig.updateConfigSync(client, options),
-    },
     policy: {
       create: (options) => policy.create(client, options),
       createSync: (options) => policy.createSync(client, options),
@@ -726,6 +728,31 @@ export type Decorator<
     revokeSync: (
       options: accessKey.revokeSync.Options,
     ) => Promise<accessKey.revokeSync.ReturnType>
+    /**
+     * Saves a signed key authorization to a relay with key authorization storage.
+     *
+     * The relay attaches the authorization to the access key's next transaction
+     * until the key is active onchain. Requires a relay running the
+     * `Relay.keyAuthorization` plugin.
+     *
+     * @example
+     * ```ts
+     * import { Client, http, withRelay } from 'viem/tempo'
+     *
+     * const client = Client.create({
+     *   transport: withRelay(http(), http('https://relay.example.com'), {
+     *     keyAuthorization: true,
+     *   }),
+     * })
+     *
+     * await client.accessKey.saveAuthorization({ keyAuthorization })
+     * ```
+     *
+     * @param options - Options.
+     */
+    saveAuthorization: (
+      options: accessKey.saveAuthorization.Options,
+    ) => Promise<accessKey.saveAuthorization.ReturnType>
     /**
      * Signs a key authorization for an access key.
      *
@@ -764,7 +791,7 @@ export type Decorator<
         options: accessKey.signAuthorization.LocalOptions<account>,
       ): Promise<accessKey.signAuthorization.ReturnType>
     }
-    /** Prepares a key authorization for local or multisig signing. */
+    /** Prepares a key authorization for local or configurable account signing. */
     prepareAuthorization: (
       options: accessKey.prepareAuthorization.Options<account>,
     ) => Promise<accessKey.prepareAuthorization.ReturnType>
@@ -920,6 +947,24 @@ export type Decorator<
       options?: accessKey.watchWitnessBurned.Options,
     ) => accessKey.watchWitnessBurned.ReturnType
   }
+  /** Configurable account configuration and coordinated operations. */
+  accounts: {
+    getConfig: (
+      options: accounts.getConfig.Options,
+    ) => Promise<accounts.getConfig.ReturnType>
+    getConfigCommitment: (
+      options: accounts.getConfigCommitment.Options,
+    ) => Promise<accounts.getConfigCommitment.ReturnType>
+    getOperation: (
+      options: accounts.getOperation.Options,
+    ) => Promise<accounts.getOperation.ReturnType>
+    updateConfig: (
+      options: accounts.updateConfig.Options,
+    ) => Promise<accounts.updateConfig.ReturnType>
+    updateConfigSync: (
+      options: accounts.updateConfigSync.Options,
+    ) => Promise<accounts.updateConfigSync.ReturnType>
+  }
   amm: {
     /**
      * Removes liquidity from a pool.
@@ -2945,24 +2990,6 @@ export type Decorator<
       options?: nonce.watchIncremented.Options,
     ) => nonce.watchIncremented.ReturnType
   }
-  /** Native multisig configuration and coordinated operations. */
-  multisig: {
-    getConfig: (
-      options: multisig.getConfig.Options,
-    ) => Promise<multisig.getConfig.ReturnType>
-    getConfigCommitment: (
-      options: multisig.getConfigCommitment.Options,
-    ) => Promise<multisig.getConfigCommitment.ReturnType>
-    getOperation: (
-      options: multisig.getOperation.Options,
-    ) => Promise<multisig.getOperation.ReturnType>
-    updateConfig: (
-      options: multisig.updateConfig.Options,
-    ) => Promise<multisig.updateConfig.ReturnType>
-    updateConfigSync: (
-      options: multisig.updateConfigSync.Options,
-    ) => Promise<multisig.updateConfigSync.ReturnType>
-  }
 
   policy: {
     /**

package/src/tempo/ExecutionError.ts

@@ -115,7 +115,7 @@ export const messages: Record<`${AbiErrorName}(${string})`, string> = {
   'InvalidMasterAddress()': 'Invalid master address.',
   'InvalidMigrationIndex()': 'Invalid migration index.',
   'InvalidMode()': 'Invalid mode.',
-  'InvalidMultisigOwner()': 'Invalid multisig owner.',
+  'InvalidMultisigOwner()': 'Invalid owner.',
   'InvalidNonceKey()': 'Invalid nonce key.',
   'InvalidOwner()': 'Invalid owner.',
   'InvalidOwnerOrder()': 'Invalid owner order.',

package/src/tempo/KeyAuthorizationManager.ts

@@ -1,7 +1,8 @@
-import type { Address } from 'ox'
-import type { KeyAuthorization } from 'ox/tempo'
+import type { Address, Hex } from 'ox'
+import { KeyAuthorization } from 'ox/tempo'
 
 import type { MaybePromise } from '../core/internal/types.js'
+import * as Store from './Store.js'
 
 /** Cache key identifying a signed key authorization. */
 export type Key = {
@@ -13,42 +14,74 @@ export type Key = {
   chainId: number
 }
 
-/** Store for signed key authorizations, keyed by account, access key, and chain. */
+/** Pending key authorizations that the client attaches to an access key's next transaction. */
 export type KeyAuthorizationManager = {
+  /** Reads the pending authorization for a key. */
   get(key: Key): MaybePromise<KeyAuthorization.Signed | undefined>
+  /** Removes the pending authorization for a key. */
   remove(key: Key): MaybePromise<void>
+  /** Stores a pending authorization for a key. */
   set(key: Key, keyAuthorization: KeyAuthorization.Signed): MaybePromise<void>
 }
 
 /**
- * Instantiates a key authorization manager from a source.
+ * Creates a key authorization manager backed by a store.
+ *
+ * Entries use the same keys as the `Relay.keyAuthorization` plugin, so both can
+ * share one store.
  *
  * @example
  * ```ts
- * import { KeyAuthorizationManager } from 'viem/tempo'
+ * import { Account, KeyAuthorizationManager, Store } from 'viem/tempo'
  *
- * const manager = KeyAuthorizationManager.from({
- *   source: {
- *     get(key) { … },
- *     remove(key) { … },
- *     set(key, keyAuthorization) { … },
- *   },
+ * const accessKey = Account.fromP256(privateKey, {
+ *   access: root,
+ *   keyAuthorizationManager: KeyAuthorizationManager.from({
+ *     store: Store.session(),
+ *   }),
  * })
  * ```
+ *
+ * @param options - Options.
+ * @returns A key authorization manager.
  */
 export function from(options: from.Options): KeyAuthorizationManager {
-  return options.source
+  const { store } = options
+  return {
+    async get(key) {
+      const value = await store.getItem(getStoreKey(key))
+      if (!value) return undefined
+      try {
+        const { signature, ...rest } = KeyAuthorization.deserialize(
+          value as Hex.Hex,
+        )
+        if (!signature) return undefined
+        return { ...rest, signature }
+      } catch {
+        return undefined
+      }
+    },
+    async remove(key) {
+      await store.removeItem(getStoreKey(key))
+    },
+    async set(key, keyAuthorization) {
+      await store.setItem(
+        getStoreKey(key),
+        KeyAuthorization.serialize(keyAuthorization),
+      )
+    },
+  }
 }
 
 export declare namespace from {
   type Options = {
-    /** Source implementation backing the manager. */
-    source: KeyAuthorizationManager
+    /** Store for pending key authorizations. */
+    store: Store.Store
   }
 }
 
 /**
- * Creates an in-memory key authorization manager backed by a `Map`.
+ * Creates a key authorization manager backed by a process-local memory store.
  *
  * @example
  * ```ts
@@ -56,27 +89,16 @@ export declare namespace from {
  *
  * const manager = KeyAuthorizationManager.memory()
  * ```
+ *
+ * @returns A key authorization manager.
  */
 export function memory(): KeyAuthorizationManager {
-  const keyAuthorizations = new Map<string, KeyAuthorization.Signed>()
-
-  return from({
-    source: {
-      get(key) {
-        return keyAuthorizations.get(serializeKey(key))
-      },
-      remove(key) {
-        keyAuthorizations.delete(serializeKey(key))
-      },
-      set(key, keyAuthorization) {
-        keyAuthorizations.set(serializeKey(key), keyAuthorization)
-      },
-    },
-  })
+  return from({ store: Store.memory() })
 }
 
-function serializeKey(key: Key) {
+function getStoreKey(key: Key) {
   return [
+    'keyAuthorization',
     key.chainId,
     key.address.toLowerCase(),
     key.accessKey.toLowerCase(),

package/src/tempo/Relay.ts

@@ -6,7 +6,8 @@ import { ChainNotConfiguredError } from '../core/Client.js'
 import type * as Transport from '../core/Transport.js'
 import * as Sponsorship from './internal/relay/feePayer.js'
 import * as FeeToken from './internal/relay/feeToken.js'
-import * as Multisig from './internal/relay/multisig.js'
+import * as Accounts from './internal/relay/accounts.js'
+import * as KeyAuthorization from './internal/relay/keyAuthorization.js'
 import * as Request_ from './internal/relay/request.js'
 import * as Simulate from './internal/relay/simulate.js'
 import * as internal from './internal/relay.js'
@@ -309,13 +310,19 @@ export declare namespace Plugin {
   }
 }
 
-declare const multisigBrand: unique symbol
+declare const accountsBrand: unique symbol
 
 /**
- * Coordinates native multisig approvals using shared atomic storage.
+ * Serves configurable accounts using shared atomic storage.
+ *
+ * The chain stores only a commitment to each account's config, so the plugin
+ * records every config it relays (including configs left by `updateConfig`
+ * calls) and serves them through `account_getConfig`. It also collects owner
+ * approvals until the account's threshold is met, then submits.
  *
  * Memory storage is process-local. Independent clients and multiple server
- * instances must use the same persistent store to share pending approvals.
+ * instances must use the same persistent store to share configs and pending
+ * approvals.
  *
  * @example
  * ```ts
@@ -323,31 +330,31 @@ declare const multisigBrand: unique symbol
  * import { Relay, Store, withRelay } from 'viem/tempo'
  *
  * const transport = withRelay(http(), {
- *   plugins: [Relay.multisig({ store: Store.memory() })],
+ *   plugins: [Relay.accounts({ store: Store.memory() })],
  * })
  * ```
  *
  * @param options - Shared atomic storage.
- * @returns A plugin that coordinates multisig requests and forwards other calls.
+ * @returns A plugin that handles configurable account requests and forwards other calls.
  */
-export function multisig(options: multisig.Options): multisig.ReturnType {
-  return Multisig.create(options)
+export function accounts(options: accounts.Options): accounts.ReturnType {
+  return Accounts.create(options)
 }
 
-export declare namespace multisig {
-  /** Multisig coordination options. */
+export declare namespace accounts {
+  /** Configurable account options. */
   export type Options = {
-    /** Store shared by multisig coordinators, with atomic compare-and-set support. */
+    /** Store shared by relays, with atomic compare-and-set support. */
     store: Store.Atomic
   }
-  /** Middleware advertising native multisig coordination. */
-  export type ReturnType = Plugin & { readonly [multisigBrand]: true }
+  /** Middleware advertising configurable account support. */
+  export type ReturnType = Plugin & { readonly [accountsBrand]: true }
 }
 
 /**
  * Sponsors transactions with a local account or an external fee-payer relay.
  *
- * Place multisig before this plugin and fee-token selection after it.
+ * Place accounts before this plugin and fee-token selection after it.
  *
  * @example
  * ```ts
@@ -402,6 +409,54 @@ export function feeToken(): Plugin {
   return FeeToken.create()
 }
 
+declare const keyAuthorizationBrand: unique symbol
+
+/**
+ * Stores pending key authorizations and attaches them to the next fill that needs them.
+ *
+ * Signing a key authorization with `Actions.accessKey.signAuthorization` through a
+ * relay with this plugin saves it with `relay_saveKeyAuthorization`. Configurable
+ * account key authorizations are saved once they reach quorum. The next `eth_fillTransaction`
+ * from the access key includes the authorization until the key is active onchain.
+ * Remote `withRelay` transports opt in with `keyAuthorization: true`.
+ *
+ * Place this plugin before `Relay.accounts` so it can observe completed configurable
+ * account key authorizations, and before plugins that read the filled transaction.
+ *
+ * A saved authorization only replaces a pending authorization that expires earlier,
+ * so a replayed older authorization cannot replace a newer one.
+ *
+ * Memory storage is process-local. Multiple server instances must use the same
+ * persistent atomic store to share pending authorizations.
+ *
+ * @example
+ * ```ts
+ * import { http, Relay, Store, withRelay } from 'viem/tempo'
+ *
+ * const transport = withRelay(http(), {
+ *   plugins: [Relay.keyAuthorization({ store: Store.memory() })],
+ * })
+ * ```
+ *
+ * @param options - Pending key authorization storage.
+ * @returns A plugin that stores and attaches pending key authorizations.
+ */
+export function keyAuthorization(
+  options: keyAuthorization.Options = {},
+): keyAuthorization.ReturnType {
+  return KeyAuthorization.create(options)
+}
+
+export declare namespace keyAuthorization {
+  /** Key authorization storage options. */
+  export type Options = {
+    /** Store for pending key authorizations, with atomic compare-and-set support. Defaults to a process-local memory store. */
+    store?: Store.Atomic | undefined
+  }
+  /** Middleware advertising pending key authorization storage. */
+  export type ReturnType = Plugin & { readonly [keyAuthorizationBrand]: true }
+}
+
 /**
  * Adds balance changes, estimated fees, and execution errors to fill capabilities.
  *

package/src/tempo/Selectors.ts

@@ -454,3 +454,16 @@ export const zoneOutbox = {
 export const zoneMessenger = {
   relayMessage: '0x11da5261',
 } as const satisfies FunctionSelectors<typeof Abis.zoneMessenger>
+
+export const zoneInbox = {
+  advanceTempo: '0x86516ec0',
+  advanceTempoHeaders: '0xae58328d',
+  claimRefund: '0xbffa55d5',
+  processedDepositNumber: '0x2d488482',
+  processedDepositQueueHash: '0x82648c3b',
+  processedEnabledTokenCount: '0x1b366d74',
+  processedTokenEnablementHash: '0x8f2e461a',
+  refunds: '0x857e85f8',
+  tempoPortal: '0xa21de6d9',
+  tempoState: '0x1fbb25ad',
+} as const satisfies FunctionSelectors<typeof Abis.zoneInbox>

package/src/tempo/Transport.ts

@@ -10,7 +10,7 @@ import type * as Relay_ from './Relay.js'
 import * as Store from './Store.js'
 
 /** A relay {@link Transport.Transport}: routes fee sponsorship traffic to a relay (fee payer service). */
-export type Relay = Transport.Transport<'relay', { multisig: true }>
+export type Relay = Transport.Transport<'relay', { accounts: true }>
 
 /**
  * Creates a {@link Transport.Transport} that routes requests between a
@@ -28,8 +28,10 @@ export type Relay = Transport.Transport<'relay', { multisig: true }>
  * - `'sign-and-broadcast'`: the submission is forwarded to the relay, which
  *   co-signs and broadcasts it itself.
  *
- * Multisig approvals and submissions are sent to the relay. Transaction and
- * receipt lookups fall back to the relay for pending multisig operations.
+ * Owner approvals and submissions are sent to the relay. Transaction and
+ * receipt lookups fall back to the relay for pending account operations.
+ * Signed key authorizations are saved to relays with key authorization storage
+ * so they can attach them to the access key's next transaction.
  * Other requests are forwarded to the default transport.
  *
  * @example
@@ -53,11 +55,11 @@ export function withRelay<
   defaultTransport: transport,
   options: withRelay.LocalOptions<plugins>,
 ): withRelay.LocalReturnValue<transport, plugins>
-export function withRelay(
+export function withRelay<const options extends withRelay.Options = {}>(
   defaultTransport: Transport.Transport,
   relayTransport: Transport.Transport,
-  options?: withRelay.Options,
-): Relay
+  options?: options | withRelay.Options,
+): withRelay.ReturnValue<options>
 export function withRelay(
   defaultTransport: Transport.Transport,
   relayTransport: Transport.Transport | withRelay.LocalOptions,
@@ -81,15 +83,20 @@ export function withRelay(
               ...options,
             })) as typeof transport.request,
           ...(relayTransport.plugins?.some((plugin) =>
-            Plugin.isMultisig(plugin),
+            Plugin.isAccounts(plugin),
+          )
+            ? { accounts: true }
+            : {}),
+          ...(relayTransport.plugins?.some((plugin) =>
+            Plugin.isKeyAuthorization(plugin),
           )
-            ? { multisig: true }
+            ? { keyAuthorization: true }
             : {}),
         }
       },
     }
 
-  const { policy = 'sign-only' } = options
+  const { keyAuthorization, policy = 'sign-only' } = options
   return Transport.from({
     key: options.key ?? 'relay',
     name: options.name ?? 'Relay Proxy',
@@ -103,7 +110,8 @@ export function withRelay(
       const relay = relayTransport.setup({ chain, retryCount: 0, timeout })
 
       return {
-        multisig: true as const,
+        accounts: true as const,
+        ...(keyAuthorization ? { keyAuthorization: true as const } : {}),
         methods: options.methods,
         retryCount: 0,
         retryDelay: options.retryDelay,
@@ -113,6 +121,9 @@ export function withRelay(
           // The relay decides whether to sponsor from the fill request's `feePayer`.
           if (method === 'eth_fillTransaction') return relay.request(args, opts)
 
+          if (method === 'relay_saveKeyAuthorization')
+            return relay.request(args, opts)
+
           if (
             method === 'eth_getTransactionByHash' ||
             method === 'eth_getTransactionReceipt'
@@ -126,7 +137,7 @@ export function withRelay(
             const operation = await (async () => {
               try {
                 return await relay.request(
-                  { method: 'multisig_getOperation', params },
+                  { method: 'account_getOperation', params },
                   opts,
                 )
               } catch (error) {
@@ -134,7 +145,7 @@ export function withRelay(
                   error instanceof RpcResponse.MethodNotFoundError ||
                   error instanceof RpcResponse.MethodNotSupportedError
                 ) {
-                  // Relays created before multisig coordination do not expose this method.
+                  // Relays without the accounts plugin do not expose this method.
                   return null
                 }
                 throw error
@@ -151,11 +162,11 @@ export function withRelay(
           }
 
           if (
-            method === 'multisig_approveKeyAuthorization' ||
-            method === 'multisig_approveRawTransaction' ||
-            method === 'multisig_approveRawTransactionSync' ||
-            method === 'multisig_getConfig' ||
-            method === 'multisig_getOperation'
+            method === 'account_approveKeyAuthorization' ||
+            method === 'account_approveRawTransaction' ||
+            method === 'account_approveRawTransactionSync' ||
+            method === 'account_getConfig' ||
+            method === 'account_getOperation'
           )
             return relay.request({ method, params: params as [Hex.Hex] }, opts)
 
@@ -178,7 +189,7 @@ export function withRelay(
                   return undefined
                 }
               })()
-              if (envelope?.signature?.type === 'multisig')
+              if (envelope?.signature?.type === 'configurable')
                 return relay.request(
                   { method, params: [serialized as Hex.Hex] },
                   opts,
@@ -226,9 +237,15 @@ export declare namespace withRelay {
       ? Transport.Transport<
           type,
           properties &
-            (Extract<plugins[number], Relay_.multisig.ReturnType> extends never
+            (Extract<plugins[number], Relay_.accounts.ReturnType> extends never
+              ? {}
+              : { accounts: true }) &
+            (Extract<
+              plugins[number],
+              Relay_.keyAuthorization.ReturnType
+            > extends never
               ? {}
-              : { multisig: true }),
+              : { keyAuthorization: true }),
           request
         >
       : never
@@ -236,6 +253,8 @@ export declare namespace withRelay {
   type Options = {
     /** Transport key. @default 'relay' */
     key?: string | undefined
+    /** Whether the relay stores key authorizations with `Relay.keyAuthorization`. @default false */
+    keyAuthorization?: boolean | undefined
     /** RPC methods to include or exclude. */
     methods?: { include?: string[] } | { exclude?: string[] } | undefined
     /** Transport name. @default 'Relay Proxy' */
@@ -247,6 +266,13 @@ export declare namespace withRelay {
     /** Base delay (ms) between retries. @default 150 */
     retryDelay?: number | undefined
   }
+
+  /** Remote relay transport, advertising key authorization storage when enabled. */
+  type ReturnValue<options extends Options = {}> = options extends {
+    keyAuthorization: true
+  }
+    ? Transport.Transport<'relay', { accounts: true; keyAuthorization: true }>
+    : Relay
 }
 
 /**