ox 0.14.32 → 0.14.34

package/tempo/MultisigConfig.ts

@@ -6,7 +6,7 @@ import * as Hex from '../core/Hex.js'
 import type { Compute, OneOf } from '../core/internal/types.js'
 
 /** Maximum number of owners allowed in a native multisig config. */
-export const maxOwners = 255
+export const maxOwners = 50
 
 /** Maximum threshold accepted by a native multisig config. */
 export const maxThreshold = 8
@@ -20,7 +20,7 @@ export const maxSignatures = maxThreshold
  */
 export const maxNestingDepth = 2
 
-/** Maximum encoded byte length for one owner approval. */
+/** Maximum encoded byte length for one primitive owner approval. */
 export const maxOwnerSignatureBytes = 2049
 
 /** Tempo signature type byte for native multisig signatures. */
@@ -224,14 +224,14 @@ export function fromTuple(tuple: Tuple): Config {
  * ```ts twoslash
  * import { MultisigConfig } from 'ox/tempo'
  *
- * const genesisConfig = MultisigConfig.from({
+ * const initialConfig = MultisigConfig.from({
  *   threshold: 1,
  *   owners: [
  *     { owner: '0x1111111111111111111111111111111111111111', weight: 1 },
  *   ],
  * })
  *
- * const address = MultisigConfig.getAddress(genesisConfig)
+ * const address = MultisigConfig.getAddress(initialConfig)
  * ```
  *
  * @param config - The initial (bootstrap) multisig config.
@@ -272,13 +272,13 @@ export declare namespace getAddress {
 /**
  * Computes the digest a native multisig owner approves (signs).
  *
- * `keccak256("tempo:multisig:signature" || inner_digest || account)`,
+ * `keccak256("tempo:multisig:signature" || inner_digest || account || uint64be(version))`,
  * where `inner_digest` is the transaction sign payload
  * ({@link ox#TxEnvelopeTempo.(getSignPayload:function)}).
  *
- * The digest is keyed on the permanent `account` derived from the genesis
- * (bootstrap) config — config updates never change it, so the genesis config
- * is the correct input even for post-update transactions.
+ * The digest is keyed on the permanent `account` derived from the initial
+ * (bootstrap) config and the current config `version`. Bootstrap approvals use
+ * version `0n`, which is also the default; each config update increments it.
  *
  * For a nested multisig owner approval, the parent digest becomes the nested
  * approval's `payload`, with the nested multisig `account`.
@@ -287,7 +287,7 @@ export declare namespace getAddress {
  * ```ts twoslash
  * import { MultisigConfig, TxEnvelopeTempo } from 'ox/tempo'
  *
- * const genesisConfig = MultisigConfig.from({
+ * const initialConfig = MultisigConfig.from({
  *   threshold: 1,
  *   owners: [
  *     { owner: '0x1111111111111111111111111111111111111111', weight: 1 },
@@ -301,7 +301,7 @@ export declare namespace getAddress {
  *
  * const digest = MultisigConfig.getSignPayload({
  *   payload: TxEnvelopeTempo.getSignPayload(envelope),
- *   genesisConfig,
+ *   initialConfig,
  * })
  * ```
  *
@@ -314,19 +314,20 @@ export declare namespace getAddress {
  * ```ts twoslash
  * import { MultisigConfig, TxEnvelopeTempo } from 'ox/tempo'
  *
- * const genesisConfig = MultisigConfig.from({
+ * const initialConfig = MultisigConfig.from({
  *   threshold: 1,
  *   owners: [
  *     { owner: '0x1111111111111111111111111111111111111111', weight: 1 },
  *   ],
  * })
- * const account = MultisigConfig.getAddress(genesisConfig)
+ * const account = MultisigConfig.getAddress(initialConfig)
  *
  * const envelope = TxEnvelopeTempo.from({ chainId: 1, calls: [] })
  *
  * const digest = MultisigConfig.getSignPayload({
  *   payload: TxEnvelopeTempo.getSignPayload(envelope),
- *   account
+ *   account,
+ *   version: 1n
  * })
  * ```
  *
@@ -334,13 +335,18 @@ export declare namespace getAddress {
  * @returns The owner approval digest.
  */
 export function getSignPayload(value: getSignPayload.Value): Hex.Hex {
-  const { payload } = value
+  const { payload, version = 0n } = value
   const account =
     'account' in value && value.account
       ? value.account
-      : getAddress((value as { genesisConfig: Config }).genesisConfig)
+      : getAddress((value as { initialConfig: Config }).initialConfig)
   return Hash.keccak256(
-    Hex.concat(Hex.fromString(signatureDomain), Hex.from(payload), account),
+    Hex.concat(
+      Hex.fromString(signatureDomain),
+      Hex.from(payload),
+      account,
+      Hex.fromNumber(version, { size: 8 }),
+    ),
   )
 }
 
@@ -348,6 +354,8 @@ export declare namespace getSignPayload {
   type Value = {
     /** The inner transaction sign payload (`tx.signature_hash()`). */
     payload: Hex.Hex | Bytes.Bytes
+    /** Current multisig config version. Defaults to `0n`. */
+    version?: bigint | undefined
   } & OneOf<
     | {
         /** The native multisig account address. */
@@ -357,10 +365,10 @@ export declare namespace getSignPayload {
         /**
          * The initial multisig config (the bootstrap config that derived the
          * permanent `account`). Used to derive the account automatically.
-         * Config updates never change `account`, so the genesis config is
-         * also the correct input for post-update transactions.
+         * Config updates never change `account`, so the initial config can
+         * continue deriving the account for post-update transactions.
          */
-        genesisConfig: Config
+        initialConfig: Config
       }
   >
 
@@ -369,6 +377,7 @@ export declare namespace getSignPayload {
     | Hash.keccak256.ErrorType
     | Hex.concat.ErrorType
     | Hex.from.ErrorType
+    | Hex.fromNumber.ErrorType
     | Errors.GlobalErrorType
 }
 

package/tempo/SignatureEnvelope.test.ts

@@ -1100,7 +1100,7 @@ describe('from', () => {
   })
 
   describe('multisig', () => {
-    const genesisConfig = MultisigConfig.from({
+    const initialConfig = MultisigConfig.from({
       threshold: 1,
       owners: [
         {
@@ -1110,29 +1110,29 @@ describe('from', () => {
       ],
     })
 
-    test('behavior: derives `account` from `genesisConfig`', () => {
+    test('behavior: derives `account` from `initialConfig`', () => {
       const envelope = SignatureEnvelope.from({
-        genesisConfig,
+        initialConfig,
         signatures: [SignatureEnvelope.from(signature_secp256k1)],
       })
 
       expect(envelope).toMatchObject({
         type: 'multisig',
-        account: MultisigConfig.getAddress(genesisConfig),
+        account: MultisigConfig.getAddress(initialConfig),
       })
-      expect('genesisConfig' in envelope).toBe(false)
+      expect('initialConfig' in envelope).toBe(false)
       expect((envelope as SignatureEnvelope.Multisig).init).toBeUndefined()
     })
 
-    test('behavior: `init: true` opts into bootstrap (uses `genesisConfig` as `init`)', () => {
+    test('behavior: `init: true` opts into bootstrap (uses `initialConfig` as `init`)', () => {
       const envelope = SignatureEnvelope.from({
-        genesisConfig,
+        initialConfig,
         signatures: [SignatureEnvelope.from(signature_secp256k1)],
         init: true,
       })
 
       expect((envelope as SignatureEnvelope.Multisig).init).toEqual(
-        genesisConfig,
+        initialConfig,
       )
     })
 
@@ -1147,7 +1147,7 @@ describe('from', () => {
         ],
       })
       const envelope = SignatureEnvelope.from({
-        genesisConfig,
+        initialConfig,
         signatures: [SignatureEnvelope.from(signature_secp256k1)],
         init: otherConfig,
       })
@@ -1156,7 +1156,7 @@ describe('from', () => {
     })
 
     test('behavior: `{ account }` form still works', () => {
-      const account = MultisigConfig.getAddress(genesisConfig)
+      const account = MultisigConfig.getAddress(initialConfig)
       const envelope = SignatureEnvelope.from({
         account,
         signatures: [SignatureEnvelope.from(signature_secp256k1)],
@@ -1769,7 +1769,7 @@ describe('serialize', () => {
 })
 
 describe('sortMultisigApprovals', () => {
-  // Build owner key pairs first so we can construct a real genesis config
+  // Build owner key pairs first so we can construct a real initial config
   // whose owner set matches the keys that produce the approvals below.
   const ownerKeys = Array.from({ length: 3 }, () => {
     const privateKey = Secp256k1.randomPrivateKey()
@@ -1782,12 +1782,15 @@ describe('sortMultisigApprovals', () => {
     Hex.toBigInt(a.address) < Hex.toBigInt(b.address) ? -1 : 1,
   )
 
-  const genesisConfig = MultisigConfig.from({
+  const initialConfig = MultisigConfig.from({
     threshold: 2,
     owners: ascendingOwners.map((o) => ({ owner: o.address, weight: 1 })),
   })
   const payload = `0x${'42'.repeat(32)}` as const
-  const digest = MultisigConfig.getSignPayload({ payload, genesisConfig })
+  const digest = MultisigConfig.getSignPayload({
+    payload,
+    initialConfig,
+  })
 
   const owners = ownerKeys.map((owner) => ({
     address: owner.address,
@@ -1802,7 +1805,7 @@ describe('sortMultisigApprovals', () => {
 
   test('behavior: orders approvals ascending by recovered owner address', () => {
     const ordered = SignatureEnvelope.sortMultisigApprovals({
-      genesisConfig,
+      initialConfig,
       payload,
       // Provide approvals in reverse of the canonical order.
       signatures: [...ascending].reverse().map((owner) => owner.signature),
@@ -1814,7 +1817,7 @@ describe('sortMultisigApprovals', () => {
     const signatures = ascending.map((owner) => owner.signature)
     expect(
       SignatureEnvelope.sortMultisigApprovals({
-        genesisConfig,
+        initialConfig,
         payload,
         signatures,
       }),
@@ -1823,7 +1826,7 @@ describe('sortMultisigApprovals', () => {
 
   test('behavior: recovered order matches the config owner order', () => {
     const ordered = SignatureEnvelope.sortMultisigApprovals({
-      genesisConfig,
+      initialConfig,
       payload,
       signatures: owners.map((owner) => owner.signature),
     })
@@ -1833,12 +1836,12 @@ describe('sortMultisigApprovals', () => {
     expect(recovered).toEqual(ascending.map((owner) => owner.address))
   })
 
-  test('behavior: `genesisConfig` and `{ account }` produce identical ordering', () => {
-    const account = MultisigConfig.getAddress(genesisConfig)
+  test('behavior: `initialConfig` and `{ account }` produce identical ordering', () => {
+    const account = MultisigConfig.getAddress(initialConfig)
     const signatures = owners.map((owner) => owner.signature)
 
     const fromConfig = SignatureEnvelope.sortMultisigApprovals({
-      genesisConfig,
+      initialConfig,
       payload,
       signatures,
     })
@@ -3013,6 +3016,14 @@ describe('multisig', () => {
     ).toThrowErrorMatchingInlineSnapshot(
       `[SignatureEnvelope.InvalidMultisigApprovalError: Invalid native multisig owner approval: multisig owner signature exceeds 2049 bytes.]`,
     )
+
+    const serialized = Hex.concat(
+      '0x05',
+      Rlp.fromHex([account, [SignatureEnvelope.serialize(oversized)]]),
+    )
+    expect(() => SignatureEnvelope.deserialize(serialized)).toThrowError(
+      SignatureEnvelope.InvalidSerializedError,
+    )
   })
 
   test('assert: rejects keychain owner approvals', () => {
@@ -3054,6 +3065,40 @@ describe('multisig', () => {
       expect(() => SignatureEnvelope.assert(depth2)).not.toThrowError()
     })
 
+    test('accepts a nested approval above the primitive byte limit', () => {
+      const primitive = SignatureEnvelope.from({
+        ...signature_webauthn,
+        metadata: {
+          ...signature_webauthn.metadata,
+          clientDataJSON: JSON.stringify({ value: 'x'.repeat(1_050) }),
+        },
+        signature: {
+          r: signature_webauthn.signature.r,
+          s: signature_webauthn.signature.s,
+        },
+      })
+      const largeNested = SignatureEnvelope.from({
+        type: 'multisig',
+        account: nestedAccount,
+        signatures: [primitive, primitive],
+      })
+      expect(Hex.size(SignatureEnvelope.serialize(primitive))).toBeLessThan(
+        MultisigConfig.maxOwnerSignatureBytes,
+      )
+      expect(
+        Hex.size(SignatureEnvelope.serialize(largeNested)),
+      ).toBeGreaterThan(MultisigConfig.maxOwnerSignatureBytes)
+
+      const parent = SignatureEnvelope.from({
+        type: 'multisig',
+        account,
+        signatures: [largeNested],
+      })
+      expect(
+        SignatureEnvelope.deserialize(SignatureEnvelope.serialize(parent)),
+      ).toEqual(parent)
+    })
+
     test('assert: rejects nesting deeper than the maximum', () => {
       const depth3 = SignatureEnvelope.from({
         type: 'multisig',

package/tempo/SignatureEnvelope.ts

@@ -424,12 +424,13 @@ function assertMultisig(envelope: Multisig, depth: number): void {
           reason: 'nested multisig owner approvals cannot carry `init`',
         })
       assertMultisig(multisig, depth + 1)
-    } else assert(inner)
-
-    if (Hex.size(serialize(inner)) > MultisigConfig.maxOwnerSignatureBytes)
-      throw new InvalidMultisigApprovalError({
-        reason: `multisig owner signature exceeds ${MultisigConfig.maxOwnerSignatureBytes} bytes`,
-      })
+    } else {
+      assert(inner)
+      if (Hex.size(serialize(inner)) > MultisigConfig.maxOwnerSignatureBytes)
+        throw new InvalidMultisigApprovalError({
+          reason: `multisig owner signature exceeds ${MultisigConfig.maxOwnerSignatureBytes} bytes`,
+        })
+    }
   }
 }
 
@@ -740,7 +741,10 @@ function deserialize_(
       })
     for (const signature of signatures)
       if (
-        Hex.size(signature as Hex.Hex) > MultisigConfig.maxOwnerSignatureBytes
+        Hex.size(signature as Hex.Hex) >
+          MultisigConfig.maxOwnerSignatureBytes &&
+        Hex.slice(signature as Hex.Hex, 0, 1) !==
+          MultisigConfig.signatureTypeByte
       )
         throw new InvalidSerializedError({
           reason: `multisig owner signature exceeds ${MultisigConfig.maxOwnerSignatureBytes} bytes`,
@@ -912,17 +916,17 @@ function deserialize_(
  * ```
  *
  * @example
- * ### Multisig (from genesis config)
+ * ### Multisig (from initial config)
  *
- * Pass `genesisConfig` to derive `account` automatically. Set `init: true` to
- * opt into bootstrap (uses `genesisConfig` as the bootstrap `init`); omit
+ * Pass `initialConfig` to derive `account` automatically. Set `init: true` to
+ * opt into bootstrap (uses `initialConfig` as the bootstrap `init`); omit
  * `init` for subsequent (non-bootstrap) transactions.
  *
  * ```ts twoslash
  * import { Secp256k1 } from 'ox'
  * import { MultisigConfig, SignatureEnvelope } from 'ox/tempo'
  *
- * const genesisConfig = MultisigConfig.from({
+ * const initialConfig = MultisigConfig.from({
  *   threshold: 1,
  *   owners: [
  *     { owner: '0x1111111111111111111111111111111111111111', weight: 1 },
@@ -936,14 +940,14 @@ function deserialize_(
  *
  * // Bootstrap transaction
  * const bootstrap = SignatureEnvelope.from({
- *   genesisConfig,
+ *   initialConfig,
  *   signatures: [signature],
  *   init: true,
  * })
  *
  * // Subsequent (non-bootstrap) transactions
  * const subsequent = SignatureEnvelope.from({
- *   genesisConfig,
+ *   initialConfig,
  *   signatures: [signature],
  * })
  * ```
@@ -970,20 +974,20 @@ export function from<const value extends from.Value>(
 
   if (type === 'multisig') {
     const multisig = value as Multisig & {
-      genesisConfig?: MultisigConfig.Config | undefined
+      initialConfig?: MultisigConfig.Config | undefined
       init?: MultisigConfig.Config | boolean | undefined
     }
-    const { genesisConfig, init, ...rest } = multisig
-    // Derive `account` from `genesisConfig` when not provided explicitly.
+    const { initialConfig, init, ...rest } = multisig
+    // Derive `account` from `initialConfig` when not provided explicitly.
     const account = (() => {
       if (rest.account) return rest.account
-      if (genesisConfig) return MultisigConfig.getAddress(genesisConfig)
+      if (initialConfig) return MultisigConfig.getAddress(initialConfig)
       return rest.account
     })()
-    // `init: true` opts into bootstrap using the supplied `genesisConfig`.
+    // `init: true` opts into bootstrap using the supplied `initialConfig`.
     // Otherwise, `init` is treated as the explicit bootstrap config (or
     // omitted).
-    const initSource = init === true ? genesisConfig : init || undefined
+    const initSource = init === true ? initialConfig : init || undefined
     return {
       ...rest,
       account,
@@ -1039,13 +1043,13 @@ export declare namespace from {
 
   /**
    * Multisig envelope input variant where `account` is derived from the
-   * supplied `genesisConfig`. Pass `init: true` to opt into bootstrap (uses
-   * `genesisConfig` as the bootstrap `init`); omit `init` for subsequent
+   * supplied `initialConfig`. Pass `init: true` to opt into bootstrap (uses
+   * `initialConfig` as the bootstrap `init`); omit `init` for subsequent
    * (non-bootstrap) transactions.
    */
-  type MultisigFromGenesisConfig = {
+  type MultisigFromInitialConfig = {
     type?: 'multisig' | undefined
-    genesisConfig: MultisigConfig.Config
+    initialConfig: MultisigConfig.Config
     signatures: readonly SignatureEnvelope[]
     init?: MultisigConfig.Config | boolean | undefined
   }
@@ -1054,7 +1058,7 @@ export declare namespace from {
     | UnionPartialBy<SignatureEnvelope, 'prehash' | 'type'>
     | Secp256k1Flat
     | Serialized
-    | MultisigFromGenesisConfig
+    | MultisigFromInitialConfig
 
   type ReturnValue<value extends Value> = Compute<
     OneOf<
@@ -1062,7 +1066,7 @@ export declare namespace from {
         ? SignatureEnvelope
         : value extends Secp256k1Flat
           ? Secp256k1
-          : value extends MultisigFromGenesisConfig
+          : value extends MultisigFromInitialConfig
             ? Multisig
             : IsNarrowable<value, SignatureEnvelope> extends true
               ? SignatureEnvelope
@@ -1285,7 +1289,7 @@ export function getType<
   // Detect Multisig signature
   if (
     ('account' in envelope ||
-      'genesisConfig' in envelope ||
+      'initialConfig' in envelope ||
       'init' in envelope) &&
     'signatures' in envelope
   )
@@ -1436,7 +1440,7 @@ export declare namespace serialize {
  * recovered owner address. Works for any owner key type (secp256k1, p256,
  * webAuthn).
  *
- * Config updates never change `account`, so the genesis config is the correct
+ * Config updates never change `account`, so the initial config is the correct
  * input even for post-update transactions.
  *
  * @example
@@ -1444,7 +1448,7 @@ export declare namespace serialize {
  * import { Secp256k1 } from 'ox'
  * import { MultisigConfig, SignatureEnvelope, TxEnvelopeTempo } from 'ox/tempo'
  *
- * const genesisConfig = MultisigConfig.from({
+ * const initialConfig = MultisigConfig.from({
  *   threshold: 2,
  *   owners: [
  *     { owner: '0x1111111111111111111111111111111111111111', weight: 1 },
@@ -1455,14 +1459,20 @@ export declare namespace serialize {
  * const tx = TxEnvelopeTempo.from({ chainId: 1, calls: [] })
  * const payload = TxEnvelopeTempo.getSignPayload(tx)
  *
- * const privateKeys = [Secp256k1.randomPrivateKey(), Secp256k1.randomPrivateKey()]
- * const digest = MultisigConfig.getSignPayload({ payload, genesisConfig })
+ * const privateKeys = [
+ *   Secp256k1.randomPrivateKey(),
+ *   Secp256k1.randomPrivateKey(),
+ * ]
+ * const digest = MultisigConfig.getSignPayload({
+ *   payload,
+ *   initialConfig,
+ * })
  * const signatures = privateKeys.map((privateKey) =>
  *   SignatureEnvelope.from(Secp256k1.sign({ payload: digest, privateKey })),
  * )
  *
  * const ordered = SignatureEnvelope.sortMultisigApprovals({ // [!code focus]
- *   genesisConfig, // [!code focus]
+ *   initialConfig, // [!code focus]
  *   payload, // [!code focus]
  *   signatures, // [!code focus]
  * }) // [!code focus]
@@ -1474,11 +1484,15 @@ export declare namespace serialize {
 export function sortMultisigApprovals(
   value: sortMultisigApprovals.Value,
 ): readonly SignatureEnvelope[] {
-  const { payload, signatures } = value
+  const { payload, signatures, version = 0n } = value
   const digest = MultisigConfig.getSignPayload(
-    'genesisConfig' in value && value.genesisConfig
-      ? { payload, genesisConfig: value.genesisConfig }
-      : { payload, account: (value as { account: Address.Address }).account },
+    'initialConfig' in value && value.initialConfig
+      ? { payload, initialConfig: value.initialConfig, version }
+      : {
+          payload,
+          account: (value as { account: Address.Address }).account,
+          version,
+        },
   )
   // Recover each signer once (decorate–sort–undecorate) rather than inside the
   // comparator.
@@ -1497,6 +1511,8 @@ export declare namespace sortMultisigApprovals {
     payload: Hex.Hex | Bytes.Bytes
     /** The owner approvals to order. */
     signatures: readonly SignatureEnvelope[]
+    /** Current multisig config version. Defaults to `0n`. */
+    version?: bigint | undefined
   } & OneOf<
     | {
         /** The native multisig account address. */
@@ -1507,7 +1523,7 @@ export declare namespace sortMultisigApprovals {
          * The initial multisig config (the bootstrap config that derived the
          * permanent `account`). Used to derive the account automatically.
          */
-        genesisConfig: MultisigConfig.Config
+        initialConfig: MultisigConfig.Config
       }
   >
 

package/tempo/ZoneId.test-d/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../../_types/tempo/ZoneId.test-d.d.ts",
+  "main": "../../_cjs/tempo/ZoneId.test-d.js",
+  "module": "../../_esm/tempo/ZoneId.test-d.js"
+}

package/tempo/ZoneId.test-d.ts

@@ -0,0 +1,16 @@
+import { expectTypeOf, test } from 'vitest'
+import * as ZoneId from './ZoneId.js'
+
+test('accepts supported source IDs', () => {
+  expectTypeOf(ZoneId.fromChainId(421_700_001)).toEqualTypeOf<number>()
+  expectTypeOf(
+    ZoneId.fromChainId(1_424_310_001, 42_431),
+  ).toEqualTypeOf<number>()
+  expectTypeOf(ZoneId.toChainId(1)).toEqualTypeOf<number>()
+  expectTypeOf(ZoneId.toChainId(1, 42_431)).toEqualTypeOf<number>()
+
+  // @ts-expect-error Unsupported source ID.
+  ZoneId.fromChainId(421_700_001, 1)
+  // @ts-expect-error Unsupported source ID.
+  ZoneId.toChainId(1, 1)
+})

package/tempo/ZoneId.test.ts

@@ -3,40 +3,75 @@ import * as ZoneId from './ZoneId.js'
 
 describe('fromChainId', () => {
   test('default', () => {
-    expect(ZoneId.fromChainId(4_217_000_006)).toBe(6)
+    expect(ZoneId.chainIdBase).toMatchInlineSnapshot(`421700000`)
+    expect(ZoneId.fromChainId(421_700_001)).toMatchInlineSnapshot(`1`)
   })
 
-  test('zone 1', () => {
-    expect(ZoneId.fromChainId(4_217_000_001)).toBe(1)
+  test('Moderato', () => {
+    expect(ZoneId.fromChainId(1_424_310_028, 42_431)).toMatchInlineSnapshot(
+      `28`,
+    )
   })
 
-  test('zone 28', () => {
-    expect(ZoneId.fromChainId(4_217_000_028)).toBe(28)
+  test('unsupported source id', () => {
+    expect(() =>
+      // @ts-expect-error Unsupported source ID.
+      ZoneId.fromChainId(421_700_001, 1),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      [ZoneId.UnsupportedSourceIdError: Source chain ID "1" is not supported.
+
+      Supported source chain IDs: 4217, 42431.]
+    `)
   })
 })
 
 describe('toChainId', () => {
   test('default', () => {
-    expect(ZoneId.toChainId(6)).toBe(4_217_000_006)
+    expect(ZoneId.toChainId(1)).toMatchInlineSnapshot(`421700001`)
+  })
+
+  test('Moderato', () => {
+    expect(ZoneId.toChainId(28, 42_431)).toMatchInlineSnapshot(`1424310028`)
   })
 
-  test('zone 1', () => {
-    expect(ZoneId.toChainId(1)).toBe(4_217_000_001)
+  test('wraps within the source chain range', () => {
+    expect(ZoneId.toChainId(1_002_610_001)).toMatchInlineSnapshot(`421700001`)
+    expect(ZoneId.toChainId(723_173_649, 42_431)).toMatchInlineSnapshot(
+      `1424310001`,
+    )
   })
 
-  test('zone 28', () => {
-    expect(ZoneId.toChainId(28)).toBe(4_217_000_028)
+  test('unsupported source id', () => {
+    expect(() =>
+      // @ts-expect-error Unsupported source ID.
+      ZoneId.toChainId(1, 1),
+    ).toThrowErrorMatchingInlineSnapshot(`
+      [ZoneId.UnsupportedSourceIdError: Source chain ID "1" is not supported.
+
+      Supported source chain IDs: 4217, 42431.]
+    `)
   })
 })
 
 describe('roundtrip', () => {
   test('fromChainId → toChainId', () => {
-    const chainId = 4_217_000_006
-    expect(ZoneId.toChainId(ZoneId.fromChainId(chainId))).toBe(chainId)
+    const chainId = 421_700_006
+    expect(ZoneId.toChainId(ZoneId.fromChainId(chainId))).toMatchInlineSnapshot(
+      `421700006`,
+    )
   })
 
   test('toChainId → fromChainId', () => {
     const zoneId = 42
-    expect(ZoneId.fromChainId(ZoneId.toChainId(zoneId))).toBe(zoneId)
+    expect(ZoneId.fromChainId(ZoneId.toChainId(zoneId))).toMatchInlineSnapshot(
+      `42`,
+    )
+  })
+
+  test('Moderato', () => {
+    const zoneId = 42
+    const sourceId = 42_431
+    const chainId = ZoneId.toChainId(zoneId, sourceId)
+    expect(ZoneId.fromChainId(chainId, sourceId)).toMatchInlineSnapshot(`42`)
   })
 })