ox 0.14.41 → 0.14.43

package/tempo/MultisigSimulation.ts

@@ -0,0 +1,266 @@
+import * as Address from '../core/Address.js'
+import * as Errors from '../core/Errors.js'
+import * as Hex from '../core/Hex.js'
+import type { Compute } from '../core/internal/types.js'
+import * as Rlp from '../core/Rlp.js'
+import * as MultisigConfig from './MultisigConfig.js'
+import type * as SignatureEnvelope from './SignatureEnvelope.js'
+
+/** Native multisig owner approval used for RPC simulation. */
+export type Approval = NestedApproval | PrimitiveApproval
+
+/** JSON-RPC native multisig owner approval used for RPC simulation. */
+export type ApprovalRpc = NestedApprovalRpc | PrimitiveApproval
+
+/** Nested native multisig owner approval used for RPC simulation. */
+export type NestedApproval = {
+  /** Depth-2 multisig simulation spec. */
+  spec: NestedSpec
+  /** Approval type. */
+  type: 'multisig'
+}
+
+/** JSON-RPC nested native multisig owner approval used for RPC simulation. */
+export type NestedApprovalRpc = {
+  /** Depth-2 multisig simulation spec. */
+  spec: NestedSpecRpc
+  /** Approval type. */
+  type: 'multisig'
+}
+
+/** Primitive approval in a depth-2 multisig simulation spec. */
+export type NestedPrimitiveApproval = {
+  /** Optional signature-specific gas-estimation data. */
+  keyData?: Hex.Hex | undefined
+  /** Signature type to model. Omission uses a maximum-size WebAuthn signature. */
+  keyType?: SignatureEnvelope.Type | undefined
+  /** Configured owner address. */
+  owner: Address.Address
+}
+
+/** Depth-2 native multisig spec used for RPC simulation. */
+export type NestedSpec = {
+  /** Nested multisig account. */
+  account: Address.Address
+  /** Primitive owner approvals to model. */
+  approvals: readonly NestedPrimitiveApproval[]
+  /** Complete applicable configuration. */
+  config: MultisigConfig.Config
+}
+
+/** JSON-RPC depth-2 native multisig spec used for RPC simulation. */
+export type NestedSpecRpc = {
+  /** Nested multisig account. */
+  account: Address.Address
+  /** Primitive owner approvals to model. */
+  approvals: readonly NestedPrimitiveApproval[]
+  /** Canonical RLP-encoded applicable configuration. */
+  config: Hex.Hex
+}
+
+/** Primitive owner approval used for RPC simulation. */
+export type PrimitiveApproval = {
+  /** Optional signature-specific gas-estimation data. */
+  keyData?: Hex.Hex | undefined
+  /** Signature type to model. Omission uses a maximum-size WebAuthn signature. */
+  keyType?: SignatureEnvelope.Type | undefined
+  /** Configured owner address. */
+  owner: Address.Address
+  /** Approval type. */
+  type: 'primitive'
+}
+
+/** JSON-RPC representation of a native multisig simulation spec. */
+export type Rpc = Compute<{
+  /** Account authorized by this spec. */
+  account: Address.Address
+  /** Owner approvals to model. */
+  approvals: readonly ApprovalRpc[]
+  /** Canonical RLP-encoded applicable configuration. */
+  config: Hex.Hex
+}>
+
+/** Native multisig spec used to construct an RPC simulation signature. */
+export type Spec = Compute<{
+  /** Account authorized by this spec. */
+  account: Address.Address
+  /** Owner approvals to model. */
+  approvals: readonly Approval[]
+  /** Complete applicable configuration. */
+  config: MultisigConfig.Config
+}>
+
+/**
+ * Converts a JSON-RPC multisig simulation spec to its domain representation.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { MultisigSimulation } from 'ox/tempo'
+ *
+ * const spec = MultisigSimulation.fromRpc(specRpc)
+ * ```
+ *
+ * @param spec - JSON-RPC multisig simulation spec.
+ * @returns The multisig simulation spec with decoded configurations.
+ */
+export function fromRpc(spec: Rpc): Spec {
+  const { account, approvals, config } = spec
+  assertApprovalCount(approvals)
+  return {
+    account,
+    approvals: approvals.map((approval) => {
+      if (approval.type === 'primitive') return approval
+      assertApprovalCount(approval.spec.approvals)
+      return {
+        spec: {
+          account: approval.spec.account,
+          approvals: approval.spec.approvals,
+          config: deserializeConfig(approval.spec.config),
+        },
+        type: 'multisig',
+      }
+    }),
+    config: deserializeConfig(config),
+  }
+}
+
+export declare namespace fromRpc {
+  /** Error type for `fromRpc`. */
+  export type ErrorType =
+    | Hex.isEqual.ErrorType
+    | InvalidSimulationError
+    | MultisigConfig.assert.ErrorType
+    | Rlp.fromHex.ErrorType
+    | Rlp.toHex.ErrorType
+    | Errors.GlobalErrorType
+}
+
+/**
+ * Converts a multisig simulation spec to its JSON-RPC representation.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { MultisigSimulation } from 'ox/tempo'
+ *
+ * const specRpc = MultisigSimulation.toRpc(spec)
+ * ```
+ *
+ * @param spec - Multisig simulation spec.
+ * @returns The JSON-RPC multisig simulation spec with encoded configurations.
+ */
+export function toRpc(spec: Spec): Rpc {
+  const { account, approvals, config } = spec
+  assertApprovalCount(approvals)
+  return {
+    account,
+    approvals: approvals.map((approval) => {
+      if (approval.type === 'primitive')
+        return {
+          ...approval,
+          ...(typeof approval.keyData !== 'undefined'
+            ? { keyData: shimKeyData(approval.keyData) }
+            : {}),
+        }
+      assertApprovalCount(approval.spec.approvals)
+      return {
+        spec: {
+          account: approval.spec.account,
+          approvals: approval.spec.approvals.map((approval) => ({
+            ...approval,
+            ...(typeof approval.keyData !== 'undefined'
+              ? { keyData: shimKeyData(approval.keyData) }
+              : {}),
+          })),
+          config: serializeConfig(approval.spec.config),
+        },
+        type: 'multisig',
+      }
+    }),
+    config: serializeConfig(config),
+  }
+}
+
+export declare namespace toRpc {
+  /** Error type for `toRpc`. */
+  export type ErrorType =
+    | Hex.fromNumber.ErrorType
+    | InvalidSimulationError
+    | MultisigConfig.assert.ErrorType
+    | Rlp.fromHex.ErrorType
+    | Errors.GlobalErrorType
+}
+
+/** @internal */
+function assertApprovalCount(approvals: readonly unknown[]) {
+  if (approvals.length > MultisigConfig.maxSignatures)
+    throw new InvalidSimulationError({
+      reason: `approval count exceeds ${MultisigConfig.maxSignatures}`,
+    })
+}
+
+/** @internal */
+function deserializeConfig(config: Hex.Hex): MultisigConfig.Config {
+  const tuple = Rlp.toHex(config)
+  if (!Array.isArray(tuple) || tuple.length !== 4)
+    throw new InvalidSimulationError({ reason: 'invalid config encoding' })
+  const [salt, version, threshold, owners] = tuple
+  if (
+    Array.isArray(salt) ||
+    Hex.size(salt) !== 32 ||
+    Array.isArray(version) ||
+    Hex.size(version) > 8 ||
+    (version !== '0x' && Hex.slice(version, 0, 1) === '0x00') ||
+    Array.isArray(threshold) ||
+    Hex.size(threshold) > 1 ||
+    !Array.isArray(owners) ||
+    owners.some(
+      (owner) =>
+        !Array.isArray(owner) ||
+        owner.length !== 2 ||
+        owner.some(Array.isArray) ||
+        !Address.validate(owner[0]) ||
+        Hex.size(owner[1] as Hex.Hex) > 1,
+    )
+  )
+    throw new InvalidSimulationError({ reason: 'invalid config encoding' })
+  const value = MultisigConfig.fromTuple(
+    tuple as unknown as MultisigConfig.Tuple,
+  )
+  MultisigConfig.assert(value)
+  if (!Hex.isEqual(config, serializeConfig(value)))
+    throw new InvalidSimulationError({ reason: 'noncanonical config encoding' })
+  return value
+}
+
+/** @internal */
+function serializeConfig(config: MultisigConfig.Input): Hex.Hex {
+  return Rlp.fromHex(MultisigConfig.toTuple(config))
+}
+
+/**
+ * Shims long key data into the length hint accepted by Tempo's gas estimator.
+ * @internal
+ */
+function shimKeyData(data: Hex.Hex): Hex.Hex {
+  const size = Hex.size(data)
+  if (size <= 4) return data
+  return Hex.fromNumber(size, { size: 2 })
+}
+
+/** Thrown when a native multisig simulation spec is invalid. */
+export class InvalidSimulationError extends Errors.BaseError {
+  override readonly name = 'MultisigSimulation.InvalidSimulationError'
+  constructor(options: InvalidSimulationError.Options) {
+    super(`Invalid multisig simulation: ${options.reason}.`)
+  }
+}
+
+export declare namespace InvalidSimulationError {
+  /** Error construction options. */
+  export type Options = {
+    /** Validation failure. */
+    reason: string
+  }
+}

