ox 1.0.0-beta.2 → 1.0.0-beta.21

package/src/erc4337/UserOperation.ts

@@ -4,6 +4,7 @@ import * as Authorization from '../core/Authorization.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 Quantity from '../core/internal/quantity.js'
 import type { Assign, Compute, OneOf } from '../core/internal/types.js'
 import * as Signature from '../core/Signature.js'
 import * as TypedData from '../core/TypedData.js'
@@ -887,17 +888,23 @@ export declare namespace fromPacked {
  * @param userOperation - The user operation to convert.
  * @returns An RPC-formatted user operation.
  */
-export function toRpc(userOperation: UserOperation): Rpc {
+export function toRpc(userOperation: toRpc.Input): Rpc {
   const rpc = {} as Rpc
 
   rpc.callData = userOperation.callData
-  rpc.callGasLimit = Hex.fromNumber(userOperation.callGasLimit)
-  rpc.maxFeePerGas = Hex.fromNumber(userOperation.maxFeePerGas)
-  rpc.maxPriorityFeePerGas = Hex.fromNumber(userOperation.maxPriorityFeePerGas)
-  rpc.nonce = Hex.fromNumber(userOperation.nonce)
-  rpc.preVerificationGas = Hex.fromNumber(userOperation.preVerificationGas)
+  rpc.callGasLimit = Quantity.fromNumberish(userOperation.callGasLimit)
+  rpc.maxFeePerGas = Quantity.fromNumberish(userOperation.maxFeePerGas)
+  rpc.maxPriorityFeePerGas = Quantity.fromNumberish(
+    userOperation.maxPriorityFeePerGas,
+  )
+  rpc.nonce = Quantity.fromNumberish(userOperation.nonce)
+  rpc.preVerificationGas = Quantity.fromNumberish(
+    userOperation.preVerificationGas,
+  )
   rpc.sender = userOperation.sender
-  rpc.verificationGasLimit = Hex.fromNumber(userOperation.verificationGasLimit)
+  rpc.verificationGasLimit = Quantity.fromNumberish(
+    userOperation.verificationGasLimit,
+  )
 
   if (userOperation.factory) rpc.factory = userOperation.factory
   if (userOperation.factoryData) rpc.factoryData = userOperation.factoryData
@@ -905,12 +912,12 @@ export function toRpc(userOperation: UserOperation): Rpc {
   if (userOperation.paymaster) rpc.paymaster = userOperation.paymaster
   if (userOperation.paymasterData)
     rpc.paymasterData = userOperation.paymasterData
-  if (typeof userOperation.paymasterPostOpGasLimit === 'bigint')
-    rpc.paymasterPostOpGasLimit = Hex.fromNumber(
+  if (userOperation.paymasterPostOpGasLimit !== undefined)
+    rpc.paymasterPostOpGasLimit = Quantity.fromNumberish(
       userOperation.paymasterPostOpGasLimit,
     )
-  if (typeof userOperation.paymasterVerificationGasLimit === 'bigint')
-    rpc.paymasterVerificationGasLimit = Hex.fromNumber(
+  if (userOperation.paymasterVerificationGasLimit !== undefined)
+    rpc.paymasterVerificationGasLimit = Quantity.fromNumberish(
       userOperation.paymasterVerificationGasLimit,
     )
   if (userOperation.signature) rpc.signature = userOperation.signature
@@ -926,6 +933,14 @@ export function toRpc(userOperation: UserOperation): Rpc {
 }
 
 export declare namespace toRpc {
+  /** Numberish input accepted by {@link ox#UserOperation.(toRpc:function)}. */
+  export type Input = UserOperation<
+    EntryPoint.Version,
+    boolean,
+    Hex.Hex | bigint | number,
+    Hex.Hex | number
+  >
+
   export type ErrorType = Hex.fromNumber.ErrorType | Errors.GlobalErrorType
 }
 

package/src/erc4337/UserOperationGas.ts

@@ -1,4 +1,5 @@
 import * as Hex from '../core/Hex.js'
+import * as Quantity from '../core/internal/quantity.js'
 import type { OneOf } from '../core/internal/types.js'
 import type * as EntryPoint from './EntryPoint.js'
 
@@ -94,23 +95,33 @@ export function fromRpc(rpc: Rpc): UserOperationGas {
  * @param userOperationGas - The user operation gas to convert.
  * @returns An RPC-formatted user operation gas.
  */
-export function toRpc(userOperationGas: UserOperationGas): Rpc {
+export function toRpc(userOperationGas: toRpc.Input): Rpc {
   const rpc = {} as Rpc
 
-  rpc.callGasLimit = Hex.fromNumber(userOperationGas.callGasLimit)
-  rpc.preVerificationGas = Hex.fromNumber(userOperationGas.preVerificationGas)
-  rpc.verificationGasLimit = Hex.fromNumber(
+  rpc.callGasLimit = Quantity.fromNumberish(userOperationGas.callGasLimit)
+  rpc.preVerificationGas = Quantity.fromNumberish(
+    userOperationGas.preVerificationGas,
+  )
+  rpc.verificationGasLimit = Quantity.fromNumberish(
     userOperationGas.verificationGasLimit,
   )
 
-  if (typeof userOperationGas.paymasterVerificationGasLimit === 'bigint')
-    rpc.paymasterVerificationGasLimit = Hex.fromNumber(
+  if (userOperationGas.paymasterVerificationGasLimit !== undefined)
+    rpc.paymasterVerificationGasLimit = Quantity.fromNumberish(
       userOperationGas.paymasterVerificationGasLimit,
     )
-  if (typeof userOperationGas.paymasterPostOpGasLimit === 'bigint')
-    rpc.paymasterPostOpGasLimit = Hex.fromNumber(
+  if (userOperationGas.paymasterPostOpGasLimit !== undefined)
+    rpc.paymasterPostOpGasLimit = Quantity.fromNumberish(
       userOperationGas.paymasterPostOpGasLimit,
     )
 
   return rpc
 }
+
+export declare namespace toRpc {
+  /** Numberish input accepted by {@link ox#UserOperationGas.(toRpc:function)}. */
+  export type Input = UserOperationGas<
+    EntryPoint.Version,
+    Hex.Hex | bigint | number
+  >
+}

package/src/erc4337/UserOperationReceipt.ts

@@ -1,5 +1,6 @@
 import type * as Address from '../core/Address.js'
 import * as Hex from '../core/Hex.js'
+import * as Quantity from '../core/internal/quantity.js'
 import * as Log from '../core/Log.js'
 import * as TransactionReceipt from '../core/TransactionReceipt.js'
 import type * as EntryPoint from './EntryPoint.js'
@@ -118,14 +119,14 @@ export function fromRpc(rpc: Rpc): UserOperationReceipt {
  * @param userOperationReceipt - The user operation receipt to convert.
  * @returns An RPC-formatted user operation receipt.
  */
-export function toRpc(userOperationReceipt: UserOperationReceipt): Rpc {
+export function toRpc(userOperationReceipt: toRpc.Input): Rpc {
   const rpc = {} as Rpc
 
-  rpc.actualGasCost = Hex.fromNumber(userOperationReceipt.actualGasCost)
-  rpc.actualGasUsed = Hex.fromNumber(userOperationReceipt.actualGasUsed)
+  rpc.actualGasCost = Quantity.fromNumberish(userOperationReceipt.actualGasCost)
+  rpc.actualGasUsed = Quantity.fromNumberish(userOperationReceipt.actualGasUsed)
   rpc.entryPoint = userOperationReceipt.entryPoint
   rpc.logs = userOperationReceipt.logs.map((log) => Log.toRpc(log))
-  rpc.nonce = Hex.fromNumber(userOperationReceipt.nonce)
+  rpc.nonce = Quantity.fromNumberish(userOperationReceipt.nonce)
   rpc.receipt = TransactionReceipt.toRpc(userOperationReceipt.receipt)
   rpc.sender = userOperationReceipt.sender
   rpc.success = userOperationReceipt.success
@@ -137,3 +138,12 @@ export function toRpc(userOperationReceipt: UserOperationReceipt): Rpc {
 
   return rpc
 }
+
+export declare namespace toRpc {
+  /** Numberish input accepted by {@link ox#UserOperationReceipt.(toRpc:function)}. */
+  export type Input = UserOperationReceipt<
+    EntryPoint.Version,
+    Hex.Hex | bigint | number,
+    Hex.Hex | number
+  >
+}

package/src/index.ts

@@ -455,6 +455,44 @@ export * as AbiFunction from './core/AbiFunction.js'
  */
 export * as AbiItem from './core/AbiItem.js'
 
+/**
+ * Utilities & types for working with a single [ABI Parameter](https://docs.soliditylang.org/en/latest/abi-spec.html#types).
+ *
+ * @example
+ * ### Instantiating Human Readable ABI Parameters
+ *
+ * A Human Readable ABI Parameter can be instantiated by using {@link ox#AbiParameter.(from:function)}:
+ *
+ * ```ts twoslash
+ * import { AbiParameter } from 'ox'
+ *
+ * const parameter = AbiParameter.from('address spender')
+ *
+ * parameter
+ * //^?
+ * ```
+ *
+ * @example
+ * ### Formatting ABI Parameters
+ *
+ * An ABI Parameter can be formatted into a human-readable ABI Parameter by using {@link ox#AbiParameter.(format:function)}:
+ *
+ * ```ts twoslash
+ * import { AbiParameter } from 'ox'
+ *
+ * const formatted = AbiParameter.format({
+ *   name: 'spender',
+ *   type: 'address'
+ * })
+ *
+ * formatted
+ * //    ^?
+ * ```
+ *
+ * @category ABI
+ */
+export * as AbiParameter from './core/AbiParameter.js'
+
 /**
  * Utilities & types for encoding, decoding, and working with [ABI Parameters](https://docs.soliditylang.org/en/latest/abi-spec.html#types)
  *

package/src/tempo/AuthorizationTempo.ts

@@ -2,6 +2,7 @@ import type * 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 Quantity from '../core/internal/quantity.js'
 import type { Compute, Mutable } from '../core/internal/types.js'
 import * as Rlp from '../core/Rlp.js'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
@@ -782,18 +783,21 @@ export declare namespace hash {
  * @param authorization - An AA Authorization.
  * @returns An RPC-formatted AA Authorization.
  */
-export function toRpc(authorization: Signed): Rpc {
+export function toRpc(authorization: toRpc.Input): Rpc {
   const { address, chainId, nonce, signature } = authorization
 
   return {
     address,
-    chainId: Hex.fromNumber(chainId),
-    nonce: Hex.fromNumber(nonce),
+    chainId: Quantity.fromNumberish(chainId),
+    nonce: Quantity.fromNumberish(nonce),
     signature: SignatureEnvelope.toRpc(signature),
   }
 }
 
 export declare namespace toRpc {
+  /** Numberish input accepted by {@link ox#AuthorizationTempo.(toRpc:function)}. */
+  type Input = Signed<Hex.Hex | bigint | number, Hex.Hex | number>
+
   type ErrorType = Errors.GlobalErrorType
 }
 
@@ -824,11 +828,14 @@ export declare namespace toRpc {
  * @param authorizationList - An AA Authorization List.
  * @returns An RPC-formatted AA Authorization List.
  */
-export function toRpcList(authorizationList: ListSigned): ListRpc {
+export function toRpcList(authorizationList: toRpcList.Input): ListRpc {
   return authorizationList.map((x) => toRpc(x as unknown as Signed)) as never
 }
 
 export declare namespace toRpcList {
+  /** Numberish input accepted by {@link ox#AuthorizationTempo.(toRpcList:function)}. */
+  type Input = ListSigned<Hex.Hex | bigint | number, Hex.Hex | number>
+
   type ErrorType = Errors.GlobalErrorType
 }
 

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

@@ -3,6 +3,7 @@ import type * 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 Quantity from '../core/internal/quantity.js'
 import type { Compute, OneOf } from '../core/internal/types.js'
 import * as Rlp from '../core/Rlp.js'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
@@ -90,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). */
@@ -102,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). */
@@ -113,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. */
@@ -531,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) } : {}),
@@ -553,7 +555,6 @@ export function fromRpc(authorization: Rpc): Signed {
     ...(witness !== undefined ? { witness } : {}),
     ...adminPair,
   }
-  return args as Signed
 }
 
 export declare namespace fromRpc {
@@ -914,7 +915,7 @@ export declare namespace serialize {
  * @param authorization - A Key Authorization.
  * @returns An RPC-formatted Key Authorization.
  */
-export function toRpc(authorization: Signed): Rpc {
+export function toRpc(authorization: toRpc.Input): Rpc {
   const {
     address,
     scopes,
@@ -953,15 +954,17 @@ export function toRpc(authorization: Signed): Rpc {
     )
   })()
 
+  const chainIdHex = Quantity.fromNumberish(chainId)
+
   return {
-    chainId: chainId === 0n ? '0x' : Hex.fromNumber(chainId),
-    expiry: typeof expiry === 'number' ? Hex.fromNumber(expiry) : null,
+    chainId: chainIdHex === '0x0' ? '0x' : chainIdHex,
+    expiry: expiry != null ? Quantity.fromNumberish(expiry) : null,
     keyId: address,
     keyType: type,
     limits: limits?.map(({ token, limit, period }) => ({
       token,
-      limit: Hex.fromNumber(limit),
-      ...(period ? { period: numberToHex(period) } : {}),
+      limit: Quantity.fromNumberish(limit),
+      ...(period ? { period: Quantity.fromNumberish(period) } : {}),
     })),
     signature: SignatureEnvelope.toRpc(signature),
     ...(allowedCalls ? { allowedCalls } : {}),
@@ -972,6 +975,9 @@ export function toRpc(authorization: Signed): Rpc {
 }
 
 export declare namespace toRpc {
+  /** Numberish input accepted by {@link ox#KeyAuthorization.(toRpc:function)}. */
+  type Input = Signed<Hex.Hex | bigint | number, Hex.Hex | number>
+
   type ErrorType = Errors.GlobalErrorType
 }
 

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({