ox 1.8.6 → 1.8.8

package/src/zod/tempo/AccountSimulation.ts

@@ -0,0 +1,53 @@
+/* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
+import * as core_AccountConfig from '../../tempo/AccountConfig.js'
+import * as core_AccountSimulation from '../../tempo/AccountSimulation.js'
+import * as z_Address from '../Address.js'
+import * as z_Hex from '../Hex.js'
+import * as z from 'zod/mini'
+import * as z_AccountConfig from './AccountConfig.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,
+})
+
+/** Account simulation spec schema. */
+export const Domain = z.object({
+  approvals: z.readonly(
+    z
+      .array(PrimitiveApproval)
+      .check(z.maxLength(core_AccountConfig.maxSignatures)),
+  ),
+  config: z_AccountConfig.Config,
+})
+
+const Rpc_ = z
+  .object({
+    approvals: z.readonly(
+      z
+        .array(PrimitiveApproval)
+        .check(z.maxLength(core_AccountConfig.maxSignatures)),
+    ),
+    config: z_Hex.Hex,
+  })
+  .check(
+    z.refine((value) => {
+      try {
+        core_AccountSimulation.fromRpc(value)
+        return true
+      } catch {
+        return false
+      }
+    }, 'expected valid account simulation spec'),
+  )
+
+/** Codec decoding an RPC account simulation spec into its domain representation. */
+export const AccountSimulation = z.codec(Rpc_, Domain, {
+  decode: (value) => core_AccountSimulation.fromRpc(value),
+  encode: (value) => core_AccountSimulation.toRpc(value),
+})
+
+/** RPC account simulation spec schema. */
+export const Rpc = Rpc_

package/src/zod/tempo/KeyAuthorization.ts

@@ -41,14 +41,14 @@ export const Rpc = z
     limits: z.optional(z.nullable(z.readonly(z.array(RpcTokenLimit)))),
     signature: z.union([
       z_SignatureEnvelope.PrimitiveRpc,
-      z_SignatureEnvelope.MultisigRpc,
+      z_SignatureEnvelope.ConfigurableRpc,
     ]),
     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',
+      'configurable account key grants require a parent account binding',
     ),
   )
 
@@ -81,9 +81,9 @@ const domainShape = {
   scopes: z.optional(z.readonly(z.array(Scope))),
   signature: z.union([
     z_SignatureEnvelope.Primitive,
-    z_SignatureEnvelope.Multisig,
+    z_SignatureEnvelope.Configurable,
   ]),
-  type: z.union([z_SignatureEnvelope.Type, z.literal('multisig')]),
+  type: z.union([z_SignatureEnvelope.Type, z.literal('configurable')]),
   witness: z.optional(z_Hex.Hex),
 }
 
@@ -96,8 +96,8 @@ export const Domain = z
   })
   .check(
     z.refine(
-      (value) => value.type !== 'multisig' || value.account != null,
-      'multisig key grants require a parent account binding',
+      (value) => value.type !== 'configurable' || value.account != null,
+      'configurable account key grants require a parent account binding',
     ),
   )
 
@@ -117,8 +117,8 @@ export const DomainToRpc = z
   })
   .check(
     z.refine(
-      (value) => value.type !== 'multisig' || value.account != null,
-      'multisig key grants require a parent account binding',
+      (value) => value.type !== 'configurable' || value.account != null,
+      'configurable account key grants require a parent account binding',
     ),
   )
 

package/src/zod/tempo/RpcSchemaTempo.ts

@@ -7,9 +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_AccountConfig from './AccountConfig.js'
 import * as z_KeyAuthorization from './KeyAuthorization.js'
