ox 0.14.54 → 0.14.56

package/tempo/KeyAuthorization.test.ts

@@ -8,8 +8,8 @@ import {
   WebAuthnP256,
 } from 'ox'
 import { describe, expect, test } from 'vitest'
+import * as AccountConfig from './AccountConfig.js'
 import * as KeyAuthorization from './KeyAuthorization.js'
-import * as MultisigConfig from './MultisigConfig.js'
 import * as Period from './Period.js'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
 
@@ -71,9 +71,9 @@ const signature_webauthn = SignatureEnvelope.from({
   },
 })
 
-const signature_multisig = {
+const signature_configurable = {
   account: address,
-  config: MultisigConfig.from({
+  config: AccountConfig.from({
     owners: [
       {
         owner: '0xf39fd6e51aad88f6f4ce6ab8827279cfffb92266',
@@ -84,9 +84,9 @@ const signature_multisig = {
     version: 1n,
   }),
   signatures: [SignatureEnvelope.from(signature_secp256k1)],
-  type: 'multisig',
-} as const satisfies SignatureEnvelope.Multisig
-const signature_multisig_rpc =
+  type: 'configurable',
+} as const satisfies SignatureEnvelope.Configurable
+const signature_configurable_rpc =
   '0xf89794be95c3f554e9fc85ec51be69a3d807a0d55bcf2cf83ba000000000000000000000000000000000000000000000000000000000000000000101d7d694f39fd6e51aad88f6f4ce6ab8827279cfffb9226601f843b841fa78c5905fb0b9d6066ef531f962a62bc6ef0d5eb59ecb134056d206f75aaed7780926ff2601a935c2c79707d9e1799948c9f19dcdde1e090e903b19a07923d01c' as const
 
 const signature_keychain = {
@@ -95,10 +95,15 @@ const signature_keychain = {
   userAddress: address,
 } as const satisfies SignatureEnvelope.Keychain
 
-describe('multisig account binding', () => {
+describe('configurable account binding', () => {
   test('resolves Tempo account bindings before encoding', () => {
     const signed = KeyAuthorization.from(
-      { account: `tempox${address}`, address, chainId: 1n, type: 'multisig' },
+      {
+        account: `tempox${address}`,
+        address,
+        chainId: 1n,
+        type: 'configurable',
+      },
       { signature: signature_secp256k1 },
     )
     expect(signed.account).toMatchInlineSnapshot(
@@ -113,36 +118,40 @@ describe('multisig account binding', () => {
   })
 
   test('rejects unbound grants before signing or encoding', () => {
-    const authorization = { address, chainId: 1n, type: 'multisig' } as const
+    const authorization = {
+      address,
+      chainId: 1n,
+      type: 'configurable',
+    } as const
     const signed = {
       ...authorization,
       signature: SignatureEnvelope.from(signature_secp256k1),
     }
     for (const encode of [
-      // @ts-expect-error Deliberately unbound multisig grant.
+      // @ts-expect-error Deliberately unbound configurable grant.
       () => KeyAuthorization.from(authorization),
-      // @ts-expect-error Deliberately unbound multisig grant.
+      // @ts-expect-error Deliberately unbound configurable grant.
       () => KeyAuthorization.toTuple(authorization),
-      // @ts-expect-error Deliberately unbound multisig grant.
+      // @ts-expect-error Deliberately unbound configurable grant.
       () => KeyAuthorization.getSignPayload(authorization),
-      // @ts-expect-error Deliberately unbound multisig grant.
+      // @ts-expect-error Deliberately unbound configurable grant.
       () => KeyAuthorization.serialize(authorization),
-      // @ts-expect-error Deliberately unbound multisig grant.
+      // @ts-expect-error Deliberately unbound configurable grant.
       () => KeyAuthorization.toRpc(signed),
     ])
       expect(encode).toThrowErrorMatchingInlineSnapshot(
-        `[KeyAuthorization.MissingAccountError: Multisig key grants require a parent account binding.]`,
+        `[KeyAuthorization.MissingAccountError: Configurable account key grants require a parent account binding.]`,
       )
   })
 
   test('rejects unbound RPC and RLP grants', () => {
     const signed = KeyAuthorization.from(
-      { account: address, address, chainId: 1n, type: 'multisig' },
+      { account: address, address, chainId: 1n, type: 'configurable' },
       { signature: signature_secp256k1 },
     )
     const rpc = KeyAuthorization.toRpc(signed)
     for (const account of [undefined, null]) {
-      // @ts-expect-error Deliberately unbound multisig grant.
+      // @ts-expect-error Deliberately unbound configurable grant.
       expect(() => KeyAuthorization.fromRpc({ ...rpc, account })).toThrowError(
         KeyAuthorization.MissingAccountError,
       )
@@ -179,15 +188,15 @@ describe('from', () => {
     }).toEqual(limitsVectors)
   })
 
-  test('accepts multisig grants and delegates', () => {
+  test('accepts configurable grants and delegates', () => {
     const signed = KeyAuthorization.from(
       {
         address,
         chainId: 1n,
-        type: 'multisig',
-        account: signature_multisig.account,
+        type: 'configurable',
+        account: signature_configurable.account,
       },
-      { signature: signature_multisig },
+      { signature: signature_configurable },
     )
     expect(
       KeyAuthorization.deserialize(KeyAuthorization.serialize(signed)),
@@ -587,7 +596,7 @@ describe('fromRpc', () => {
     `)
   })
 
-  test('with signature (multisig)', () => {
+  test('with signature (configurable)', () => {
     const authorization = KeyAuthorization.from({
       address,
       chainId: 1n,
@@ -595,20 +604,20 @@ describe('fromRpc', () => {
     })
 
     const signed = KeyAuthorization.from(authorization, {
-      signature: signature_multisig,
+      signature: signature_configurable,
     })
-    expect(signed.signature).toEqual(signature_multisig)
+    expect(signed.signature).toEqual(signature_configurable)
     expect(
       KeyAuthorization.from(authorization, {
-        signature: SignatureEnvelope.serialize(signature_multisig),
+        signature: SignatureEnvelope.serialize(signature_configurable),
       }).signature,
-    ).toEqual(signature_multisig)
+    ).toEqual(signature_configurable)
     expect(
       KeyAuthorization.from({
         ...authorization,
-        signature: signature_multisig,
+        signature: signature_configurable,
       }).signature,
-    ).toEqual(signature_multisig)
+    ).toEqual(signature_configurable)
     expect(
       KeyAuthorization.deserialize(KeyAuthorization.serialize(signed)),
     ).toEqual(signed)
@@ -626,7 +635,7 @@ describe('fromRpc', () => {
         signature: signature_keychain as never,
       }),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[KeyAuthorization.InvalidSignatureTypeError: Signature type \`keychain\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`multisig\`.]`,
+      `[KeyAuthorization.InvalidSignatureTypeError: Signature type \`keychain\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`configurable\`.]`,
     )
 
     expect(() =>
@@ -634,7 +643,7 @@ describe('fromRpc', () => {
         signature: SignatureEnvelope.serialize(signature_keychain),
       }),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[KeyAuthorization.InvalidSignatureTypeError: Signature type \`keychain\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`multisig\`.]`,
+      `[KeyAuthorization.InvalidSignatureTypeError: Signature type \`keychain\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`configurable\`.]`,
     )
 
     expect(() =>
@@ -643,19 +652,19 @@ describe('fromRpc', () => {
         signature: signature_keychain,
       } as never),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[KeyAuthorization.InvalidSignatureTypeError: Signature type \`keychain\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`multisig\`.]`,
+      `[KeyAuthorization.InvalidSignatureTypeError: Signature type \`keychain\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`configurable\`.]`,
     )
   })
 })
 
 describe('fromRpc', () => {
-  test('behavior: multisig', () => {
+  test('behavior: configurable', () => {
     const authorization = KeyAuthorization.fromRpc({
       chainId: '0x1',
       expiry: null,
       keyId: address,
       keyType: 'secp256k1',
-      signature: signature_multisig_rpc,
+      signature: signature_configurable_rpc,
     })
 
     expect(authorization.signature).toMatchInlineSnapshot(`
@@ -682,7 +691,7 @@ describe('fromRpc', () => {
             "type": "secp256k1",
           },
         ],
-        "type": "multisig",
+        "type": "configurable",
       }
     `)
   })
@@ -697,7 +706,7 @@ describe('fromRpc', () => {
         signature: SignatureEnvelope.toRpc(signature_keychain),
       } as never),
     ).toThrowErrorMatchingInlineSnapshot(
-      `[KeyAuthorization.InvalidSignatureTypeError: Signature type \`keychain\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`multisig\`.]`,
+      `[KeyAuthorization.InvalidSignatureTypeError: Signature type \`keychain\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`configurable\`.]`,
     )
   })
 
@@ -934,13 +943,13 @@ describe('fromTuple', () => {
     `)
   })
 
-  test('multisig', () => {
+  test('configurable', () => {
     const authorization = KeyAuthorization.fromTuple([
       ['0x1', '0x', address],
-      SignatureEnvelope.serialize(signature_multisig),
+      SignatureEnvelope.serialize(signature_configurable),
     ])
 
-    expect(authorization.signature).toEqual(signature_multisig)
+    expect(authorization.signature).toEqual(signature_configurable)
   })
 
   test('default', () => {
@@ -1280,7 +1289,7 @@ describe('getSignPayload', () => {
 })
 
 describe('deserialize', () => {
-  test('example: matches the frozen multisig witness vector', () => {
+  test('example: matches the frozen configurable witness vector', () => {
     const serialized =
       '0xf8f1f85382107980941eff47bc3a10a45d4b230b5d10e37751fe6aa718808080a053535353535353535353535353535353535353535353535353535353535353538094c4a590afa7337e5cd5eb3aa60cacf91c5400044bb89a05f89794c4a590afa7337e5cd5eb3aa60cacf91c5400044bf83ba000000000000000000000000000000000000000000000000000000000000000008001d7d6947e5f4552091a69125d5dfcb7b8c2659029395bdf01f843b8412cfed9350faf80e4115e3c4c967356b80a8e6ee42e4a49ab953c8c8a3537d8d8359bf035a9bea18f32b0da7129cdce3ce701abc09ad8919b93da21a0d57e21451b' as const
     const authorization = KeyAuthorization.deserialize(serialized)
@@ -1313,7 +1322,7 @@ describe('deserialize', () => {
               "type": "secp256k1",
             },
           ],
-          "type": "multisig",
+          "type": "configurable",
         },
         "type": "secp256k1",
         "witness": "0x5353535353535353535353535353535353535353535353535353535353535353",
@@ -1322,14 +1331,14 @@ describe('deserialize', () => {
     expect(KeyAuthorization.serialize(authorization)).toBe(serialized)
   })
 
-  test('multisig', () => {
+  test('configurable', () => {
     const serialized = Rlp.fromHex([
       ['0x1', '0x', address],
-      SignatureEnvelope.serialize(signature_multisig),
+      SignatureEnvelope.serialize(signature_configurable),
     ])
 
     expect(KeyAuthorization.deserialize(serialized).signature).toEqual(
-      signature_multisig,
+      signature_configurable,
     )
   })
 
@@ -1503,16 +1512,28 @@ describe('serialize', () => {
 })
 
 describe('toRpc', () => {
-  test('behavior: multisig', () => {
+  test('behavior: configurable key type uses the RPC multisig key type', () => {
+    const authorization = KeyAuthorization.from(
+      { account: address, address, chainId: 1n, type: 'configurable' },
+      { signature: signature_secp256k1 },
+    )
+    const rpc = KeyAuthorization.toRpc(authorization)
+    expect(rpc.keyType).toMatchInlineSnapshot(`"multisig"`)
+    expect(KeyAuthorization.fromRpc(rpc).type).toMatchInlineSnapshot(
+      `"configurable"`,
+    )
+  })
+
+  test('behavior: configurable', () => {
     const authorization = KeyAuthorization.toRpc({
       address,
       chainId: 1n,
-      signature: signature_multisig,
+      signature: signature_configurable,
       type: 'secp256k1',
     })
 
     expect(authorization.signature).toMatchInlineSnapshot(
-      `"${signature_multisig_rpc}"`,
+      `"${signature_configurable_rpc}"`,
     )
   })
 
@@ -1783,15 +1804,15 @@ describe('toTuple', () => {
     }
   })
 
-  test('multisig', () => {
+  test('configurable', () => {
     const tuple = KeyAuthorization.toTuple({
       address,
       chainId: 1n,
-      signature: signature_multisig,
+      signature: signature_configurable,
       type: 'secp256k1',
     })
 
-    expect(tuple[1]).toBe(SignatureEnvelope.serialize(signature_multisig))
+    expect(tuple[1]).toBe(SignatureEnvelope.serialize(signature_configurable))
   })
 
   test('default', () => {

package/tempo/KeyAuthorization.ts

@@ -29,7 +29,7 @@ import * as TempoAddress from './TempoAddress.js'
  * - `chainId`: Chain ID for replay protection (0 = valid on any chain)
  * - `expiry`: Unix timestamp when the key expires (undefined = never expires)
  * - `limits`: Per-TIP-20 token spending limits (only applies to `transfer()` and `approve()` calls)
- * - `type`: Key type (`secp256k1`, `p256`, `webAuthn`, or `multisig`)
+ * - `type`: Key type (`secp256k1`, `p256`, `webAuthn`, or `configurable`)
  *
  * [Access Keys Specification](https://docs.tempo.xyz/protocol/transactions/spec-tempo-transaction#access-keys)
  */
@@ -83,33 +83,33 @@ export type KeyAuthorization<
       type: SignatureEnvelope.Type
     }
   | {
-      /** Required parent account binding for a multisig grant. */
+      /** Required parent account binding for a configurable account grant. */
       account: addressType
-      /** Multisig key type. */
-      type: 'multisig'
+      /** Configurable account key type. */
+      type: 'configurable'
     }
 ) &
   (signed extends true
     ? {
         signature:
           | SignatureEnvelope.Primitive<bigintType, numberType>
-          | SignatureEnvelope.Multisig<bigintType, numberType>
+          | SignatureEnvelope.Configurable<bigintType, numberType>
       }
     : {
         signature?:
           | SignatureEnvelope.Primitive<bigintType, numberType>
-          | SignatureEnvelope.Multisig<bigintType, numberType>
+          | SignatureEnvelope.Configurable<bigintType, numberType>
           | undefined
       })
 
 /** Signature that can authorize an access key. */
 export type Signature<bigintType = bigint, numberType = number> =
   | SignatureEnvelope.Primitive<bigintType, numberType>
-  | SignatureEnvelope.Multisig<bigintType, numberType>
+  | SignatureEnvelope.Configurable<bigintType, numberType>
 
 /** RPC-formatted signature that can authorize an access key. */
 export type SignatureRpc =
-  | SignatureEnvelope.MultisigRpc
+  | SignatureEnvelope.ConfigurableRpc
   | SignatureEnvelope.PrimitiveRpc
 
 /** Input type for a Key Authorization. */
@@ -146,9 +146,9 @@ export type Rpc = {
       keyType: SignatureEnvelope.Type
     }
   | {
-      /** Required parent account binding for a multisig grant. */
+      /** Required parent account binding for a configurable account grant. */
       account: Address.Address
-      /** Multisig key type. */
+      /** Configurable account key type, named `multisig` by the node. */
       keyType: 'multisig'
     }
 )
@@ -180,9 +180,9 @@ export type Signed<
 > = KeyAuthorization<true, bigintType, numberType, addressType>
 
 type SignatureValue =
-  | SignatureEnvelope.from.MultisigFromConfig
+  | SignatureEnvelope.from.ConfigurableFromConfig
   | UnionPartialBy<SignatureEnvelope.Primitive, 'prehash' | 'type'>
-  | PartialBy<SignatureEnvelope.Multisig, 'type'>
+  | PartialBy<SignatureEnvelope.Configurable, 'type'>
   | SignatureEnvelope.Secp256k1Flat
   | SignatureEnvelope.Serialized
 
@@ -508,11 +508,11 @@ export declare namespace from {
   type Options<
     signature extends SignatureValue | undefined = SignatureValue | undefined,
   > = {
-    /** The primitive or multisig signature to attach to the Key Authorization. */
+    /** The primitive or configurable account signature to attach to the Key Authorization. */
     signature?:
       | signature
       | SignatureEnvelope.Primitive
-      | SignatureEnvelope.Multisig
+      | SignatureEnvelope.Configurable
       | undefined
   }
 
@@ -572,7 +572,8 @@ export function fromRpc(authorization: Rpc): Signed {
   const witness = authorization.witness ?? undefined
   const isAdmin = authorization.isAdmin ?? undefined
   const account = authorization.account ?? undefined
-  assertAccountBinding(keyType, account)
+  const type = keyType === 'multisig' ? 'configurable' : keyType
+  assertAccountBinding(type, account)
   const signature = SignatureEnvelope.fromRpc(authorization.signature)
   assertSignature(signature)
   if (witness !== undefined) assertWitness(witness)
@@ -607,9 +608,7 @@ export function fromRpc(authorization: Rpc): Signed {
     })),
     ...(scopes ? { scopes } : {}),
     signature,
-    ...(keyType === 'multisig'
-      ? { account: account!, type: keyType }
-      : { type: keyType }),
+    ...(type === 'configurable' ? { account: account!, type } : { type }),
     ...(witness !== undefined ? { witness } : {}),
     ...(account !== undefined ? { account } : {}),
     ...(isAdmin ? { isAdmin: true as const } : {}),
@@ -683,7 +682,7 @@ export function fromTuple<const tuple extends Tuple>(
       case '0x02':
         return 'webAuthn'
       case '0x03':
-        return 'multisig'
+        return 'configurable'
       default:
         throw new Error(`Invalid key type: ${keyType_hex}`)
     }
@@ -744,7 +743,7 @@ export function fromTuple<const tuple extends Tuple>(
   const args: KeyAuthorization = {
     address: keyId,
     chainId: chainId === '0x' ? 0n : Hex.toBigInt(chainId),
-    ...(keyType === 'multisig'
+    ...(keyType === 'configurable'
       ? { account: account!, type: keyType }
       : { type: keyType }),
     ...(expiry !== undefined ? { expiry } : {}),
@@ -1006,7 +1005,9 @@ export function toRpc(authorization: Signed): Rpc {
     chainId: chainId === 0n ? '0x' : Hex.fromNumber(chainId),
     expiry: typeof expiry === 'number' ? Hex.fromNumber(expiry) : null,
     keyId: TempoAddress.resolve(address),
-    ...(type === 'multisig' ? { account, keyType: type } : { keyType: type }),
+    ...(type === 'configurable'
+      ? { account, keyType: 'multisig' as const }
+      : { keyType: type }),
     limits: limits?.map(({ token, limit, period }) => ({
       token,
       limit: Hex.fromNumber(limit),
@@ -1014,7 +1015,7 @@ export function toRpc(authorization: Signed): Rpc {
     })),
     signature: SignatureEnvelope.toRpc(signature) as
       | SignatureEnvelope.PrimitiveRpc
-      | SignatureEnvelope.MultisigRpc,
+      | SignatureEnvelope.ConfigurableRpc,
     ...(allowedCalls ? { allowedCalls } : {}),
     ...(witness !== undefined ? { witness } : {}),
     ...(isAdmin ? { isAdmin: true } : {}),
@@ -1089,7 +1090,7 @@ export function toTuple<const authorization extends KeyAuthorization>(
         return '0x01'
       case 'webAuthn':
         return '0x02'
-      case 'multisig':
+      case 'configurable':
         return '0x03'
       default:
         throw new Error(`Invalid key type: ${keyType}`)
@@ -1213,7 +1214,8 @@ function assertAccountBinding(
   type: KeyAuthorization['type'],
   account: TempoAddress.Address | null | undefined,
 ): void {
-  if (type === 'multisig' && account == null) throw new MissingAccountError()
+  if (type === 'configurable' && account == null)
+    throw new MissingAccountError()
 }
 
 function assertWitness(witness: Hex.Hex): void {
@@ -1256,15 +1258,15 @@ export class InvalidSignatureTypeError extends Error {
   override readonly name = 'KeyAuthorization.InvalidSignatureTypeError'
   constructor(type: SignatureEnvelope.SignatureEnvelope['type']) {
     super(
-      `Signature type \`${type}\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`multisig\`.`,
+      `Signature type \`${type}\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, \`webAuthn\`, or \`configurable\`.`,
     )
   }
 }
 
-/** Thrown when a multisig key grant omits its parent account binding. */
+/** Thrown when a configurable account key grant omits its parent account binding. */
 export class MissingAccountError extends Error {
   override readonly name = 'KeyAuthorization.MissingAccountError'
   constructor() {
-    super('Multisig key grants require a parent account binding.')
+    super('Configurable account key grants require a parent account binding.')
   }
 }

package/tempo/RpcSchemaTempo.test-d.ts

@@ -1,76 +1,76 @@
 import type { Provider } from 'ox'
 import type {
+  AccountConfig,
+  AccountOperation,
+  AccountSimulation,
   KeyAuthorization,
-  MultisigConfig,
-  MultisigOperation,
-  MultisigSimulation,
   RpcSchemaTempo,
 } from 'ox/tempo'
 import { expectTypeOf, test } from 'vitest'
 import type * as Address from '../core/Address.js'
 import type * as Hex from '../core/Hex.js'
 
-declare const provider: Provider.Provider<{ schema: RpcSchemaTempo.Multisig }>
+declare const provider: Provider.Provider<{ schema: RpcSchemaTempo.Account }>
 declare const tempoProvider: Provider.Provider<{
   schema: RpcSchemaTempo.Tempo
 }>
 declare const address: Address.Address
 declare const hash: Hex.Hex
 declare const keyAuthorization: KeyAuthorization.Rpc
-declare const multisigSimulation: MultisigSimulation.Rpc
+declare const multisigSimulation: AccountSimulation.Rpc
 declare const serializedTransaction: Hex.Hex
 declare const signature: Hex.Hex
 
-test('multisig provider methods', () => {
+test('account provider methods', () => {
   expectTypeOf(
     provider.request({
-      method: 'multisig_approveRawTransaction',
+      method: 'account_approveRawTransaction',
       params: [serializedTransaction],
     }),
   ).resolves.toEqualTypeOf<Hex.Hex>()
 
   expectTypeOf(
     provider.request({
-      method: 'multisig_approveRawTransactionSync',
+      method: 'account_approveRawTransactionSync',
       params: [serializedTransaction],
     }),
-  ).resolves.toEqualTypeOf<MultisigOperation.TransactionRpc>()
+  ).resolves.toEqualTypeOf<AccountOperation.TransactionRpc>()
 
   provider.request({
-    method: 'multisig_approveRawTransactionSync',
+    method: 'account_approveRawTransactionSync',
     params: [serializedTransaction, 30_000],
   })
 
   expectTypeOf(
     provider.request({
-      method: 'multisig_approveKeyAuthorization',
+      method: 'account_approveKeyAuthorization',
       params: [{ keyAuthorization }],
     }),
-  ).resolves.toEqualTypeOf<MultisigOperation.KeyAuthorizationRpc>()
+  ).resolves.toEqualTypeOf<AccountOperation.KeyAuthorizationRpc>()
 
   expectTypeOf(
     provider.request({
-      method: 'multisig_approveKeyAuthorization',
+      method: 'account_approveKeyAuthorization',
       params: [{ hash, signature }],
     }),
-  ).resolves.toEqualTypeOf<MultisigOperation.KeyAuthorizationRpc>()
+  ).resolves.toEqualTypeOf<AccountOperation.KeyAuthorizationRpc>()
 
   expectTypeOf(
     provider.request({
-      method: 'multisig_getConfig',
+      method: 'account_getConfig',
       params: [{ address }],
     }),
-  ).resolves.toEqualTypeOf<MultisigConfig.Rpc | null>()
+  ).resolves.toEqualTypeOf<AccountConfig.Rpc | null>()
 
   expectTypeOf(
     provider.request({
-      method: 'multisig_getOperation',
+      method: 'account_getOperation',
       params: [hash],
     }),
-  ).resolves.toEqualTypeOf<MultisigOperation.Rpc | null>()
+  ).resolves.toEqualTypeOf<AccountOperation.Rpc | null>()
 })
 
-test('tempo simulation accepts multisig specs', () => {
+test('tempo simulation accepts account simulation specs', () => {
   tempoProvider.request({
     method: 'tempo_simulateV1',
     params: [

package/tempo/RpcSchemaTempo.ts

@@ -5,9 +5,9 @@ import type * as Hex from '../core/Hex.js'
 import type * as Log from '../core/Log.js'
 import type * as RpcSchema from '../core/RpcSchema.js'
 import type * as StateOverrides from '../core/StateOverrides.js'
+import type * as AccountConfig from './AccountConfig.js'
+import type * as AccountOperation from './AccountOperation.js'
 import type * as KeyAuthorization from './KeyAuthorization.js'
-import type * as MultisigConfig from './MultisigConfig.js'
-import type * as MultisigOperation from './MultisigOperation.js'
 import type * as TransactionRequest from './TransactionRequest.js'
 
 /**
@@ -58,44 +58,44 @@ export type Tempo = RpcSchema.From<{
   }
 }>
 
-/** Union of all JSON-RPC methods for the `multisig_` namespace. */
-export type Multisig = RpcSchema.From<
+/** Union of all JSON-RPC methods for the `account_` namespace. */
+export type Account = RpcSchema.From<
   | {
       Request: {
-        method: 'multisig_approveRawTransaction'
+        method: 'account_approveRawTransaction'
         params: [serializedTransaction: Hex.Hex]
       }
       ReturnType: Hex.Hex
     }
   | {
       Request: {
-        method: 'multisig_approveRawTransactionSync'
+        method: 'account_approveRawTransactionSync'
         params: [serializedTransaction: Hex.Hex, timeout?: number]
       }
-      ReturnType: MultisigOperation.TransactionRpc
+      ReturnType: AccountOperation.TransactionRpc
     }
   | {
       Request: {
-        method: 'multisig_approveKeyAuthorization'
+        method: 'account_approveKeyAuthorization'
         params: [
           | { keyAuthorization: KeyAuthorization.Rpc }
           | { hash: Hex.Hex; signature: Hex.Hex },
         ]
       }
-      ReturnType: MultisigOperation.KeyAuthorizationRpc
+      ReturnType: AccountOperation.KeyAuthorizationRpc
     }
   | {
       Request: {
-        method: 'multisig_getConfig'
+        method: 'account_getConfig'
         params: [{ address: Address.Address }]
       }
-      ReturnType: MultisigConfig.Rpc | null
+      ReturnType: AccountConfig.Rpc | null
     }
   | {
       Request: {
-        method: 'multisig_getOperation'
+        method: 'account_getOperation'
         params: [hash: Hex.Hex]
       }
-      ReturnType: MultisigOperation.Rpc | null
+      ReturnType: AccountOperation.Rpc | null
     }
 >