viem 2.57.4 → 2.57.6

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,

package/tempo/Transport.ts

@@ -86,7 +86,7 @@ type RelayProxyParameters = {
 }
 
 export type FeePayer = Transport<typeof withFeePayer.type>
-export type Relay = Transport<typeof withRelay.type, { multisig: true }>
+export type Relay = Transport<typeof withRelay.type, { accounts: true }>
 
 /**
  * Creates a relay transport that routes requests between
@@ -94,8 +94,10 @@ export type Relay = Transport<typeof withRelay.type, { multisig: true }>
  *
  * All `eth_fillTransaction` requests are sent to the relay with the request's
  * `feePayer` value preserved so the relay can decide whether to sponsor the transaction.
- * Multisig approvals, configs, operations, and operation-aware transaction
+ * Owner approvals, configs, operations, and operation-aware transaction
  * lookups are also sent to the relay so it can coordinate approvals in its store.
+ * Signed key authorizations are saved to relays with key authorization storage
+ * so they can attach them to the access key's next transaction.
  *
  * The policy parameter controls how the relay handles sponsored transactions:
  * - `'sign-only'`: Relay co-signs the transaction and returns it to the client transport, which then broadcasts it via the default transport
@@ -116,11 +118,11 @@ export function withRelay<
   defaultTransport: transport,
   options: withRelay.LocalOptions<plugins>,
 ): withRelay.LocalReturnValue<transport, plugins>
-export function withRelay(
+export function withRelay<const parameters extends withRelay.Parameters = {}>(
   defaultTransport: Transport,
   relayTransport: Transport,
-  parameters?: withRelay.Parameters,
-): withRelay.ReturnValue
+  parameters?: parameters | withRelay.Parameters,
+): withRelay.ReturnValue<parameters>
 export function withRelay(
   defaultTransport: Transport,
   relayTransport: Transport | withRelay.LocalOptions,
@@ -145,14 +147,17 @@ export function withRelay(
           })) as typeof transport.request,
         value: {
           ...transport.value,
-          ...(relayTransport.plugins?.some(Plugin_.isMultisig)
-            ? { multisig: true }
+          ...(relayTransport.plugins?.some(Plugin_.isAccounts)
+            ? { accounts: true }
+            : {}),
+          ...(relayTransport.plugins?.some(Plugin_.isKeyAuthorization)
+            ? { keyAuthorization: true }
             : {}),
         },
       }
     }
 
-  const { policy = 'sign-only' } = parameters ?? {}
+  const { keyAuthorization, policy = 'sign-only' } = parameters ?? {}
 
   return (config) => {
     const transport_default = defaultTransport(config)
@@ -179,7 +184,7 @@ export function withRelay(
           const operation = await (async () => {
             try {
               return await transport_relay.request(
-                { method: 'multisig_getOperation', params },
+                { method: 'account_getOperation', params },
                 options,
               )
             } catch (error) {
@@ -187,7 +192,7 @@ export function withRelay(
                 error instanceof MethodNotFoundRpcError ||
                 error instanceof MethodNotSupportedRpcError
               ) {
-                // Relays created before multisig coordination do not expose this method.
+                // Relays without the accounts plugin do not expose this method.
                 return null
               }
               throw error
@@ -204,11 +209,12 @@ 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' ||
+          method === 'relay_saveKeyAuthorization'
         )
           return transport_relay.request({ method, params }, options) as never
 
@@ -219,7 +225,7 @@ export function withRelay(
           const serialized = (params as any)[0] as `0x76${string}`
           const transaction = Transaction.deserialize(serialized)
 
-          if (transaction.signature?.type === 'multisig')
+          if (transaction.signature?.type === 'configurable')
             return transport_relay.request({ method, params }, options) as never
 
           // Serialized Tempo envelopes encode `feePayer: true` as a missing fee payer
@@ -259,14 +265,23 @@ export function withRelay(
       },
       type: withRelay.type,
     })
-    return { ...transport, value: { multisig: true } }
+    return {
+      ...transport,
+      value: {
+        accounts: true,
+        ...(keyAuthorization ? { keyAuthorization } : {}),
+      },
+    }
   }
 }
 
 export declare namespace withRelay {
   export const type = 'relay'
 
-  export type Parameters = RelayProxyParameters
+  export type Parameters = RelayProxyParameters & {
+    /** Whether the relay stores key authorizations with `Relay.keyAuthorization`. Defaults to `false`. */
+    keyAuthorization?: boolean | undefined
+  }
 
   /** Plugins applied directly to the default transport. */
   export type LocalOptions<
