ox 1.7.2 → 1.7.4

package/src/tempo/TransactionRequest.ts

@@ -7,7 +7,7 @@ import * as Signature from '../core/Signature.js'
 import * as ox_TransactionRequest from '../core/TransactionRequest.js'
 import * as AuthorizationTempo from './AuthorizationTempo.js'
 import * as KeyAuthorization from './KeyAuthorization.js'
-import * as MultisigWitness from './MultisigWitness.js'
+import * as MultisigSimulation from './MultisigSimulation.js'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
 import * as Transaction from './Transaction.js'
 import * as TxEnvelopeTempo from './TxEnvelopeTempo.js'
@@ -44,7 +44,7 @@ export type TransactionRequest<
     keyData?: Hex.Hex | undefined
     keyId?: Address.Address | undefined
     keyType?: KeyType | undefined
-    multisigWitness?: MultisigWitness.MultisigWitness | undefined
+    multisigSimulation?: MultisigSimulation.Spec | undefined
     nonceKey?: 'random' | bigintType | undefined
     signature?: SignatureEnvelope.SignatureEnvelope<numberType> | undefined
     validAfter?: numberType | undefined
@@ -59,14 +59,14 @@ export type Rpc = Omit<
   | 'feePayerSignature'
   | 'feeToken'
   | 'keyAuthorization'
-  | 'multisigWitness'
+  | 'multisigSimulation'
   | 'signature'
 > & {
   authorizationList?: AuthorizationTempo.ListRpc | undefined
   feePayerSignature?: Signature.Rpc | null | undefined
   feeToken?: Hex.Hex | undefined
   keyAuthorization?: KeyAuthorization.Rpc | undefined
-  multisigWitness?: MultisigWitness.Rpc | undefined
+  multisigSimulation?: MultisigSimulation.Rpc | undefined
   nonceKey?: Hex.Hex | undefined
   signature?: SignatureEnvelope.SignatureEnvelopeRpc | undefined
 }
