ox 1.7.2 → 1.7.5

package/src/version.ts

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

package/src/zod/tempo/KeyAuthorization.ts

@@ -9,16 +9,6 @@ import {
 import * as z from 'zod/mini'
 import * as z_SignatureEnvelope from './SignatureEnvelope.js'
 
-const SignatureRpc = z.union([
-  z_SignatureEnvelope.PrimitiveRpc,
-  z_SignatureEnvelope.MultisigRpc,
-])
-
-const Signature = z.union([
-  z_SignatureEnvelope.Primitive,
-  z_SignatureEnvelope.Multisig,
-])
-
 /** RPC token spending limit schema. */
 export const RpcTokenLimit = z.object({
   limit: z_Hex.Hex,
@@ -39,18 +29,28 @@ export const RpcCallScope = z.object({
 })
 
 /** RPC key authorization schema. */
-export const Rpc = z.object({
-  account: z.optional(z.nullable(z_Address.Address)),
-  allowedCalls: z.optional(z.nullable(z.readonly(z.array(RpcCallScope)))),
-  chainId: z_Hex.Hex,
-  expiry: z.optional(z.nullable(z_Hex.Hex)),
-  isAdmin: z.optional(z.nullable(z.boolean())),
-  keyId: z_Address.Address,
-  keyType: z_SignatureEnvelope.Type,
-  limits: z.optional(z.nullable(z.readonly(z.array(RpcTokenLimit)))),
-  signature: SignatureRpc,
-  witness: z.optional(z.nullable(z_Hex.Hex)),
-})
+export const Rpc = z
+  .object({
+    account: z.optional(z.nullable(z_Address.Address)),
+    allowedCalls: z.optional(z.nullable(z.readonly(z.array(RpcCallScope)))),
+    chainId: z_Hex.Hex,
+    expiry: z.optional(z.nullable(z_Hex.Hex)),
+    isAdmin: z.optional(z.nullable(z.boolean())),
+    keyId: z_Address.Address,
+    keyType: z.union([z_SignatureEnvelope.Type, z.literal('multisig')]),
+    limits: z.optional(z.nullable(z.readonly(z.array(RpcTokenLimit)))),
+    signature: z.union([
+      z_SignatureEnvelope.PrimitiveRpc,
+      z_SignatureEnvelope.MultisigRpc,
+    ]),
+    witness: z.optional(z.nullable(z_Hex.Hex)),
+  })
+  .check(
+    z.refine(
+      (value) => value.keyType !== 'multisig' || value.account != null,
+      'multisig key grants require a parent account binding',
+    ),
+  )
 
 /** Token spending limit schema. */
 export const TokenLimit = z.object({
@@ -79,20 +79,27 @@ const domainShape = {
   expiry: z.optional(z.number()),
   limits: z.optional(z.readonly(z.array(TokenLimit))),
   scopes: z.optional(z.readonly(z.array(Scope))),
-  signature: Signature,
-  type: z_SignatureEnvelope.Type,
+  signature: z.union([
+    z_SignatureEnvelope.Primitive,
+    z_SignatureEnvelope.Multisig,
+  ]),
+  type: z.union([z_SignatureEnvelope.Type, z.literal('multisig')]),
   witness: z.optional(z_Hex.Hex),
 }
 
-/** Decoded key authorization schema (TIP-1049 admin fields are paired: both or neither). */
-export const Domain = z.union([
-  z.object({
+/** Decoded key authorization schema. */
+export const Domain = z
+  .object({
     ...domainShape,
-    account: z_Address.Address,
-    isAdmin: z.boolean(),
-  }),
-  z.object(domainShape),
-])
+    account: z.optional(z_Address.Address),
+    isAdmin: z.optional(z.boolean()),
+  })
+  .check(
+    z.refine(
+      (value) => value.type !== 'multisig' || value.account != null,
+      'multisig key grants require a parent account binding',
+    ),
+  )
 
 const domainToRpcShape = {
   ...domainShape,
@@ -102,14 +109,18 @@ const domainToRpcShape = {
 }
 
 /** Encode-only decoded key authorization schema accepting numberish `toRpc` inputs. */
-export const DomainToRpc = z.union([
-  z.object({
+export const DomainToRpc = z
+  .object({
     ...domainToRpcShape,
-    account: z_Address.Address,
-    isAdmin: z.boolean(),
-  }),
-  z.object(domainToRpcShape),
-])
+    account: z.optional(z_Address.Address),
+    isAdmin: z.optional(z.boolean()),
+  })
+  .check(
+    z.refine(
+      (value) => value.type !== 'multisig' || value.account != null,
+      'multisig key grants require a parent account binding',
+    ),
+  )
 
 /** Codec decoding an RPC key authorization into a signed key authorization. */
 export const KeyAuthorization = z.codec(Rpc, Domain, {

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/MultisigSimulation.ts

@@ -0,0 +1,53 @@
+/* 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_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 PrimitiveApproval = z.strictObject({
+  keyData: z.optional(z_Hex.Hex),
+  keyType: z.optional(z_SignatureEnvelope.Type),
+  owner: z_Address.Address,
+})
+
+/** Native multisig simulation spec schema. */
+export const Domain = z.object({
+  approvals: z.readonly(
+    z
+      .array(PrimitiveApproval)
+      .check(z.maxLength(core_MultisigConfig.maxSignatures)),
+  ),
+  config: z_MultisigConfig.Config,
+})
+
+const Rpc_ = z
+  .object({
+    approvals: z.readonly(
+      z
+        .array(PrimitiveApproval)
+        .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 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 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

@@ -72,39 +72,18 @@ export const WebAuthnRpc = z.object({
 export const PrimitiveRpc = z.union([Secp256k1Rpc, P256Rpc, WebAuthnRpc])
 
 /** RPC keychain signature envelope schema. */
-export const KeychainRpc = z.object({
-  keyId: z.optional(z_Address.Address),
-  // `signature` is recursive; type the getter concretely to break the cycle.
-  signature: z.lazy(
-    (): z.ZodMiniType<core_SignatureEnvelope.SignatureEnvelopeRpc> =>
-      Rpc as never,
-  ),
-  type: z.literal('keychain'),
-  userAddress: z_Address.Address,
-  version: z.optional(KeychainVersion),
-})
-
-/** 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,
+export const KeychainRpc = z
+  .object({
+    keyId: z.optional(z_Address.Address),
+    // `signature` is recursive; type the getter concretely to break the cycle.
+    signature: z.lazy(
+      (): z.ZodMiniType<core_SignatureEnvelope.SignatureEnvelopeRpc> =>
+        Rpc as never,
     ),
+    type: z.literal('keychain'),
+    userAddress: z_Address.Address,
+    version: z.optional(KeychainVersion),
   })
-  // Keep invalid recursive approvals inside Zod's issue path.
   .check(
     z.refine((value) => {
       try {
@@ -113,9 +92,21 @@ export const MultisigRpc = z
       } catch {
         return false
       }
-    }, 'expected valid native multisig signature'),
+    }, 'multisig access keys require keychain V2'),
   )
 
+/** RPC native multisig signature envelope schema. */
+export const MultisigRpc = z_Hex.Hex.check(
+  z.refine((value) => {
+    try {
+      core_SignatureEnvelope.fromRpc(value)
+      return true
+    } catch {
+      return false
+    }
+  }, 'expected valid native multisig signature'),
+)
+
 /** RPC signature envelope schema. */
 export const Rpc = z.union([
   Secp256k1Rpc,
@@ -154,34 +145,34 @@ export const WebAuthn = z.object({
 export const Primitive = z.union([Secp256k1, P256, WebAuthn])
 
 /** Keychain signature envelope schema. */
-export const Keychain = z.object({
-  // `inner` is recursive; type the getter concretely to break the cycle.
-  inner: z.lazy(
-    (): z.ZodMiniType<core_SignatureEnvelope.SignatureEnvelope> =>
-      Domain as never,
-  ),
-  keyId: z.optional(z_Address.Address),
-  type: z.literal('keychain'),
-  userAddress: z_Address.Address,
-  version: z.optional(KeychainVersion),
-})
+export const Keychain = z
+  .object({
+    // `inner` is recursive; type the getter concretely to break the cycle.
+    inner: z.lazy(
+      (): z.ZodMiniType<core_SignatureEnvelope.SignatureEnvelope> =>
+        Domain as never,
+    ),
+    keyId: z.optional(z_Address.Address),
+    type: z.literal('keychain'),
+    userAddress: z_Address.Address,
+    version: z.optional(KeychainVersion),
+  })
+  .check(
+    z.refine(
+      (value) => core_SignatureEnvelope.validate(value),
+      'multisig access keys require keychain V2',
+    ),
+  )
 
 /** Native multisig signature envelope schema. */
 export const Multisig = z
   .object({
     account: z_Address.Address,
     config: z_MultisigConfig.Config,
-    // `signatures` is recursive; type the getter concretely to break the cycle.
-    signatures: z.lazy(
-      (): z.ZodMiniType<readonly core_SignatureEnvelope.SignatureEnvelope[]> =>
-        z.readonly(
-          z
-            .array(Domain)
-            .check(
-              z.minLength(1),
-              z.maxLength(core_MultisigConfig.maxSignatures),
-            ),
-        ) as never,
+    signatures: z.readonly(
+      z
+        .array(Primitive)
+        .check(z.minLength(1), z.maxLength(core_MultisigConfig.maxSignatures)),
     ),
     type: z.literal('multisig'),
   })
@@ -209,6 +200,7 @@ 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 +247,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
@@ -23,6 +23,7 @@ const KeyType = z.union([
   z.literal('secp256k1'),
   z.literal('p256'),
   z.literal('webAuthn'),
+  z.literal('multisig'),
 ])
 
 const SignatureRpc = z.object({
@@ -83,7 +84,8 @@ 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),
+  keyAuthorizationSimulation: z.optional(z_MultisigSimulation.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 +138,8 @@ 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),
+  keyAuthorizationSimulation: z.optional(z_MultisigSimulation.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 +178,8 @@ export const DomainToRpc = z.object({
   maxFeePerBlobGas: z.optional(uintBigintNumberish()),
   maxFeePerGas: z.optional(uintBigintNumberish()),
   maxPriorityFeePerGas: z.optional(uintBigintNumberish()),
-  multisigWitness: z.optional(z_MultisigWitness.Domain),
+  keyAuthorizationSimulation: z.optional(z_MultisigSimulation.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 +210,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 +254,15 @@ 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.keyAuthorizationSimulation !== 'undefined')
+    request_.keyAuthorizationSimulation = z.decode(
+      z_MultisigSimulation.MultisigSimulation,
+      request.keyAuthorizationSimulation,
+    )
+  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 +292,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 +347,15 @@ 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.keyAuthorizationSimulation !== 'undefined')
+    request_rpc.keyAuthorizationSimulation = z.encode(
+      z_MultisigSimulation.MultisigSimulation,
+      request.keyAuthorizationSimulation,
+    )
+  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

@@ -1,4 +1,5 @@
 import { describe, expect, test } from 'vp/test'
+import * as core_SignatureEnvelope from '../../../tempo/SignatureEnvelope.js'
 import * as core_KeyAuthorization from '../../../tempo/KeyAuthorization.js'
 import * as z_KeyAuthorization from '../KeyAuthorization.js'
 import * as z from 'zod/mini'
@@ -20,6 +21,35 @@ const rpc = {
 } as const
 
 describe('KeyAuthorization', () => {
+  test('rejects unbound multisig grants through every schema', () => {
+    const domain = {
+      ...z.decode(z_KeyAuthorization.KeyAuthorization, rpc),
+      type: 'multisig',
+    } as const
+    for (const account of [undefined, null])
+      expect(
+        z.safeDecode(z_KeyAuthorization.KeyAuthorization, {
+          ...rpc,
+          keyType: 'multisig',
+          account,
+        }).success,
+      ).toMatchInlineSnapshot(`false`)
+    for (const schema of [
+      z_KeyAuthorization.Domain,
+      z_KeyAuthorization.DomainToRpc,
+    ]) {
+      expect(z.safeParse(schema, domain).success).toMatchInlineSnapshot(`false`)
+      expect(
+        z.safeParse(schema, { ...domain, account: rpc.keyId }).success,
+      ).toMatchInlineSnapshot(`true`)
+    }
+    for (const codec of [
+      z_KeyAuthorization.KeyAuthorization,
+      z_KeyAuthorization.KeyAuthorizationToRpc,
+    ])
+      expect(z.safeEncode(codec, domain).success).toMatchInlineSnapshot(`false`)
+  })
+
   test('decodes an RPC key authorization', () => {
     expect(z.decode(z_KeyAuthorization.KeyAuthorization, rpc)).toEqual(
       core_KeyAuthorization.fromRpc(rpc),
@@ -141,40 +171,15 @@ describe('KeyAuthorization', () => {
     ).toBe(false)
   })
 
-  test('round-trips multisig signatures', () => {
+  test('rejects legacy 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 }
-    const decoded = z.decode(z_KeyAuthorization.KeyAuthorization, withMultisig)
-    expect(decoded).toEqual(core_KeyAuthorization.fromRpc(withMultisig))
-    expect(z.encode(z_KeyAuthorization.KeyAuthorization, decoded)).toEqual(
-      core_KeyAuthorization.toRpc(decoded),
-    )
-  })
-
-  test('rejects keychain signatures', () => {
-    const keychainRpc = {
-      signature: rpc.signature,
-      type: 'keychain',
-      userAddress: '0x1111111111111111111111111111111111111111',
-    } as const
     expect(
       z.safeDecode(z_KeyAuthorization.KeyAuthorization, {
         ...rpc,
-        signature: keychainRpc,
+        signature: multisigRpc,
       } as never).success,
     ).toBe(false)
 
@@ -183,11 +188,42 @@ describe('KeyAuthorization', () => {
       z.safeEncode(z_KeyAuthorization.KeyAuthorization, {
         ...authorization,
         signature: {
-          inner: authorization.signature,
-          type: 'keychain',
-          userAddress: keychainRpc.userAddress,
+          account: multisigRpc.account,
+          signatures: [authorization.signature],
+          type: 'multisig',
         },
       } as never).success,
     ).toBe(false)
   })
+  test('round-trips account-bound multisig grants', () => {
+    const signature = core_SignatureEnvelope.from({
+      account: '0x2222222222222222222222222222222222222222',
+      config: {
+        threshold: 1,
+        owners: [
+          { owner: '0x1111111111111111111111111111111111111111', weight: 1 },
+        ],
+      },
+      signatures: [
+        core_SignatureEnvelope.fromRpc(
+          rpc.signature,
+        ) as core_SignatureEnvelope.Primitive,
+      ],
+    })
+    const signed = core_KeyAuthorization.from(
+      {
+        account: signature.account,
+        address: '0x3333333333333333333333333333333333333333',
+        chainId: 1n,
+        type: 'multisig',
+      },
+      { signature },
+    )
+    const encoded = z.encode(z_KeyAuthorization.KeyAuthorization, signed)
+    const decoded = z.decode(z_KeyAuthorization.KeyAuthorization, encoded)
+    expect(decoded).toEqual(
+      core_KeyAuthorization.fromRpc(core_KeyAuthorization.toRpc(signed)),
+    )
+    expect(decoded.account).toBe(signature.account)
+  })
 })

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