@@ -284,14 +299,27 @@ export declare namespace withRelay {
     ? Transport<
         type,
         attributes &
-          (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
 
-  export type ReturnValue = Relay
+  /** Remote relay transport, advertising key authorization storage when enabled. */
+  export type ReturnValue<parameters extends Parameters = {}> =
+    parameters extends { keyAuthorization: true }
+      ? Transport<
+          typeof withRelay.type,
+          { accounts: true; keyAuthorization: true }
+        >
+      : Relay
 }
 
 /** @deprecated Use `withRelay` instead. */

package/tempo/{multisig → accounts}/Config.ts

@@ -2,7 +2,7 @@ import * as Address from 'ox/Address'
 import * as Hash from 'ox/Hash'
 import type * as Hex from 'ox/Hex'
 import * as Json from 'ox/Json'
-import { MultisigConfig } from 'ox/tempo'
+import { AccountConfig } from 'ox/tempo'
 import { BaseError } from '../../errors/base.js'
 import { nativeMultisigFactory } from '../Addresses.js'
 import type * as Store from '../Store.js'
@@ -13,11 +13,11 @@ const maxStoredValueLength = 65_536
 /** Zero commitment used before an account is initialized. */
 const zeroCommitment = `0x${'00'.repeat(32)}` as const
 
-/** Reads a cached multisig config. */
+/** Reads a cached account config. */
 export async function read(
   store: Store.Store,
   options: read.Options,
-): Promise<MultisigConfig.Config | null> {
+): Promise<AccountConfig.Config | null> {
   const { address, commitment } = options
   const value = await store.getItem(key({ address, commitment }))
   if (value === null || value === undefined) return null
@@ -29,27 +29,27 @@ export async function read(
 export declare namespace read {
   /** Parameters for {@link read}. */
   export type Options = {
-    /** Multisig account address. */
+    /** Configurable account address. */
     address: Address.Address
     /** Config commitment observed onchain. */
     commitment: Hex.Hex
   }
 }
 
-/** Writes a validated multisig config. */
+/** Writes a validated account config. */
 export async function write(
   store: Store.Store,
   options: write.Options,
 ): Promise<void> {
   const { address, commitment } = options
-  const config = MultisigConfig.from(options.config)
+  const config = AccountConfig.from(options.config)
   assertKey({ address, commitment, config })
   const value = serialize(config)
   await store.setItem(key({ address, commitment }), value)
   // Initialization commits the version-zero config without changing its version.
   if (commitment.toLowerCase() === zeroCommitment)
     await store.setItem(
-      key({ address, commitment: MultisigConfig.getCommitment(config) }),
+      key({ address, commitment: AccountConfig.getCommitment(config) }),
       value,
     )
 }
@@ -57,12 +57,12 @@ export async function write(
 export declare namespace write {
   /** Parameters for {@link write}. */
   export type Options = {
-    /** Multisig account address. */
+    /** Configurable account address. */
     address: Address.Address
     /** Config commitment used for lookup. */
     commitment: Hex.Hex
     /** Complete config. */
-    config: MultisigConfig.Config
+    config: AccountConfig.Config
   }
 }
 
@@ -70,7 +70,7 @@ export declare namespace write {
 function assertKey(options: {
   address: Address.Address
   commitment: Hex.Hex
-  config: MultisigConfig.Config
+  config: AccountConfig.Config
 }) {
   const { address, commitment, config } = options
   if (!Address.validate(address) || !Hash.validate(commitment))
@@ -78,7 +78,7 @@ function assertKey(options: {
   if (config.version === 0n) {
     if (
       !Address.isEqual(
-        MultisigConfig.getAddress(config, { factory: nativeMultisigFactory }),
+        AccountConfig.getAddress(config, { factory: nativeMultisigFactory }),
         address,
       )
     )
@@ -86,17 +86,17 @@ function assertKey(options: {
     if (commitment.toLowerCase() === zeroCommitment) return
   }
   if (
-    MultisigConfig.getCommitment(config).toLowerCase() !==
+    AccountConfig.getCommitment(config).toLowerCase() !==
     commitment.toLowerCase()
   )
     throw new InvalidStoreValueError()
 }
 
-/** Deserializes a multisig config from storage. */
-function deserialize(value: string): MultisigConfig.Config {
+/** Deserializes an account config from storage. */
+function deserialize(value: string): AccountConfig.Config {
   try {
     if (value.length > maxStoredValueLength) throw new InvalidStoreValueError()
-    return MultisigConfig.fromRpc(Json.parse(value) as never)
+    return AccountConfig.fromRpc(Json.parse(value) as never)
   } catch (cause) {
     if (cause instanceof InvalidStoreValueError) throw cause
     throw new InvalidStoreValueError({ cause })
@@ -109,10 +109,10 @@ function key(options: { address: Address.Address; commitment: Hex.Hex }) {
   return `multisig:config:${address.toLowerCase()}:${commitment.toLowerCase()}`
 }
 
-/** Serializes a multisig config for storage. */
-function serialize(config: MultisigConfig.Config): string {
+/** Serializes an account config for storage. */
+function serialize(config: AccountConfig.Config): string {
   try {
-    const value = Json.stringify(MultisigConfig.toRpc(config))
+    const value = Json.stringify(AccountConfig.toRpc(config))
     if (value.length > maxStoredValueLength) throw new InvalidStoreValueError()
     return value
   } catch (cause) {
@@ -121,14 +121,14 @@ function serialize(config: MultisigConfig.Config): string {
   }
 }
 
-/** Thrown when a stored multisig config is malformed or mismatched. */
+/** Thrown when a stored account config is malformed or mismatched. */
 // biome-ignore lint/correctness/noUnusedVariables: declaration merge
 class InvalidStoreValueError extends BaseError {
   /** Creates an invalid store value error. */
   constructor(options: InvalidStoreValueError.Options = {}) {
-    super('Stored multisig config is malformed or mismatched.', {
+    super('Stored account config is malformed or mismatched.', {
       cause: options.cause as Error | undefined,
-      name: 'Multisig.Config.InvalidStoreValueError',
+      name: 'Accounts.Config.InvalidStoreValueError',
     })
   }
 }