ox 1.0.0-beta.0 → 1.0.0-beta.2

package/dist/zod/tempo/TxEnvelopeTempo.d.ts

@@ -51,7 +51,7 @@ export declare const TxEnvelopeTempo: z.ZodMiniObject<{
         version: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"v1">, z.ZodMiniLiteral<"v2">]>>;
     }, z.core.$strip>, z.ZodMiniObject<{
         account: z.ZodMiniTemplateLiteral<`0x${string}`>;
-        configId: z.ZodMiniTemplateLiteral<`0x${string}`>;
+        genesisConfigId: z.ZodMiniTemplateLiteral<`0x${string}`>;
         init: z.ZodMiniOptional<z.ZodMiniObject<{
             salt: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
             threshold: z.ZodMiniNumber<number>;
@@ -113,7 +113,7 @@ export declare const TxEnvelopeTempo: z.ZodMiniObject<{
             version: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"v1">, z.ZodMiniLiteral<"v2">]>>;
         }, z.core.$strip>, z.ZodMiniObject<{
             account: z.ZodMiniTemplateLiteral<`0x${string}`>;
-            configId: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            genesisConfigId: z.ZodMiniTemplateLiteral<`0x${string}`>;
             init: z.ZodMiniOptional<z.ZodMiniObject<{
                 salt: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
                 threshold: z.ZodMiniNumber<number>;
@@ -197,7 +197,7 @@ export declare const TxEnvelopeTempo: z.ZodMiniObject<{
             version: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"v1">, z.ZodMiniLiteral<"v2">]>>;
         }, z.core.$strip>, z.ZodMiniObject<{
             account: z.ZodMiniTemplateLiteral<`0x${string}`>;
-            configId: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            genesisConfigId: z.ZodMiniTemplateLiteral<`0x${string}`>;
             init: z.ZodMiniOptional<z.ZodMiniObject<{
                 salt: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
                 threshold: z.ZodMiniNumber<number>;
@@ -263,7 +263,7 @@ export declare const Signed: z.ZodMiniObject<{
         version: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"v1">, z.ZodMiniLiteral<"v2">]>>;
     }, z.core.$strip>, z.ZodMiniObject<{
         account: z.ZodMiniTemplateLiteral<`0x${string}`>;
-        configId: z.ZodMiniTemplateLiteral<`0x${string}`>;
+        genesisConfigId: z.ZodMiniTemplateLiteral<`0x${string}`>;
         init: z.ZodMiniOptional<z.ZodMiniObject<{
             salt: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
             threshold: z.ZodMiniNumber<number>;
@@ -325,7 +325,7 @@ export declare const Signed: z.ZodMiniObject<{
             version: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"v1">, z.ZodMiniLiteral<"v2">]>>;
         }, z.core.$strip>, z.ZodMiniObject<{
             account: z.ZodMiniTemplateLiteral<`0x${string}`>;
-            configId: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            genesisConfigId: z.ZodMiniTemplateLiteral<`0x${string}`>;
             init: z.ZodMiniOptional<z.ZodMiniObject<{
                 salt: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
                 threshold: z.ZodMiniNumber<number>;
@@ -409,7 +409,7 @@ export declare const Signed: z.ZodMiniObject<{
             version: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"v1">, z.ZodMiniLiteral<"v2">]>>;
         }, z.core.$strip>, z.ZodMiniObject<{
             account: z.ZodMiniTemplateLiteral<`0x${string}`>;
-            configId: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            genesisConfigId: z.ZodMiniTemplateLiteral<`0x${string}`>;
             init: z.ZodMiniOptional<z.ZodMiniObject<{
                 salt: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
                 threshold: z.ZodMiniNumber<number>;
@@ -475,7 +475,7 @@ export declare const serialized: z.ZodMiniCodec<z.ZodMiniTemplateLiteral<`0x${st
         version: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"v1">, z.ZodMiniLiteral<"v2">]>>;
     }, z.core.$strip>, z.ZodMiniObject<{
         account: z.ZodMiniTemplateLiteral<`0x${string}`>;
-        configId: z.ZodMiniTemplateLiteral<`0x${string}`>;
+        genesisConfigId: z.ZodMiniTemplateLiteral<`0x${string}`>;
         init: z.ZodMiniOptional<z.ZodMiniObject<{
             salt: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
             threshold: z.ZodMiniNumber<number>;
@@ -537,7 +537,7 @@ export declare const serialized: z.ZodMiniCodec<z.ZodMiniTemplateLiteral<`0x${st
             version: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"v1">, z.ZodMiniLiteral<"v2">]>>;
         }, z.core.$strip>, z.ZodMiniObject<{
             account: z.ZodMiniTemplateLiteral<`0x${string}`>;
-            configId: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            genesisConfigId: z.ZodMiniTemplateLiteral<`0x${string}`>;
             init: z.ZodMiniOptional<z.ZodMiniObject<{
                 salt: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
                 threshold: z.ZodMiniNumber<number>;
@@ -621,7 +621,7 @@ export declare const serialized: z.ZodMiniCodec<z.ZodMiniTemplateLiteral<`0x${st
             version: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"v1">, z.ZodMiniLiteral<"v2">]>>;
         }, z.core.$strip>, z.ZodMiniObject<{
             account: z.ZodMiniTemplateLiteral<`0x${string}`>;
-            configId: z.ZodMiniTemplateLiteral<`0x${string}`>;
+            genesisConfigId: z.ZodMiniTemplateLiteral<`0x${string}`>;
             init: z.ZodMiniOptional<z.ZodMiniObject<{
                 salt: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
                 threshold: z.ZodMiniNumber<number>;

package/dist/zod/tempo/ZoneRpcAuthentication.d.ts

@@ -61,7 +61,7 @@ export declare const Signed: z.ZodMiniObject<{
         version: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"v1">, z.ZodMiniLiteral<"v2">]>>;
     }, z.core.$strip>, z.ZodMiniObject<{
         account: z.ZodMiniTemplateLiteral<`0x${string}`>;
-        configId: z.ZodMiniTemplateLiteral<`0x${string}`>;
+        genesisConfigId: z.ZodMiniTemplateLiteral<`0x${string}`>;
         init: z.ZodMiniOptional<z.ZodMiniObject<{
             salt: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
             threshold: z.ZodMiniNumber<number>;
@@ -123,7 +123,7 @@ export declare const ZoneRpcAuthentication: z.ZodMiniUnion<readonly [z.ZodMiniOb
         version: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"v1">, z.ZodMiniLiteral<"v2">]>>;
     }, z.core.$strip>, z.ZodMiniObject<{
         account: z.ZodMiniTemplateLiteral<`0x${string}`>;
-        configId: z.ZodMiniTemplateLiteral<`0x${string}`>;
+        genesisConfigId: z.ZodMiniTemplateLiteral<`0x${string}`>;
         init: z.ZodMiniOptional<z.ZodMiniObject<{
             salt: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
             threshold: z.ZodMiniNumber<number>;
@@ -192,7 +192,7 @@ export declare const serialized: z.ZodMiniCodec<z.ZodMiniTemplateLiteral<`0x${st
         version: z.ZodMiniOptional<z.ZodMiniUnion<readonly [z.ZodMiniLiteral<"v1">, z.ZodMiniLiteral<"v2">]>>;
     }, z.core.$strip>, z.ZodMiniObject<{
         account: z.ZodMiniTemplateLiteral<`0x${string}`>;
-        configId: z.ZodMiniTemplateLiteral<`0x${string}`>;
+        genesisConfigId: z.ZodMiniTemplateLiteral<`0x${string}`>;
         init: z.ZodMiniOptional<z.ZodMiniObject<{
             salt: z.ZodMiniOptional<z.ZodMiniTemplateLiteral<`0x${string}`>>;
             threshold: z.ZodMiniNumber<number>;

package/package.json

@@ -2,7 +2,7 @@
   "name": "ox",
   "description": "Ethereum Standard Library",
   "type": "module",
-  "version": "1.0.0-beta.0",
+  "version": "1.0.0-beta.2",
   "main": "./dist/index.js",
   "sideEffects": false,
   "license": "MIT",

package/src/CHANGELOG.md

@@ -1,5 +1,11 @@
 # ox
 
+## 0.14.29
+
+### Patch Changes
+
+- [#268](https://github.com/wevm/ox/pull/268) [`ed93945`](https://github.com/wevm/ox/commit/ed93945197dd505d4848535de72a93c225fa8466) Thanks [@jxom](https://github.com/jxom)! - `viem/tempo`: Added `genesisConfig` shorthand to TIP-1061 multisig helpers and renamed `configId` → `genesisConfigId` on the typed `SignatureEnvelope.Multisig`.
+
 ## 0.14.28
 
 ### Patch Changes

package/src/core/Provider.ts

@@ -14,7 +14,7 @@ export type Options = {
    *
    * @default `RpcSchema.Generic`
    */
-  schema?: RpcSchema.Generic | undefined
+  schema?: RpcSchema.Schema | undefined
 }
 
 /** Root type for an EIP-1193 Provider. */
@@ -23,9 +23,9 @@ export type Provider<
   eventMap extends boolean | Record<string, unknown> = false,
   ///
   _schema extends RpcSchema.Generic = options extends {
-    schema: infer schema extends RpcSchema.Generic
+    schema: infer schema extends RpcSchema.Schema
   }
-    ? schema
+    ? RpcSchema.ToGeneric<schema>
     : RpcSchema.Default,
 > = Compute<
   {
@@ -499,9 +499,9 @@ export declare namespace from {
   > & {
     request: (
       parameters: options extends {
-        schema: infer schema extends RpcSchema.Generic
+        schema: infer schema extends RpcSchema.Schema
       }
-        ? schema['Request']
+        ? RpcSchema.ToGeneric<schema>['Request']
         : RpcSchema.Generic['Request'],
     ) => unknown
   }
@@ -513,8 +513,8 @@ export declare namespace from {
       | undefined,
   > = Omit<provider, 'request'> & {
     request: RequestFn<
-      options extends { schema: infer schema extends RpcSchema.Generic }
-        ? schema
+      options extends { schema: infer schema extends RpcSchema.Schema }
+        ? RpcSchema.ToGeneric<schema>
         : RpcSchema.Default
     >
   }

package/src/core/RpcSchema.ts

@@ -1,3 +1,4 @@
+import type * as z from 'zod/mini'
 import type { ResolvedRegister } from './internal/register.js'
 import type { Compute, IsNarrowable } from './internal/types.js'
 
@@ -281,6 +282,65 @@ export type FromViem<schema extends readonly ViemSchemaItem[]> = {
     : never
 }[number]
 
+/**
+ * Converts a record of Zod `params`/`returns` schemas (keyed by method name) to
+ * an Ox {@link ox#RpcSchema.Generic} (union of `{ Request, ReturnType }`).
+ *
+ * Each method's name comes from its key. Both `params` and `ReturnType` are
+ * derived from the Zod schema's input (wire) type, since raw JSON-RPC clients
+ * send and receive wire values. Decode wire results to their native
+ * representation explicitly via {@link ox#zod/RpcSchema.decodeReturns}.
+ *
+ * @example
+ * ```ts twoslash
+ * import { RpcSchema } from 'ox'
+ * import { z } from 'ox/zod'
+ *
+ * type Schema = RpcSchema.FromZod<typeof z.RpcSchema.Eth>
+ * //   ^?
+ * ```
+ */
+export type FromZod<namespace extends FromZod.Namespace> = {
+  [method in keyof namespace & string]: Compute<{
+    Request: {
+      method: method
+      params: z.input<namespace[method]['params']>
+    }
+    ReturnType: z.input<namespace[method]['returns']>
+  }>
+}[keyof namespace & string]
+
+export declare namespace FromZod {
+  /** A single method schema: Zod `params`/`returns`, keyed by method name. */
+  type Item = {
+    params: z.ZodMiniType
+    returns: z.ZodMiniType
+  }
+
+  /** A record of Zod method schemas keyed by method name. */
+  type Namespace = Record<string, Item>
+}
+
+/**
+ * Schema input accepted by APIs that statically type JSON-RPC requests
+ * (e.g. {@link ox#Provider.(from:function)}, {@link ox#RpcTransport.(fromHttp:function)}):
+ * either an Ox {@link ox#RpcSchema.Generic} or a record of Zod `params`/`returns`
+ * schemas (keyed by method name) from `ox/zod`.
+ */
+export type Schema = Generic | FromZod.Namespace
+
+/**
+ * Resolves a {@link ox#RpcSchema.Schema} input to an Ox {@link ox#RpcSchema.Generic}.
+ * A Zod namespace is converted via {@link ox#RpcSchema.FromZod}; a `Generic` is
+ * passed through; otherwise falls back to {@link ox#RpcSchema.Default}.
+ */
+export type ToGeneric<schema extends Schema | undefined> =
+  schema extends FromZod.Namespace
+    ? FromZod<schema>
+    : schema extends Generic
+      ? schema
+      : Default
+
 /** @internal */
 type ViemSchemaItem = {
   Method: string

package/src/core/RpcTransport.ts

@@ -81,9 +81,12 @@ export type RequestFn<
  */
 export function fromHttp<
   raw extends boolean = false,
-  schema extends RpcSchema.Generic = RpcSchema.Default,
->(url: string, options: fromHttp.Options<raw, schema> = {}): Http<raw, schema> {
-  return internal.create<HttpOptions, schema, raw>(
+  schema extends RpcSchema.Schema = RpcSchema.Default,
+>(
+  url: string,
+  options: fromHttp.Options<raw, schema> = {},
+): Http<raw, RpcSchema.ToGeneric<schema>> {
+  return internal.create<HttpOptions, RpcSchema.ToGeneric<schema>, raw>(
     {
       async request(body_, options_) {
         const {
@@ -175,7 +178,7 @@ export function fromHttp<
 export declare namespace fromHttp {
   type Options<
     raw extends boolean = false,
-    schema extends RpcSchema.Generic = RpcSchema.Default,
+    schema extends RpcSchema.Schema = RpcSchema.Default,
   > = internal.Options<raw, HttpOptions, schema>
 
   type ErrorType =

package/src/core/_test/Provider.test-d.ts

@@ -1,4 +1,5 @@
 import { Provider, RpcSchema } from 'ox'
+import { z } from 'ox/zod'
 import { describe, expectTypeOf, test } from 'vp/test'
 
 describe('Provider.createEmitter', () => {
@@ -132,6 +133,26 @@ describe('Provider.from', () => {
     ).resolves.toEqualTypeOf<`0x${string}`>()
   })
 
+  test('with zod schema', () => {
+    const schema = z.RpcSchema.from({
+      abe_foo: {
+        params: z.tuple([z.number()]),
+        returns: z.string(),
+      },
+    })
+
+    const provider = Provider.from(
+      {
+        request: async (args) => args,
+      },
+      { schema },
+    )
+
+    expectTypeOf(
+      provider.request({ method: 'abe_foo', params: [123] }),
+    ).resolves.toEqualTypeOf<string>()
+  })
+
   test('with emitter', () => {
     const emitter = Provider.createEmitter()
     const provider = Provider.from({

package/src/core/_test/RpcSchema.test-d.ts

@@ -1,4 +1,5 @@
-import type { RpcSchema } from 'ox'
+import { RpcSchema } from 'ox'
+import { z } from 'ox/zod'
 import { expectTypeOf, test } from 'vp/test'
 
 test('ToViem: converts ox schema to viem schema', () => {
@@ -116,3 +117,88 @@ test('roundtrip: FromViem -> ToViem preserves schema', () => {
   expectTypeOf<Roundtrip[0]['Method']>().toEqualTypeOf<'eth_blockNumber'>()
   expectTypeOf<Roundtrip[0]['ReturnType']>().toEqualTypeOf<`0x${string}`>()
 })
+
+test('FromZod: derives Generic from a record of zod schemas', () => {
+  const namespace = {
+    eth_blockNumber: {
+      params: z.optional(z.tuple([])),
+      returns: z.Hex.Hex,
+    },
+    abe_foo: {
+      params: z.tuple([z.number()]),
+      returns: z.string(),
+    },
+  }
+
+  type Schema = RpcSchema.FromZod<typeof namespace>
+
+  type MethodName = RpcSchema.ExtractMethodName<Schema>
+  expectTypeOf<MethodName>().toEqualTypeOf<'eth_blockNumber' | 'abe_foo'>()
+
+  expectTypeOf<
+    RpcSchema.ExtractReturnType<Schema, 'eth_blockNumber'>
+  >().toEqualTypeOf<`0x${string}`>()
+  expectTypeOf<
+    RpcSchema.ExtractReturnType<Schema, 'abe_foo'>
+  >().toEqualTypeOf<string>()
+  expectTypeOf<RpcSchema.ExtractParams<Schema, 'abe_foo'>>().toEqualTypeOf<
+    [number]
+  >()
+})
+
+test('FromZod: accepts an ox/zod namespace', () => {
+  type Schema = RpcSchema.FromZod<typeof z.RpcSchema.Eth>
+
+  expectTypeOf<
+    RpcSchema.ExtractReturnType<Schema, 'eth_blockNumber'>
+  >().toEqualTypeOf<`0x${string}`>()
+})
+
+test('ToGeneric: resolves a zod namespace to a Generic', () => {
+  const namespace = {
+    abe_foo: {
+      params: z.tuple([z.number()]),
+      returns: z.string(),
+    },
+  }
+
+  type Schema = RpcSchema.ToGeneric<typeof namespace>
+
+  expectTypeOf<
+    RpcSchema.ExtractReturnType<Schema, 'abe_foo'>
+  >().toEqualTypeOf<string>()
+  expectTypeOf<RpcSchema.ExtractParams<Schema, 'abe_foo'>>().toEqualTypeOf<
+    [number]
+  >()
+})
+
+test('ToGeneric: passes a Generic through', () => {
+  type Schema = RpcSchema.ToGeneric<{
+    Request: { method: 'abe_bar'; params: [id: string] }
+    ReturnType: string
+  }>
+
+  expectTypeOf<
+    RpcSchema.ExtractReturnType<Schema, 'abe_bar'>
+  >().toEqualTypeOf<string>()
+})
+
+test('ToGeneric: falls back to Default for undefined', () => {
+  expectTypeOf<
+    RpcSchema.ToGeneric<undefined>
+  >().toEqualTypeOf<RpcSchema.Default>()
+})
+
+test('from: no-arg type tag still works', () => {
+  const schema = RpcSchema.from<
+    | RpcSchema.Default
+    | {
+        Request: { method: 'abe_bar'; params: [id: string] }
+        ReturnType: string
+      }
+  >()
+
+  expectTypeOf<
+    RpcSchema.ExtractReturnType<typeof schema, 'abe_bar'>
+  >().toEqualTypeOf<string>()
+})

package/src/core/_test/RpcTransport.test-d.ts

@@ -0,0 +1,43 @@
+import { RpcSchema, RpcTransport } from 'ox'
+import { z } from 'ox/zod'
+import { describe, expectTypeOf, test } from 'vp/test'
+
+describe('fromHttp', () => {
+  test('default schema', () => {
+    const transport = RpcTransport.fromHttp('https://example.com')
+    expectTypeOf(
+      transport.request({ method: 'eth_blockNumber' }),
+    ).resolves.toEqualTypeOf<`0x${string}`>()
+  })
+
+  test('with custom generic schema', () => {
+    const schema = RpcSchema.from<
+      | RpcSchema.Default
+      | {
+          Request: { method: 'abe_foo'; params: [id: number] }
+          ReturnType: string
+        }
+    >()
+
+    const transport = RpcTransport.fromHttp('https://example.com', { schema })
+
+    expectTypeOf(
+      transport.request({ method: 'abe_foo', params: [123] }),
+    ).resolves.toEqualTypeOf<string>()
+  })
+
+  test('with zod schema', () => {
+    const schema = z.RpcSchema.from({
+      abe_foo: {
+        params: z.tuple([z.number()]),
+        returns: z.string(),
+      },
+    })
+
+    const transport = RpcTransport.fromHttp('https://example.com', { schema })
+
+    expectTypeOf(
+      transport.request({ method: 'abe_foo', params: [123] }),
+    ).resolves.toEqualTypeOf<string>()
+  })
+})

package/src/core/internal/rpcTransport.ts

@@ -9,7 +9,7 @@ import type { Compute } from './types.js'
 export type Options<
   raw extends boolean | undefined = undefined,
   options extends Record<string, unknown> = {},
-  schema extends RpcSchema.Generic = RpcSchema.Default,
+  schema extends RpcSchema.Schema = RpcSchema.Default,
 > = {
   /**
    * Enables raw mode – responses will return an object with `result` and `error` properties instead of returning the `result` directly and throwing errors.

package/src/index.ts

@@ -1515,6 +1515,8 @@ export * as Ens from './core/Ens.js'
 
 export * as Errors from './core/Errors.js'
 /**
+ * Utility types for working with Ethereum transaction fees and fee history.
+ *
  * @category Execution Spec
  */
 export * as Fee from './core/Fee.js'

package/src/tempo/MultisigConfig.test.ts

@@ -30,7 +30,7 @@ describe('from', () => {
   })
 })
 
-describe('configId', () => {
+describe('genesisConfigId', () => {
   test('matches independent ground truth', () => {
     expect(MultisigConfig.toId(singleOwnerConfig)).toMatchInlineSnapshot(
       `"0xd1f20e1a5bfdd89488f57f68db5bd1aae9a51b510f4a042b2604b57a0b7b471d"`,
@@ -64,15 +64,15 @@ describe('configId', () => {
 
 describe('getAddress', () => {
   test('matches independent ground truth', () => {
-    expect(
-      MultisigConfig.getAddress({ config: singleOwnerConfig }),
-    ).toMatchInlineSnapshot(`"0x6ca655065b1de473d903eebd50e5cb4996e10468"`)
+    expect(MultisigConfig.getAddress(singleOwnerConfig)).toMatchInlineSnapshot(
+      `"0x6ca655065b1de473d903eebd50e5cb4996e10468"`,
+    )
   })
 
-  test('derives from config or configId identically', () => {
-    const configId = MultisigConfig.toId(singleOwnerConfig)
-    expect(MultisigConfig.getAddress({ configId })).toBe(
-      MultisigConfig.getAddress({ config: singleOwnerConfig }),
+  test('derives from positional config or `{ genesisConfigId }` identically', () => {
+    const genesisConfigId = MultisigConfig.toId(singleOwnerConfig)
+    expect(MultisigConfig.getAddress({ genesisConfigId })).toBe(
+      MultisigConfig.getAddress(singleOwnerConfig),
     )
   })
 
@@ -86,18 +86,27 @@ describe('getAddress', () => {
 
 describe('getSignPayload', () => {
   test('matches independent ground truth', () => {
-    const configId = MultisigConfig.toId(singleOwnerConfig)
-    const account = MultisigConfig.getAddress({ configId })
     expect(
       MultisigConfig.getSignPayload({
         payload: `0x${'42'.repeat(32)}`,
-        account,
-        configId,
+        genesisConfig: singleOwnerConfig,
       }),
     ).toMatchInlineSnapshot(
       `"0xe3d66f6118b89a67c71c8137c46abf0c829056a46ee6a038a1b42c84529fc17e"`,
     )
   })
+
+  test('behavior: `genesisConfig` and `{account, genesisConfigId}` produce identical digests', () => {
+    const genesisConfigId = MultisigConfig.toId(singleOwnerConfig)
+    const account = MultisigConfig.getAddress({ genesisConfigId })
+    const payload = `0x${'42'.repeat(32)}` as const
+    expect(
+      MultisigConfig.getSignPayload({
+        payload,
+        genesisConfig: singleOwnerConfig,
+      }),
+    ).toBe(MultisigConfig.getSignPayload({ payload, account, genesisConfigId }))
+  })
 })
 
 describe('toTuple / fromTuple', () => {