-import * as z_MultisigConfig from './MultisigConfig.js'
-import * as z_MultisigOperation from './MultisigOperation.js'
+import * as z_AccountOperation from './AccountOperation.js'
 import * as z_TransactionRequest from './TransactionRequest.js'
 
 const BlockNumberOrTagOrIdentifier = z.union([
@@ -90,51 +90,51 @@ 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',
+/** Schema for the `account_approveKeyAuthorization` JSON-RPC method. */
+export const account_approveKeyAuthorization = from({
+  method: 'account_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,
+  returns: z_AccountOperation.KeyAuthorizationOperation,
 })
 
-/** Schema for the `multisig_approveRawTransaction` JSON-RPC method. */
-export const multisig_approveRawTransaction = from({
-  method: 'multisig_approveRawTransaction',
+/** Schema for the `account_approveRawTransaction` JSON-RPC method. */
+export const account_approveRawTransaction = from({
+  method: 'account_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',
+/** Schema for the `account_approveRawTransactionSync` JSON-RPC method. */
+export const account_approveRawTransactionSync = from({
+  method: 'account_approveRawTransactionSync',
   params: z.tuple([z_Hex.Hex, z.optional(z.number())]),
-  returns: z_MultisigOperation.TransactionOperation,
+  returns: z_AccountOperation.TransactionOperation,
 })
 
-/** Schema for the `multisig_getConfig` JSON-RPC method. */
-export const multisig_getConfig = from({
-  method: 'multisig_getConfig',
+/** Schema for the `account_getConfig` JSON-RPC method. */
+export const account_getConfig = from({
+  method: 'account_getConfig',
   params: z.tuple([z.object({ address: z_Address.Address })]),
-  returns: z.nullable(z_MultisigConfig.Rpc),
+  returns: z.nullable(z_AccountConfig.Rpc),
 })
 
-/** Schema for the `multisig_getOperation` JSON-RPC method. */
-export const multisig_getOperation = from({
-  method: 'multisig_getOperation',
+/** Schema for the `account_getOperation` JSON-RPC method. */
+export const account_getOperation = from({
+  method: 'account_getOperation',
   params: z.tuple([z_Hex.Hex]),
-  returns: z.nullable(z_MultisigOperation.Operation),
+  returns: z.nullable(z_AccountOperation.Operation),
 })
 
-/** JSON-RPC method schemas for the `multisig_` namespace. */
-export const Multisig = {
-  multisig_approveKeyAuthorization,
-  multisig_approveRawTransaction,
-  multisig_approveRawTransactionSync,
-  multisig_getConfig,
-  multisig_getOperation,
+/** JSON-RPC method schemas for the `account_` namespace. */
+export const Account = {
+  account_approveKeyAuthorization,
+  account_approveRawTransaction,
+  account_approveRawTransactionSync,
+  account_getConfig,
+  account_getOperation,
 }

package/src/zod/tempo/SignatureEnvelope.ts

@@ -1,10 +1,10 @@
 /* eslint-disable jsdoc-js/require-jsdoc, jsdoc-js/require-description, jsdoc-js/require-example */
 import * as core_SignatureEnvelope from '../../tempo/SignatureEnvelope.js'
 import * as core_Hex from '../../core/Hex.js'
-import * as core_MultisigConfig from '../../tempo/MultisigConfig.js'
+import * as core_AccountConfig from '../../tempo/AccountConfig.js'
 import * as z_Address from '../Address.js'
 import * as z_Hex from '../Hex.js'
-import * as z_MultisigConfig from './MultisigConfig.js'
+import * as z_AccountConfig from './AccountConfig.js'
 import * as z from 'zod/mini'
 
 /** Signature envelope key type schema. */
@@ -92,11 +92,11 @@ export const KeychainRpc = z
       } catch {
         return false
       }
-    }, 'multisig access keys require keychain V2'),
+    }, 'configurable access keys require keychain V2'),
   )
 
-/** RPC native multisig signature envelope schema. */
-export const MultisigRpc = z_Hex.Hex.check(
+/** RPC configurable account signature envelope schema. */
+export const ConfigurableRpc = z_Hex.Hex.check(
   z.refine((value) => {
     try {
       core_SignatureEnvelope.fromRpc(value)
@@ -104,7 +104,7 @@ export const MultisigRpc = z_Hex.Hex.check(
     } catch {
       return false
     }
-  }, 'expected valid native multisig signature'),
+  }, 'expected valid configurable account signature'),
 )
 
 /** RPC signature envelope schema. */
@@ -113,7 +113,7 @@ export const Rpc = z.union([
   P256Rpc,
   WebAuthnRpc,
   KeychainRpc,
-  MultisigRpc,
+  ConfigurableRpc,
 ])
 
 /** secp256k1 signature envelope schema. */
@@ -160,32 +160,38 @@ export const Keychain = z
   .check(
     z.refine(
       (value) => core_SignatureEnvelope.validate(value),
-      'multisig access keys require keychain V2',
+      'configurable access keys require keychain V2',
     ),
   )
 
-/** Native multisig signature envelope schema. */
-export const Multisig = z
+/** Configurable account signature envelope schema. */
+export const Configurable = z
   .object({
     account: z_Address.Address,
-    config: z_MultisigConfig.Config,
+    config: z_AccountConfig.Config,
     signatures: z.readonly(
       z
         .array(Primitive)
-        .check(z.minLength(1), z.maxLength(core_MultisigConfig.maxSignatures)),
+        .check(z.minLength(1), z.maxLength(core_AccountConfig.maxSignatures)),
     ),
-    type: z.literal('multisig'),
+    type: z.literal('configurable'),
   })
   // Keep invalid recursive approvals inside Zod's issue path.
   .check(
     z.refine(
       (value) => core_SignatureEnvelope.validate(value),
-      'expected valid native multisig signature',
+      'expected valid configurable account signature',
     ),
   )
 
 /** Decoded signature envelope schema. */
-export const Domain = z.union([Secp256k1, P256, WebAuthn, Keychain, Multisig])
+export const Domain = z.union([
+  Secp256k1,
+  P256,
+  WebAuthn,
+  Keychain,
+  Configurable,
+])
 
 /** Codec decoding an RPC signature envelope into a signature envelope. */
 export const SignatureEnvelope = z.codec(Rpc, Domain, {
@@ -298,9 +304,9 @@ function toRpc(
     }
   }
 
-  if (value.type === 'multisig')
+  if (value.type === 'configurable')
     return core_SignatureEnvelope.toRpc(
-      value as core_SignatureEnvelope.Multisig,
+      value as core_SignatureEnvelope.Configurable,
     )
 
   const keychain = value as core_SignatureEnvelope.Keychain

package/src/zod/tempo/TransactionRequest.ts

@@ -11,15 +11,23 @@ import {
   uintNumberNumberish,
 } from '../internal/Integer.js'
 import * as z from 'zod/mini'
+import * as z_AccountSimulation from './AccountSimulation.js'
 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
 const toRpcType = { tempo: '0x76' } as const
 
 const KeyType = z.union([
+  z.literal('secp256k1'),
+  z.literal('p256'),
+  z.literal('webAuthn'),
+  z.literal('configurable'),
+])
+
+// The node's wire format names the configurable account key type `multisig`.
+const KeyTypeRpc = z.union([
   z.literal('secp256k1'),
   z.literal('p256'),
   z.literal('webAuthn'),
@@ -80,12 +88,12 @@ export const Rpc = z.object({
   keyAuthorization: z.optional(z_KeyAuthorization.Rpc),
   keyData: z.optional(z_Hex.Hex),
   keyId: z.optional(z_Address.Address),
-  keyType: z.optional(KeyType),
+  keyType: z.optional(KeyTypeRpc),
   maxFeePerBlobGas: z.optional(z_Hex.Hex),
   maxFeePerGas: z.optional(z_Hex.Hex),
   maxPriorityFeePerGas: z.optional(z_Hex.Hex),
-  keyAuthorizationSimulation: z.optional(z_MultisigSimulation.Rpc),
-  multisigSimulation: z.optional(z_MultisigSimulation.Rpc),
+  keyAuthorizationSimulation: z.optional(z_AccountSimulation.Rpc),
+  multisigSimulation: z.optional(z_AccountSimulation.Rpc),
   nonce: z.optional(z_Hex.Hex),
   nonceKey: z.optional(z_Hex.Hex),
   r: z.optional(z_Hex.Hex),
@@ -117,6 +125,7 @@ const AuthorizationSignedToRpc = z.object({
 /** Decoded tempo transaction request schema. */
 export const Domain = z.object({
   accessList: z.optional(z_AccessList.AccessList),
+  accountSimulation: z.optional(z_AccountSimulation.Domain),
   authorizationList: z.optional(z.readonly(z.array(AuthorizationSigned))),
   blobVersionedHashes: z.optional(z.readonly(z.array(z_Hex.Hex))),
   blobs: z.optional(z.readonly(z.array(z_Hex.Hex))),
@@ -138,8 +147,7 @@ export const Domain = z.object({
   maxFeePerBlobGas: z.optional(z.bigint()),
   maxFeePerGas: z.optional(z.bigint()),
   maxPriorityFeePerGas: z.optional(z.bigint()),
-  keyAuthorizationSimulation: z.optional(z_MultisigSimulation.Domain),
-  multisigSimulation: z.optional(z_MultisigSimulation.Domain),
+  keyAuthorizationSimulation: z.optional(z_AccountSimulation.Domain),
   nonce: z.optional(z.bigint()),
   nonceKey: z.optional(z.union([z.bigint(), z.literal('random')])),
   r: z.optional(z_Hex.Hex),
@@ -157,6 +165,7 @@ export const Domain = z.object({
 /** Encode-only decoded tempo transaction request schema accepting numberish `toRpc` inputs. */
 export const DomainToRpc = z.object({
   accessList: z.optional(z_AccessList.AccessList),
+  accountSimulation: z.optional(z_AccountSimulation.Domain),
   authorizationList: z.optional(z.readonly(z.array(AuthorizationSignedToRpc))),
   blobVersionedHashes: z.optional(z.readonly(z.array(z_Hex.Hex))),
   blobs: z.optional(z.readonly(z.array(z_Hex.Hex))),
@@ -178,8 +187,7 @@ export const DomainToRpc = z.object({
   maxFeePerBlobGas: z.optional(uintBigintNumberish()),
   maxFeePerGas: z.optional(uintBigintNumberish()),
   maxPriorityFeePerGas: z.optional(uintBigintNumberish()),
-  keyAuthorizationSimulation: z.optional(z_MultisigSimulation.Domain),
-  multisigSimulation: z.optional(z_MultisigSimulation.Domain),
+  keyAuthorizationSimulation: z.optional(z_AccountSimulation.Domain),
   nonce: z.optional(uintBigintNumberish()),
   nonceKey: z.optional(z.union([uintBigintNumberish(), z.literal('random')])),
   r: z.optional(z_Hex.Hex),
@@ -253,15 +261,17 @@ function fromRpc(
     request_.feePayer = request.feePayer
   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.keyType !== 'undefined')
+    request_.keyType =
+      request.keyType === 'multisig' ? 'configurable' : request.keyType
   if (typeof request.keyAuthorizationSimulation !== 'undefined')
     request_.keyAuthorizationSimulation = z.decode(
-      z_MultisigSimulation.MultisigSimulation,
+      z_AccountSimulation.AccountSimulation,
       request.keyAuthorizationSimulation,
     )
   if (typeof request.multisigSimulation !== 'undefined')
-    request_.multisigSimulation = z.decode(
-      z_MultisigSimulation.MultisigSimulation,
+    request_.accountSimulation = z.decode(
+      z_AccountSimulation.AccountSimulation,
       request.multisigSimulation,
     )
   if (typeof request.validBefore !== 'undefined')
@@ -284,6 +294,7 @@ function toRpc(
   } as never) as core_TransactionRequest.Rpc
 
   const tempo =
+    typeof request.accountSimulation !== 'undefined' ||
     typeof request.calls !== 'undefined' ||
     typeof request.capabilities !== 'undefined' ||
     typeof request.feePayer !== 'undefined' ||
@@ -292,7 +303,6 @@ function toRpc(
     typeof request.keyData !== 'undefined' ||
     typeof request.keyId !== 'undefined' ||
     typeof request.keyType !== 'undefined' ||
-    typeof request.multisigSimulation !== 'undefined' ||
     typeof request.nonceKey !== 'undefined' ||
     typeof request.validBefore !== 'undefined' ||
     typeof request.validAfter !== 'undefined' ||
@@ -346,16 +356,17 @@ function toRpc(
     request_rpc.keyData = shimKeyData(request.keyData)
   if (typeof request.keyId !== 'undefined') request_rpc.keyId = request.keyId
   if (typeof request.keyType !== 'undefined')
-    request_rpc.keyType = request.keyType
+    request_rpc.keyType =
+      request.keyType === 'configurable' ? 'multisig' : request.keyType
   if (typeof request.keyAuthorizationSimulation !== 'undefined')
     request_rpc.keyAuthorizationSimulation = z.encode(
-      z_MultisigSimulation.MultisigSimulation,
+      z_AccountSimulation.AccountSimulation,
       request.keyAuthorizationSimulation,
     )
-  if (typeof request.multisigSimulation !== 'undefined')
+  if (typeof request.accountSimulation !== 'undefined')
     request_rpc.multisigSimulation = z.encode(
-      z_MultisigSimulation.MultisigSimulation,
-      request.multisigSimulation,
+      z_AccountSimulation.AccountSimulation,
+      request.accountSimulation,
     )
   if (typeof request.validBefore !== 'undefined')
     request_rpc.validBefore = encodeNumberish(request.validBefore)

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

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

package/src/zod/tempo/_test/{MultisigConfig.test.ts → AccountConfig.test.ts}

@@ -1,5 +1,5 @@
 import { describe, expect, test } from 'vp/test'
-import * as z_MultisigConfig from '../MultisigConfig.js'
+import * as z_AccountConfig from '../AccountConfig.js'
 import * as z from 'zod/mini'
 
 const config = {
@@ -17,20 +17,20 @@ const config = {
 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('accepts valid account configurations', () => {
+    expect(z.safeDecode(z_AccountConfig.Config, config).success).toBe(true)
   })
 
   test('round-trips RPC configurations', () => {
-    const decoded = z.decode(z_MultisigConfig.MultisigConfig, rpc)
+    const decoded = z.decode(z_AccountConfig.AccountConfig, rpc)
 
     expect(decoded).toEqual(config)
-    expect(z.encode(z_MultisigConfig.MultisigConfig, decoded)).toEqual(rpc)
+    expect(z.encode(z_AccountConfig.AccountConfig, decoded)).toEqual(rpc)
   })
 
   test('rejects configurations outside protocol limits', () => {
     expect(
-      z.safeDecode(z_MultisigConfig.Config, {
+      z.safeDecode(z_AccountConfig.Config, {
         ...config,
         owners: [{ ...config.owners[0], weight: 255 }],
         threshold: 256,
@@ -40,7 +40,7 @@ describe('Config', () => {
 
   test('rejects non-canonical owner order', () => {
     expect(
-      z.safeDecode(z_MultisigConfig.Config, {
+      z.safeDecode(z_AccountConfig.Config, {
         ...config,
         owners: [
           {

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

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

package/src/zod/tempo/_test/{MultisigOperation.test.ts → AccountOperation.test.ts}

@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'vp/test'
-import * as core_MultisigOperation from '../../../tempo/MultisigOperation.js'
-import * as z_MultisigOperation from '../MultisigOperation.js'
+import * as core_AccountOperation from '../../../tempo/AccountOperation.js'
+import * as z_AccountOperation from '../AccountOperation.js'
 import * as z from 'zod/mini'
 
 const rpc = {
@@ -37,21 +37,21 @@ const rpc = {
 
 describe('TransactionOperation', () => {
   test('decodes an RPC operation', () => {
-    expect(z.decode(z_MultisigOperation.TransactionOperation, rpc)).toEqual(
-      core_MultisigOperation.fromRpc(rpc),
+    expect(z.decode(z_AccountOperation.TransactionOperation, rpc)).toEqual(
+      core_AccountOperation.fromRpc(rpc),
     )
   })
 
   test('round-trips via encode', () => {
-    const operation = z.decode(z_MultisigOperation.TransactionOperation, rpc)
+    const operation = z.decode(z_AccountOperation.TransactionOperation, rpc)
     expect(
-      z.encode(z_MultisigOperation.TransactionOperation, operation),
-    ).toEqual(core_MultisigOperation.toRpc(operation))
+      z.encode(z_AccountOperation.TransactionOperation, operation),
+    ).toEqual(core_AccountOperation.toRpc(operation))
   })
 
   test('rejects internally inconsistent operations', () => {
     expect(
-      z.safeDecode(z_MultisigOperation.TransactionOperation, {
+      z.safeDecode(z_AccountOperation.TransactionOperation, {
         ...rpc,
         weight: 2,
       }).success,
@@ -61,6 +61,6 @@ describe('TransactionOperation', () => {
 
 describe('Operation', () => {
   test('accepts transaction operations', () => {
-    expect(z.safeDecode(z_MultisigOperation.Operation, rpc).success).toBe(true)
+    expect(z.safeDecode(z_AccountOperation.Operation, rpc).success).toBe(true)
   })
 })

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

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

package/src/zod/tempo/_test/{MultisigSimulation.test.ts → AccountSimulation.test.ts}

@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'vp/test'
-import * as core_MultisigSimulation from '../../../tempo/MultisigSimulation.js'
-import * as z_MultisigSimulation from '../MultisigSimulation.js'
+import * as core_AccountSimulation from '../../../tempo/AccountSimulation.js'
+import * as z_AccountSimulation from '../AccountSimulation.js'
 import * as z from 'zod/mini'
 
 const rpc = {
@@ -13,21 +13,21 @@ const rpc = {
   ],
   config:
     '0xf852a011111111111111111111111111111111111111111111111111111111111111110102eed694aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa01d694bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb01',
-} as const satisfies core_MultisigSimulation.Rpc
+} as const satisfies core_AccountSimulation.Rpc
 
-describe('MultisigSimulation', () => {
+describe('AccountSimulation', () => {
   test('behavior: converts between RPC and domain specs', () => {
-    const spec = z.decode(z_MultisigSimulation.MultisigSimulation, rpc)
+    const spec = z.decode(z_AccountSimulation.AccountSimulation, rpc)
 
-    expect(spec).toEqual(core_MultisigSimulation.fromRpc(rpc))
-    expect(
-      z.encode(z_MultisigSimulation.MultisigSimulation, spec),
-    ).toStrictEqual(rpc)
+    expect(spec).toEqual(core_AccountSimulation.fromRpc(rpc))
+    expect(z.encode(z_AccountSimulation.AccountSimulation, spec)).toStrictEqual(
+      rpc,
+    )
   })
 
   test('error: rejects more than eight root approvals', () => {
     expect(
-      z.safeDecode(z_MultisigSimulation.Rpc, {
+      z.safeDecode(z_AccountSimulation.Rpc, {
         ...rpc,
         approvals: Array.from({ length: 9 }, () => rpc.approvals[0]),
       }).success,
@@ -35,16 +35,16 @@ describe('MultisigSimulation', () => {
   })
   test('error: rejects nested approvals', () => {
     expect(
-      z.safeDecode(z_MultisigSimulation.Rpc, {
+      z.safeDecode(z_AccountSimulation.Rpc, {
         ...rpc,
-        approvals: [{ type: 'multisig', spec: rpc }],
+        approvals: [{ type: 'configurable', spec: rpc }],
       } as never).success,
     ).toMatchInlineSnapshot(`false`)
   })
 
   test('error: rejects malformed encoded configurations', () => {
     expect(
-      z.safeDecode(z_MultisigSimulation.Rpc, {
+      z.safeDecode(z_AccountSimulation.Rpc, {
         ...rpc,
         config: '0x01',
       }).success,