ox 1.7.1 → 1.7.2

package/src/zod/tempo/SignatureEnvelope.ts

@@ -86,42 +86,24 @@ export const KeychainRpc = z.object({
 
 /** RPC native multisig signature envelope schema. */
 export const MultisigRpc = z
-  .union([
-    z.strictObject({
-      account: z_Address.Address,
-      signatures: z.lazy(
-        (): z.ZodMiniType<
-          readonly core_SignatureEnvelope.SignatureEnvelopeRpc[],
-          readonly core_SignatureEnvelope.SignatureEnvelopeRpc[]
-        > =>
-          z.readonly(
-            z
-              .array(Rpc)
-              .check(
-                z.minLength(1),
-                z.maxLength(core_MultisigConfig.maxSignatures),
-              ),
-          ) as never,
-      ),
-    }),
-    z.strictObject({
-      init: z_MultisigConfig.Config,
-      signatures: z.lazy(
-        (): z.ZodMiniType<
-          readonly core_SignatureEnvelope.SignatureEnvelopeRpc[],
-          readonly core_SignatureEnvelope.SignatureEnvelopeRpc[]
-        > =>
-          z.readonly(
-            z
-              .array(Rpc)
-              .check(
-                z.minLength(1),
-                z.maxLength(core_MultisigConfig.maxSignatures),
-              ),
-          ) as never,
-      ),
-    }),
-  ])
+  .strictObject({
+    account: z_Address.Address,
+    config: z_MultisigConfig.Rpc,
+    signatures: z.lazy(
+      (): z.ZodMiniType<
+        readonly core_SignatureEnvelope.SignatureEnvelopeRpc[],
+        readonly core_SignatureEnvelope.SignatureEnvelopeRpc[]
+      > =>
+        z.readonly(
+          z
+            .array(Rpc)
+            .check(
+              z.minLength(1),
+              z.maxLength(core_MultisigConfig.maxSignatures),
+            ),
+        ) as never,
+    ),
+  })
   // Keep invalid recursive approvals inside Zod's issue path.
   .check(
     z.refine((value) => {
@@ -188,7 +170,7 @@ export const Keychain = z.object({
 export const Multisig = z
   .object({
     account: z_Address.Address,
-    init: z.optional(z_MultisigConfig.Config),
+    config: z_MultisigConfig.Config,
     // `signatures` is recursive; type the getter concretely to break the cycle.
     signatures: z.lazy(
       (): z.ZodMiniType<readonly core_SignatureEnvelope.SignatureEnvelope[]> =>
@@ -273,7 +255,7 @@ function fromRpc(
     }
   }
 
-  if ('signatures' in value && ('account' in value || 'init' in value))
+  if ('config' in value && 'signatures' in value)
     return core_SignatureEnvelope.fromRpc(
       value as core_SignatureEnvelope.MultisigRpc,
     )

package/src/zod/tempo/TransactionRequest.ts

@@ -1,6 +1,6 @@
 /* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
-import type * as core_TransactionRequest from '../../tempo/TransactionRequest.js'
 import * as core_Hex from '../../core/Hex.js'
+import type * as core_TransactionRequest from '../../tempo/TransactionRequest.js'
 import * as z_AccessList from '../AccessList.js'
 import * as z_Address from '../Address.js'
 import * as z_Hex from '../Hex.js'
@@ -13,6 +13,7 @@ import {
 import * as z from 'zod/mini'
 import * as z_AuthorizationTempo from './AuthorizationTempo.js'
 import * as z_KeyAuthorization from './KeyAuthorization.js'
+import * as z_MultisigWitness from './MultisigWitness.js'
 import * as z_SignatureEnvelope from './SignatureEnvelope.js'
 
 const fromRpcType = { '0x76': 'tempo' } as const
@@ -58,14 +59,6 @@ const CallToRpc = z.object({
 
 const Capabilities = z.record(z.string(), z.unknown())
 
-const MultisigInit = z.object({
-  salt: z_Hex.Hex,
-  threshold: z.number(),
-  owners: z.readonly(
-    z.array(z.object({ owner: z_Address.Address, weight: z.number() })),
-  ),
-})
-
 /** RPC tempo transaction request schema. */
 export const Rpc = z.object({
   accessList: z.optional(z_AccessList.AccessList),
@@ -90,8 +83,7 @@ export const Rpc = z.object({
   maxFeePerBlobGas: z.optional(z_Hex.Hex),
   maxFeePerGas: z.optional(z_Hex.Hex),
   maxPriorityFeePerGas: z.optional(z_Hex.Hex),
-  multisigInit: z.optional(MultisigInit),
-  multisigSignatureCount: z.optional(z.number()),
+  multisigWitness: z.optional(z_MultisigWitness.Rpc),
   nonce: z.optional(z_Hex.Hex),
   nonceKey: z.optional(z_Hex.Hex),
   r: z.optional(z_Hex.Hex),
@@ -144,8 +136,7 @@ export const Domain = z.object({
   maxFeePerBlobGas: z.optional(z.bigint()),
   maxFeePerGas: z.optional(z.bigint()),
   maxPriorityFeePerGas: z.optional(z.bigint()),
-  multisigInit: z.optional(MultisigInit),
-  multisigSignatureCount: z.optional(z.number()),
+  multisigWitness: z.optional(z_MultisigWitness.Domain),
   nonce: z.optional(z.bigint()),
   nonceKey: z.optional(z.union([z.bigint(), z.literal('random')])),
   r: z.optional(z_Hex.Hex),
@@ -184,8 +175,7 @@ export const DomainToRpc = z.object({
   maxFeePerBlobGas: z.optional(uintBigintNumberish()),
   maxFeePerGas: z.optional(uintBigintNumberish()),
   maxPriorityFeePerGas: z.optional(uintBigintNumberish()),
-  multisigInit: z.optional(MultisigInit),
-  multisigSignatureCount: z.optional(z.number()),
+  multisigWitness: z.optional(z_MultisigWitness.Domain),
   nonce: z.optional(uintBigintNumberish()),
   nonceKey: z.optional(z.union([uintBigintNumberish(), z.literal('random')])),
   r: z.optional(z_Hex.Hex),
@@ -216,7 +206,7 @@ export const TransactionRequestToRpc = z.codec(Rpc, DomainToRpc, {
 function fromRpc(
   request: core_TransactionRequest.Rpc,
 ): core_TransactionRequest.TransactionRequest {
-  const { authorizationList: _, ...rest } = request
+  const { authorizationList: _, multisigWitness: __, ...rest } = request
   const request_ = z.decode(
     z_TransactionRequest.TransactionRequest,
     rest as never,
@@ -260,10 +250,11 @@ function fromRpc(
   if (typeof request.keyData !== 'undefined') request_.keyData = request.keyData
   if (typeof request.keyId !== 'undefined') request_.keyId = request.keyId
   if (typeof request.keyType !== 'undefined') request_.keyType = request.keyType
-  if (typeof request.multisigInit !== 'undefined')
-    request_.multisigInit = request.multisigInit
-  if (typeof request.multisigSignatureCount !== 'undefined')
-    request_.multisigSignatureCount = request.multisigSignatureCount
+  if (typeof request.multisigWitness !== 'undefined')
+    request_.multisigWitness = z.decode(
+      z_MultisigWitness.MultisigWitness,
+      request.multisigWitness,
+    )
   if (typeof request.validBefore !== 'undefined')
     request_.validBefore = core_Hex.toNumber(request.validBefore)
   if (typeof request.validAfter !== 'undefined')
@@ -292,8 +283,7 @@ function toRpc(
     typeof request.keyData !== 'undefined' ||
     typeof request.keyId !== 'undefined' ||
     typeof request.keyType !== 'undefined' ||
-    typeof request.multisigInit !== 'undefined' ||
-    typeof request.multisigSignatureCount !== 'undefined' ||
+    typeof request.multisigWitness !== 'undefined' ||
     typeof request.nonceKey !== 'undefined' ||
     typeof request.validBefore !== 'undefined' ||
     typeof request.validAfter !== 'undefined' ||
@@ -348,10 +338,11 @@ function toRpc(
   if (typeof request.keyId !== 'undefined') request_rpc.keyId = request.keyId
   if (typeof request.keyType !== 'undefined')
     request_rpc.keyType = request.keyType
-  if (typeof request.multisigInit !== 'undefined')
-    request_rpc.multisigInit = request.multisigInit
-  if (typeof request.multisigSignatureCount !== 'undefined')
-    request_rpc.multisigSignatureCount = request.multisigSignatureCount
+  if (typeof request.multisigWitness !== 'undefined')
+    request_rpc.multisigWitness = z.encode(
+      z_MultisigWitness.MultisigWitness,
+      request.multisigWitness,
+    )
   if (typeof request.validBefore !== 'undefined')
     request_rpc.validBefore = encodeNumberish(request.validBefore)
   if (typeof request.validAfter !== 'undefined')

package/src/zod/tempo/_test/KeyAuthorization.test.ts

@@ -144,6 +144,17 @@ describe('KeyAuthorization', () => {
   test('round-trips multisig signatures', () => {
     const multisigRpc = {
       account: '0x1111111111111111111111111111111111111111',
+      config: {
+        owners: [
+          {
+            owner: '0x2222222222222222222222222222222222222222',
+            weight: 1,
+          },
+        ],
+        salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
+        threshold: 1,
+        version: '0x1',
+      },
       signatures: [rpc.signature],
     } as const
     const withMultisig = { ...rpc, signature: multisigRpc }

package/src/zod/tempo/_test/MultisigConfig.test-d.ts

@@ -0,0 +1,13 @@
+import type * as core_MultisigConfig from '../../../tempo/MultisigConfig.js'
+import type * as z from 'zod/mini'
+import { expectTypeOf, test } from 'vp/test'
+import * as z_MultisigConfig from '../MultisigConfig.js'
+
+test('MultisigConfig decodes RPC configurations', () => {
+  expectTypeOf<core_MultisigConfig.Rpc>().toMatchTypeOf<
+    z.input<typeof z_MultisigConfig.MultisigConfig>
+  >()
+  expectTypeOf<
+    z.output<typeof z_MultisigConfig.MultisigConfig>
+  >().toMatchTypeOf<core_MultisigConfig.Config>()
+})

package/src/zod/tempo/_test/MultisigConfig.test.ts

@@ -9,20 +9,31 @@ const config = {
       weight: 1,
     },
   ],
+  salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
   threshold: 1,
+  version: 0n,
 } as const
 
+const rpc = { ...config, version: '0x0' } as const
+
 describe('Config', () => {
   test('accepts valid native multisig configurations', () => {
     expect(z.safeDecode(z_MultisigConfig.Config, config).success).toBe(true)
   })
 
+  test('round-trips RPC configurations', () => {
+    const decoded = z.decode(z_MultisigConfig.MultisigConfig, rpc)
+
+    expect(decoded).toEqual(config)
+    expect(z.encode(z_MultisigConfig.MultisigConfig, decoded)).toEqual(rpc)
+  })
+
   test('rejects configurations outside protocol limits', () => {
     expect(
       z.safeDecode(z_MultisigConfig.Config, {
         ...config,
-        owners: [{ ...config.owners[0], weight: 9 }],
-        threshold: 9,
+        owners: [{ ...config.owners[0], weight: 255 }],
+        threshold: 256,
       }).success,
     ).toMatchInlineSnapshot(`false`)
   })

package/src/zod/tempo/_test/MultisigOperation.test-d.ts

@@ -0,0 +1,27 @@
+import type * as core_MultisigOperation from '../../../tempo/MultisigOperation.js'
+import type * as z from 'zod/mini'
+import { expectTypeOf, test } from 'vp/test'
+import * as z_MultisigOperation from '../MultisigOperation.js'
+
+test('operation schemas decode RPC operations', () => {
+  expectTypeOf<core_MultisigOperation.TransactionRpc>().toMatchTypeOf<
+    z.input<typeof z_MultisigOperation.TransactionOperation>
+  >()
+  expectTypeOf<
+    z.output<typeof z_MultisigOperation.TransactionOperation>
+  >().toMatchTypeOf<core_MultisigOperation.TransactionOperation>()
+
+  expectTypeOf<core_MultisigOperation.KeyAuthorizationRpc>().toMatchTypeOf<
+    z.input<typeof z_MultisigOperation.KeyAuthorizationOperation>
+  >()
+  expectTypeOf<
+    z.output<typeof z_MultisigOperation.KeyAuthorizationOperation>
+  >().toMatchTypeOf<core_MultisigOperation.KeyAuthorizationOperation>()
+
+  expectTypeOf<core_MultisigOperation.Rpc>().toMatchTypeOf<
+    z.input<typeof z_MultisigOperation.Operation>
+  >()
+  expectTypeOf<
+    z.output<typeof z_MultisigOperation.Operation>
+  >().toMatchTypeOf<core_MultisigOperation.Operation>()
+})

package/src/zod/tempo/_test/MultisigOperation.test.ts

@@ -0,0 +1,68 @@
+import { describe, expect, test } from 'vp/test'
+import * as core_MultisigOperation from '../../../tempo/MultisigOperation.js'
+import * as z_MultisigOperation from '../MultisigOperation.js'
+import * as z from 'zod/mini'
+
+const rpc = {
+  account: '0xf81b7763d3a6876195d780865bd783dbd97dd36e',
+  approvals: [
+    '0x01000000000000000000000000000000000000000000000000000000000000000500000000000000000000000000000000000000000000000000000000000000065ecbe4d1a6330a44c8f7ef951d4bf165e6c6b721efada985fb41661bc6e7fd6c8734640c4998ff7e374b06ce1a64a2ecd82ab036384fb83d9a79b127a27d503200',
+  ],
+  config: {
+    owners: [
+      {
+        owner: '0x07e1ed8ea0e9601e5546b0a03aed683df3601407',
+        weight: 1,
+      },
+      {
+        owner: '0x288f0cd85005f34168f731a468aef268c2f9456f',
+        weight: 1,
+      },
+    ],
+    salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
+    threshold: 2,
+    version: '0x1',
+  },
+  configVersion: '0x1',
+  createdAt: 1,
+  hash: '0xcdbc24a8fb192f799c5d166b13a99fb29cbb15e71a5e730988d6f8b3c5959d02',
+  init: false,
+  signatureCount: 1,
+  status: 'pending',
+  threshold: 2,
+  transaction:
+    '0x76e9821079808080dad99407e1ed8ea0e9601e5546b0a03aed683df360140780821234c0808080808080c0',
+  type: 'transaction',
+  updatedAt: 2,
+  weight: 1,
+} as const
+
+describe('TransactionOperation', () => {
+  test('decodes an RPC operation', () => {
+    expect(z.decode(z_MultisigOperation.TransactionOperation, rpc)).toEqual(
+      core_MultisigOperation.fromRpc(rpc),
+    )
+  })
+
+  test('round-trips via encode', () => {
+    const operation = z.decode(z_MultisigOperation.TransactionOperation, rpc)
+    expect(
+      z.encode(z_MultisigOperation.TransactionOperation, operation),
+    ).toEqual(core_MultisigOperation.toRpc(operation))
+  })
+
+  test('rejects internally inconsistent operations', () => {
+    expect(
+      z.safeDecode(z_MultisigOperation.TransactionOperation, {
+        ...rpc,
+        weight: 2,
+      }).success,
+    ).toBe(false)
+  })
+})
+
+describe('Operation', () => {
+  test('accepts transaction operations', () => {
+    expect(z.safeDecode(z_MultisigOperation.Operation, rpc).success).toBe(true)
+  })
+})

package/src/zod/tempo/_test/MultisigWitness.test-d.ts

@@ -0,0 +1,13 @@
+import type * as core_MultisigWitness from '../../../tempo/MultisigWitness.js'
+import type * as z from 'zod/mini'
+import { expectTypeOf, test } from 'vp/test'
+import * as z_MultisigWitness from '../MultisigWitness.js'
+
+test('MultisigWitness decodes RPC witnesses', () => {
+  expectTypeOf<core_MultisigWitness.Rpc>().toMatchTypeOf<
+    z.input<typeof z_MultisigWitness.MultisigWitness>
+  >()
+  expectTypeOf<
+    z.output<typeof z_MultisigWitness.MultisigWitness>
+  >().toMatchTypeOf<core_MultisigWitness.MultisigWitness>()
+})

package/src/zod/tempo/_test/MultisigWitness.test.ts

@@ -0,0 +1,149 @@
+import { describe, expect, test } from 'vp/test'
+import * as z from 'zod/mini'
+import * as z_MultisigWitness from '../MultisigWitness.js'
+
+const rpc = {
+  account: '0xcccccccccccccccccccccccccccccccccccccccc',
+  approvals: [
+    {
+      owner: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+      type: 'primitive',
+    },
+    {
+      type: 'multisig',
+      witness: {
+        account: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+        approvals: [
+          {
+            owner: '0xdddddddddddddddddddddddddddddddddddddddd',
+          },
+        ],
+        config: {
+          owners: [
+            {
+              owner: '0xdddddddddddddddddddddddddddddddddddddddd',
+              weight: 1,
+            },
+          ],
+          salt: '0x2222222222222222222222222222222222222222222222222222222222222222',
+          threshold: 1,
+          version: 2,
+        },
+      },
+    },
+  ],
+  config: {
+    owners: [
+      {
+        owner: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+        weight: 1,
+      },
+      {
+        owner: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+        weight: 1,
+      },
+    ],
+    salt: '0x1111111111111111111111111111111111111111111111111111111111111111',
+    threshold: 2,
+    version: 1,
+  },
+} as const
+
+describe('MultisigWitness', () => {
+  test('behavior: converts between RPC and domain witnesses', () => {
+    const witness = z.decode(z_MultisigWitness.MultisigWitness, rpc)
+
+    expect(witness).toMatchInlineSnapshot(`
+      {
+        "account": "0xcccccccccccccccccccccccccccccccccccccccc",
+        "approvals": [
+          {
+            "owner": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+            "type": "primitive",
+          },
+          {
+            "type": "multisig",
+            "witness": {
+              "account": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+              "approvals": [
+                {
+                  "owner": "0xdddddddddddddddddddddddddddddddddddddddd",
+                },
+              ],
+              "config": {
+                "owners": [
+                  {
+                    "owner": "0xdddddddddddddddddddddddddddddddddddddddd",
+                    "weight": 1,
+                  },
+                ],
+                "salt": "0x2222222222222222222222222222222222222222222222222222222222222222",
+                "threshold": 1,
+                "version": 2n,
+              },
+            },
+          },
+        ],
+        "config": {
+          "owners": [
+            {
+              "owner": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
+              "weight": 1,
+            },
+            {
+              "owner": "0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb",
+              "weight": 1,
+            },
+          ],
+          "salt": "0x1111111111111111111111111111111111111111111111111111111111111111",
+          "threshold": 2,
+          "version": 1n,
+        },
+      }
+    `)
+    expect(z.encode(z_MultisigWitness.MultisigWitness, witness)).toStrictEqual(
+      rpc,
+    )
+  })
+
+  test('error: rejects more than eight root approvals', () => {
+    expect(
+      z.safeDecode(z_MultisigWitness.Rpc, {
+        ...rpc,
+        approvals: Array.from({ length: 9 }, () => rpc.approvals[0]),
+      }).success,
+    ).toMatchInlineSnapshot(`false`)
+  })
+
+  test('error: rejects more than eight nested approvals', () => {
+    expect(
+      z.safeDecode(z_MultisigWitness.Rpc, {
+        ...rpc,
+        approvals: [
+          {
+            ...rpc.approvals[1],
+            witness: {
+              ...rpc.approvals[1].witness,
+              approvals: Array.from(
+                { length: 9 },
+                () => rpc.approvals[1].witness.approvals[0],
+              ),
+            },
+          },
+        ],
+      }).success,
+    ).toMatchInlineSnapshot(`false`)
+  })
+
+  test('error: rejects unsafe numeric configuration versions', () => {
+    expect(
+      z.safeDecode(z_MultisigWitness.Rpc, {
+        ...rpc,
+        config: {
+          ...rpc.config,
+          version: Number.MAX_SAFE_INTEGER + 1,
+        },
+      }).success,
+    ).toMatchInlineSnapshot(`false`)
+  })
+})

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

@@ -1,3 +1,4 @@
+import type * as core_MultisigOperation from '../../../tempo/MultisigOperation.js'
 import type * as z from 'zod/mini'
 import { expectTypeOf, test } from 'vp/test'
 import * as z_RpcSchemaTempo from '../RpcSchemaTempo.js'
@@ -20,3 +21,33 @@ test('Tempo namespace exposes tempo_simulateV1', () => {
     typeof z_RpcSchemaTempo.tempo_simulateV1
   >()
 })
+
+test('multisig methods have the expected method names', () => {
+  expectTypeOf<
+    typeof z_RpcSchemaTempo.multisig_approveRawTransaction.method
+  >().toEqualTypeOf<'multisig_approveRawTransaction'>()
+  expectTypeOf<
+    typeof z_RpcSchemaTempo.multisig_approveRawTransactionSync.method
+  >().toEqualTypeOf<'multisig_approveRawTransactionSync'>()
+  expectTypeOf<
+    typeof z_RpcSchemaTempo.multisig_approveKeyAuthorization.method
+  >().toEqualTypeOf<'multisig_approveKeyAuthorization'>()
+  expectTypeOf<
+    typeof z_RpcSchemaTempo.multisig_getOperation.method
+  >().toEqualTypeOf<'multisig_getOperation'>()
+})
+
+test('multisig return schemas decode RPC operations', () => {
+  expectTypeOf<
+    z.output<typeof z_RpcSchemaTempo.multisig_approveRawTransactionSync.returns>
+  >().toMatchTypeOf<core_MultisigOperation.TransactionOperation>()
+  expectTypeOf<
+    z.output<typeof z_RpcSchemaTempo.multisig_getOperation.returns>
+  >().toMatchTypeOf<core_MultisigOperation.Operation | null>()
+})
+
+test('Multisig namespace exposes multisig methods', () => {
+  expectTypeOf<
+    typeof z_RpcSchemaTempo.Multisig.multisig_getOperation
+  >().toEqualTypeOf<typeof z_RpcSchemaTempo.multisig_getOperation>()
+})

package/src/zod/tempo/_test/RpcSchemaTempo.test.ts

@@ -54,3 +54,44 @@ describe('tempo_simulateV1', () => {
     ).toBe(true)
   })
 })
+
+describe('multisig methods', () => {
+  test('decodes raw transaction params', () => {
+    expect(
+      z_RpcSchema.decodeParams(
+        z_RpcSchemaTempo.Multisig,
+        'multisig_approveRawTransactionSync',
+        ['0x76', 30_000],
+      ),
+    ).toEqual(['0x76', 30_000])
+  })
+
+  test('decodes key authorization approval params', () => {
+    expect(
+      z_RpcSchema.decodeParams(
+        z_RpcSchemaTempo.Multisig,
+        'multisig_approveKeyAuthorization',
+        [{ hash: '0x01', signature: '0x02' }],
+      ),
+    ).toEqual([{ hash: '0x01', signature: '0x02' }])
+  })
+
+  test('accepts a missing operation result', () => {
+    expect(
+      z_RpcSchema.decodeReturns(
+        z_RpcSchemaTempo.Multisig,
+        'multisig_getOperation',
+        null,
+      ),
+    ).toBeNull()
+  })
+
+  test('exposes method and request schemas', () => {
+    expect(
+      z.safeDecode(z_RpcSchemaTempo.multisig_getOperation.request, {
+        method: 'multisig_getOperation',
+        params: ['0x01'],
+      }).success,
+    ).toBe(true)
+  })
+})

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

@@ -12,7 +12,7 @@ test('SignatureEnvelope decodes RPC into a signature envelope', () => {
   >()
 })
 
-test('MultisigRpc preserves the native multisig RPC union', () => {
+test('MultisigRpc preserves the complete witness shape', () => {
   expectTypeOf<core_SignatureEnvelope.MultisigRpc>().toExtend<
     z.input<typeof z_SignatureEnvelope.MultisigRpc>
   >()