ox 1.7.1 → 1.7.4

package/src/zod/tempo/RpcSchemaTempo.ts

@@ -1,4 +1,5 @@
 /* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as z_Address from '../Address.js'
 import * as z_Block from '../Block.js'
 import * as z_BlockOverrides from '../BlockOverrides.js'
 import * as z_Hex from '../Hex.js'
@@ -6,6 +7,9 @@ import * as z_Log from '../Log.js'
 import * as z_StateOverrides from '../StateOverrides.js'
 import { from } from '../internal/rpcSchemas/from.js'
 import * as z from 'zod/mini'
+import * as z_KeyAuthorization from './KeyAuthorization.js'
+import * as z_MultisigConfig from './MultisigConfig.js'
+import * as z_MultisigOperation from './MultisigOperation.js'
 import * as z_TransactionRequest from './TransactionRequest.js'
 
 const BlockNumberOrTagOrIdentifier = z.union([
@@ -85,3 +89,52 @@ export const tempo_simulateV1 = from({
 
 /** JSON-RPC method schemas for the `tempo_` namespace. */
 export const Tempo = { tempo_simulateV1 }
+
+/** Schema for the `multisig_approveKeyAuthorization` JSON-RPC method. */
+export const multisig_approveKeyAuthorization = from({
+  method: 'multisig_approveKeyAuthorization',
+  params: z.tuple([
+    z.union([
+      z.object({ keyAuthorization: z_KeyAuthorization.Rpc }),
+      z.object({ hash: z_Hex.Hex, signature: z_Hex.Hex }),
+    ]),
+  ]),
+  returns: z_MultisigOperation.KeyAuthorizationOperation,
+})
+
+/** Schema for the `multisig_approveRawTransaction` JSON-RPC method. */
+export const multisig_approveRawTransaction = from({
+  method: 'multisig_approveRawTransaction',
+  params: z.tuple([z_Hex.Hex]),
+  returns: z_Hex.Hex,
+})
+
+/** Schema for the `multisig_approveRawTransactionSync` JSON-RPC method. */
+export const multisig_approveRawTransactionSync = from({
+  method: 'multisig_approveRawTransactionSync',
+  params: z.tuple([z_Hex.Hex, z.optional(z.number())]),
+  returns: z_MultisigOperation.TransactionOperation,
+})
+
+/** Schema for the `multisig_getConfig` JSON-RPC method. */
+export const multisig_getConfig = from({
+  method: 'multisig_getConfig',
+  params: z.tuple([z.object({ address: z_Address.Address })]),
+  returns: z.nullable(z_MultisigConfig.Rpc),
+})
+
+/** Schema for the `multisig_getOperation` JSON-RPC method. */
+export const multisig_getOperation = from({
+  method: 'multisig_getOperation',
+  params: z.tuple([z_Hex.Hex]),
+  returns: z.nullable(z_MultisigOperation.Operation),
+})
+
+/** JSON-RPC method schemas for the `multisig_` namespace. */
+export const Multisig = {
+  multisig_approveKeyAuthorization,
+  multisig_approveRawTransaction,
+  multisig_approveRawTransactionSync,
+  multisig_getConfig,
+  multisig_getOperation,
+}

package/src/zod/tempo/SignatureEnvelope.ts

