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

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

@@ -1,6 +1,6 @@
 import type { Hex } from 'ox'
 import { Address, Hash, Json } from 'ox'
-import { MultisigConfig } from 'ox/tempo'
+import { AccountConfig } from 'ox/tempo'
 import { BaseError } from '../../core/Errors.js'
 import { nativeMultisigFactory } from '../Addresses.js'
 import type * as Store from '../Store.js'
@@ -11,11 +11,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
@@ -27,27 +27,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,
     )
 }
@@ -55,12 +55,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
   }
 }
 
@@ -68,7 +68,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))
@@ -76,7 +76,7 @@ function assertKey(options: {
   if (config.version === 0n) {
     if (
       !Address.isEqual(
-        MultisigConfig.getAddress(config, { factory: nativeMultisigFactory }),
+        AccountConfig.getAddress(config, { factory: nativeMultisigFactory }),
         address,
       )
     )
@@ -84,17 +84,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 })
@@ -107,10 +107,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) {
@@ -119,12 +119,12 @@ 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. */
 export class InvalidStoreValueError extends BaseError<Error | undefined> {
-  override name = 'Multisig.Config.InvalidStoreValueError'
+  override name = 'Accounts.Config.InvalidStoreValueError'
   /** 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,
     })
   }

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

@@ -1,6 +1,6 @@
 import type { Hex } from 'ox'
 import { Json } from 'ox'
-import { MultisigOperation, SignatureEnvelope, TxEnvelopeTempo } from 'ox/tempo'
+import { AccountOperation, SignatureEnvelope, TxEnvelopeTempo } from 'ox/tempo'
 import { BaseError } from '../../core/Errors.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,12 +181,12 @@ 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<Error | undefined> {
-  override name = 'Multisig.Operation.InvalidStoreValueError'
+  override name = 'Accounts.Operation.InvalidStoreValueError'
   /** 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,
     })
   }
@@ -200,13 +200,13 @@ 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. */
 export class StoreConflictError extends BaseError<Error | undefined> {
-  override name = 'Multisig.Operation.StoreConflictError'
+  override name = 'Accounts.Operation.StoreConflictError'
   /** Creates a store conflict error. */
   constructor() {
     super(
-      'Multisig operation could not be updated after repeated conflicts.',
+      'Account operation could not be updated after repeated conflicts.',
       {},
     )
   }

package/src/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
 }

package/src/tempo/actions/accessKey/index.ts

@@ -9,6 +9,7 @@ export { isAdmin } from './isAdmin.js'
 export { isWitnessBurned } from './isWitnessBurned.js'
 export { revoke } from './revoke.js'
 export { revokeSync } from './revokeSync.js'
+export { saveAuthorization } from './saveAuthorization.js'
 export { signAuthorization } from './signAuthorization.js'
 export { updateLimit } from './updateLimit.js'
 export { updateLimitSync } from './updateLimitSync.js'

package/src/tempo/actions/accessKey/prepareAuthorization.ts

@@ -1,5 +1,5 @@
 import { Address, type Hex } from 'ox'
-import { KeyAuthorization, MultisigConfig } from 'ox/tempo'
+import { AccountConfig, KeyAuthorization } from 'ox/tempo'
 import * as CoreAccount from '../../../core/Account.js'
 import type * as Chain from '../../../core/Chain.js'
 import type * as Client from '../../../core/Client.js'
@@ -8,7 +8,7 @@ import {
   getKeyAuthorizationSignPayload,
   resolveAccessKey,
   signKeyAuthorization,
-  type MultisigAccount,
+  type ConfigurableAccount,
 } from '../../Account.js'
 
 /**
@@ -42,13 +42,14 @@ export async function prepareAuthorization<
   if (!account_) throw new Error('account is required.')
   if (!chainId) throw new Error('chainId is required.')
   const parsed = CoreAccount.from(account_)
-  const multisigState = await (async () => {
-    if ('multisig' in parameters) return parameters.multisig
-    if (!('source' in parsed) || parsed.source !== 'multisig') return undefined
-    const account = parsed as MultisigAccount
+  const configurableState = await (async () => {
+    if ('configurable' in parameters) return parameters.configurable
+    if (!('source' in parsed) || parsed.source !== 'configurable')
+      return undefined
+    const account = parsed as ConfigurableAccount
     if (!account.config)
       throw new Error(
-        'A multisig config is required to prepare a key authorization.',
+        'An account config is required to prepare a key authorization.',
       )
     return { config: account.config }
   })()
@@ -61,10 +62,10 @@ export async function prepareAuthorization<
     },
   )
   const signPayload =
-    'source' in parsed && parsed.source === 'multisig' && multisigState
-      ? MultisigConfig.getSignPayload({
+    'source' in parsed && parsed.source === 'configurable' && configurableState
+      ? AccountConfig.getSignPayload({
           account: parsed.address,
-          config: multisigState.config,
+          config: configurableState.config,
           payload: authorizationSignPayload,
         })
       : authorizationSignPayload
@@ -72,7 +73,7 @@ export async function prepareAuthorization<
     ...parameters,
     account: parsed,
     chainId,
-    multisig: multisigState,
+    configurable: configurableState,
     signPayload,
   } as prepareAuthorization.ReturnType
 }
@@ -103,8 +104,8 @@ export namespace prepareAuthorization {
     limits?:
       | { token: Address.Address; limit: bigint; period?: number | undefined }[]
       | undefined
-    /** @internal Prepared multisig state. */
-    multisig?: signKeyAuthorization.Parameters['multisig']
+    /** @internal Prepared configurable account state. */
+    configurable?: signKeyAuthorization.Parameters['configurable']
     /** Call scopes restricting which contracts/selectors this key can call. */
     scopes?: KeyAuthorization.Scope[] | undefined
     /**
@@ -124,8 +125,8 @@ export namespace prepareAuthorization {
     Omit<Options<CoreAccount.Account | undefined>, 'account' | 'chainId'> & {
       account: CoreAccount.Account
       chainId: number
-      multisig: signKeyAuthorization.Parameters['multisig']
-      /** Payload that the authorizing account or multisig owners sign. */
+      configurable: signKeyAuthorization.Parameters['configurable']
+      /** Payload that the authorizing account or owners sign. */
       signPayload: Hex.Hex
     }
   >

package/src/tempo/actions/accessKey/saveAuthorization.ts

@@ -0,0 +1,51 @@
+import type { Errors } from 'ox'
+import { KeyAuthorization } from 'ox/tempo'
+import type * as Client from '../../../core/Client.js'
+
+/**
+ * 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. Use this for authorizations signed outside
+ * `signAuthorization`, such as on another device. Requires a relay running the
+ * `Relay.keyAuthorization` plugin.
+ *
+ * @example
+ * ```ts
+ * import { Actions, Client, http, withRelay } from 'viem/tempo'
+ *
+ * const client = Client.create({
+ *   transport: withRelay(http(), http('https://relay.example.com'), {
+ *     keyAuthorization: true,
+ *   }),
+ * })
+ *
+ * await Actions.accessKey.saveAuthorization(client, { keyAuthorization })
+ * ```
+ *
+ * @param client - Client.
+ * @param options - Options.
+ */
+export async function saveAuthorization(
+  client: Client.Client,
+  options: saveAuthorization.Options,
+): Promise<saveAuthorization.ReturnType> {
+  await client.request({
+    method: 'relay_saveKeyAuthorization',
+    params: [KeyAuthorization.toRpc(options.keyAuthorization)],
+  })
+}
+
+export declare namespace saveAuthorization {
+  /** Options for {@link saveAuthorization}. */
+  export type Options = {
+    /** Signed key authorization to save. */
+    keyAuthorization: KeyAuthorization.Signed
+  }
+
+  /** Return value for {@link saveAuthorization}. */
+  export type ReturnType = void
+
+  /** Error type for {@link saveAuthorization}. */
+  export type ErrorType = Errors.GlobalErrorType
+}

package/src/tempo/actions/accessKey/signAuthorization.ts

@@ -1,23 +1,20 @@
-import { parseApproval } from '../../multisig/Signature.js'
-import { Address, type Errors, type Hex } from 'ox'
-import {
-  KeyAuthorization,
-  MultisigOperation,
-  SignatureEnvelope,
-} from 'ox/tempo'
+import { parseApproval } from '../../accounts/Signature.js'
+import { Address, type Errors, type Hex, RpcResponse } from 'ox'
+import { AccountOperation, KeyAuthorization, SignatureEnvelope } from 'ox/tempo'
 import * as CoreAccount from '../../../core/Account.js'
 import type * as Chain from '../../../core/Chain.js'
 import type * as Client from '../../../core/Client.js'
 import type { Compute, OneOf } from '../../../core/internal/types.js'
 import {
-  fromMultisig,
+  fromConfig,
   resolveAccessKey,
   signKeyAuthorization,
-  type MultisigAccount,
+  type ConfigurableAccount,
   type RootAccount,
 } from '../../Account.js'
-import { getConfig } from '../multisig/getConfig.js'
+import { getConfig } from '../accounts/getConfig.js'
 import { prepareAuthorization } from './prepareAuthorization.js'
+import { saveAuthorization } from './saveAuthorization.js'
 
 /**
  * Signs a key authorization for an access key.
@@ -25,9 +22,13 @@ import { prepareAuthorization } from './prepareAuthorization.js'
  * Use {@link prepareAuthorization} before this action when signing requires
  * transient user activation.
  *
+ * When the client transport is a relay with the `Relay.keyAuthorization` plugin,
+ * an authorization signed by the account is saved to the relay, which attaches it
+ * to the access key's next transaction.
+ *
  * @param client - Client.
  * @param parameters - Authorization fields, or a stored operation hash.
- * @returns A signed key authorization with multisig operation metadata when coordinated.
+ * @returns A signed key authorization with account operation metadata when coordinated.
  */
 export function signAuthorization<
   chain extends Chain.Chain | undefined,
@@ -61,13 +62,13 @@ export async function signAuthorization<
     const owner_ = parameters_.owner
     if (!owner_ || typeof owner_ === 'string')
       throw new Error(
-        'A local owner account is required to approve a multisig key authorization.',
+        'A local owner account is required to approve a configurable account key authorization.',
       )
     const owner = owner_
     const sign = owner.sign
     if (!sign)
       throw new Error(
-        'A local owner account is required to approve a multisig key authorization.',
+        'A local owner account is required to approve a configurable account key authorization.',
       )
 
     const request = await (async () => {
@@ -90,16 +91,16 @@ export async function signAuthorization<
         const config = await getConfig(client, { address })
         if (config) return config
         throw new Error(
-          `No current multisig config is cached for account ${address}. Provide the current config.`,
+          `No current account config is cached for account ${address}. Provide the current config.`,
         )
       })()
       const account = (() => {
-        if (config.version !== 0n) return fromMultisig({ address, ...config })
+        if (config.version !== 0n) return fromConfig({ address, ...config })
         const { version: _, ...initialConfig } = config
-        return fromMultisig({ address: 'infer', ...initialConfig })
+        return fromConfig({ address: 'infer', ...initialConfig })
       })()
       if (!Address.isEqual(account.address, address))
-        throw new Error('Initial multisig config does not match the account.')
+        throw new Error('Initial account config does not match the account.')
       const prepared = await prepareAuthorization(client, {
         ...authorization,
         account,
@@ -127,41 +128,43 @@ export async function signAuthorization<
     })()
 
     const operation = await client.request({
-      method: 'multisig_approveKeyAuthorization',
+      method: 'account_approveKeyAuthorization',
       params: [request],
     })
-    const multisig = MultisigOperation.fromRpc(
-      operation as MultisigOperation.KeyAuthorizationRpc,
+    const operation_ = AccountOperation.fromRpc(
+      operation as AccountOperation.KeyAuthorizationRpc,
     )
     const keyAuthorization = KeyAuthorization.deserialize(
       await (async () => {
-        if (multisig.status === 'success') return multisig.keyAuthorization
-        const approvals = await MultisigOperation.selectApprovals({
-          account: multisig.account,
-          approvals: multisig.approvals,
-          config: multisig.config,
-          hash: multisig.hash,
+        if (operation_.status === 'success') return operation_.keyAuthorization
+        const approvals = await AccountOperation.selectApprovals({
+          account: operation_.account,
+          approvals: operation_.approvals,
+          config: operation_.config,
+          hash: operation_.hash,
         })
-        return MultisigOperation.serializeKeyAuthorization(
-          multisig.keyAuthorization,
+        return AccountOperation.serializeKeyAuthorization(
+          operation_.keyAuthorization,
           {
-            account: multisig.account,
+            account: operation_.account,
             approvals:
               approvals.selectedApprovals.length > 0
                 ? approvals.selectedApprovals
                 : approvals.approvals.slice(0, 1),
-            config: multisig.config,
+            config: operation_.config,
           },
         )
       })(),
     )
     if (!keyAuthorization.signature)
-      throw new Error('Expected a signed multisig key authorization.')
+      throw new Error(
+        'Expected a signed configurable account key authorization.',
+      )
     return {
       ...keyAuthorization,
-      hash: multisig.hash,
-      multisig,
-      status: multisig.status,
+      hash: operation_.hash,
+      operation: operation_,
+      status: operation_.status,
     } as signAuthorization.CoordinatedReturnType
   }
 
@@ -177,26 +180,45 @@ export async function signAuthorization<
     accessKey,
     account: account_,
     chainId,
-    multisig: multisigState,
+    configurable: configurableState,
     signPayload: _,
     ...rest
   } = prepared
-  return signKeyAuthorization(account_ as CoreAccount.Local, {
-    chainId: BigInt(chainId),
-    key: accessKey,
-    multisig: multisigState,
-    ...rest,
-  })
+  const keyAuthorization = await signKeyAuthorization(
+    account_ as CoreAccount.Local,
+    {
+      chainId: BigInt(chainId),
+      key: accessKey,
+      configurable: configurableState,
+      ...rest,
+    },
+  )
+  // Admin-signed authorizations can only be submitted by the admin key.
+  if (
+    'keyAuthorization' in client.transport &&
+    client.transport.keyAuthorization &&
+    !('source' in account_ && account_.source === 'accessKey')
+  )
+    await saveAuthorization(client, { keyAuthorization }).catch((error) => {
+      // Remote relays without key authorization storage do not expose this method.
+      if (
+        error instanceof RpcResponse.MethodNotFoundError ||
+        error instanceof RpcResponse.MethodNotSupportedError
+      )
+        return
+      throw error
+    })
+  return keyAuthorization
 }
 
 export namespace signAuthorization {
   /** Initial coordinated key authorization parameters. */
   export type CoordinatedInitialOptions = Omit<
     prepareAuthorization.Options<CoreAccount.Account>,
-    'account' | 'multisig'
+    'account' | 'configurable'
   > & {
-    /** Multisig account being authorized. */
-    account: Address.Address | MultisigAccount
+    /** Configurable account being authorized. */
+    account: Address.Address | ConfigurableAccount
     /** Local owner that approves the authorization. */
     owner: RootAccount
   }
@@ -205,7 +227,7 @@ export namespace signAuthorization {
   export type CoordinatedOptions = OneOf<
     | CoordinatedInitialOptions
     | {
-        /** Stored multisig operation hash. */
+        /** Stored account operation hash. */
         hash: Hex.Hex
         /** Local owner that approves the authorization. */
         owner: RootAccount
@@ -218,7 +240,7 @@ export namespace signAuthorization {
       | CoreAccount.Account
       | undefined,
   > = prepareAuthorization.Options<account> & {
-    /** Serialized approvals from external multisig owners. */
+    /** Serialized approvals from external owners. */
     signatures?: readonly SignatureEnvelope.Serialized[] | undefined
   }
 
@@ -235,12 +257,12 @@ export namespace signAuthorization {
   /** Coordinated return value for {@link signAuthorization}. */
   export type CoordinatedReturnType = Compute<
     ReturnType & {
-      /** Deterministic multisig operation hash. */
+      /** Deterministic account operation hash. */
       hash: Hex.Hex
-      /** Current multisig operation. */
-      multisig: MultisigOperation.KeyAuthorizationOperation
-      /** Current multisig operation status. */
-      status: MultisigOperation.KeyAuthorizationOperation['status']
+      /** Current account operation. */
+      operation: AccountOperation.KeyAuthorizationOperation
+      /** Current account operation status. */
+      status: AccountOperation.KeyAuthorizationOperation['status']
     }
   >