viem 2.57.4 → 2.57.5

package/tempo/ExecutionError.ts

@@ -114,7 +114,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/tempo/Formatters.ts

@@ -3,7 +3,7 @@
 import type { Address } from 'abitype'
 import * as Hex from 'ox/Hex'
 import {
-  MultisigOperation,
+  AccountOperation,
   Transaction as ox_Transaction,
   TransactionRequest as ox_TransactionRequest,
 } from 'ox/tempo'
@@ -12,7 +12,7 @@ import { parseAccount } from '../accounts/utils/parseAccount.js'
 import { formatTransaction as viem_formatTransaction } from '../utils/formatters/transaction.js'
 import { formatTransactionReceipt as viem_formatTransactionReceipt } from '../utils/formatters/transactionReceipt.js'
 import { formatTransactionRequest as viem_formatTransactionRequest } from '../utils/formatters/transactionRequest.js'
-import type { Account, MultisigAccount } from './Account.js'
+import type { Account, ConfigurableAccount } from './Account.js'
 import {
   isTempo,
   type Transaction,
@@ -33,7 +33,7 @@ export function formatTransaction(
     transaction.blockTimestamp == null
       ? undefined
       : BigInt(transaction.blockTimestamp)
-  const multisig = transaction.multisig
+  const operation = transaction.operation
   const {
     feePayerSignature,
     gasPrice: _,
@@ -53,8 +53,8 @@ export function formatTransaction(
           yParity: feePayerSignature.yParity,
         }
       : undefined,
-    multisig: formatMultisig(multisig),
     nonce: Number(nonce),
+    operation: formatOperation(operation),
     typeHex:
       ox_Transaction.toRpcType[
         tx.type as keyof typeof ox_Transaction.toRpcType
@@ -69,7 +69,7 @@ export function formatTransactionReceipt(
   const transactionReceipt = viem_formatTransactionReceipt(receipt as never)
   return {
     ...transactionReceipt,
-    multisig: formatMultisig(receipt.multisig),
+    operation: formatOperation(receipt.operation),
     ...(receipt.status === 'pending'
       ? { status: 'pending', type: 'tempo' }
       : {}),
@@ -77,11 +77,11 @@ export function formatTransactionReceipt(
 }
 
 /** Formats a transaction operation attached to an RPC result. */
-function formatMultisig(value: MultisigOperation.TransactionRpc | undefined) {
+function formatOperation(value: AccountOperation.TransactionRpc | undefined) {
   if (!value) return undefined
-  const operation = MultisigOperation.fromRpc(value)
+  const operation = AccountOperation.fromRpc(value)
   if (operation.type !== 'transaction')
-    throw new Error('Expected a multisig transaction operation.')
+    throw new Error('Expected an account transaction operation.')
   return operation
 }
 
@@ -98,21 +98,21 @@ export function formatTransactionRequest(
     keyData?: Hex.Hex | undefined
     keyId?: Address | undefined
     keyType?: 'p256' | 'secp256k1' | 'webAuthn' | undefined
-    owner?: viem_Account | MultisigAccount | Address | undefined
+    owner?: viem_Account | ConfigurableAccount | Address | undefined
     signatures?: unknown
   }
   const account = request.account
     ? parseAccount<Account | viem_Account | Address>(request.account)
     : undefined
   const owner = request.owner
-    ? parseAccount<Account | MultisigAccount | viem_Account | Address>(
+    ? parseAccount<Account | ConfigurableAccount | viem_Account | Address>(
         request.owner,
       )
     : undefined
 
   if (owner?.type === 'json-rpc')
     throw new Error(
-      'A local owner account is required to approve a multisig transaction.',
+      'A local owner account is required to approve a configurable account transaction.',
     )
 
   // If the request is not a Tempo transaction, route to Viem formatter.
@@ -147,7 +147,7 @@ export function formatTransactionRequest(
   if (request.feePayer === true && !request.feePayerSignature)
     delete request.feeToken
 
-  // Client-only TIP-1061 fields drive local signing and envelope assembly.
+  // Client-only TIP-1107 fields drive local signing and envelope assembly.
   const { owner: _owner, signatures: _signatures, ...rpcRequest } = request
 
   const rpc = ox_TransactionRequest.toRpc({
@@ -191,7 +191,8 @@ export function formatTransactionRequest(
     ...(keyData ? { keyData } : {}),
     ...(keyId ? { keyId } : {}),
     ...(keyType ? { keyType } : {}),
-    // Keep the key visible to `extract`; the undefined value never reaches JSON-RPC.
+    // Keep client-only keys visible to `extract`; undefined values never reach JSON-RPC.
+    ...(request.accountSimulation ? { accountSimulation: undefined } : {}),
     ...(request.owner ? { owner: undefined } : {}),
     ...(typeof request.feePayer !== 'undefined'
       ? {

package/tempo/KeyAuthorizationManager.ts

@@ -1,49 +1,101 @@
 import type { Address } from 'abitype'
-import type { KeyAuthorization } from 'ox/tempo'
+import { KeyAuthorization } from 'ox/tempo'
 import type { MaybePromise } from '../types/utils.js'
+import * as Store from './Store.js'
 
+/** Identifies a pending key authorization by account, access key, and chain. */
 export type Key = {
+  /** Account the access key acts for. */
   address: Address
+  /** Access key address. */
   accessKey: Address
+  /** Chain the authorization is for. */
   chainId: number
 }
 
+/** 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>
 }
 
+/**
+ * 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 { Account, KeyAuthorizationManager, Store } from 'viem/tempo'
+ *
+ * const accessKey = Account.fromP256(privateKey, {
+ *   access: root,
+ *   keyAuthorizationManager: KeyAuthorizationManager.from({
+ *     store: Store.session(),
+ *   }),
+ * })
+ * ```
+ *
+ * @param options - Manager 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 {
+        return KeyAuthorization.deserialize(
+          value as `0x${string}`,
+        ) as KeyAuthorization.Signed
+      } 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: KeyAuthorizationManager
+    /** Store for pending key authorizations. */
+    store: Store.Store
   }
 }
 
+/**
+ * Creates a key authorization manager backed by a process-local memory store.
+ *
+ * @example
+ * ```ts
+ * import { KeyAuthorizationManager } from 'viem/tempo'
+ *
+ * const keyAuthorizationManager = 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/tempo/Relay.ts

@@ -4,9 +4,10 @@ import type { LocalAccount } from '../accounts/types.js'
 import type { Client as Client_ } from '../clients/createClient.js'
 import { ChainNotConfiguredError } from '../clients/createClientResolver.js'
 import type { EIP1193RequestOptions } from '../types/eip1193.js'
+import * as Accounts from './internal/relay/accounts.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 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'
@@ -307,13 +308,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
@@ -321,31 +328,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
@@ -400,6 +407,55 @@ 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 } from 'viem'
+ * import { 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/tempo/Transaction.ts

@@ -4,11 +4,11 @@ import type { Address } from 'abitype'
 import * as Hex from 'ox/Hex'
 import * as Signature from 'ox/Signature'
 import {
+  AccountConfig,
+  type AccountOperation,
+  type AccountSimulation,
   type AuthorizationTempo,
   type KeyAuthorization,
-  MultisigConfig,
-  type MultisigOperation,
-  type MultisigSimulation,
   type TransactionReceipt as ox_TransactionReceipt,
   SignatureEnvelope,
   type TempoAddress,
@@ -43,7 +43,7 @@ import {
 } from '../utils/transaction/parseTransaction.js'
 import { serializeTransaction as viem_serializeTransaction } from '../utils/transaction/serializeTransaction.js'
 import type { RootAccount } from './Account.js'
-import { parseApproval } from './multisig/Signature.js'
+import { parseApproval } from './accounts/Signature.js'
 
 export type Transaction<
   bigintType = bigint,
@@ -61,7 +61,7 @@ export type TransactionRpc<pending extends boolean = false> = OneOf<
     > & {
       authorizationList?: AuthorizationTempo.ListRpc | undefined
       keyAuthorization?: KeyAuthorization.Rpc | null | undefined
-      multisig?: MultisigOperation.TransactionRpc | undefined
+      operation?: AccountOperation.TransactionRpc | undefined
       signature: SignatureEnvelope.SignatureEnvelopeRpc
     })
 >
@@ -82,7 +82,7 @@ export type TransactionTempo<
   feeToken?: Address | undefined
   feePayerSignature?: viem_Signature | undefined
   keyAuthorization?: KeyAuthorization.Signed<quantity, index> | null | undefined
-  multisig?: MultisigOperation.TransactionOperation | undefined
+  operation?: AccountOperation.TransactionOperation | undefined
   nonceKey?: quantity | undefined
   signature: SignatureEnvelope.SignatureEnvelope
   type: type
@@ -98,7 +98,14 @@ export type TransactionRequest<
   | TransactionRequestTempo<bigintType, numberType>
 >
 export type TransactionRequestRpc = OneOf<
-  viem_RpcTransactionRequest | TransactionRequestTempo<Hex.Hex, Hex.Hex, '0x76'>
+  | viem_RpcTransactionRequest
+  | (Omit<
+      TransactionRequestTempo<Hex.Hex, Hex.Hex, '0x76'>,
+      'accountSimulation'
+    > & {
+      /** Account simulation spec, named `multisigSimulation` by the node. */
+      multisigSimulation?: AccountSimulation.Rpc | undefined
+    })
 >
 
 export type TransactionReceipt<
@@ -106,11 +113,11 @@ export type TransactionReceipt<
   index = number,
   status = 'success' | 'reverted' | 'pending',
   type = TransactionType,
-  multisig = MultisigOperation.TransactionOperation,
+  operation = AccountOperation.TransactionOperation,
 > = viem_TransactionReceipt<quantity, index, status, type> & {
   feePayer?: Address | undefined
   feeToken?: Address | undefined
-  multisig?: multisig | undefined
+  operation?: operation | undefined
 }
 
 export type TransactionReceiptRpc = TransactionReceipt<
@@ -118,7 +125,7 @@ export type TransactionReceiptRpc = TransactionReceipt<
   Hex.Hex,
   ox_TransactionReceipt.RpcStatus | 'pending',
   ox_TransactionReceipt.RpcType,
-  MultisigOperation.TransactionRpc
+  AccountOperation.TransactionRpc
 >
 
 export type TransactionRequestTempo<
@@ -128,6 +135,7 @@ export type TransactionRequestTempo<
 > = TransactionRequestBase<quantity, index, type> &
   ExactPartial<FeeValuesEIP1559<quantity>> & {
     accessList?: AccessList | undefined
+    accountSimulation?: AccountSimulation.Spec | undefined
     calls?: readonly TxTempo.Call<quantity, TempoAddress.Address>[] | undefined
     capabilities?: ExtractCapabilities<'fillTransaction', 'Request'> | undefined
     /** Fee-payer account, external relay URL, or sponsorship preference. */
@@ -135,7 +143,6 @@ export type TransactionRequestTempo<
     feeToken?: TempoAddress.Address | bigint | undefined
     hash?: Hex.Hex | undefined
     keyAuthorization?: KeyAuthorization.Signed<quantity, index> | undefined
-    multisigSimulation?: MultisigSimulation.Spec | undefined
     /** Nonce lane, or `'expiring'` for time-bounded transactions. `nonce` can distinguish otherwise identical expiring transactions. */
     nonceKey?: 'expiring' | quantity | undefined
     owner?: RootAccount | undefined
@@ -168,17 +175,17 @@ export type TransactionSerializableTempo<
   } & (
     | {
         from: Address
-        multisigSimulation?: MultisigSimulation.Spec | undefined
+        accountSimulation?: AccountSimulation.Spec | undefined
         signatures?: readonly SignatureEnvelope.Serialized[] | undefined
       }
     | {
         from?: Address | undefined
-        multisigSimulation?: undefined
+        accountSimulation?: undefined
         signatures?: readonly SignatureEnvelope.Serialized[] | undefined
       }
     | {
         from?: Address | undefined
-        multisigSimulation?: MultisigSimulation.Spec | undefined
+        accountSimulation?: AccountSimulation.Spec | undefined
         signatures?: undefined
       }
   )
@@ -201,13 +208,13 @@ export function getType(
   if (
     (account?.keyType && account.keyType !== 'secp256k1') ||
     account?.source === 'accessKey' ||
-    account?.source === 'multisig' ||
+    account?.source === 'configurable' ||
     typeof transaction.calls !== 'undefined' ||
     typeof transaction.feePayer !== 'undefined' ||
     typeof transaction.feePayerSignature !== 'undefined' ||
     typeof transaction.feeToken !== 'undefined' ||
     typeof transaction.keyAuthorization !== 'undefined' ||
-    typeof transaction.multisigSimulation !== 'undefined' ||
+    typeof transaction.accountSimulation !== 'undefined' ||
     typeof transaction.nonceKey !== 'undefined' ||
     typeof transaction.owner !== 'undefined' ||
     typeof transaction.signature !== 'undefined' ||
@@ -314,7 +321,7 @@ async function serializeTempo(
   },
   sig?: OneOf<SignatureEnvelope.SignatureEnvelope | viem_Signature> | undefined,
 ) {
-  // Track caller signatures separately from synthesized multisig approvals.
+  // Track caller signatures separately from synthesized owner approvals.
   const signature_provided = (() => {
     if (transaction.signature) return transaction.signature
     if (sig && 'type' in sig) return sig as SignatureEnvelope.SignatureEnvelope
@@ -330,7 +337,7 @@ async function serializeTempo(
   const {
     chainId,
     feePayer,
-    multisigSimulation,
+    accountSimulation,
     nonce,
     owner: _owner,
     ...rest
@@ -352,7 +359,7 @@ async function serializeTempo(
     transaction.feePayerSignature !== null
   const hasSenderSignature =
     typeof signature_provided !== 'undefined' ||
-    Boolean(multisigSimulation && transaction.signatures)
+    Boolean(accountSimulation && transaction.signatures)
   // Sponsorship sender signatures omit `feeToken`.
   const shouldStripFeeTokenForSponsorship =
     // Relay fills a partial sender envelope first.
@@ -393,16 +400,17 @@ async function serializeTempo(
   // Combine owner approvals before fee-payer handling.
   const signature = (() => {
     if (signature_provided) return signature_provided
-    if (!multisigSimulation || !transaction.signatures) return undefined
+    if (!accountSimulation || !transaction.signatures) return undefined
 
     const payload = TxTempo.getSignPayload(TxTempo.from(transaction_sender_ox))
     const signatures = transaction.signatures.map((approval) =>
       parseApproval(approval),
     )
-    const config = MultisigConfig.from(multisigSimulation.config)
+    const config = AccountConfig.from(accountSimulation.config)
     const account = transaction.from
-    if (!account) throw new Error('A multisig sender is required for signing.')
-    const sorted = SignatureEnvelope.sortMultisigApprovals({
+    if (!account)
+      throw new Error('A configurable account sender is required for signing.')
+    const sorted = SignatureEnvelope.sortApprovals({
       account,
       config,
       payload,