@@ -85,54 +85,15 @@ 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,
-      ),
-    }),
-  ])
-  // Keep invalid recursive approvals inside Zod's issue path.
-  .check(
-    z.refine((value) => {
-      try {
-        core_SignatureEnvelope.fromRpc(value)
-        return true
-      } catch {
-        return false
-      }
-    }, 'expected valid native multisig signature'),
-  )
+export const MultisigRpc = z_Hex.Hex.check(
+  z.refine((value) => {
+    try {
+      return core_SignatureEnvelope.fromRpc(value).type === 'multisig'
+    } catch {
+      return false
+    }
+  }, 'expected valid native multisig signature'),
+)
 
 /** RPC signature envelope schema. */
 export const Rpc = z.union([
@@ -188,7 +149,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[]> =>
@@ -227,6 +188,8 @@ export const Serialized = z_Hex.Hex
 function fromRpc(
   value: core_SignatureEnvelope.SignatureEnvelopeRpc,
 ): core_SignatureEnvelope.SignatureEnvelope {
+  if (typeof value === 'string') return core_SignatureEnvelope.fromRpc(value)
+
   if (value.type === 'secp256k1') {
     const secp256k1 = value as core_SignatureEnvelope.Secp256k1Rpc
     return {
@@ -273,11 +236,6 @@ function fromRpc(
     }
   }
 
-  if ('signatures' in value && ('account' in value || 'init' in value))
-    return core_SignatureEnvelope.fromRpc(
-      value as core_SignatureEnvelope.MultisigRpc,
-    )
-
   const keychain = value as core_SignatureEnvelope.KeychainRpc
   return {
     inner: fromRpc(keychain.signature),

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_MultisigSimulation from './MultisigSimulation.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()),
+  multisigSimulation: z.optional(z_MultisigSimulation.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()),
+  multisigSimulation: z.optional(z_MultisigSimulation.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()),
+  multisigSimulation: z.optional(z_MultisigSimulation.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: _, multisigSimulation: __, ...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.multisigSimulation !== 'undefined')
+    request_.multisigSimulation = z.decode(
+      z_MultisigSimulation.MultisigSimulation,
+      request.multisigSimulation,
+    )
   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.multisigSimulation !== '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.multisigSimulation !== 'undefined')
+    request_rpc.multisigSimulation = z.encode(
+      z_MultisigSimulation.MultisigSimulation,
+      request.multisigSimulation,
+    )
   if (typeof request.validBefore !== 'undefined')
     request_rpc.validBefore = encodeNumberish(request.validBefore)
   if (typeof request.validAfter !== 'undefined')

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

@@ -142,10 +142,8 @@ describe('KeyAuthorization', () => {
   })
 
   test('round-trips multisig signatures', () => {
-    const multisigRpc = {
-      account: '0x1111111111111111111111111111111111111111',
-      signatures: [rpc.signature],
-    } as const
+    const multisigRpc =
+      '0xf89794be95c3f554e9fc85ec51be69a3d807a0d55bcf2cf83ba000000000000000000000000000000000000000000000000000000000000000000101d7d694f39fd6e51aad88f6f4ce6ab8827279cfffb9226601f843b841fa78c5905fb0b9d6066ef531f962a62bc6ef0d5eb59ecb134056d206f75aaed7780926ff2601a935c2c79707d9e1799948c9f19dcdde1e090e903b19a07923d01c' as const
     const withMultisig = { ...rpc, signature: multisigRpc }
     const decoded = z.decode(z_KeyAuthorization.KeyAuthorization, withMultisig)
     expect(decoded).toEqual(core_KeyAuthorization.fromRpc(withMultisig))

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,66 @@
+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',
+  },
+  createdAt: 1,
+  hash: '0xcdbc24a8fb192f799c5d166b13a99fb29cbb15e71a5e730988d6f8b3c5959d02',
+  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/MultisigSimulation.test-d.ts

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

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

@@ -0,0 +1,78 @@
+import { describe, expect, test } from 'vp/test'
+import * as core_MultisigSimulation from '../../../tempo/MultisigSimulation.js'
+import * as z_MultisigSimulation from '../MultisigSimulation.js'
+import * as z from 'zod/mini'
+
+const rpc = {
+  account: '0xcccccccccccccccccccccccccccccccccccccccc',
+  approvals: [
+    {
+      owner: '0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa',
+      type: 'primitive',
+    },
+    {
+      spec: {
+        account: '0xbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb',
+        approvals: [
+          {
+            owner: '0xdddddddddddddddddddddddddddddddddddddddd',
+          },
+        ],
+        config:
+          '0xf83ba022222222222222222222222222222222222222222222222222222222222222220201d7d694dddddddddddddddddddddddddddddddddddddddd01',
+      },
+      type: 'multisig',
+    },
+  ],
+  config:
+    '0xf852a011111111111111111111111111111111111111111111111111111111111111110102eed694aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa01d694bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb01',
+} as const satisfies core_MultisigSimulation.Rpc
+
+describe('MultisigSimulation', () => {
+  test('behavior: converts between RPC and domain specs', () => {
+    const spec = z.decode(z_MultisigSimulation.MultisigSimulation, rpc)
+
+    expect(spec).toEqual(core_MultisigSimulation.fromRpc(rpc))
+    expect(
+      z.encode(z_MultisigSimulation.MultisigSimulation, spec),
+    ).toStrictEqual(rpc)
+  })
+
+  test('error: rejects more than eight root approvals', () => {
+    expect(
+      z.safeDecode(z_MultisigSimulation.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_MultisigSimulation.Rpc, {
+        ...rpc,
+        approvals: [
+          {
+            ...rpc.approvals[1],
+            spec: {
+              ...rpc.approvals[1].spec,
+              approvals: Array.from(
+                { length: 9 },
+                () => rpc.approvals[1].spec.approvals[0],
+              ),
+            },
+          },
+        ],
+      }).success,
+    ).toMatchInlineSnapshot(`false`)
+  })
+
+  test('error: rejects malformed encoded configurations', () => {
+    expect(
+      z.safeDecode(z_MultisigSimulation.Rpc, {
+        ...rpc,
+        config: '0x01',
+      }).success,
+    ).toMatchInlineSnapshot(`false`)
+  })
+})

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

@@ -1,3 +1,6 @@
+import type * as core_Address from '../../../core/Address.js'
+import type * as core_MultisigConfig from '../../../tempo/MultisigConfig.js'
+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 +23,48 @@ test('Tempo namespace exposes tempo_simulateV1', () => {
     typeof z_RpcSchemaTempo.tempo_simulateV1
   >()
 })
+
+test('multisig methods have the expected method names', () => {
+  expectTypeOf<
+    typeof z_RpcSchemaTempo.multisig_approveKeyAuthorization.method
+  >().toEqualTypeOf<'multisig_approveKeyAuthorization'>()
+  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_getConfig.method
+  >().toEqualTypeOf<'multisig_getConfig'>()
+  expectTypeOf<
+    typeof z_RpcSchemaTempo.multisig_getOperation.method
+  >().toEqualTypeOf<'multisig_getOperation'>()
+})
+
+test('multisig_getConfig has the expected request and return types', () => {
+  expectTypeOf<
+    z.input<typeof z_RpcSchemaTempo.multisig_getConfig.params>
+  >().toEqualTypeOf<[{ address: core_Address.Address }]>()
+  expectTypeOf<
+    z.output<typeof z_RpcSchemaTempo.multisig_getConfig.returns>
+  >().toEqualTypeOf<core_MultisigConfig.Rpc | null>()
+})
+
+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_getConfig
+  >().toEqualTypeOf<typeof z_RpcSchemaTempo.multisig_getConfig>()
+  expectTypeOf<
+    typeof z_RpcSchemaTempo.Multisig.multisig_getOperation
+  >().toEqualTypeOf<typeof z_RpcSchemaTempo.multisig_getOperation>()
+})

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

@@ -54,3 +54,86 @@ describe('tempo_simulateV1', () => {
     ).toBe(true)
   })
 })
+
+describe('multisig methods', () => {
+  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('decodes raw transaction params', () => {
+    expect(
+      z_RpcSchema.decodeParams(
+        z_RpcSchemaTempo.Multisig,
+        'multisig_approveRawTransactionSync',
+        ['0x76', 30_000],
+      ),
+    ).toEqual(['0x76', 30_000])
+  })
+
+  test('decodes config params', () => {
+    expect(
+      z_RpcSchema.decodeParams(
+        z_RpcSchemaTempo.Multisig,
+        'multisig_getConfig',
+        [{ address: '0xcafebabecafebabecafebabecafebabecafebabe' }],
+      ),
+    ).toEqual([{ address: '0xcafebabecafebabecafebabecafebabecafebabe' }])
+  })
+
+  test('decodes config result', () => {
+    const config = {
+      owners: [
+        {
+          owner: '0x1111111111111111111111111111111111111111',
+          weight: 1,
+        },
+      ],
+      salt: '0x0000000000000000000000000000000000000000000000000000000000000000',
+      threshold: 1,
+      version: '0x0',
+    } as const
+
+    expect(
+      z_RpcSchema.decodeReturns(
+        z_RpcSchemaTempo.Multisig,
+        'multisig_getConfig',
+        config,
+      ),
+    ).toEqual(config)
+  })
+
+  test('accepts a missing config result', () => {
+    expect(
+      z_RpcSchema.decodeReturns(
+        z_RpcSchemaTempo.Multisig,
+        'multisig_getConfig',
+        null,
+      ),
+    ).toBeNull()
+  })
+
+  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>
   >()