ox 0.14.29 → 0.14.31

package/tempo/KeyAuthorization.ts

@@ -3,7 +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 type { Compute, OneOf } from '../core/internal/types.js'
+import type { Compute, OneOf, UnionPartialBy } from '../core/internal/types.js'
 import * as Rlp from '../core/Rlp.js'
 import * as SignatureEnvelope from './SignatureEnvelope.js'
 import * as TempoAddress from './TempoAddress.js'
@@ -81,10 +81,10 @@ export type KeyAuthorization<
   | {}
 > &
   (signed extends true
-    ? { signature: SignatureEnvelope.SignatureEnvelope<bigintType, numberType> }
+    ? { signature: SignatureEnvelope.Primitive<bigintType, numberType> }
     : {
         signature?:
-          | SignatureEnvelope.SignatureEnvelope<bigintType, numberType>
+          | SignatureEnvelope.Primitive<bigintType, numberType>
           | undefined
       })
 
@@ -114,8 +114,8 @@ export type Rpc = {
   keyType: SignatureEnvelope.Type
   /** Token spending limits. */
   limits?: readonly RpcTokenLimit[] | undefined
-  /** Signature envelope. */
-  signature: SignatureEnvelope.SignatureEnvelopeRpc
+  /** Primitive signature authorizing this key. */
+  signature: SignatureEnvelope.PrimitiveRpc
   /** Optional 32-byte witness (hex). */
   witness?: Hex.Hex | null | undefined
 }
@@ -146,6 +146,11 @@ export type Signed<
   addressType = Address.Address,
 > = KeyAuthorization<true, bigintType, numberType, addressType>
 
+type PrimitiveSignatureValue =
+  | UnionPartialBy<SignatureEnvelope.Primitive, 'prehash' | 'type'>
+  | SignatureEnvelope.Secp256k1Flat
+  | SignatureEnvelope.Serialized
+
 type BaseTuple = readonly [
   chainId: Hex.Hex,
   keyType: Hex.Hex,
@@ -403,7 +408,7 @@ export type TokenLimit<
  */
 export function from<
   const authorization extends Input | Rpc,
-  const signature extends SignatureEnvelope.from.Value | undefined = undefined,
+  const signature extends PrimitiveSignatureValue | undefined = undefined,
 >(
   authorization: authorization | KeyAuthorization,
   options: from.Options<signature> = {},
@@ -418,6 +423,7 @@ export function from<
     }[]
   }
   if (auth.witness !== undefined) assertWitness(auth.witness)
+  if (auth.signature) assertSignature(auth.signature)
   const resolved = {
     ...auth,
     address: TempoAddress.resolve(auth.address as TempoAddress.Address),
@@ -446,41 +452,51 @@ export function from<
         }
       : {}),
   }
