ox 1.8.6 → 1.8.8

package/src/tempo/TransactionRequest.test.ts

@@ -1,11 +1,11 @@
 import {
-  MultisigConfig,
-  type MultisigSimulation,
+  AccountConfig,
+  type AccountSimulation,
   TransactionRequest,
 } from 'ox/tempo'
 import { describe, expect, test } from 'vp/test'
 
-const multisigSimulationRpc = {
+const accountSimulationRpc = {
   approvals: [
     {
       keyType: 'webAuthn',
@@ -15,9 +15,9 @@ const multisigSimulationRpc = {
   ],
   config:
     '0xf852a011111111111111111111111111111111111111111111111111111111111111118002eed694111111111111111111111111111111111111111101d694bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb01',
-} as const satisfies MultisigSimulation.Rpc
+} as const satisfies AccountSimulation.Rpc
 
-const multisigSimulation = {
+const accountSimulation = {
   approvals: [
     {
       keyType: 'webAuthn',
@@ -25,7 +25,7 @@ const multisigSimulation = {
       owner: '0x1111111111111111111111111111111111111111',
     },
   ],
-  config: MultisigConfig.from({
+  config: AccountConfig.from({
     owners: [
       {
         owner: '0x1111111111111111111111111111111111111111',
@@ -39,7 +39,7 @@ const multisigSimulation = {
     salt: `0x${'11'.repeat(32)}`,
     threshold: 2,
   }),
-} as const satisfies MultisigSimulation.Spec
+} as const satisfies AccountSimulation.Spec
 
 describe('fromRpc', () => {
   test('default', () => {
@@ -139,14 +139,22 @@ describe('fromRpc', () => {
     `)
   })
 
-  test('behavior: multisig simulation', () => {
+  test('behavior: multisig key type decodes as configurable', () => {
+    const request = TransactionRequest.fromRpc({
+      keyType: 'multisig',
+      type: '0x76',
+    })
+    expect(request.keyType).toMatchInlineSnapshot(`"configurable"`)
+  })
+
+  test('behavior: account simulation', () => {
     const request = TransactionRequest.fromRpc({
       from: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-      multisigSimulation: multisigSimulationRpc,
+      multisigSimulation: accountSimulationRpc,
       type: '0x76',
     })
 
-    expect(request.multisigSimulation).toMatchInlineSnapshot(`
+    expect(request.accountSimulation).toMatchInlineSnapshot(`
       {
         "approvals": [
           {
@@ -258,10 +266,17 @@ describe('toRpc', () => {
     `)
   })
 
-  test('behavior: multisig simulation', () => {
+  test('behavior: configurable key type encodes as multisig', () => {
+    const request = TransactionRequest.toRpc({
+      keyType: 'configurable',
+    })
+    expect(request.keyType).toMatchInlineSnapshot(`"multisig"`)
+  })
+
+  test('behavior: account simulation', () => {
     const request = TransactionRequest.toRpc({
+      accountSimulation,
       from: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
-      multisigSimulation,
     })
 
     expect(request).toMatchInlineSnapshot(`
@@ -386,8 +401,8 @@ describe('roundtrip', () => {
       nonceKey: 255n,
       gas: 100000n,
       maxFeePerGas: 1000000000n,
-      keyAuthorizationSimulation: multisigSimulation,
-      multisigSimulation,
+      keyAuthorizationSimulation: accountSimulation,
+      accountSimulation,
     }
 
     const rpc = TransactionRequest.toRpc(original)
@@ -411,7 +426,7 @@ describe('roundtrip', () => {
     expect(converted.keyAuthorizationSimulation).toEqual(
       original.keyAuthorizationSimulation,
     )
-    expect(converted.multisigSimulation).toEqual(original.multisigSimulation)
+    expect(converted.accountSimulation).toEqual(original.accountSimulation)
     expect(converted.type).toBe('tempo')
   })
 
@@ -429,8 +444,8 @@ describe('roundtrip', () => {
       validAfter: '0x32',
       nonceKey: '0xff',
       gas: '0x186a0',
-      keyAuthorizationSimulation: multisigSimulationRpc,
-      multisigSimulation: multisigSimulationRpc,
+      keyAuthorizationSimulation: accountSimulationRpc,
+      multisigSimulation: accountSimulationRpc,
       type: '0x76',
     }
 

package/src/tempo/TransactionRequest.ts

@@ -5,15 +5,15 @@ import * as Quantity from '../core/internal/quantity.js'
 import type { Compute } from '../core/internal/types.js'
 import * as Signature from '../core/Signature.js'
 import * as ox_TransactionRequest from '../core/TransactionRequest.js'
+import * as AccountSimulation from './AccountSimulation.js'
 import * as AuthorizationTempo from './AuthorizationTempo.js'
 import * as KeyAuthorization from './KeyAuthorization.js'
-import * as MultisigSimulation from './MultisigSimulation.js'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
 import * as Transaction from './Transaction.js'
 import * as TxEnvelopeTempo from './TxEnvelopeTempo.js'
 import type { Call } from './TxEnvelopeTempo.js'
 
-type KeyType = SignatureEnvelope.Type | 'multisig'
+type KeyType = SignatureEnvelope.Type | 'configurable'
 
 /**
  * A Transaction Request that is generic to all transaction types.
@@ -32,6 +32,7 @@ export type TransactionRequest<
     ox_TransactionRequest.TransactionRequest<bigintType, numberType, type>,
     'authorizationList'
   > & {
+    accountSimulation?: AccountSimulation.Spec | undefined
     authorizationList?:
       | AuthorizationTempo.ListSigned<bigintType, numberType>
       | undefined
@@ -41,11 +42,10 @@ export type TransactionRequest<
     feePayerSignature?: Signature.Signature<true, numberType> | null | undefined
     feeToken?: Address.Address | undefined
     keyAuthorization?: KeyAuthorization.KeyAuthorization<true> | undefined
-    keyAuthorizationSimulation?: MultisigSimulation.Spec | undefined
+    keyAuthorizationSimulation?: AccountSimulation.Spec | undefined
     keyData?: Hex.Hex | undefined
     keyId?: Address.Address | undefined
     keyType?: KeyType | undefined
-    multisigSimulation?: MultisigSimulation.Spec | undefined
     nonceKey?: 'random' | bigintType | undefined
     signature?: SignatureEnvelope.SignatureEnvelope<numberType> | undefined
     validAfter?: numberType | undefined
@@ -56,20 +56,23 @@ export type TransactionRequest<
 /** RPC representation of a {@link ox#TransactionRequest.TransactionRequest}. */
 export type Rpc = Omit<
   TransactionRequest<Hex.Hex, Hex.Hex, string>,
+  | 'accountSimulation'
   | 'authorizationList'
   | 'feePayerSignature'
   | 'feeToken'
   | 'keyAuthorization'
-  | 'multisigSimulation'
   | 'keyAuthorizationSimulation'
+  | 'keyType'
   | 'signature'
 > & {
   authorizationList?: AuthorizationTempo.ListRpc | undefined
   feePayerSignature?: Signature.Rpc | null | undefined
   feeToken?: Hex.Hex | undefined
   keyAuthorization?: KeyAuthorization.Rpc | undefined
-  keyAuthorizationSimulation?: MultisigSimulation.Rpc | undefined
-  multisigSimulation?: MultisigSimulation.Rpc | undefined
+  keyAuthorizationSimulation?: AccountSimulation.Rpc | undefined
+  /** Key type. Configurable accounts use the node's `multisig` key type. */
+  keyType?: SignatureEnvelope.Type | 'multisig' | undefined
+  multisigSimulation?: AccountSimulation.Rpc | undefined
   nonceKey?: Hex.Hex | undefined
   signature?: SignatureEnvelope.SignatureEnvelopeRpc | undefined
 }
@@ -99,8 +102,9 @@ export type Rpc = Omit<
 export function fromRpc(request: Rpc): TransactionRequest {
   const {
     authorizationList: _,
-    multisigSimulation: __,
-    keyAuthorizationSimulation: ___,
+    keyAuthorizationSimulation: __,
+    keyType: ___,
+    multisigSimulation: ____,
     ...rest
   } = request
   const request_ = ox_TransactionRequest.fromRpc(
@@ -138,11 +142,14 @@ export function fromRpc(request: Rpc): TransactionRequest {
       request.keyAuthorization,
     )
   if (request.keyAuthorizationSimulation)
-    request_.keyAuthorizationSimulation = MultisigSimulation.fromRpc(
+    request_.keyAuthorizationSimulation = AccountSimulation.fromRpc(
       request.keyAuthorizationSimulation,
     )
+  if (typeof request.keyType !== 'undefined')
+    request_.keyType =
+      request.keyType === 'multisig' ? 'configurable' : request.keyType
   if (request.multisigSimulation)
-    request_.multisigSimulation = MultisigSimulation.fromRpc(
+    request_.accountSimulation = AccountSimulation.fromRpc(
       request.multisigSimulation,
     )
   if (typeof request.validBefore !== 'undefined')
@@ -160,7 +167,7 @@ export declare namespace fromRpc {
     | AuthorizationTempo.fromRpcList.ErrorType
     | Hex.toNumber.ErrorType
     | Hex.toBigInt.ErrorType
-    | MultisigSimulation.fromRpc.ErrorType
+    | AccountSimulation.fromRpc.ErrorType
     | Errors.GlobalErrorType
 }
 
@@ -226,6 +233,7 @@ export function toRpc(request: toRpc.Input): Rpc {
   }) as Rpc
 
   const tempo =
+    typeof request.accountSimulation !== 'undefined' ||
     typeof request.calls !== 'undefined' ||
     typeof request.capabilities !== 'undefined' ||
     typeof request.feePayer !== 'undefined' ||
@@ -235,7 +243,6 @@ export function toRpc(request: toRpc.Input): Rpc {
     typeof request.keyId !== 'undefined' ||
     typeof request.keyType !== 'undefined' ||
     typeof request.keyAuthorizationSimulation !== 'undefined' ||
-    typeof request.multisigSimulation !== 'undefined' ||
     typeof request.nonceKey !== 'undefined' ||
     typeof request.validBefore !== 'undefined' ||
     typeof request.validAfter !== 'undefined' ||
@@ -284,14 +291,15 @@ export function toRpc(request: toRpc.Input): Rpc {
     request_rpc.keyData = shimKeyData(request.keyData)
   if (typeof request.keyId !== 'undefined') request_rpc.keyId = request.keyId
   if (typeof request.keyType !== 'undefined')
-    request_rpc.keyType = request.keyType
+    request_rpc.keyType =
+      request.keyType === 'configurable' ? 'multisig' : request.keyType
   if (typeof request.keyAuthorizationSimulation !== 'undefined')
-    request_rpc.keyAuthorizationSimulation = MultisigSimulation.toRpc(
+    request_rpc.keyAuthorizationSimulation = AccountSimulation.toRpc(
       request.keyAuthorizationSimulation,
     )
-  if (typeof request.multisigSimulation !== 'undefined')
-    request_rpc.multisigSimulation = MultisigSimulation.toRpc(
-      request.multisigSimulation,
+  if (typeof request.accountSimulation !== 'undefined')
+    request_rpc.multisigSimulation = AccountSimulation.toRpc(
+      request.accountSimulation,
     )
   if (typeof request.validBefore !== 'undefined')
     request_rpc.validBefore = Quantity.fromNumberish(request.validBefore)
@@ -327,7 +335,7 @@ export declare namespace toRpc {
   export type ErrorType =
     | AuthorizationTempo.toRpcList.ErrorType
     | Hex.fromNumber.ErrorType
-    | MultisigSimulation.toRpc.ErrorType
+    | AccountSimulation.toRpc.ErrorType
     | Errors.GlobalErrorType
 }
 

package/src/tempo/{multisig.e2e.test.ts → configurableAccounts.e2e.test.ts}

@@ -1,11 +1,11 @@
 import { AbiFunction, Address, Hex, Secp256k1, Value } from 'ox'
 import { describe, expect, test } from 'vp/test'
 import { chain, client, fundAddress } from '../../test/tempo/config.js'
-import { factory } from '../../test/tempo/multisig.js'
+import { factory } from '../../test/tempo/configurableAccounts.js'
 import {
+  AccountConfig,
   KeyAuthorization,
-  MultisigConfig,
-  MultisigOperation,
+  AccountOperation,
   SignatureEnvelope,
 } from './index.js'
 import * as Transaction from './Transaction.js'
@@ -26,12 +26,12 @@ async function setup() {
       address: Address.fromPublicKey(Secp256k1.getPublicKey({ privateKey })),
     }
   })
-  const config: MultisigConfig.Config = MultisigConfig.from({
+  const config: AccountConfig.Config = AccountConfig.from({
     salt: Hex.random(32),
     threshold: 2,
     owners: keys.map((key) => ({ owner: key.address, weight: 1 })),
   })
-  const account = MultisigConfig.getAddress(config, { factory })
+  const account = AccountConfig.getAddress(config, { factory })
   await fundAddress(client, { address: account })
   return { account, config, keys }
 }
@@ -59,11 +59,11 @@ function sign(account: Awaited<ReturnType<typeof setup>>, payload: Hex.Hex) {
     config: account.config,
     payload,
   }
-  const digest = MultisigConfig.getSignPayload(value)
+  const digest = AccountConfig.getSignPayload(value)
   return SignatureEnvelope.from({
     account: account.account,
     config: account.config,
-    signatures: SignatureEnvelope.sortMultisigApprovals({
+    signatures: SignatureEnvelope.sortApprovals({
       ...value,
       signatures: account.keys
         .slice(0, 2)
@@ -109,13 +109,13 @@ describe('behavior: configurable accounts', () => {
     const account = await setup()
     const tx = transaction(0n)
     const serialized = TxEnvelopeTempo.serialize(tx)
-    const hash = MultisigOperation.getHash({
+    const hash = AccountOperation.getHash({
       account: account.account,
       config: account.config,
       transaction: serialized,
       type: 'transaction',
     })
-    const selected = await MultisigOperation.selectApprovals({
+    const selected = await AccountOperation.selectApprovals({
       account: account.account,
       approvals: account.keys.map(({ privateKey }) =>
         SignatureEnvelope.serialize(
@@ -125,7 +125,7 @@ describe('behavior: configurable accounts', () => {
       config: account.config,
       hash,
     })
-    const operation = MultisigOperation.from({
+    const operation = AccountOperation.from({
       account: account.account,
       approvals: selected.approvals,
       config: account.config,
@@ -139,7 +139,7 @@ describe('behavior: configurable accounts', () => {
       updatedAt: 1,
       weight: selected.weight,
     })
-    const signed = MultisigOperation.serializeTransaction(operation, {
+    const signed = AccountOperation.serializeTransaction(operation, {
       approvals: selected.selectedApprovals,
     })
     const result = await client.request({
@@ -167,7 +167,7 @@ describe('behavior: configurable accounts', () => {
       data,
       gas: 5_000_000n,
       feeToken: '0x20c0000000000000000000000000000000000001',
-      multisigSimulation: {
+      accountSimulation: {
         config: account.config,
         approvals: account.config.owners
           .slice(0, 2)
@@ -178,7 +178,7 @@ describe('behavior: configurable accounts', () => {
       method: 'eth_call',
       params: [request as never, 'latest'],
     })
-    expect(simulated).not.toBe(MultisigConfig.zeroSalt)
+    expect(simulated).not.toBe(AccountConfig.zeroSalt)
     const estimate = await client.request({
       method: 'eth_estimateGas',
       params: [request as never],
@@ -188,7 +188,7 @@ describe('behavior: configurable accounts', () => {
       method: 'eth_call',
       params: [{ to: precompile, data }, 'latest'],
     })
-    expect(persisted).toBe(MultisigConfig.zeroSalt)
+    expect(persisted).toBe(AccountConfig.zeroSalt)
     const tx = transaction(0n)
     await submit(tx, sign(account, TxEnvelopeTempo.getSignPayload(tx)))
     expect(
@@ -252,14 +252,14 @@ describe('behavior: configurable accounts', () => {
     )
   })
 
-  test('authorizes a multisig delegate and preserves the grant after delegate rotation', async () => {
+  test('authorizes a configurable delegate and preserves the grant after delegate rotation', async () => {
     const parent = await setup()
     const delegate = await setup()
     const grant = KeyAuthorization.from({
       address: delegate.account,
       account: parent.account,
       chainId: BigInt(chain.id),
-      type: 'multisig',
+      type: 'configurable',
     })
     const signed = KeyAuthorization.from(grant, {
       signature: sign(parent, KeyAuthorization.getSignPayload(grant)),

package/src/tempo/index.ts

@@ -1,6 +1,60 @@
 /** @entrypointCategory Tempo */
 // biome-ignore lint/complexity/noUselessEmptyExport: tsdoc
 
+/**
+ * Configurable account configuration utilities (TIP-1107).
+ *
+ * Configurable accounts have weighted owners and an approval threshold that
+ * can change without changing the account address. Derives the stable account
+ * address from the initial configuration, computes configuration commitments,
+ * and computes the owner approval digest that owners sign.
+ *
+ * [TIP-1107](https://tips.sh/1107) · [TIP-1114](https://tips.sh/1114)
+ *
+ * @example
+ * ```ts twoslash
+ * import { AccountConfig } from 'ox/tempo'
+ *
+ * const initialConfig = AccountConfig.from({
+ *   threshold: 2,
+ *   owners: [
+ *     {
+ *       owner: '0x1111111111111111111111111111111111111111',
+ *       weight: 1
+ *     },
+ *     {
+ *       owner: '0x2222222222222222222222222222222222222222',
+ *       weight: 1
+ *     }
+ *   ]
+ * })
+ *
+ * const account = AccountConfig.getAddress(initialConfig, {
+ *   factory: '0x7171717171717171717171717171717171717171'
+ * })
+ * ```
+ *
+ * @category Reference
+ */
+export * as AccountConfig from './AccountConfig.js'
+/**
+ * Offchain configurable account transaction and key authorization operation utilities.
+ *
+ * Derives operation hashes, selects owner approvals, serializes transactions,
+ * validates operation state, and converts JSON-RPC representations.
+ *
+ * @category Reference
+ */
+export * as AccountOperation from './AccountOperation.js'
+/**
+ * Configurable account RPC simulation utilities.
+ *
+ * Converts the owner approvals and configuration modeled during gas estimation
+ * between their domain and Tempo JSON-RPC representations.
+ *
+ * @category Reference
+ */
+export * as AccountSimulation from './AccountSimulation.js'
 /**
  * Utilities for Tempo-flavoured EIP-7702 authorizations.
  *
@@ -141,58 +195,6 @@ export * as EarnShares from './EarnShares.js'
  * @category Reference
  */
 export * as KeyAuthorization from './KeyAuthorization.js'
-/**
- * Native multisig account utilities (TIP-1061).
- *
- * Derives stable multisig account addresses from a weighted owner
- * configuration, and computes the owner approval digest that owners sign.
- *
- * [TIP-1061](https://tips.sh/1061)
- *
- * @example
- * ```ts twoslash
- * import { MultisigConfig } from 'ox/tempo'
- *
- * const initialConfig = MultisigConfig.from({
- *   threshold: 2,
- *   owners: [
- *     {
- *       owner: '0x1111111111111111111111111111111111111111',
- *       weight: 1
- *     },
- *     {
- *       owner: '0x2222222222222222222222222222222222222222',
- *       weight: 1
- *     }
- *   ]
- * })
- *
- * const account = MultisigConfig.getAddress(initialConfig, {
- *   factory: '0x7171717171717171717171717171717171717171'
- * })
- * ```
- *
- * @category Reference
- */
-export * as MultisigConfig from './MultisigConfig.js'
-/**
- * Offchain multisig transaction and key authorization operation utilities.
- *
- * Derives operation hashes, selects owner approvals, serializes transactions,
- * validates operation state, and converts JSON-RPC representations.
- *
- * @category Reference
- */
-export * as MultisigOperation from './MultisigOperation.js'
-/**
- * Native multisig RPC simulation utilities.
- *
- * Converts complete root and nested owner specs between their domain and Tempo
- * JSON-RPC representations.
- *
- * @category Reference
- */
-export * as MultisigSimulation from './MultisigSimulation.js'
 /**
  * Utilities for constructing period durations (in seconds) for recurring spending limits.
  *
@@ -271,7 +273,7 @@ export * as PoolId from './PoolId.js'
  */
 export * as ReceivePolicyReceipt from './ReceivePolicyReceipt.js'
 /**
- * JSON-RPC schemas for the `tempo_` and `multisig_` namespaces.
+ * JSON-RPC schemas for the `tempo_` and `account_` namespaces.
  *
  * @example
  * ```ts twoslash
@@ -281,7 +283,7 @@ export * as ReceivePolicyReceipt from './ReceivePolicyReceipt.js'
  *
  * const schema = RpcSchema.from<
  *   | RpcSchema.Default
- *   | RpcSchemaTempo.Multisig
+ *   | RpcSchemaTempo.Account
  *   | RpcSchemaTempo.Tempo
  * >()
  *

package/src/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '1.8.6'
+export const version = '1.8.8'

package/src/zod/tempo/{MultisigConfig.ts → AccountConfig.ts}

@@ -1,16 +1,16 @@
 /* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
-import * as core_MultisigConfig from '../../tempo/MultisigConfig.js'
+import * as core_AccountConfig from '../../tempo/AccountConfig.js'
 import * as z_Address from '../Address.js'
 import * as z_Hex from '../Hex.js'
 import * as z from 'zod/mini'
 
-/** Multisig owner schema. */
+/** Account config owner schema. */
 export const Owner = z.object({
   owner: z_Address.Address,
   weight: z.number(),
 })
 
-/** Native multisig configuration domain schema. */
+/** Account configuration domain schema. */
 export const Config = z
   .object({
     owners: z.readonly(z.array(Owner)),
@@ -20,12 +20,12 @@ export const Config = z
   })
   .check(
     z.refine(
-      (value) => core_MultisigConfig.validate(value),
-      'expected valid native multisig configuration',
+      (value) => core_AccountConfig.validate(value),
+      'expected valid account configuration',
     ),
   )
 
-/** Native multisig configuration RPC schema. */
+/** Account configuration RPC schema. */
 export const Rpc = z
   .object({
     owners: z.readonly(z.array(Owner)),
@@ -36,16 +36,16 @@ export const Rpc = z
   .check(
     z.refine((value) => {
       try {
-        core_MultisigConfig.fromRpc(value)
+        core_AccountConfig.fromRpc(value)
         return true
       } catch {
         return false
       }
-    }, 'expected valid native multisig configuration'),
+    }, 'expected valid account configuration'),
   )
 
-/** Codec decoding an RPC multisig configuration into a domain configuration. */
-export const MultisigConfig = z.codec(Rpc, Config, {
-  decode: (value) => core_MultisigConfig.fromRpc(value),
-  encode: (value) => core_MultisigConfig.toRpc(value),
+/** Codec decoding an RPC account configuration into a domain configuration. */
+export const AccountConfig = z.codec(Rpc, Config, {
+  decode: (value) => core_AccountConfig.fromRpc(value),
+  encode: (value) => core_AccountConfig.toRpc(value),
 })

package/src/zod/tempo/{MultisigOperation.ts → AccountOperation.ts}

@@ -1,16 +1,16 @@
 /* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
-import * as core_MultisigOperation from '../../tempo/MultisigOperation.js'
+import * as core_AccountOperation from '../../tempo/AccountOperation.js'
 import * as z_Address from '../Address.js'
 import * as z_Hash from '../Hash.js'
 import * as z_Hex from '../Hex.js'
 import * as z from 'zod/mini'
-import * as z_MultisigConfig from './MultisigConfig.js'
+import * as z_AccountConfig from './AccountConfig.js'
 
 function baseFields() {
   return {
     account: z_Address.Address,
     approvals: z.readonly(z.array(z_Hex.Hex)),
-    config: z_MultisigConfig.MultisigConfig,
+    config: z_AccountConfig.AccountConfig,
     createdAt: z.number(),
     hash: z_Hash.Hash,
     signatureCount: z.number(),
@@ -22,17 +22,17 @@ function baseFields() {
 
 const valid = z.refine((value) => {
   try {
-    core_MultisigOperation.from(value as never)
+    core_AccountOperation.from(value as never)
     return true
   } catch {
     return false
   }
-}, 'expected valid multisig operation')
+}, 'expected valid account operation')
 
-/** Fields shared by every multisig operation schema. */
+/** Fields shared by every account operation schema. */
 export const Base = z.object(baseFields())
 
-/** Multisig transaction approval operation schema. */
+/** Account transaction approval operation schema. */
 export const TransactionOperation = z
   .object({
     ...baseFields(),
@@ -49,7 +49,7 @@ export const TransactionOperation = z
   })
   .check(valid)
 
-/** Multisig key authorization approval operation schema. */
+/** Account key authorization approval operation schema. */
 export const KeyAuthorizationOperation = z
   .object({
     ...baseFields(),
@@ -59,7 +59,7 @@ export const KeyAuthorizationOperation = z
   })
   .check(valid)
 
-/** Transaction or key authorization multisig operation schema. */
+/** Transaction or key authorization account operation schema. */
 export const Operation = z.union([
   TransactionOperation,
   KeyAuthorizationOperation,