ox 1.7.2 → 1.7.4

package/src/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/src/tempo/RpcSchemaTempo.test-d.ts

@@ -1,19 +1,41 @@
 import type { Provider } from 'ox'
 import type {
   KeyAuthorization,
+  MultisigConfig,
   MultisigOperation,
+  MultisigSimulation,
   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 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 serializedTransaction: Hex.Hex
 declare const signature: Hex.Hex
 
 test('multisig provider methods', () => {
+  expectTypeOf(
+    provider.request({
+      method: 'multisig_approveKeyAuthorization',
+      params: [{ keyAuthorization }],
+    }),
+  ).resolves.toEqualTypeOf<MultisigOperation.KeyAuthorizationRpc>()
+
+  expectTypeOf(
+    provider.request({
+      method: 'multisig_approveKeyAuthorization',
+      params: [{ hash, signature }],
+    }),
+  ).resolves.toEqualTypeOf<MultisigOperation.KeyAuthorizationRpc>()
+
   expectTypeOf(
     provider.request({
       method: 'multisig_approveRawTransaction',
@@ -35,17 +57,10 @@ test('multisig provider methods', () => {
 
   expectTypeOf(
     provider.request({
-      method: 'multisig_approveKeyAuthorization',
-      params: [{ keyAuthorization }],
+      method: 'multisig_getConfig',
+      params: [{ address }],
     }),
-  ).resolves.toEqualTypeOf<MultisigOperation.KeyAuthorizationRpc>()
-
-  expectTypeOf(
-    provider.request({
-      method: 'multisig_approveKeyAuthorization',
-      params: [{ hash, signature }],
-    }),
-  ).resolves.toEqualTypeOf<MultisigOperation.KeyAuthorizationRpc>()
+  ).resolves.toEqualTypeOf<MultisigConfig.Rpc | null>()
 
   expectTypeOf(
     provider.request({
@@ -54,3 +69,23 @@ test('multisig provider methods', () => {
     }),
   ).resolves.toEqualTypeOf<MultisigOperation.Rpc | null>()
 })
+
+test('tempo simulation accepts multisig specs', () => {
+  void tempoProvider.request({
+    method: 'tempo_simulateV1',
+    params: [
+      {
+        blockStateCalls: [
+          {
+            calls: [
+              {
+                multisigSimulation,
+              },
+            ],
+          },
+        ],
+      },
+      'latest',
+    ],
+  })
+})

package/src/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'
 
@@ -58,6 +60,16 @@ export type Tempo = RpcSchema.From<{
 
 /** Union of all JSON-RPC methods for the `multisig_` namespace. */
 export type Multisig = RpcSchema.From<
+  | {
+      Request: {
+        method: 'multisig_approveKeyAuthorization'
+        params: [
+          | { keyAuthorization: KeyAuthorization.Rpc }
+          | { hash: Hex.Hex; signature: Hex.Hex },
+        ]
+      }
+      ReturnType: MultisigOperation.KeyAuthorizationRpc
+    }
   | {
       Request: {
         method: 'multisig_approveRawTransaction'
@@ -74,13 +86,10 @@ export type Multisig = RpcSchema.From<
     }
   | {
       Request: {
-        method: 'multisig_approveKeyAuthorization'
-        params: [
-          | { keyAuthorization: KeyAuthorization.Rpc }
-          | { hash: Hex.Hex; signature: Hex.Hex },
-        ]
+        method: 'multisig_getConfig'
+        params: [{ address: Address.Address }]
       }
-      ReturnType: MultisigOperation.KeyAuthorizationRpc
+      ReturnType: MultisigConfig.Rpc | null
     }
   | {
       Request: {

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

@@ -2,13 +2,6 @@ import { expectTypeOf, test } from 'vp/test'
 import * as MultisigConfig from './MultisigConfig.js'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
 
-const signatureRpc = {
-  r: '0x01',
-  s: '0x02',
-  type: 'secp256k1',
-  yParity: '0x0',
-} as const satisfies SignatureEnvelope.SignatureEnvelopeRpc
-
 const signature = {
   signature: {
     r: '0x01',
@@ -34,20 +27,9 @@ test('toRpc preserves the signature type', () => {
   ).toEqualTypeOf<SignatureEnvelope.Secp256k1Rpc>()
 })
 
-test('MultisigRpc carries one complete witness shape', () => {
-  const rpc = {
-    account: '0x1111111111111111111111111111111111111111',
-    config: MultisigConfig.toRpc(config),
-    signatures: [signatureRpc],
-  } as const satisfies SignatureEnvelope.MultisigRpc
-
-  expectTypeOf(rpc.config).toMatchTypeOf<MultisigConfig.Rpc>()
-  expectTypeOf(rpc.signatures).toMatchTypeOf<
-    readonly SignatureEnvelope.SignatureEnvelopeRpc[]
-  >()
-  expectTypeOf<
-    SignatureEnvelope.GetType<typeof rpc>
-  >().toEqualTypeOf<'multisig'>()
+test('MultisigRpc contains an untagged serialized multisig signature', () => {
+  const rpc = '0xf8' as const satisfies SignatureEnvelope.MultisigRpc
+  expectTypeOf(rpc).toMatchTypeOf<`0x${string}`>()
 })
 
 test('from derives an initial account', () => {
@@ -74,41 +56,3 @@ 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: MultisigConfig.toRpc(config),
-    signatures: ['0x1234'],
-  } as const
-  // @ts-expect-error Owner approvals use structured RPC envelopes.
-  const serializedRpc: SignatureEnvelope.MultisigRpc = serialized
-
-  const tagged = {
-    account: '0x1111111111111111111111111111111111111111',
-    config: MultisigConfig.toRpc(config),
-    signatures: [signatureRpc],
-    type: 'multisig',
-  } as const
-  // @ts-expect-error Multisig RPC signatures are untagged.
-  const taggedRpc: SignatureEnvelope.MultisigRpc = tagged
-
-  expectTypeOf(accountOnlyRpc).toEqualTypeOf<SignatureEnvelope.MultisigRpc>()
-  expectTypeOf(initRpc).toEqualTypeOf<SignatureEnvelope.MultisigRpc>()
-  expectTypeOf(serializedRpc).toEqualTypeOf<SignatureEnvelope.MultisigRpc>()
-  expectTypeOf(taggedRpc).toEqualTypeOf<SignatureEnvelope.MultisigRpc>()
-})

package/src/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', () => {
@@ -2492,6 +2495,41 @@ describe('fromRpc', () => {
       expect(envelope.keyId).toBe('0xbe95c3f554e9fc85ec51be69a3d807a0d55bcf2c')
     })
   })
+  describe('multisig', () => {
+    test('behavior: converts an untagged serialized multisig signature', () => {
+      expect(
+        SignatureEnvelope.serialize(
+          SignatureEnvelope.fromRpc(signature_multisig_rpc),
+        ),
+      ).toMatchInlineSnapshot(`"0x05${signature_multisig_rpc.slice(2)}"`)
+    })
+
+    test('error: rejects a payload with the transaction type byte', () => {
+      expect(() =>
+        SignatureEnvelope.fromRpc(`0x05${signature_multisig_rpc.slice(2)}`),
+      ).toThrowError()
+    })
+
+    test('error: rejects trailing bytes', () => {
+      expect(() =>
+        SignatureEnvelope.fromRpc(`${signature_multisig_rpc}00`),
+      ).toThrowErrorMatchingInlineSnapshot(
+        `[Rlp.TrailingBytesError: RLP payload encodes a single item, but \`1\` trailing byte remains.]`,
+      )
+    })
+
+    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', () => {
@@ -2589,6 +2627,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)
@@ -2601,6 +2640,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)
@@ -2644,6 +2684,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', () => {
@@ -2888,7 +2940,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(`
@@ -2921,7 +2973,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(`
@@ -2954,7 +3006,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(`
@@ -3042,7 +3094,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 = {
@@ -3052,50 +3104,8 @@ describe('multisig', () => {
 
     expect(rpc).toMatchInlineSnapshot(`
       {
-        "current": {
-          "account": "0x9dba7f426b711d4893c11611eacf7cc334e7146b",
-          "config": {
-            "owners": [
-              {
-                "owner": "0x2b5ad5c4795c026514f8317c7a215e218dccd6cf",
-                "weight": 1,
-              },
-            ],
-            "salt": "0x0000000000000000000000000000000000000000000000000000000000000000",
-            "threshold": 1,
-            "version": "0x1",
-          },
-          "signatures": [
-            {
-              "r": "0x4a0e5b5b4a90f08e6e8d676a73a22dc2cf022ffdcc9299512b5d9a6daf66e050",
-              "s": "0x4a395a2ef6f6c0f173910b875c45d01aa66d928e56ba6f49bbc8186f80268bf5",
-              "type": "secp256k1",
-              "yParity": "0x0",
-            },
-          ],
-        },
-        "initial": {
-          "account": "0x9dba7f426b711d4893c11611eacf7cc334e7146b",
-          "config": {
-            "owners": [
-              {
-                "owner": "0x7e5f4552091a69125d5dfcb7b8c2659029395bdf",
-                "weight": 1,
-              },
-            ],
-            "salt": "0x0000000000000000000000000000000000000000000000000000000000000000",
-            "threshold": 1,
-            "version": "0x0",
-          },
-          "signatures": [
-            {
-              "r": "0x869437e01f64bebeb78a8a6b30bfd3a993819c8cad82c807515d9b9e9b36f985",
-              "s": "0x35dfaa5eebc597715d05f6ce4927747f14fa4cd2acc717fdcd3877146437f8f4",
-              "type": "secp256k1",
-              "yParity": "0x0",
-            },
-          ],
-        },
+        "current": "0xf897949dba7f426b711d4893c11611eacf7cc334e7146bf83ba000000000000000000000000000000000000000000000000000000000000000000101d7d6942b5ad5c4795c026514f8317c7a215e218dccd6cf01f843b8414a0e5b5b4a90f08e6e8d676a73a22dc2cf022ffdcc9299512b5d9a6daf66e0504a395a2ef6f6c0f173910b875c45d01aa66d928e56ba6f49bbc8186f80268bf51b",
+        "initial": "0xf897949dba7f426b711d4893c11611eacf7cc334e7146bf83ba000000000000000000000000000000000000000000000000000000000000000008001d7d6947e5f4552091a69125d5dfcb7b8c2659029395bdf01f843b841869437e01f64bebeb78a8a6b30bfd3a993819c8cad82c807515d9b9e9b36f98535dfaa5eebc597715d05f6ce4927747f14fa4cd2acc717fdcd3877146437f8f41b",
       }
     `)
     expect(SignatureEnvelope.fromRpc(rpc.initial)).toStrictEqual(
@@ -3106,7 +3116,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')
@@ -3177,7 +3187,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 (
@@ -3219,7 +3229,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