-  if (options.signature)
+  if (options.signature) {
+    const signature = SignatureEnvelope.from(
+      options.signature,
+    ) as SignatureEnvelope.SignatureEnvelope
+    assertSignature(signature)
     return {
       ...resolved,
-      signature: SignatureEnvelope.from(options.signature),
+      signature,
     } as never
+  }
   return resolved as never
 }
 
 export declare namespace from {
   type Options<
-    signature extends SignatureEnvelope.from.Value | undefined =
-      | SignatureEnvelope.from.Value
+    signature extends PrimitiveSignatureValue | undefined =
+      | PrimitiveSignatureValue
       | undefined,
   > = {
-    /** The {@link ox#SignatureEnvelope.SignatureEnvelope} to attach to the Key Authorization. */
-    signature?: signature | SignatureEnvelope.SignatureEnvelope | undefined
+    /** The primitive signature to attach to the Key Authorization. */
+    signature?: signature | SignatureEnvelope.Primitive | undefined
   }
 
   type ReturnType<
     authorization extends KeyAuthorization | Input | Rpc = KeyAuthorization,
-    signature extends SignatureEnvelope.from.Value | undefined =
-      | SignatureEnvelope.from.Value
+    signature extends PrimitiveSignatureValue | undefined =
+      | PrimitiveSignatureValue
       | undefined,
   > = Compute<
     authorization extends Rpc
       ? Signed
       : TempoAddress.ResolveAddresses<
           authorization &
-            (signature extends SignatureEnvelope.from.Value
-              ? { signature: SignatureEnvelope.from.ReturnValue<signature> }
+            (signature extends PrimitiveSignatureValue
+              ? {
+                  signature: Extract<
+                    SignatureEnvelope.from.ReturnValue<signature>,
+                    SignatureEnvelope.Primitive
+                  >
+                }
               : {})
         >
   >
 
-  type ErrorType = Errors.GlobalErrorType
+  type ErrorType = InvalidSignatureTypeError | Errors.GlobalErrorType
 }
 
 /**
@@ -515,6 +531,7 @@ export function fromRpc(authorization: Rpc): Signed {
   const isAdmin = authorization.isAdmin ?? undefined
   const account = authorization.account ?? undefined
   const signature = SignatureEnvelope.fromRpc(authorization.signature)
+  assertSignature(signature)
   if (witness !== undefined) assertWitness(witness)
 
   // Unflatten nested allowedCalls into flat scopes
@@ -534,6 +551,12 @@ export function fromRpc(authorization: Rpc): Signed {
       })
     : undefined
 
+  // 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 } : {}
+
   return {
     address: keyId,
     chainId: chainId === '0x' ? 0n : Hex.toBigInt(chainId),
@@ -549,13 +572,12 @@ export function fromRpc(authorization: Rpc): Signed {
     signature,
     type: keyType,
     ...(witness !== undefined ? { witness } : {}),
-    ...(isAdmin ? { isAdmin: true } : {}),
-    ...(account !== undefined ? { account } : {}),
+    ...adminPair,
   }
 }
 
 export declare namespace fromRpc {
-  type ErrorType = Errors.GlobalErrorType
+  type ErrorType = InvalidSignatureTypeError | Errors.GlobalErrorType
 }
 
 /**
@@ -687,8 +709,11 @@ export function fromTuple<const tuple extends Tuple>(
     ...(witness !== undefined ? { witness } : {}),
     ...adminPair,
   }
-  if (signatureSerialized)
-    args.signature = SignatureEnvelope.deserialize(signatureSerialized)
+  if (signatureSerialized) {
+    const signature = SignatureEnvelope.deserialize(signatureSerialized)
+    assertSignature(signature)
+    args.signature = signature
+  }
   return from(args) as never
 }
 
@@ -697,7 +722,7 @@ export declare namespace fromTuple {
     KeyAuthorization<authorization extends Tuple<true> ? true : false>
   >
 
-  type ErrorType = Errors.GlobalErrorType
+  type ErrorType = InvalidSignatureTypeError | Errors.GlobalErrorType
 }
 
 /**
@@ -901,6 +926,7 @@ export function toRpc(authorization: Signed): Rpc {
     isAdmin,
     account,
   } = authorization
+  assertSignature(signature)
   if (witness !== undefined) assertWitness(witness)
 
   // Group flat scopes by address into nested allowedCalls wire format
@@ -937,7 +963,9 @@ export function toRpc(authorization: Signed): Rpc {
       limit: Hex.fromNumber(limit),
       ...(period ? { period: numberToHex(period) } : {}),
     })),
-    signature: SignatureEnvelope.toRpc(signature),
+    signature: SignatureEnvelope.toRpc(
+      signature,
+    ) as SignatureEnvelope.PrimitiveRpc,
     ...(allowedCalls ? { allowedCalls } : {}),
     ...(witness !== undefined ? { witness } : {}),
     ...(isAdmin ? { isAdmin: true } : {}),
@@ -946,7 +974,7 @@ export function toRpc(authorization: Signed): Rpc {
 }
 
 export declare namespace toRpc {
-  type ErrorType = Errors.GlobalErrorType
+  type ErrorType = InvalidSignatureTypeError | Errors.GlobalErrorType
 }
 
 /**
@@ -994,9 +1022,11 @@ export function toTuple<const authorization extends KeyAuthorization>(
     account,
   } = authorization
   if (witness !== undefined) assertWitness(witness)
-  const signature = authorization.signature
-    ? SignatureEnvelope.serialize(authorization.signature)
-    : undefined
+  const signature = (() => {
+    if (!authorization.signature) return undefined
+    assertSignature(authorization.signature)
+    return SignatureEnvelope.serialize(authorization.signature)
+  })()
   const type = (() => {
     switch (authorization.type) {
       case 'secp256k1':
@@ -1092,7 +1122,7 @@ export declare namespace toTuple {
   type ReturnType<authorization extends KeyAuthorization = KeyAuthorization> =
     Compute<Tuple<authorization extends KeyAuthorization<true> ? true : false>>
 
-  type ErrorType = Errors.GlobalErrorType
+  type ErrorType = InvalidSignatureTypeError | Errors.GlobalErrorType
 }
 
 function bigintToHex(value: bigint): Hex.Hex {
@@ -1130,6 +1160,13 @@ function assertWitness(witness: Hex.Hex): void {
   if (Hex.size(witness) !== 32) throw new InvalidWitnessSizeError(witness)
 }
 
+function assertSignature<bigintType, numberType>(
+  signature: SignatureEnvelope.SignatureEnvelope<bigintType, numberType>,
+): asserts signature is SignatureEnvelope.Primitive<bigintType, numberType> {
+  if (signature.type === 'keychain' || signature.type === 'multisig')
+    throw new InvalidSignatureTypeError(signature.type)
+}
+
 function isAbsent(value: unknown): boolean {
   return value === undefined || value === '0x'
 }
@@ -1153,3 +1190,13 @@ export class InvalidAdminMarkerError extends Error {
     )
   }
 }
+
+/** Thrown when a key authorization contains a non-primitive signature. */
+export class InvalidSignatureTypeError extends Error {
+  override readonly name = 'KeyAuthorization.InvalidSignatureTypeError'
+  constructor(type: SignatureEnvelope.SignatureEnvelope['type']) {
+    super(
+      `Signature type \`${type}\` is invalid for key authorizations; expected \`secp256k1\`, \`p256\`, or \`webAuthn\`.`,
+    )
+  }
+}

package/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,21 @@ 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: MultisigConfig.maxThreshold,
+        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,
     }))