package/tempo/RpcSchemaTempo.test-d.ts

@@ -1,20 +1,23 @@
 import type { Provider } from 'ox'
 import type {
   KeyAuthorization,
+  MultisigConfig,
   MultisigOperation,
-  MultisigWitness,
+  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 tempoProvider: Provider.Provider<{
   schema: RpcSchemaTempo.Tempo
 }>
+declare const address: Address.Address
 declare const hash: Hex.Hex
 declare const keyAuthorization: KeyAuthorization.Rpc
-declare const multisigWitness: MultisigWitness.Rpc
+declare const multisigSimulation: MultisigSimulation.Rpc
 declare const serializedTransaction: Hex.Hex
 declare const signature: Hex.Hex
 
@@ -52,6 +55,13 @@ test('multisig provider methods', () => {
     }),
   ).resolves.toEqualTypeOf<MultisigOperation.KeyAuthorizationRpc>()
 
+  expectTypeOf(
+    provider.request({
+      method: 'multisig_getConfig',
+      params: [{ address }],
+    }),
+  ).resolves.toEqualTypeOf<MultisigConfig.Rpc | null>()
+
   expectTypeOf(
     provider.request({
       method: 'multisig_getOperation',
@@ -60,7 +70,7 @@ test('multisig provider methods', () => {
   ).resolves.toEqualTypeOf<MultisigOperation.Rpc | null>()
 })
 
-test('tempo simulation accepts multisig witnesses', () => {
+test('tempo simulation accepts multisig specs', () => {
   tempoProvider.request({
     method: 'tempo_simulateV1',
     params: [
@@ -69,7 +79,7 @@ test('tempo simulation accepts multisig witnesses', () => {
           {
             calls: [
               {
-                multisigWitness,
+                multisigSimulation,
               },
             ],
           },

package/tempo/RpcSchemaTempo.ts

@@ -1,3 +1,4 @@
+import type * as Address from '../core/Address.js'
 import type * as Block from '../core/Block.js'
 import type * as BlockOverrides from '../core/BlockOverrides.js'
 import type * as Hex from '../core/Hex.js'
@@ -5,6 +6,7 @@ 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 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'
 
@@ -82,6 +84,13 @@ export type Multisig = RpcSchema.From<
       }
       ReturnType: MultisigOperation.KeyAuthorizationRpc
     }
+  | {
+      Request: {
+        method: 'multisig_getConfig'
+        params: [{ address: Address.Address }]
+      }
+      ReturnType: MultisigConfig.Rpc | null
+    }
   | {
       Request: {
         method: 'multisig_getOperation'

package/tempo/SignatureEnvelope.test-d.ts

@@ -34,20 +34,10 @@ test('toRpc preserves the signature type', () => {
   ).toEqualTypeOf<SignatureEnvelope.Secp256k1Rpc>()
 })
 
-test('MultisigRpc carries one complete witness shape', () => {
-  const rpc = {
-    account: '0x1111111111111111111111111111111111111111',
-    config: { ...config, version: 0 },
-    signatures: [signatureRpc],
-  } as const satisfies SignatureEnvelope.MultisigRpc
+test('MultisigRpc contains an untagged serialized multisig signature', () => {
+  const rpc = '0xf8' as const satisfies SignatureEnvelope.MultisigRpc
 
-  expectTypeOf(rpc.config).toMatchTypeOf<MultisigConfig.Config<number>>()
-  expectTypeOf(rpc.signatures).toMatchTypeOf<
-    readonly SignatureEnvelope.SignatureEnvelopeRpc[]
-  >()
-  expectTypeOf<
-    SignatureEnvelope.GetType<typeof rpc>
-  >().toEqualTypeOf<'multisig'>()
+  expectTypeOf(rpc).toMatchTypeOf<`0x${string}`>()
 })
 
 test('from derives an initial account', () => {
@@ -75,40 +65,14 @@ test('from requires an account for a current config', () => {
   expectTypeOf(multisig).toMatchTypeOf<SignatureEnvelope.Multisig>()
 })
 
-test('MultisigRpc rejects old witness shapes', () => {
-  const accountOnly = {
-    account: '0x1111111111111111111111111111111111111111',
-    signatures: [signatureRpc],
-  } as const
-  // @ts-expect-error Multisig RPC signatures require config.
-  const accountOnlyRpc: SignatureEnvelope.MultisigRpc = accountOnly
-
-  const init = {
-    init: config,
-    signatures: [signatureRpc],
-  } as const
-  // @ts-expect-error Multisig RPC signatures no longer accept init.
-  const initRpc: SignatureEnvelope.MultisigRpc = init
-
-  const serialized = {
-    account: '0x1111111111111111111111111111111111111111',
-    config: { ...config, version: 0 },
-    signatures: ['0x1234'],
-  } as const
-  // @ts-expect-error Owner approvals use structured RPC envelopes.
-  const serializedRpc: SignatureEnvelope.MultisigRpc = serialized
-
-  const tagged = {
+test('MultisigRpc rejects structured signatures', () => {
+  const structured = {
     account: '0x1111111111111111111111111111111111111111',
     config: { ...config, version: 0 },
     signatures: [signatureRpc],
-    type: 'multisig',
   } as const
-  // @ts-expect-error Multisig RPC signatures are untagged.
-  const taggedRpc: SignatureEnvelope.MultisigRpc = tagged
+  // @ts-expect-error Multisig RPC signatures are serialized hex.
+  const rpc: SignatureEnvelope.MultisigRpc = structured
 
-  expectTypeOf(accountOnlyRpc).toEqualTypeOf<SignatureEnvelope.MultisigRpc>()
-  expectTypeOf(initRpc).toEqualTypeOf<SignatureEnvelope.MultisigRpc>()
-  expectTypeOf(serializedRpc).toEqualTypeOf<SignatureEnvelope.MultisigRpc>()
-  expectTypeOf(taggedRpc).toEqualTypeOf<SignatureEnvelope.MultisigRpc>()
+  expectTypeOf(rpc).toEqualTypeOf<SignatureEnvelope.MultisigRpc>()
 })

package/tempo/SignatureEnvelope.test.ts

@@ -68,6 +68,9 @@ const signature_keychain_webauthn = SignatureEnvelope.from({
   version: 'v2',
 })
 
+const signature_multisig_rpc =
+  '0xf897949dba7f426b711d4893c11611eacf7cc334e7146bf83ba000000000000000000000000000000000000000000000000000000000000000008001d7d6947e5f4552091a69125d5dfcb7b8c2659029395bdf01f843b841869437e01f64bebeb78a8a6b30bfd3a993819c8cad82c807515d9b9e9b36f98535dfaa5eebc597715d05f6ce4927747f14fa4cd2acc717fdcd3877146437f8f41b' as const
+
 describe('assert', () => {
   describe('secp256k1', () => {
     test('behavior: validates valid signature', () => {
@@ -2468,6 +2471,72 @@ describe('fromRpc', () => {
       expect(envelope.keyId).toBe('0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c')
     })
   })
+
+  describe('multisig', () => {
+    test('behavior: converts an untagged serialized multisig signature', () => {
+      expect(
+        SignatureEnvelope.fromRpc(signature_multisig_rpc),
+      ).toMatchInlineSnapshot(`
+        {
+          "account": "0x9dba7f426b711d4893c11611eacf7cc334e7146b",
+          "config": {
+            "owners": [
+              {
+                "owner": "0x7e5f4552091a69125d5dfcb7b8c2659029395bdf",
+                "weight": 1,
+              },
+            ],
+            "salt": "0x0000000000000000000000000000000000000000000000000000000000000000",
+            "threshold": 1,
+            "version": 0n,
+          },
+          "signatures": [
+            {
+              "signature": {
+                "r": 60871800714128149016591846789173983752390955456021923556141688418770269698437n,
+                "s": 24367763726302312398084372528434045669788111037623467391175388828437596076276n,
+                "yParity": 0,
+              },
+              "type": "secp256k1",
+            },
+          ],
+          "type": "multisig",
+        }
+      `)
+    })
+
+    test('error: rejects a payload with the transaction type byte', () => {
+      expect(() =>
+        SignatureEnvelope.fromRpc(`0x05${signature_multisig_rpc.slice(2)}`),
+      ).toThrowErrorMatchingInlineSnapshot(`
+        [SignatureEnvelope.InvalidSerializedError: Unable to deserialize signature envelope: invalid multisig wire shape: expected exactly three fields
+
+        Serialized: 0x0505f897949dba7f426b711d4893c11611eacf7cc334e7146bf83ba000000000000000000000000000000000000000000000000000000000000000008001d7d6947e5f4552091a69125d5dfcb7b8c2659029395bdf01f843b841869437e01f64bebeb78a8a6b30bfd3a993819c8cad82c807515d9b9e9b36f98535dfaa5eebc597715d05f6ce4927747f14fa4cd2acc717fdcd3877146437f8f41b]
+      `)
+    })
+
+    test('error: rejects trailing bytes', () => {
+      expect(() =>
+        SignatureEnvelope.fromRpc(`${signature_multisig_rpc}00`),
+      ).toThrowErrorMatchingInlineSnapshot(`
+        [SignatureEnvelope.InvalidSerializedError: Unable to deserialize signature envelope: invalid multisig RPC signature
+
+        Serialized: 0xf897949dba7f426b711d4893c11611eacf7cc334e7146bf83ba000000000000000000000000000000000000000000000000000000000000000008001d7d6947e5f4552091a69125d5dfcb7b8c2659029395bdf01f843b841869437e01f64bebeb78a8a6b30bfd3a993819c8cad82c807515d9b9e9b36f98535dfaa5eebc597715d05f6ce4927747f14fa4cd2acc717fdcd3877146437f8f41b00]
+      `)
+    })
+
+    test('error: rejects a structured multisig signature', () => {
+      expect(() =>
+        SignatureEnvelope.fromRpc({
+          account: '0x9dba7f426b711d4893c11611eacf7cc334e7146b',
+          config: {},
+          signatures: [],
+        } as never),
+      ).toThrowErrorMatchingInlineSnapshot(
+        `[SignatureEnvelope.CoercionError: Unable to coerce value (\`{"account":"0x9dba7f426b711d4893c11611eacf7cc334e7146b","config":{},"signatures":[]}\`) to a valid signature envelope.]`,
+      )
+    })
+  })
 })
 
 describe('toRpc', () => {
@@ -2565,6 +2634,7 @@ describe('toRpc', () => {
       const rpc = SignatureEnvelope.toRpc(
         signature_keychain_p256,
       ) as SignatureEnvelope.KeychainRpc
+      if (typeof rpc.signature === 'string') throw new Error('unreachable')
 
       expect(rpc.type).toBe('keychain')
       expect(rpc.userAddress).toBe(signature_keychain_p256.userAddress)
@@ -2577,6 +2647,7 @@ describe('toRpc', () => {
       const rpc = SignatureEnvelope.toRpc(
         signature_keychain_webauthn,
       ) as SignatureEnvelope.KeychainRpc
+      if (typeof rpc.signature === 'string') throw new Error('unreachable')
 
       expect(rpc.type).toBe('keychain')
       expect(rpc.userAddress).toBe(signature_keychain_webauthn.userAddress)
@@ -2620,6 +2691,18 @@ describe('toRpc', () => {
       expect(rpc.keyId).toBeUndefined()
     })
   })
+
+  describe('multisig', () => {
+    test('behavior: removes the transaction type byte', () => {
+      const envelope = SignatureEnvelope.deserialize(
+        `0x05${signature_multisig_rpc.slice(2)}`,
+      )
+
+      expect(SignatureEnvelope.toRpc(envelope)).toMatchInlineSnapshot(
+        `"${signature_multisig_rpc}"`,
+      )
+    })
+  })
 })
 
 describe('roundtrip: toRpc <-> fromRpc', () => {
@@ -2860,7 +2943,7 @@ describe('multisig', () => {
   const nested =
     '0x05f8f0949969e2243075b27a8eab61009c59b77ab13b83f6f83ba033333333333333333333333333333333333333333333333333333333333333338001d7d6944f9f5b162a7464bcc260ce44d7ae0d935f9c583701f89cb89a05f897944f9f5b162a7464bcc260ce44d7ae0d935f9c5837f83ba022222222222222222222222222222222222222222222222222222222222222228001d7d6946813eb9362372eef6200f3b1dbc3f819671cba6901f843b841032aa6f3ea7b0b7069720d0f3891983c493d149326c5c957d864ed7371b8475e3e95325079b24491f4b6d68920e4b3bacd7c6094df6ed88b8674864ab559c8fb1b' as const
 
-  test('example: decodes and re-encodes the frozen initial witness', () => {
+  test('example: decodes and re-encodes the frozen initial signature', () => {
     const envelope = SignatureEnvelope.deserialize(initial)
 
     expect(envelope).toMatchInlineSnapshot(`
@@ -2893,7 +2976,7 @@ describe('multisig', () => {
     expect(SignatureEnvelope.serialize(envelope)).toBe(initial)
   })
 
-  test('example: decodes and re-encodes the frozen current witness', () => {
+  test('example: decodes and re-encodes the frozen current signature', () => {
     const envelope = SignatureEnvelope.deserialize(current)
 
     expect(envelope).toMatchInlineSnapshot(`
@@ -2926,7 +3009,7 @@ describe('multisig', () => {
     expect(SignatureEnvelope.serialize(envelope)).toBe(current)
   })
 
-  test('example: decodes and re-encodes the frozen nested witness', () => {
+  test('example: decodes and re-encodes the frozen nested signature', () => {
     const envelope = SignatureEnvelope.deserialize(nested)
 
     expect(envelope).toMatchInlineSnapshot(`
@@ -3014,7 +3097,7 @@ describe('multisig', () => {
     `)
   })
 
-  test('behavior: round trips initial and current RPC witnesses', () => {
+  test('behavior: round trips initial and current RPC signatures', () => {
     const initialEnvelope = SignatureEnvelope.deserialize(initial)
     const currentEnvelope = SignatureEnvelope.deserialize(current)
     const rpc = {
@@ -3024,50 +3107,8 @@ describe('multisig', () => {
 
     expect(rpc).toMatchInlineSnapshot(`
       {
-        "current": {
-          "account": "0x9dba7f426b711d4893c11611eacf7cc334e7146b",
-          "config": {
-            "owners": [
-              {
-                "owner": "0x2b5ad5c4795c026514f8317c7a215e218dccd6cf",
-                "weight": 1,
-              },
-            ],
-            "salt": "0x0000000000000000000000000000000000000000000000000000000000000000",
-            "threshold": 1,
-            "version": 1,
-          },
-          "signatures": [
-            {
-              "r": "0x4a0e5b5b4a90f08e6e8d676a73a22dc2cf022ffdcc9299512b5d9a6daf66e050",
-              "s": "0x4a395a2ef6f6c0f173910b875c45d01aa66d928e56ba6f49bbc8186f80268bf5",
-              "type": "secp256k1",
-              "yParity": "0x0",
-            },
-          ],
-        },
-        "initial": {
-          "account": "0x9dba7f426b711d4893c11611eacf7cc334e7146b",
-          "config": {
-            "owners": [
-              {
-                "owner": "0x7e5f4552091a69125d5dfcb7b8c2659029395bdf",
-                "weight": 1,
-              },
-            ],
-            "salt": "0x0000000000000000000000000000000000000000000000000000000000000000",
-            "threshold": 1,
-            "version": 0,
-          },
-          "signatures": [
-            {
-              "r": "0x869437e01f64bebeb78a8a6b30bfd3a993819c8cad82c807515d9b9e9b36f985",
-              "s": "0x35dfaa5eebc597715d05f6ce4927747f14fa4cd2acc717fdcd3877146437f8f4",
-              "type": "secp256k1",
-              "yParity": "0x0",
-            },
-          ],
-        },
+        "current": "0xf897949dba7f426b711d4893c11611eacf7cc334e7146bf83ba000000000000000000000000000000000000000000000000000000000000000000101d7d6942b5ad5c4795c026514f8317c7a215e218dccd6cf01f843b8414a0e5b5b4a90f08e6e8d676a73a22dc2cf022ffdcc9299512b5d9a6daf66e0504a395a2ef6f6c0f173910b875c45d01aa66d928e56ba6f49bbc8186f80268bf51b",
+        "initial": "0xf897949dba7f426b711d4893c11611eacf7cc334e7146bf83ba000000000000000000000000000000000000000000000000000000000000000008001d7d6947e5f4552091a69125d5dfcb7b8c2659029395bdf01f843b841869437e01f64bebeb78a8a6b30bfd3a993819c8cad82c807515d9b9e9b36f98535dfaa5eebc597715d05f6ce4927747f14fa4cd2acc717fdcd3877146437f8f41b",
       }
     `)
     expect(SignatureEnvelope.fromRpc(rpc.initial)).toStrictEqual(
@@ -3078,7 +3119,7 @@ describe('multisig', () => {
     )
   })
 
-  test('behavior: derives the account only for an initial witness', () => {
+  test('behavior: derives the account only for an initial config', () => {
     const initialEnvelope = SignatureEnvelope.deserialize(initial)
     if (initialEnvelope.type !== 'multisig') throw new Error('unreachable')
     if (initialEnvelope.config.version !== 0n) throw new Error('unreachable')
@@ -3149,7 +3190,7 @@ describe('multisig', () => {
     `)
   })
 
-  test('behavior: accepts initial and current nested witnesses', () => {
+  test('behavior: accepts initial and current nested signatures', () => {
     const initialEnvelope = SignatureEnvelope.deserialize(initial)
     const currentEnvelope = SignatureEnvelope.deserialize(current)
     if (
@@ -3191,7 +3232,7 @@ describe('multisig', () => {
     )
   })
 
-  test('error: rejects a self-owned current witness', () => {
+  test('error: rejects a self-owned current signature', () => {
     const envelope = SignatureEnvelope.deserialize(current)
     if (envelope.type !== 'multisig') throw new Error('unreachable')
     const account = envelope.config.owners[0]!.owner