@@ -94,7 +94,7 @@ export type Rpc = Omit<
  * @returns A transaction request.
  */
 export function fromRpc(request: Rpc): TransactionRequest {
-  const { authorizationList: _, multisigWitness: __, ...rest } = request
+  const { authorizationList: _, multisigSimulation: __, ...rest } = request
   const request_ = ox_TransactionRequest.fromRpc(
     rest as any,
   ) as TransactionRequest
@@ -129,8 +129,10 @@ export function fromRpc(request: Rpc): TransactionRequest {
     request_.keyAuthorization = KeyAuthorization.fromRpc(
       request.keyAuthorization,
     )
-  if (request.multisigWitness)
-    request_.multisigWitness = MultisigWitness.fromRpc(request.multisigWitness)
+  if (request.multisigSimulation)
+    request_.multisigSimulation = MultisigSimulation.fromRpc(
+      request.multisigSimulation,
+    )
   if (typeof request.validBefore !== 'undefined')
     request_.validBefore = Hex.toNumber(request.validBefore as Hex.Hex)
   if (typeof request.validAfter !== 'undefined')
@@ -146,7 +148,7 @@ export declare namespace fromRpc {
     | AuthorizationTempo.fromRpcList.ErrorType
     | Hex.toNumber.ErrorType
     | Hex.toBigInt.ErrorType
-    | MultisigWitness.fromRpc.ErrorType
+    | MultisigSimulation.fromRpc.ErrorType
     | Errors.GlobalErrorType
 }
 
@@ -220,7 +222,7 @@ export function toRpc(request: toRpc.Input): Rpc {
     typeof request.keyData !== 'undefined' ||
     typeof request.keyId !== 'undefined' ||
     typeof request.keyType !== 'undefined' ||
-    typeof request.multisigWitness !== 'undefined' ||
+    typeof request.multisigSimulation !== 'undefined' ||
     typeof request.nonceKey !== 'undefined' ||
     typeof request.validBefore !== 'undefined' ||
     typeof request.validAfter !== 'undefined' ||
@@ -270,8 +272,10 @@ export function toRpc(request: toRpc.Input): Rpc {
   if (typeof request.keyId !== 'undefined') request_rpc.keyId = request.keyId
   if (typeof request.keyType !== 'undefined')
     request_rpc.keyType = request.keyType
-  if (typeof request.multisigWitness !== 'undefined')
-    request_rpc.multisigWitness = MultisigWitness.toRpc(request.multisigWitness)
+  if (typeof request.multisigSimulation !== 'undefined')
+    request_rpc.multisigSimulation = MultisigSimulation.toRpc(
+      request.multisigSimulation,
+    )
   if (typeof request.validBefore !== 'undefined')
     request_rpc.validBefore = Quantity.fromNumberish(request.validBefore)
   if (typeof request.validAfter !== 'undefined')
@@ -306,7 +310,7 @@ export declare namespace toRpc {
   export type ErrorType =
     | AuthorizationTempo.toRpcList.ErrorType
     | Hex.fromNumber.ErrorType
-    | MultisigWitness.toRpc.ErrorType
+    | MultisigSimulation.toRpc.ErrorType
     | Errors.GlobalErrorType
 }
 

package/src/tempo/index.ts

@@ -183,14 +183,14 @@ export * as MultisigConfig from './MultisigConfig.js'
  */
 export * as MultisigOperation from './MultisigOperation.js'
 /**
- * Native multisig RPC simulation witness utilities.
+ * Native multisig RPC simulation utilities.
  *
- * Converts complete root and nested owner witnesses between their domain and
- * Tempo JSON-RPC representations.
+ * Converts complete root and nested owner specs between their domain and Tempo
+ * JSON-RPC representations.
  *
  * @category Reference
  */
-export * as MultisigWitness from './MultisigWitness.js'
+export * as MultisigSimulation from './MultisigSimulation.js'
 /**
  * Utilities for constructing period durations (in seconds) for recurring spending limits.
  *

package/src/tempo/multisig.e2e.test.ts

@@ -2,7 +2,12 @@ import { AbiFunction, Address, Hex, Secp256k1, Value } from 'ox'
 import { getTransactionCount } from 'viem/actions'
 import { describe, expect, test } from 'vp/test'
 import { chain, client, fundAddress } from '../../test/tempo/config.js'
-import { KeyAuthorization, MultisigConfig, SignatureEnvelope } from './index.js'
+import {
+  KeyAuthorization,
+  MultisigConfig,
+  SignatureEnvelope,
+  TransactionRequest,
+} from './index.js'
 import * as Transaction from './Transaction.js'
 import * as TransactionReceipt from './TransactionReceipt.js'
 import * as TxEnvelopeTempo from './TxEnvelopeTempo.js'
@@ -135,6 +140,51 @@ describe('behavior: multisig (TIP-1061)', () => {
     })
   }
 
+  test('behavior: fills a multisig simulation', async () => {
+    const { account, initialConfig, ownerKeys } = setup({
+      count: 2,
+      threshold: 2,
+    })
+    await fundAddress(client, { address: account })
+
+    const request = TransactionRequest.toRpc({
+      calls: [{ to: '0x0000000000000000000000000000000000000000' }],
+      from: account,
+      multisigSimulation: {
+        account,
+        approvals: ownerKeys.map((owner) => ({
+          keyType: 'secp256k1',
+          owner: owner.address,
+          type: 'primitive',
+        })),
+        config: initialConfig,
+      },
+    })
+    expect(request.multisigSimulation?.config).toBeTypeOf('string')
+
+    const response = await client.request({
+      method: 'eth_fillTransaction',
+      params: [request as never],
+    })
+    const transaction = TransactionRequest.fromRpc(
+      response.tx as TransactionRequest.Rpc,
+    )
+
+    expect(Hex.validate(response.raw)).toBe(true)
+    expect(transaction.calls).toHaveLength(1)
+    expect(transaction.calls?.[0]?.to).toBe(
+      '0x0000000000000000000000000000000000000000',
+    )
+    expect(transaction.chainId).toBe(chainId)
+    expect(transaction.feeToken).toBeNull()
+    expect(transaction.gas).toBeGreaterThan(0n)
+    expect(transaction.maxFeePerGas).toBeTypeOf('bigint')
+    expect(transaction.maxPriorityFeePerGas).toBeTypeOf('bigint')
+    expect(transaction.nonce ?? 0n).toBe(0n)
+    expect(transaction.nonceKey ?? 0n).toBe(0n)
+    expect(transaction.type).toBe('tempo')
+  })
+
   test('examples: bootstrap, initialized, and configuration rotation', async () => {
     const { account, initialConfig, ownerKeys } = setup({
       count: 3,

package/src/version.ts

@@ -1,2 +1,2 @@
 /** @internal */
-export const version = '1.7.2'
+export const version = '1.7.4'

package/src/zod/tempo/MultisigOperation.ts

@@ -3,7 +3,6 @@ import * as core_MultisigOperation from '../../tempo/MultisigOperation.js'
 import * as z_Address from '../Address.js'
 import * as z_Hash from '../Hash.js'
 import * as z_Hex from '../Hex.js'
-import * as z_Uint from '../Uint.js'
 import * as z from 'zod/mini'
 import * as z_MultisigConfig from './MultisigConfig.js'
 
@@ -12,10 +11,8 @@ function baseFields() {
     account: z_Address.Address,
     approvals: z.readonly(z.array(z_Hex.Hex)),
     config: z_MultisigConfig.MultisigConfig,
-    configVersion: z_Uint.Uint64,
     createdAt: z.number(),
     hash: z_Hash.Hash,
-    init: z.boolean(),
     signatureCount: z.number(),
     threshold: z.number(),
     updatedAt: z.number(),

package/src/zod/tempo/{MultisigWitness.ts → MultisigSimulation.ts}

@@ -1,26 +1,12 @@
 /* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
 import * as core_MultisigConfig from '../../tempo/MultisigConfig.js'
-import * as core_MultisigWitness from '../../tempo/MultisigWitness.js'
+import * as core_MultisigSimulation from '../../tempo/MultisigSimulation.js'
 import * as z_Address from '../Address.js'
 import * as z_Hex from '../Hex.js'
 import * as z from 'zod/mini'
 import * as z_MultisigConfig from './MultisigConfig.js'
 import * as z_SignatureEnvelope from './SignatureEnvelope.js'
 
-const ConfigRpc = z
-  .object({
-    owners: z.readonly(z.array(z_MultisigConfig.Owner)),
-    salt: z_Hex.Hex,
-    threshold: z.number(),
-    version: z.number(),
-  })
-  .check(
-    z.refine(
-      (value) => core_MultisigConfig.validate(value),
-      'expected valid native multisig configuration',
-    ),
-  )
-
 const NestedPrimitiveApproval = z.object({
   keyData: z.optional(z_Hex.Hex),
   keyType: z.optional(z_SignatureEnvelope.Type),
@@ -34,7 +20,7 @@ const PrimitiveApproval = z.object({
   type: z.literal('primitive'),
 })
 
-const NestedWitness = z.object({
+const NestedSpec = z.object({
   account: z_Address.Address,
   approvals: z.readonly(
     z
@@ -44,17 +30,17 @@ const NestedWitness = z.object({
   config: z_MultisigConfig.Config,
 })
 
-const NestedWitnessRpc = z.object({
+const NestedSpecRpc = z.object({
   account: z_Address.Address,
   approvals: z.readonly(
     z
       .array(NestedPrimitiveApproval)
       .check(z.maxLength(core_MultisigConfig.maxSignatures)),
   ),
-  config: ConfigRpc,
+  config: z_Hex.Hex,
 })
 
-/** Native multisig simulation witness schema. */
+/** Native multisig simulation spec schema. */
 export const Domain = z.object({
   account: z_Address.Address,
   approvals: z.readonly(
@@ -63,8 +49,8 @@ export const Domain = z.object({
         z.union([
           PrimitiveApproval,
           z.object({
+            spec: NestedSpec,
             type: z.literal('multisig'),
-            witness: NestedWitness,
           }),
         ]),
       )
@@ -73,29 +59,40 @@ export const Domain = z.object({
   config: z_MultisigConfig.Config,
 })
 
-const Rpc_ = z.object({
-  account: z_Address.Address,
-  approvals: z.readonly(
-    z
-      .array(
-        z.union([
-          PrimitiveApproval,
-          z.object({
-            type: z.literal('multisig'),
-            witness: NestedWitnessRpc,
-          }),
-        ]),
-      )
-      .check(z.maxLength(core_MultisigConfig.maxSignatures)),
-  ),
-  config: ConfigRpc,
-})
+const Rpc_ = z
+  .object({
+    account: z_Address.Address,
+    approvals: z.readonly(
+      z
+        .array(
+          z.union([
+            PrimitiveApproval,
+            z.object({
+              spec: NestedSpecRpc,
+              type: z.literal('multisig'),
+            }),
+          ]),
+        )
+        .check(z.maxLength(core_MultisigConfig.maxSignatures)),
+    ),
+    config: z_Hex.Hex,
+  })
+  .check(
+    z.refine((value) => {
+      try {
+        core_MultisigSimulation.fromRpc(value)
+        return true
+      } catch {
+        return false
+      }
+    }, 'expected valid native multisig simulation spec'),
+  )
 
-/** Codec decoding an RPC multisig witness into its domain representation. */
-export const MultisigWitness = z.codec(Rpc_, Domain, {
-  decode: (value) => core_MultisigWitness.fromRpc(value),
-  encode: (value) => core_MultisigWitness.toRpc(value),
+/** Codec decoding an RPC multisig simulation spec into its domain representation. */
+export const MultisigSimulation = z.codec(Rpc_, Domain, {
+  decode: (value) => core_MultisigSimulation.fromRpc(value),
+  encode: (value) => core_MultisigSimulation.toRpc(value),
 })
 
-/** RPC native multisig simulation witness schema. */
+/** RPC native multisig simulation spec schema. */
 export const Rpc = Rpc_

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'
@@ -7,6 +8,7 @@ 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'
 
@@ -88,6 +90,18 @@ 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',
@@ -102,16 +116,11 @@ export const multisig_approveRawTransactionSync = from({
   returns: z_MultisigOperation.TransactionOperation,
 })
 
-/** 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_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. */
@@ -126,5 +135,6 @@ export const Multisig = {
   multisig_approveKeyAuthorization,
   multisig_approveRawTransaction,
   multisig_approveRawTransactionSync,
+  multisig_getConfig,
   multisig_getOperation,
 }

package/src/zod/tempo/SignatureEnvelope.ts

@@ -85,36 +85,15 @@ export const KeychainRpc = z.object({
 })
 
 /** RPC native multisig signature envelope schema. */
-export const MultisigRpc = z
-  .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) => {
-      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([
@@ -209,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 {
@@ -255,11 +236,6 @@ function fromRpc(
     }
   }
 
-  if ('config' in value && 'signatures' 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

@@ -13,7 +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_MultisigSimulation from './MultisigSimulation.js'
 import * as z_SignatureEnvelope from './SignatureEnvelope.js'
 
 const fromRpcType = { '0x76': 'tempo' } as const
@@ -83,7 +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),
-  multisigWitness: z.optional(z_MultisigWitness.Rpc),
+  multisigSimulation: z.optional(z_MultisigSimulation.Rpc),
   nonce: z.optional(z_Hex.Hex),
   nonceKey: z.optional(z_Hex.Hex),
   r: z.optional(z_Hex.Hex),
@@ -136,7 +136,7 @@ export const Domain = z.object({
   maxFeePerBlobGas: z.optional(z.bigint()),
   maxFeePerGas: z.optional(z.bigint()),
   maxPriorityFeePerGas: z.optional(z.bigint()),
-  multisigWitness: z.optional(z_MultisigWitness.Domain),
+  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),
@@ -175,7 +175,7 @@ export const DomainToRpc = z.object({
   maxFeePerBlobGas: z.optional(uintBigintNumberish()),
   maxFeePerGas: z.optional(uintBigintNumberish()),
   maxPriorityFeePerGas: z.optional(uintBigintNumberish()),
-  multisigWitness: z.optional(z_MultisigWitness.Domain),
+  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),
@@ -206,7 +206,7 @@ export const TransactionRequestToRpc = z.codec(Rpc, DomainToRpc, {
 function fromRpc(
   request: core_TransactionRequest.Rpc,
 ): core_TransactionRequest.TransactionRequest {
-  const { authorizationList: _, multisigWitness: __, ...rest } = request
+  const { authorizationList: _, multisigSimulation: __, ...rest } = request
   const request_ = z.decode(
     z_TransactionRequest.TransactionRequest,
     rest as never,
@@ -250,10 +250,10 @@ 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.multisigWitness !== 'undefined')
-    request_.multisigWitness = z.decode(
-      z_MultisigWitness.MultisigWitness,
-      request.multisigWitness,
+  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)
@@ -283,7 +283,7 @@ function toRpc(
     typeof request.keyData !== 'undefined' ||
     typeof request.keyId !== 'undefined' ||
     typeof request.keyType !== 'undefined' ||
-    typeof request.multisigWitness !== 'undefined' ||
+    typeof request.multisigSimulation !== 'undefined' ||
     typeof request.nonceKey !== 'undefined' ||
     typeof request.validBefore !== 'undefined' ||
     typeof request.validAfter !== 'undefined' ||
@@ -338,10 +338,10 @@ 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.multisigWitness !== 'undefined')
-    request_rpc.multisigWitness = z.encode(
-      z_MultisigWitness.MultisigWitness,
-      request.multisigWitness,
+  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)

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

@@ -142,21 +142,8 @@ 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 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/MultisigOperation.test.ts

@@ -23,10 +23,8 @@ const rpc = {
     threshold: 2,
     version: '0x1',
   },
-  configVersion: '0x1',
   createdAt: 1,
   hash: '0xcdbc24a8fb192f799c5d166b13a99fb29cbb15e71a5e730988d6f8b3c5959d02',
-  init: false,
   signatureCount: 1,
   status: 'pending',
   threshold: 2,

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`)
+  })
+})