ox 1.8.5 → 1.8.7

package/src/tempo/RpcSchemaTempo.test-d.ts

@@ -1,76 +1,76 @@
 import type { Provider } from 'ox'
 import type {
+  AccountConfig,
+  AccountSimulation,
   KeyAuthorization,
-  MultisigConfig,
-  MultisigOperation,
-  MultisigSimulation,
+  AccountOperation,
   RpcSchemaTempo,
 } from 'ox/tempo'
 import { expectTypeOf, test } from 'vp/test'
 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_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_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>()
 
   void provider.request({
-    method: 'multisig_approveRawTransactionSync',
+    method: 'account_approveRawTransactionSync',
     params: [serializedTransaction, 30_000],
   })
 
   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', () => {
   void tempoProvider.request({
     method: 'tempo_simulateV1',
     params: [

package/src/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 KeyAuthorization from './KeyAuthorization.js'
-import type * as MultisigConfig from './MultisigConfig.js'
-import type * as MultisigOperation from './MultisigOperation.js'
+import type * as AccountOperation from './AccountOperation.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_approveKeyAuthorization'
+        method: 'account_approveKeyAuthorization'
         params: [
           | { keyAuthorization: KeyAuthorization.Rpc }
           | { hash: Hex.Hex; signature: Hex.Hex },
         ]
       }
-      ReturnType: MultisigOperation.KeyAuthorizationRpc
+      ReturnType: AccountOperation.KeyAuthorizationRpc
     }
   | {
       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_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
     }
 >

package/src/tempo/SignatureEnvelope.test-d.ts

@@ -15,24 +15,24 @@ const envelope = SignatureEnvelope.from({
   signatures: [primitive],
 })
 
-test('preserves primitive and multisig RPC types', () => {
+test('preserves primitive and configurable RPC types', () => {
   expectTypeOf(
     SignatureEnvelope.toRpc(primitive),
   ).toEqualTypeOf<SignatureEnvelope.Secp256k1Rpc>()
   expectTypeOf(SignatureEnvelope.toRpc(envelope)).toEqualTypeOf<Hex.Hex>()
   expectTypeOf<
     SignatureEnvelope.GetType<typeof envelope>
-  >().toEqualTypeOf<'multisig'>()
-  expectTypeOf(envelope).toMatchTypeOf<SignatureEnvelope.Multisig>()
+  >().toEqualTypeOf<'configurable'>()
+  expectTypeOf(envelope).toMatchTypeOf<SignatureEnvelope.Configurable>()
 })
 
 test('requires config and primitive approvals', () => {
-  // @ts-expect-error Every multisig signature carries its current config.
+  // @ts-expect-error Every configurable signature carries its current config.
   SignatureEnvelope.from({ account: envelope.account, signatures: [primitive] })
-  // @ts-expect-error Multisig owners cannot recursively approve with multisigs.
+  // @ts-expect-error Configurable owners cannot recursively approve with configurable signatures.
   SignatureEnvelope.from({ ...envelope, signatures: [envelope] })
-  // @ts-expect-error Multisig RPC signatures are hex-encoded RLP.
-  const rpc: SignatureEnvelope.MultisigRpc = {
+  // @ts-expect-error Configurable RPC signatures are hex-encoded RLP.
+  const rpc: SignatureEnvelope.ConfigurableRpc = {
     account: envelope.account,
     signatures: [],
   }

package/src/tempo/SignatureEnvelope.test.ts

@@ -10,7 +10,7 @@ import {
   WebCryptoP256,
 } from 'ox'
 import { describe, expect, test } from 'vp/test'
-import * as MultisigConfig from './MultisigConfig.js'
+import * as AccountConfig from './AccountConfig.js'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
 
 const publicKey = PublicKey.from({
@@ -530,7 +530,7 @@ describe('deserialize', () => {
         SignatureEnvelope.deserialize('0xdeadbeef'),
       ).toThrowErrorMatchingInlineSnapshot(
         `
-        [SignatureEnvelope.InvalidSerializedError: Unable to deserialize signature envelope: Unknown signature type identifier: 0xde. Expected 0x01 (P256), 0x02 (WebAuthn), 0x03 (Keychain V1), 0x04 (Keychain V2), or 0x05 (Multisig)
+        [SignatureEnvelope.InvalidSerializedError: Unable to deserialize signature envelope: Unknown signature type identifier: 0xde. Expected 0x01 (P256), 0x02 (WebAuthn), 0x03 (Keychain V1), 0x04 (Keychain V2), or 0x05 (Configurable)
 
         Serialized: 0xdeadbeef]
       `,
@@ -690,7 +690,7 @@ describe('deserialize', () => {
         SignatureEnvelope.deserialize(unknownType),
       ).toThrowErrorMatchingInlineSnapshot(
         `
-        [SignatureEnvelope.InvalidSerializedError: Unable to deserialize signature envelope: Unknown signature type identifier: 0xff. Expected 0x01 (P256), 0x02 (WebAuthn), 0x03 (Keychain V1), 0x04 (Keychain V2), or 0x05 (Multisig)
+        [SignatureEnvelope.InvalidSerializedError: Unable to deserialize signature envelope: Unknown signature type identifier: 0xff. Expected 0x01 (P256), 0x02 (WebAuthn), 0x03 (Keychain V1), 0x04 (Keychain V2), or 0x05 (Configurable)
 
         Serialized: 0xff000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000]
       `,
@@ -1115,7 +1115,7 @@ describe('from', () => {
     })
   })
 
-  describe('multisig', () => {
+  describe('configurable', () => {
     test('normalizes the current config', () => {
       const envelope = SignatureEnvelope.from({
         account: '0x2222222222222222222222222222222222222222',
@@ -1750,7 +1750,7 @@ describe('serialize', () => {
   })
 })
 
-describe('sortMultisigApprovals', () => {
+describe('sortApprovals', () => {
   // Build owner key pairs first so we can construct a real genesis config
   // whose owner set matches the keys that produce the approvals below.
   const ownerKeys = Array.from({ length: 3 }, () => {
@@ -1764,16 +1764,16 @@ describe('sortMultisigApprovals', () => {
     Hex.toBigInt(a.address) < Hex.toBigInt(b.address) ? -1 : 1,
   )
 
-  const genesisConfig = MultisigConfig.from({
+  const genesisConfig = AccountConfig.from({
     threshold: 2,
     owners: ascendingOwners.map((o) => ({ owner: o.address, weight: 1 })),
   })
   const payload = `0x${'42'.repeat(32)}` as const
-  const account = MultisigConfig.getAddress(genesisConfig, {
+  const account = AccountConfig.getAddress(genesisConfig, {
     factory: '0x7171717171717171717171717171717171717171',
   })
   const version = 3n
-  const digest = MultisigConfig.getSignPayload({
+  const digest = AccountConfig.getSignPayload({
     payload,
     account,
     config: { version },
@@ -1791,7 +1791,7 @@ describe('sortMultisigApprovals', () => {
   }))
 
   test('behavior: orders approvals ascending by recovered owner address', () => {
-    const ordered = SignatureEnvelope.sortMultisigApprovals({
+    const ordered = SignatureEnvelope.sortApprovals({
       account,
       config: { version },
       payload,
@@ -1804,7 +1804,7 @@ describe('sortMultisigApprovals', () => {
   test('behavior: already-sorted input is unchanged', () => {
     const signatures = ascending.map((owner) => owner.signature)
     expect(
-      SignatureEnvelope.sortMultisigApprovals({
+      SignatureEnvelope.sortApprovals({
         account,
         config: { version },
         payload,
@@ -1814,7 +1814,7 @@ describe('sortMultisigApprovals', () => {
   })
 
   test('behavior: recovered order matches the config owner order', () => {
-    const ordered = SignatureEnvelope.sortMultisigApprovals({
+    const ordered = SignatureEnvelope.sortApprovals({
       account,
       config: { version },
       payload,
@@ -2832,9 +2832,9 @@ describe('CoercionError', () => {
   })
 })
 
-describe('multisig', () => {
+describe('configurable', () => {
   const account = '0x2222222222222222222222222222222222222222'
-  const config = MultisigConfig.from({
+  const config = AccountConfig.from({
     threshold: 1,
     owners: [
       { owner: '0x1111111111111111111111111111111111111111', weight: 1 },
@@ -2853,7 +2853,7 @@ describe('multisig', () => {
     expect(Rlp.toHex(Hex.slice(serialized, 1))).toEqual([
       account,
       [
-        MultisigConfig.zeroSalt,
+        AccountConfig.zeroSalt,
         '0x',
         '0x01',
         [['0x1111111111111111111111111111111111111111', '0x01']],
@@ -2894,7 +2894,7 @@ describe('multisig', () => {
   })
 
   test('rejects old wire and RPC shapes', () => {
-    for (const first of [account, MultisigConfig.toTuple(config)] as const)
+    for (const first of [account, AccountConfig.toTuple(config)] as const)
       expect(() =>
         SignatureEnvelope.deserialize(
           Hex.concat(
@@ -2909,7 +2909,7 @@ describe('multisig', () => {
   })
 
   test('rejects malformed configs', () => {
-    const valid = MultisigConfig.toTuple(config)
+    const valid = AccountConfig.toTuple(config)
     for (const tuple of [
       ['0x00', ...valid.slice(1)],
       [valid[0], '0x00', valid[2], valid[3]],
@@ -2929,7 +2929,7 @@ describe('multisig', () => {
             ]),
           ),
         ),
-      ).toThrowError(MultisigConfig.InvalidConfigError)
+      ).toThrowError(AccountConfig.InvalidConfigError)
   })
 
   test('rejects invalid accounts, missing configs, and invalid approval counts', () => {
@@ -2955,7 +2955,7 @@ describe('multisig', () => {
       config: { ...config, owners: [{ owner: account, weight: 1 }] },
     } as const
     expect(() => SignatureEnvelope.assert(self)).toThrowError(
-      SignatureEnvelope.InvalidMultisigApprovalError,
+      SignatureEnvelope.InvalidApprovalError,
     )
     expect(() =>
       SignatureEnvelope.assert({
@@ -2972,12 +2972,12 @@ describe('multisig', () => {
           ...envelope,
           signatures: [signature],
         } as never),
-      ).toThrowError(SignatureEnvelope.InvalidMultisigApprovalError)
+      ).toThrowError(SignatureEnvelope.InvalidApprovalError)
       const wire = Hex.concat(
         '0x05',
         Rlp.fromHex([
           account,
-          MultisigConfig.toTuple(config),
+          AccountConfig.toTuple(config),
           [SignatureEnvelope.serialize(signature)],
         ]),
       )
@@ -2997,9 +2997,9 @@ describe('multisig', () => {
     }
     expect(() =>
       SignatureEnvelope.assert({ ...envelope, signatures: [oversized] }),
-    ).toThrowError(SignatureEnvelope.InvalidMultisigApprovalError)
+    ).toThrowError(SignatureEnvelope.InvalidApprovalError)
   })
-  test('requires keychain V2 for multisig delegates', () => {
+  test('requires keychain V2 for configurable delegates', () => {
     const keychain = SignatureEnvelope.from({
       userAddress: account,
       version: 'v2',
@@ -3009,12 +3009,12 @@ describe('multisig', () => {
     expect(SignatureEnvelope.deserialize(serialized)).toEqual(keychain)
     expect(() =>
       SignatureEnvelope.serialize({ ...keychain, version: 'v1' }),
-    ).toThrowError(SignatureEnvelope.InvalidMultisigApprovalError)
+    ).toThrowError(SignatureEnvelope.InvalidApprovalError)
     expect(() =>
       SignatureEnvelope.deserialize(
         Hex.concat('0x03', Hex.slice(serialized, 1)),
       ),
-    ).toThrowError(SignatureEnvelope.InvalidMultisigApprovalError)
+    ).toThrowError(SignatureEnvelope.InvalidApprovalError)
     expect(() =>
       SignatureEnvelope.fromRpc({
         type: 'keychain',
@@ -3022,9 +3022,9 @@ describe('multisig', () => {
         version: 'v1',
         signature: SignatureEnvelope.toRpc(envelope),
       }),
-    ).toThrowError(SignatureEnvelope.InvalidMultisigApprovalError)
+    ).toThrowError(SignatureEnvelope.InvalidApprovalError)
   })
-  test('rejects V1 wrappers around recursively nested multisig delegates', () => {
+  test('rejects V1 wrappers around recursively nested configurable delegates', () => {
     let inner: SignatureEnvelope.SignatureEnvelope = envelope
     for (let depth = 0; depth < 3; depth++) {
       inner = { inner, type: 'keychain', userAddress: account, version: 'v2' }
@@ -3038,10 +3038,10 @@ describe('multisig', () => {
       expect(SignatureEnvelope.validate(valid)).toBe(true)
       expect(SignatureEnvelope.validate(invalid)).toBe(false)
       expect(() => SignatureEnvelope.serialize(invalid)).toThrowError(
-        SignatureEnvelope.InvalidMultisigApprovalError,
+        SignatureEnvelope.InvalidApprovalError,
       )
       expect(() => SignatureEnvelope.toRpc(invalid)).toThrowError(
-        SignatureEnvelope.InvalidMultisigApprovalError,
+        SignatureEnvelope.InvalidApprovalError,
       )
       expect(() =>
         SignatureEnvelope.fromRpc({
@@ -3050,15 +3050,15 @@ describe('multisig', () => {
           version: 'v1',
           signature: SignatureEnvelope.toRpc(inner),
         }),
-      ).toThrowError(SignatureEnvelope.InvalidMultisigApprovalError)
+      ).toThrowError(SignatureEnvelope.InvalidApprovalError)
       expect(() =>
         SignatureEnvelope.deserialize(
           Hex.concat('0x03', account, SignatureEnvelope.serialize(inner)),
         ),
-      ).toThrowError(SignatureEnvelope.InvalidMultisigApprovalError)
+      ).toThrowError(SignatureEnvelope.InvalidApprovalError)
       expect(() =>
         SignatureEnvelope.serialize({ ...valid, inner: invalid }),
-      ).toThrowError(SignatureEnvelope.InvalidMultisigApprovalError)
+      ).toThrowError(SignatureEnvelope.InvalidApprovalError)
     }
     expect(
       SignatureEnvelope.validate({
@@ -3123,7 +3123,7 @@ describe('multisig', () => {
   })
 })
 
-describe('multisig vectors', () => {
+describe('configurable vectors', () => {
   const initial =
     '0x05f89794c4a590afa7337e5cd5eb3aa60cacf91c5400044bf83ba000000000000000000000000000000000000000000000000000000000000000008001d7d6947e5f4552091a69125d5dfcb7b8c2659029395bdf01f843b841869437e01f64bebeb78a8a6b30bfd3a993819c8cad82c807515d9b9e9b36f98535dfaa5eebc597715d05f6ce4927747f14fa4cd2acc717fdcd3877146437f8f41b' as const
   const current =
@@ -3156,7 +3156,7 @@ describe('multisig vectors', () => {
             "type": "secp256k1",
           },
         ],
-        "type": "multisig",
+        "type": "configurable",
       }
     `)
     expect(SignatureEnvelope.serialize(envelope)).toBe(initial)
@@ -3189,7 +3189,7 @@ describe('multisig vectors', () => {
             "type": "secp256k1",
           },
         ],
-        "type": "multisig",
+        "type": "configurable",
       }
     `)
     expect(SignatureEnvelope.serialize(envelope)).toBe(current)