viem 2.57.4 → 2.57.5

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',
     })
   }
 }

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

@@ -1,6 +1,6 @@
 import type * as Hex from 'ox/Hex'
 import * as Json from 'ox/Json'
-import { MultisigOperation, SignatureEnvelope, TxEnvelopeTempo } from 'ox/tempo'
+import { AccountOperation, SignatureEnvelope, TxEnvelopeTempo } from 'ox/tempo'
 import { BaseError } from '../../errors/base.js'
 import type * as Store from '../Store.js'
 
@@ -13,11 +13,11 @@ const maxUpdateAttempts = 32
 /** Bounds abandoned operation state while allowing long-lived approval ceremonies. */
 const pendingOperationTtl = 30 * 24 * 60 * 60 * 1_000
 
-/** Reads a persisted multisig operation. */
+/** Reads a persisted account operation. */
 export async function read(
   store: Store.Store,
   hash: Hex.Hex,
-): Promise<MultisigOperation.Operation | null> {
+): Promise<AccountOperation.Operation | null> {
   const value = await store.getItem(operationKey(hash))
   if (value === null || value === undefined) return null
   const operation = deserialize(value)
@@ -26,14 +26,14 @@ export async function read(
   return operation
 }
 
-/** Atomically updates a multisig operation. */
+/** Atomically updates an account operation. */
 export async function update(
   store: Store.Atomic,
   hash: Hex.Hex,
   update: (
-    operation: MultisigOperation.Operation | null,
-  ) => MultisigOperation.Operation | Promise<MultisigOperation.Operation>,
-): Promise<MultisigOperation.Operation> {
+    operation: AccountOperation.Operation | null,
+  ) => AccountOperation.Operation | Promise<AccountOperation.Operation>,
+): Promise<AccountOperation.Operation> {
   const key = operationKey(hash)
   for (let attempt = 0; attempt < maxUpdateAttempts; attempt++) {
     const value = (await store.getItem(key)) ?? null
@@ -41,9 +41,9 @@ export async function update(
     if (current && current.hash.toLowerCase() !== hash.toLowerCase())
       throw new InvalidStoreValueError()
     const value_ = await update(current)
-    let next: MultisigOperation.Operation
+    let next: AccountOperation.Operation
     try {
-      next = MultisigOperation.from(value_)
+      next = AccountOperation.from(value_)
     } catch (cause) {
       throw new InvalidStoreValueError({ cause })
     }
@@ -62,7 +62,7 @@ export async function update(
 /** Reads a submission hash without rebuilding its envelope from mutable configurations. */
 export async function readSubmission(
   store: Store.Store,
-  operation: MultisigOperation.TransactionOperation,
+  operation: AccountOperation.TransactionOperation,
   submissionId: Hex.Hex,
 ): Promise<Hex.Hex | null> {
   const value = await store.getItem(submissionKey(operation.hash, submissionId))
@@ -72,9 +72,9 @@ export async function readSubmission(
     const transaction = TxEnvelopeTempo.deserialize(
       value as TxEnvelopeTempo.Serialized,
     )
-    if (transaction.signature?.type !== 'multisig')
+    if (transaction.signature?.type !== 'configurable')
       throw new InvalidStoreValueError()
-    const serialized = MultisigOperation.serializeTransaction(operation, {
+    const serialized = AccountOperation.serializeTransaction(operation, {
       approvals: transaction.signature.signatures.map((signature) =>
         SignatureEnvelope.serialize(signature),
       ),
@@ -123,11 +123,11 @@ export async function writeSubmission(
   }
 }
 
-/** Deserializes a multisig operation from storage. */
-function deserialize(value: string): MultisigOperation.Operation {
+/** Deserializes an account operation from storage. */
+function deserialize(value: string): AccountOperation.Operation {
   try {
     if (value.length > maxStoredValueLength) throw new InvalidStoreValueError()
-    const operation = MultisigOperation.from(Json.parse(value) as never)
+    const operation = AccountOperation.from(Json.parse(value) as never)
     assertHash(operation)
     return operation
   } catch (cause) {
@@ -136,10 +136,10 @@ function deserialize(value: string): MultisigOperation.Operation {
   }
 }
 
-/** Serializes a multisig operation for storage. */
-function serialize(operation: MultisigOperation.Operation): string {
+/** Serializes an account operation for storage. */
+function serialize(operation: AccountOperation.Operation): string {
   try {
-    const operation_ = MultisigOperation.from(operation)
+    const operation_ = AccountOperation.from(operation)
     assertHash(operation_)
     const value = Json.stringify(operation_)
     if (value.length > maxStoredValueLength) throw new InvalidStoreValueError()
@@ -151,8 +151,8 @@ function serialize(operation: MultisigOperation.Operation): string {
 }
 
 /** Verifies that the operation hash commits to its stored payload. */
-function assertHash(operation: MultisigOperation.Operation) {
-  const hash = MultisigOperation.getHash(
+function assertHash(operation: AccountOperation.Operation) {
+  const hash = AccountOperation.getHash(
     operation.type === 'transaction'
       ? {
           account: operation.account,
@@ -181,13 +181,13 @@ function submissionKey(hash: Hex.Hex, submissionId: Hex.Hex) {
   return `multisig:submission:${hash.toLowerCase()}:${submissionId.toLowerCase()}`
 }
 
-/** Thrown when a stored multisig operation is malformed or unsupported. */
+/** Thrown when a stored account operation is malformed or unsupported. */
 export class InvalidStoreValueError extends BaseError {
   /** Creates an invalid store value error. */
   constructor(options: InvalidStoreValueError.Options = {}) {
-    super('Stored multisig operation is malformed or unsupported.', {
+    super('Stored account operation is malformed or unsupported.', {
       cause: options.cause as Error | undefined,
-      name: 'Multisig.Operation.InvalidStoreValueError',
+      name: 'Accounts.Operation.InvalidStoreValueError',
     })
   }
 }
@@ -200,12 +200,12 @@ export declare namespace InvalidStoreValueError {
   }
 }
 
-/** Thrown when a multisig operation cannot be updated due to contention. */
+/** Thrown when an account operation cannot be updated due to contention. */
 class StoreConflictError extends BaseError {
   /** Creates a store conflict error. */
   constructor() {
-    super('Multisig operation could not be updated after repeated conflicts.', {
-      name: 'Multisig.Operation.StoreConflictError',
+    super('Account operation could not be updated after repeated conflicts.', {
+      name: 'Accounts.Operation.StoreConflictError',
     })
   }
 }

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

@@ -1,11 +1,13 @@
 import { SignatureEnvelope } from 'ox/tempo'
 
-/** Parses a primitive multisig owner approval. */
+/** Parses a primitive owner approval. */
 export function parseApproval(
   signature: SignatureEnvelope.Serialized,
 ): SignatureEnvelope.Primitive {
   const approval = SignatureEnvelope.from(signature)
-  if (approval.type === 'multisig' || approval.type === 'keychain')
-    throw new Error('Multisig owners must use primitive signatures.')
+  if (approval.type === 'configurable' || approval.type === 'keychain')
+    throw new Error(
+      'Configurable account owners must use primitive signatures.',
+    )
   return approval
 }