@@ -169,6 +179,24 @@ describe('assert / validate', () => {
     ).toBe(false)
   })
 
+  test('threshold exceeds protocol maximum', () => {
+    expect(
+      MultisigConfig.validate({
+        threshold: MultisigConfig.maxThreshold + 1,
+        owners: [{ owner: owner1, weight: MultisigConfig.maxThreshold + 1 }],
+      }),
+    ).toBe(false)
+  })
+
+  test('fractional threshold', () => {
+    expect(
+      MultisigConfig.validate({
+        threshold: 1.5,
+        owners: [{ owner: owner1, weight: 2 }],
+      }),
+    ).toBe(false)
+  })
+
   test('threshold exceeds total weight', () => {
     expect(
       MultisigConfig.validate({
@@ -178,6 +206,18 @@ describe('assert / validate', () => {
     ).toBe(false)
   })
 
+  test('total weight exceeds u8 max', () => {
+    expect(
+      MultisigConfig.validate({
+        threshold: MultisigConfig.maxThreshold,
+        owners: [
+          { owner: owner1, weight: 128 },
+          { owner: owner2, weight: 128 },
+        ],
+      }),
+    ).toBe(false)
+  })
+
   test('zero owner weight', () => {
     expect(
       MultisigConfig.validate({
@@ -187,6 +227,15 @@ describe('assert / validate', () => {
     ).toBe(false)
   })
 
+  test('fractional owner weight', () => {
+    expect(
+      MultisigConfig.validate({
+        threshold: 1,
+        owners: [{ owner: owner1, weight: 1.5 }],
+      }),
+    ).toBe(false)
+  })
+
   test('zero owner address', () => {
     expect(
       MultisigConfig.validate({