ox 1.0.0-beta.9 → 1.0.0

package/src/erc4337/_test/UserOperation.test.ts

@@ -215,6 +215,52 @@ describe('getSignPayload', () => {
 })
 
 describe('hash', () => {
+  describe('v0.9', () => {
+    const userOperation = {
+      callData: '0x',
+      callGasLimit: 6942069n,
+      maxFeePerGas: 69420n,
+      maxPriorityFeePerGas: 69n,
+      nonce: 0n,
+      paymaster: '0x1234567890123456789012345678901234567890',
+      paymasterData: '0xdeadbeef',
+      paymasterPostOpGasLimit: 6942069n,
+      paymasterVerificationGasLimit: 6942069n,
+      preVerificationGas: 6942069n,
+      sender: '0x1234567890123456789012345678901234567890',
+      signature: '0x',
+      verificationGasLimit: 6942069n,
+    } as const satisfies UserOperation.UserOperation<'0.9', true>
+
+    test('args: paymasterSignature', () => {
+      const options = {
+        chainId: 1,
+        entryPointAddress: '0x433709009B8330FDa32311DF1C2AFA402eD8D009',
+        entryPointVersion: '0.9',
+      } as const
+
+      expect(
+        UserOperation.hash(
+          { ...userOperation, paymasterSignature: '0xcafebabe' },
+          options,
+        ),
+      ).toMatchInlineSnapshot(
+        `"0x802c25af5d98cd349b2118227faa93172fb791c4130a482272095cec45c4fc6e"`,
+      )
+      expect(
+        UserOperation.hash(
+          { ...userOperation, paymasterSignature: '0xdeadbeef' },
+          options,
+        ),
+      ).toMatchInlineSnapshot(
+        `"0x802c25af5d98cd349b2118227faa93172fb791c4130a482272095cec45c4fc6e"`,
+      )
+      expect(UserOperation.hash(userOperation, options)).toMatchInlineSnapshot(
+        `"0xde381ae0368b77df677808c3a2da72abd68a07eab11ef31c35923f56a75bbe6d"`,
+      )
+    })
+  })
+
   describe('v0.8', () => {
     test('default', () => {
       expect(
@@ -818,6 +864,54 @@ describe('toPacked', () => {
       }
     `)
   })
+
+  describe('v0.9 paymasterSignature', () => {
+    const userOperation = {
+      callData: '0x',
+      callGasLimit: 6942069n,
+      maxFeePerGas: 69420n,
+      maxPriorityFeePerGas: 69n,
+      nonce: 0n,
+      paymaster: '0x1234567890123456789012345678901234567890',
+      paymasterData: '0xdeadbeef',
+      paymasterPostOpGasLimit: 6942069n,
+      paymasterSignature: '0xcafebabe',
+      paymasterVerificationGasLimit: 6942069n,
+      preVerificationGas: 6942069n,
+      sender: '0x1234567890123456789012345678901234567890',
+      signature: '0x',
+      verificationGasLimit: 6942069n,
+    } as const satisfies UserOperation.UserOperation<'0.9', true>
+
+    test('default', () => {
+      expect(
+        UserOperation.toPacked(userOperation).paymasterAndData,
+      ).toMatchInlineSnapshot(
+        `"0x12345678901234567890123456789012345678900000000000000000000000000069ed750000000000000000000000000069ed75deadbeefcafebabe000422e325a297439656"`,
+      )
+    })
+
+    test('options: forHash', () => {
+      expect(
+        UserOperation.toPacked(userOperation, { forHash: true })
+          .paymasterAndData,
+      ).toMatchInlineSnapshot(
+        `"0x12345678901234567890123456789012345678900000000000000000000000000069ed750000000000000000000000000069ed75deadbeef22e325a297439656"`,
+      )
+    })
+
+    test('encodes a uint16 signature length', () => {
+      const paymasterSignature = Hex.fromBytes(new Uint8Array(65).fill(0x11))
+      const paymasterAndData = UserOperation.toPacked({
+        ...userOperation,
+        paymasterSignature,
+      }).paymasterAndData
+
+      expect(
+        Hex.slice(paymasterAndData, Hex.size(paymasterAndData) - 10),
+      ).toMatchInlineSnapshot(`"0x004122e325a297439656"`)
+    })
+  })
 })
 
 describe('toInitCode', () => {
@@ -1170,6 +1264,96 @@ describe('toRpc', () => {
       }
     `)
   })
+
+  test('v0.6 preserves paymasterAndData', () => {
+    expect(
+      UserOperation.toRpc({
+        callData: '0x',
+        callGasLimit: 0n,
+        maxFeePerGas: 0n,
+        maxPriorityFeePerGas: 0n,
+        nonce: 0n,
+        paymasterAndData: '0x1234567890123456789012345678901234567890deadbeef',
+        preVerificationGas: 0n,
+        sender: '0x1234567890123456789012345678901234567890',
+        signature: '0x',
+        verificationGasLimit: 0n,
+      } satisfies UserOperation.UserOperation<'0.6', true>),
+    ).toMatchInlineSnapshot(`
+      {
+        "callData": "0x",
+        "callGasLimit": "0x0",
+        "maxFeePerGas": "0x0",
+        "maxPriorityFeePerGas": "0x0",
+        "nonce": "0x0",
+        "paymasterAndData": "0x1234567890123456789012345678901234567890deadbeef",
+        "preVerificationGas": "0x0",
+        "sender": "0x1234567890123456789012345678901234567890",
+        "signature": "0x",
+        "verificationGasLimit": "0x0",
+      }
+    `)
+  })
+
+  test('v0.6 preserves empty paymasterAndData', () => {
+    expect(
+      UserOperation.toRpc({
+        callData: '0x',
+        callGasLimit: 0n,
+        maxFeePerGas: 0n,
+        maxPriorityFeePerGas: 0n,
+        nonce: 0n,
+        paymasterAndData: '0x',
+        preVerificationGas: 0n,
+        sender: '0x1234567890123456789012345678901234567890',
+        signature: '0x',
+        verificationGasLimit: 0n,
+      } satisfies UserOperation.UserOperation<'0.6', true>),
+    ).toMatchInlineSnapshot(`
+      {
+        "callData": "0x",
+        "callGasLimit": "0x0",
+        "maxFeePerGas": "0x0",
+        "maxPriorityFeePerGas": "0x0",
+        "nonce": "0x0",
+        "paymasterAndData": "0x",
+        "preVerificationGas": "0x0",
+        "sender": "0x1234567890123456789012345678901234567890",
+        "signature": "0x",
+        "verificationGasLimit": "0x0",
+      }
+    `)
+  })
+
+  test('v0.9 preserves paymasterSignature', () => {
+    expect(
+      UserOperation.toRpc({
+        callData: '0x',
+        callGasLimit: 0n,
+        maxFeePerGas: 0n,
+        maxPriorityFeePerGas: 0n,
+        nonce: 0n,
+        paymasterSignature: '0xcafebabe',
+        preVerificationGas: 0n,
+        sender: '0x1234567890123456789012345678901234567890',
+        signature: '0x',
+        verificationGasLimit: 0n,
+      } satisfies UserOperation.UserOperation<'0.9', true>),
+    ).toMatchInlineSnapshot(`
+      {
+        "callData": "0x",
+        "callGasLimit": "0x0",
+        "maxFeePerGas": "0x0",
+        "maxPriorityFeePerGas": "0x0",
+        "nonce": "0x0",
+        "paymasterSignature": "0xcafebabe",
+        "preVerificationGas": "0x0",
+        "sender": "0x1234567890123456789012345678901234567890",
+        "signature": "0x",
+        "verificationGasLimit": "0x0",
+      }
+    `)
+  })
 })
 
 describe('toTypedData', () => {
@@ -1465,9 +1649,9 @@ describe('v0.8 authorization round-trip', () => {
     verificationGasLimit: 100_000n,
   } as const satisfies UserOperation.UserOperation<'0.8', true>
 
-  test('toRpc serializes authorization', () => {
+  test('toRpc serializes eip7702Auth', () => {
     const rpc = UserOperation.toRpc(userOperation) as UserOperation.Rpc<'0.8'>
-    expect(rpc.authorization).toMatchInlineSnapshot(`
+    expect(rpc.eip7702Auth).toMatchInlineSnapshot(`
       {
         "address": "0x1234567890123456789012345678901234567890",
         "chainId": "0x1",
@@ -1479,7 +1663,7 @@ describe('v0.8 authorization round-trip', () => {
     `)
   })
 
-  test('fromRpc parses authorization', () => {
+  test('fromRpc parses eip7702Auth', () => {
     const rpc = UserOperation.toRpc(userOperation) as UserOperation.Rpc<'0.8'>
     const parsed = UserOperation.fromRpc(rpc) as UserOperation.UserOperation<
       '0.8',
@@ -1494,9 +1678,41 @@ describe('v0.8 authorization round-trip', () => {
     expect(parsed).toEqual(userOperation)
   })
 
-  test('toRpc omits authorization when absent', () => {
+  test('toRpc omits eip7702Auth when absent', () => {
     const { authorization: _omit, ...rest } = userOperation
     const rpc = UserOperation.toRpc(rest)
-    expect('authorization' in rpc).toBe(false)
+    expect('eip7702Auth' in rpc).toBe(false)
+  })
+})
+
+describe('v0.9 RPC round-trip', () => {
+  test('preserves paymasterSignature and parses eip7702Auth', () => {
+    const userOperation = {
+      authorization: {
+        address: '0x1234567890123456789012345678901234567890',
+        chainId: 1,
+        nonce: 0n,
+        r: '0x0000000000000000000000000000000000000000000000000000000000000001',
+        s: '0x0000000000000000000000000000000000000000000000000000000000000002',
+        yParity: 0,
+      },
+      callData: '0x',
+      callGasLimit: 0n,
+      maxFeePerGas: 0n,
+      maxPriorityFeePerGas: 0n,
+      nonce: 0n,
+      paymasterSignature: '0xcafebabe',
+      preVerificationGas: 0n,
+      sender: '0x1234567890123456789012345678901234567890',
+      signature: '0x',
+      verificationGasLimit: 0n,
+    } as const satisfies UserOperation.UserOperation<'0.9', true>
+
+    const rpc = UserOperation.toRpc(userOperation)
+    const parsed = UserOperation.fromRpc(rpc)
+
+    expect(rpc).toHaveProperty('eip7702Auth')
+    expect(rpc).not.toHaveProperty('authorization')
+    expect(parsed).toEqual(userOperation)
   })
 })

package/src/erc4337/_test/UserOperationGas.test.ts

@@ -1,5 +1,5 @@
 import { UserOperationGas } from 'ox/erc4337'
-import { describe, expect, test } from 'vp/test'
+import { describe, expect, expectTypeOf, test } from 'vp/test'
 
 describe('fromRpc', () => {
   test('default', () => {
@@ -91,3 +91,32 @@ describe('v0.8', () => {
     expect(parsed).toEqual(v08)
   })
 })
+
+describe('v0.9', () => {
+  test('round-trips matching v0.8 shape', () => {
+    const v09 = {
+      callGasLimit: 300_000n,
+      paymasterPostOpGasLimit: 100_000n,
+      paymasterVerificationGasLimit: 100_000n,
+      preVerificationGas: 100_000n,
+      verificationGasLimit: 100_000n,
+    } as const satisfies UserOperationGas.UserOperationGas<'0.9'>
+
+    const rpc = UserOperationGas.toRpc<'0.9'>(v09)
+    const parsed = UserOperationGas.fromRpc<'0.9'>(rpc)
+
+    expectTypeOf(rpc).toEqualTypeOf<UserOperationGas.Rpc<'0.9'>>()
+    expectTypeOf(parsed).toEqualTypeOf<
+      UserOperationGas.UserOperationGas<'0.9'>
+    >()
+    expect(parsed).toMatchInlineSnapshot(`
+      {
+        "callGasLimit": 300000n,
+        "paymasterPostOpGasLimit": 100000n,
+        "paymasterVerificationGasLimit": 100000n,
+        "preVerificationGas": 100000n,
+        "verificationGasLimit": 100000n,
+      }
+    `)
+  })
+})

package/src/tempo/Channel.test.ts

@@ -10,7 +10,7 @@ const channel = {
   payee: '0x2222222222222222222222222222222222222222',
   payer: '0x1111111111111111111111111111111111111111',
   salt: '0x0000000000000000000000000000000000000000000000000000000000000001',
-  token: 1n,
+  token: '0x20c0000000000000000000000000000000000001',
 } as const
 
 const chainId = 4217
@@ -84,26 +84,6 @@ describe('from', () => {
     `)
   })
 
-  test('token address input', () => {
-    expect(
-      Channel.from({
-        ...channel,
-        operator: '0x4444444444444444444444444444444444444444',
-        token: '0x20c0000000000000000000000000000000000001',
-      }),
-    ).toMatchInlineSnapshot(`
-      {
-        "authorizedSigner": "0x3333333333333333333333333333333333333333",
-        "expiringNonceHash": "0x0000000000000000000000000000000000000000000000000000000000000002",
-        "operator": "0x4444444444444444444444444444444444444444",
-        "payee": "0x2222222222222222222222222222222222222222",
-        "payer": "0x1111111111111111111111111111111111111111",
-        "salt": "0x0000000000000000000000000000000000000000000000000000000000000001",
-        "token": "0x20c0000000000000000000000000000000000001",
-      }
-    `)
-  })
-
   test('return type', () => {
     const resolved = Channel.from({
       expiringNonceHash:
@@ -111,10 +91,9 @@ describe('from', () => {
       payee: '0x2222222222222222222222222222222222222222',
       payer: '0x1111111111111111111111111111111111111111',
       salt: '0x0000000000000000000000000000000000000000000000000000000000000001',
-      token: 1n,
+      token: '0x20c0000000000000000000000000000000000001',
     })
 
-    resolved satisfies Channel.Resolved
     resolved satisfies Channel.Channel
     resolved.payer satisfies Address.Address
     resolved.token satisfies Address.Address

package/src/tempo/Channel.ts

@@ -3,7 +3,6 @@ import * as Address from '../core/Address.js'
 import type * as Errors from '../core/Errors.js'
 import * as Hash from '../core/Hash.js'
 import * as Hex from '../core/Hex.js'
-import * as TokenId from './TokenId.js'
 
 const channelIdParameters = AbiParameters.from(
   'address, address, address, address, bytes32, address, bytes32, address, uint256',
@@ -57,18 +56,14 @@ export type Channel = {
   payer: Address.Address
   /** User-supplied salt to distinguish otherwise identical channels. */
   salt: Hex.Hex
-  /** TIP-20 token address or ID held by the channel. */
-  token: TokenId.TokenIdOrAddress
+  /** TIP-20 token address held by the channel. */
+  token: Address.Address
 }
 
-/** Hex-address-normalized {@link ox#Channel.Channel}. */
-export type Resolved = Omit<Channel, 'token'> & { token: Address.Address }
-
 /**
  * Instantiates a TIP-20 channel reserve descriptor.
  *
- * Accepts a TIP-20 token ID or address, and defaults `operator` and
- * `authorizedSigner` to the zero address.
+ * Defaults `operator` and `authorizedSigner` to the zero address.
  *
  * @example
  * ```ts twoslash
@@ -80,7 +75,7 @@ export type Resolved = Omit<Channel, 'token'> & { token: Address.Address }
  *   payee: '0x2222222222222222222222222222222222222222',
  *   payer: '0x1111111111111111111111111111111111111111',
  *   salt: '0x0000000000000000000000000000000000000000000000000000000000000001',
- *   token: 1n
+ *   token: '0x20c0000000000000000000000000000000000001'
  * })
  * ```
  *
@@ -105,10 +100,7 @@ export function from(value: from.Value): from.ReturnType {
     payee: resolveAddress(payee),
     payer: resolveAddress(payer),
     salt,
-    token:
-      typeof token === 'string'
-        ? resolveAddress(token)
-        : TokenId.toAddress(token),
+    token: resolveAddress(token),
   }
 }
 
@@ -126,17 +118,13 @@ export declare namespace from {
     payer: Address.Address
     /** User-supplied salt to distinguish otherwise identical channels. */
     salt: Hex.Hex
-    /** TIP-20 token address or ID held by the channel. */
-    token: TokenId.TokenIdOrAddress
+    /** TIP-20 token address held by the channel. */
+    token: Address.Address
   }
 
-  type ReturnType = Resolved
+  type ReturnType = Channel
 
-  type ErrorType =
-    | Address.from.ErrorType
-    | Hex.concat.ErrorType
-    | Hex.fromNumber.ErrorType
-    | Errors.GlobalErrorType
+  type ErrorType = Address.from.ErrorType | Errors.GlobalErrorType
 }
 
 /**
@@ -159,7 +147,7 @@ export declare namespace from {
  *     payee: '0x2222222222222222222222222222222222222222',
  *     payer: '0x1111111111111111111111111111111111111111',
  *     salt: '0x0000000000000000000000000000000000000000000000000000000000000001',
- *     token: 1n
+ *     token: '0x20c0000000000000000000000000000000000001'
  *   },
  *   {
  *     chainId: 4217

package/src/tempo/KeyAuthorization.test.ts

@@ -2407,6 +2407,28 @@ describe('admin keys (TIP-1049)', () => {
     expect(restored.account).toBe(account)
   })
 
+  test('fromRpc: drops orphan isAdmin without account', () => {
+    const authorization = KeyAuthorization.from(
+      { address, chainId: 1n, type: 'secp256k1' },
+      { signature: SignatureEnvelope.from(signature_secp256k1) },
+    )
+    const rpc = KeyAuthorization.toRpc(authorization)
+    const restored = KeyAuthorization.fromRpc({ ...rpc, isAdmin: true })
+    expect(restored.isAdmin).toBeUndefined()
+    expect(restored.account).toBeUndefined()
+  })
+
+  test('fromRpc: drops orphan account without isAdmin', () => {
+    const authorization = KeyAuthorization.from(
+      { address, chainId: 1n, type: 'secp256k1' },
+      { signature: SignatureEnvelope.from(signature_secp256k1) },
+    )
+    const rpc = KeyAuthorization.toRpc(authorization)
+    const restored = KeyAuthorization.fromRpc({ ...rpc, account })
+    expect(restored.isAdmin).toBeUndefined()
+    expect(restored.account).toBeUndefined()
+  })
+
   test('hash: changes when admin pair is added', () => {
     const plain = KeyAuthorization.from({
       address,

package/src/tempo/KeyAuthorization.ts

@@ -91,7 +91,7 @@ export type Rpc = {
   /** Optional account address binding (TIP-1049). */
   account?: Address.Address | null | undefined
   /** Allowed call scopes (node field: `allowedCalls`). */
-  allowedCalls?: readonly RpcCallScope[] | undefined
+  allowedCalls?: readonly RpcCallScope[] | null | undefined
   /** Chain ID (hex quantity). */
   chainId: Hex.Hex
   /** Expiry timestamp (hex quantity or null). */
@@ -103,7 +103,7 @@ export type Rpc = {
   /** Key type. */
   keyType: SignatureEnvelope.Type
   /** Token spending limits. */
-  limits?: readonly RpcTokenLimit[] | undefined
+  limits?: readonly RpcTokenLimit[] | null | undefined
   /** Signature envelope. */
   signature: SignatureEnvelope.SignatureEnvelopeRpc
   /** Optional 32-byte witness (hex). */
@@ -114,19 +114,19 @@ export type Rpc = {
 export type RpcTokenLimit = {
   token: Address.Address
   limit: Hex.Hex
-  period?: Hex.Hex | undefined
+  period?: Hex.Hex | null | undefined
 }
 
 /** RPC representation of a call scope (matches node's `CallScope` serde). */
 export type RpcCallScope = {
   target: Address.Address
-  selectorRules?: readonly RpcSelectorRule[]
+  selectorRules?: readonly RpcSelectorRule[] | null | undefined
 }
 
 /** RPC representation of a selector rule (matches node's `SelectorRule` serde). */
 export type RpcSelectorRule = {
   selector: Hex.Hex
-  recipients?: readonly Address.Address[]
+  recipients?: readonly Address.Address[] | null | undefined
 }
 
 /** Signed representation of a Key Authorization. */
@@ -532,12 +532,13 @@ export function fromRpc(authorization: Rpc): Signed {
       })
     : undefined
 
-  // TIP-1049 admin fields are paired: only emit both when both are present on
-  // the wire. Orphan fields are dropped since the public API requires both.
+  // TIP-1049 admin fields are paired: emit both or neither; orphan wire
+  // fields are dropped. Separate conditional spreads break `Signed`
+  // assignability without `exactOptionalPropertyTypes` (#290).
   const adminPair =
     account !== undefined && isAdmin ? { account, isAdmin: true as const } : {}
 
-  const args: KeyAuthorization = {
+  return {
     address: keyId,
     chainId: chainId === '0x' ? 0n : Hex.toBigInt(chainId),
     ...(expiry != null ? { expiry: Number(expiry) } : {}),
@@ -554,7 +555,6 @@ export function fromRpc(authorization: Rpc): Signed {
     ...(witness !== undefined ? { witness } : {}),
     ...adminPair,
   }
-  return args as Signed
 }
 
 export declare namespace fromRpc {

package/src/tempo/MultisigConfig.test.ts

@@ -30,31 +30,51 @@ describe('from', () => {
   })
 })
 
-describe('genesisConfigId', () => {
+describe('getAddress', () => {
   test('matches independent ground truth', () => {
-    expect(MultisigConfig.toId(singleOwnerConfig)).toMatchInlineSnapshot(
-      `"0xd1f20e1a5bfdd89488f57f68db5bd1aae9a51b510f4a042b2604b57a0b7b471d"`,
+    expect(MultisigConfig.getAddress(singleOwnerConfig)).toMatchInlineSnapshot(
+      `"0x8820d1497eeaf4f68e00b2cfc00a2f3b1dbb00da"`,
     )
   })
 
+  test('matches independent ground truth (salt + weights)', () => {
+    expect(
+      MultisigConfig.getAddress({
+        salt: `0x${'42'.repeat(32)}`,
+        threshold: 2,
+        owners: [
+          { owner: owner1, weight: 1 },
+          { owner: owner2, weight: 2 },
+        ],
+      }),
+    ).toMatchInlineSnapshot(`"0x0773e28146400643e42cb28f6659b74e7c0b451d"`)
+  })
+
   test('is stable across calls', () => {
-    expect(MultisigConfig.toId(singleOwnerConfig)).toBe(
-      MultisigConfig.toId(singleOwnerConfig),
+    expect(MultisigConfig.getAddress(singleOwnerConfig)).toBe(
+      MultisigConfig.getAddress(singleOwnerConfig),
     )
   })
 
   test('differs for a different salt', () => {
-    expect(MultisigConfig.toId(singleOwnerConfig)).not.toBe(
-      MultisigConfig.toId({
+    expect(MultisigConfig.getAddress(singleOwnerConfig)).not.toBe(
+      MultisigConfig.getAddress({
         ...singleOwnerConfig,
         salt: `0x${'42'.repeat(32)}`,
       }),
     )
   })
 
+  test('address is chain-independent', () => {
+    // Derivation does not include chain ID; identical config → identical address.
+    const a = MultisigConfig.getAddress(singleOwnerConfig)
+    const b = MultisigConfig.getAddress(MultisigConfig.from(singleOwnerConfig))
+    expect(a).toBe(b)
+  })
+
   test('throws on invalid config', () => {
     expect(() =>
-      MultisigConfig.toId({
+      MultisigConfig.getAddress({
         threshold: 5,
         owners: singleOwnerConfig.owners,
       }),
@@ -62,50 +82,27 @@ describe('genesisConfigId', () => {
   })
 })
 
-describe('getAddress', () => {
-  test('matches independent ground truth', () => {
-    expect(MultisigConfig.getAddress(singleOwnerConfig)).toMatchInlineSnapshot(
-      `"0x6ca655065b1de473d903eebd50e5cb4996e10468"`,
-    )
-  })
-
-  test('derives from positional config or `{ genesisConfigId }` identically', () => {
-    const genesisConfigId = MultisigConfig.toId(singleOwnerConfig)
-    expect(MultisigConfig.getAddress({ genesisConfigId })).toBe(
-      MultisigConfig.getAddress(singleOwnerConfig),
-    )
-  })
-
-  test('config ID and address are chain-independent', () => {
-    // Derivation does not include chain ID; identical config → identical id/address.
-    const a = MultisigConfig.toId(singleOwnerConfig)
-    const b = MultisigConfig.toId(MultisigConfig.from(singleOwnerConfig))
-    expect(a).toBe(b)
-  })
-})
-
 describe('getSignPayload', () => {
   test('matches independent ground truth', () => {
     expect(
       MultisigConfig.getSignPayload({
-        payload: `0x${'42'.repeat(32)}`,
+        payload: `0x${'de'.repeat(32)}`,
         genesisConfig: singleOwnerConfig,
       }),
     ).toMatchInlineSnapshot(
-      `"0xe3d66f6118b89a67c71c8137c46abf0c829056a46ee6a038a1b42c84529fc17e"`,
+      `"0x7df8cb9fef4fc2aeb271b617d1a4c6178b720ae1d7564f48a363069b7d77a079"`,
     )
   })
 
-  test('behavior: `genesisConfig` and `{account, genesisConfigId}` produce identical digests', () => {
-    const genesisConfigId = MultisigConfig.toId(singleOwnerConfig)
-    const account = MultisigConfig.getAddress({ genesisConfigId })
+  test('behavior: `genesisConfig` and `{ account }` produce identical digests', () => {
+    const account = MultisigConfig.getAddress(singleOwnerConfig)
     const payload = `0x${'42'.repeat(32)}` as const
     expect(
       MultisigConfig.getSignPayload({
         payload,
         genesisConfig: singleOwnerConfig,
       }),
-    ).toBe(MultisigConfig.getSignPayload({ payload, account, genesisConfigId }))
+    ).toBe(MultisigConfig.getSignPayload({ payload, account }))
   })
 })
 
@@ -152,8 +149,16 @@ describe('assert / validate', () => {
     expect(MultisigConfig.validate({ threshold: 1, owners: [] })).toBe(false)
   })
 
+  test('accepts 255 owners', () => {
+    const owners = Array.from({ length: 255 }, (_, i) => ({
+      owner: `0x${(i + 1).toString(16).padStart(40, '0')}` as `0x${string}`,
+      weight: 1,
+    }))
+    expect(MultisigConfig.validate({ threshold: 255, owners })).toBe(true)
+  })
+
   test('too many owners', () => {
-    const owners = Array.from({ length: 11 }, (_, i) => ({
+    const owners = Array.from({ length: 256 }, (_, i) => ({
       owner: `0x${(i + 1).toString(16).padStart(40, '0')}` as `0x${string}`,
       weight: 1,
     }))
@@ -178,6 +183,18 @@ describe('assert / validate', () => {
     ).toBe(false)
   })
 
+  test('total weight exceeds u8 max', () => {
+    expect(
+      MultisigConfig.validate({
+        threshold: 255,
+        owners: [
+          { owner: owner1, weight: 128 },
+          { owner: owner2, weight: 128 },
+        ],
+      }),
+    ).toBe(false)
+  })
+
   test('zero owner weight', () => {
     expect(
       MultisigConfig.validate({