ox 1.7.2 → 1.7.5

package/src/tempo/MultisigOperation.ts

@@ -15,14 +15,10 @@ export type Base<quantity = bigint> = {
   approvals: readonly Hex.Hex[]
   /** Root configuration used to verify approvals. */
   config: MultisigConfig.Config<quantity>
-  /** Root configuration version. */
-  configVersion: quantity
   /** Unix creation time in milliseconds. */
   createdAt: number
   /** Deterministic multisig operation hash. */
   hash: Hex.Hex
-  /** Whether the operation initializes the root multisig account. */
-  init: boolean
   /** Number of approvals selected for quorum evaluation. */
   signatureCount: number
   /** Required root owner weight. */
@@ -73,9 +69,6 @@ export type KeyAuthorizationRpc = KeyAuthorizationOperation<Hex.Hex>
 /** JSON-RPC multisig operation. */
 export type Rpc = Operation<Hex.Hex>
 
-/** Maximum supported multisig configuration version. */
-const maxConfigVersion = 2n ** 64n - 1n
-
 /**
  * Derives the deterministic hash for a multisig operation.
  *
@@ -86,7 +79,7 @@ const maxConfigVersion = 2n ** 64n - 1n
  *
  * const hash = MultisigOperation.getHash({
  *   account,
- *   configVersion: 1n,
+ *   config,
  *   transaction,
  *   type: 'transaction'
  * })
@@ -96,7 +89,7 @@ const maxConfigVersion = 2n ** 64n - 1n
  * @returns The operation hash signed by each owner.
  */
 export function getHash(options: getHash.Options): Hex.Hex {
-  const { account, configVersion } = options
+  const { account, config } = options
   const payload =
     options.type === 'transaction'
       ? TxEnvelopeTempo.getSignPayload(
@@ -107,7 +100,7 @@ export function getHash(options: getHash.Options): Hex.Hex {
         )
   return MultisigConfig.getSignPayload({
     account,
-    config: { version: configVersion },
+    config,
     payload,
   })
 }
@@ -117,8 +110,8 @@ export declare namespace getHash {
   export type Options = {
     /** Root multisig account. */
     account: Address.Address
-    /** Root configuration version. */
-    configVersion: bigint
+    /** Complete root multisig configuration witness. */
+    config: MultisigConfig.Config
   } & (
     | {
         /** Canonical serialized key authorization. */
@@ -149,7 +142,8 @@ export declare namespace getHash {
  *
  * The function retains one canonical approval per owner. It selects the
  * smallest deterministic quorum by owner weight, then orders the selected
- * approvals by owner address for serialization.
+ * approvals by owner address for serialization. The caller supplies the
+ * account and config; the chain validates their factory-derived identity.
  *
  * @example
  * ```ts twoslash
@@ -160,8 +154,7 @@ export declare namespace getHash {
  *   account,
  *   approvals,
  *   config,
- *   hash,
- *   resolveConfig
+ *   hash
  * })
  * ```
  *
@@ -171,21 +164,18 @@ export declare namespace getHash {
 export async function selectApprovals(
   options: selectApprovals.Options,
 ): Promise<selectApprovals.ReturnValue> {
-  const { account, approvals, hash, resolveConfig } = options
+  const { account, approvals, hash } = options
   if (!Address.validate(account) || Hex.toBigInt(account) === 0n)
     throw new InvalidApprovalError({ reason: 'account is invalid' })
   if (!Hash.validate(hash))
     throw new InvalidApprovalError({ reason: 'hash is invalid' })
-  return selectApprovals_internal(
-    {
-      account,
-      approvals,
-      config: MultisigConfig.from(options.config),
-      hash,
-      resolveConfig,
-    },
-    [account.toLowerCase()],
-  )
+  const config = MultisigConfig.from(options.config)
+  return selectApprovals_internal({
+    account,
+    approvals,
+    config,
+    hash,
+  })
 }
 
 export declare namespace selectApprovals {
@@ -193,33 +183,12 @@ export declare namespace selectApprovals {
   export type Options = {
     /** Root multisig account. */
     account: Address.Address
-    /** Serialized primitive or nested owner approvals. */
+    /** Serialized primitive owner approvals. */
     approvals: readonly SignatureEnvelope.Serialized[]
     /** Current root multisig configuration. */
     config: MultisigConfig.Config
     /** Deterministic operation hash approved by root owners. */
     hash: Hex.Hex
-    /** Resolves the current configuration of a nested multisig owner. */
-    resolveConfig?: ResolveConfig | undefined
-  }
-
-  /** Resolves an initialized nested multisig configuration. */
-  export type ResolveConfig = (
-    options: ResolveConfigOptions,
-  ) => ResolvedConfig | Promise<ResolvedConfig>
-
-  /** Nested multisig configuration lookup parameters. */
-  export type ResolveConfigOptions = {
-    /** Nested multisig account. */
-    account: Address.Address
-  }
-
-  /** Resolved nested multisig configuration. */
-  export type ResolvedConfig = {
-    /** Current nested multisig configuration. */
-    config: MultisigConfig.Config
-    /** Current nested multisig configuration version. */
-    version: bigint
   }
 
   /** Result of validating and selecting approvals. */
@@ -248,6 +217,90 @@ export declare namespace selectApprovals {
     | Errors.GlobalErrorType
 }
 
+/**
+ * Serializes a key authorization with selected multisig owner approvals.
+ *
+ * @example
+ * ```ts twoslash
+ * // @noErrors
+ * import { MultisigOperation } from 'ox/tempo'
+ *
+ * const authorization =
+ *   MultisigOperation.serializeKeyAuthorization(
+ *     keyAuthorization,
+ *     {
+ *       account,
+ *       approvals: selection.selectedApprovals,
+ *       config
+ *     }
+ *   )
+ * ```
+ *
+ * @param keyAuthorization - Canonical serialized unsigned key authorization.
+ * @param options - Multisig account, config, and selected approvals.
+ * @returns The signed serialized key authorization.
+ */
+export function serializeKeyAuthorization(
+  keyAuthorization: Hex.Hex,
+  options: serializeKeyAuthorization.Options,
+): Hex.Hex {
+  const authorization = KeyAuthorization_.deserialize(keyAuthorization)
+  if (authorization.signature)
+    throw new InvalidOperationError({
+      reason: 'keyAuthorization must not contain a signature',
+    })
+  if (
+    KeyAuthorization_.serialize(authorization).toLowerCase() !==
+    keyAuthorization.toLowerCase()
+  )
+    throw new InvalidOperationError({
+      reason: 'keyAuthorization is not canonically serialized',
+    })
+  const config = MultisigConfig.from(options.config)
+  const signatures = SignatureEnvelope.sortMultisigApprovals({
+    account: options.account,
+    config,
+    payload: KeyAuthorization_.getSignPayload(authorization),
+    signatures: options.approvals.map((approval) =>
+      assertApproval(options.account, approval, config),
+    ),
+  })
+  return KeyAuthorization_.serialize(
+    KeyAuthorization_.from(authorization, {
+      signature: SignatureEnvelope.from({
+        account: options.account,
+        config,
+        signatures,
+      }),
+    }),
+  )
+}
+
+export declare namespace serializeKeyAuthorization {
+  /** Options for `serializeKeyAuthorization`. */
+  export type Options = {
+    /** Root multisig account. */
+    account: Address.Address
+    /** Selected serialized owner approvals. */
+    approvals: readonly SignatureEnvelope.Serialized[]
+    /** Complete applicable root multisig config. */
+    config: MultisigConfig.Config
+  }
+
+  /** Error type for `serializeKeyAuthorization`. */
+  export type ErrorType =
+    | InvalidOperationError
+    | KeyAuthorization_.deserialize.ErrorType
+    | KeyAuthorization_.from.ErrorType
+    | KeyAuthorization_.getSignPayload.ErrorType
+    | KeyAuthorization_.serialize.ErrorType
+    | MultisigConfig.assert.ErrorType
+    | SignatureEnvelope.assert.ErrorType
+    | SignatureEnvelope.InvalidSerializedError
+    | SignatureEnvelope.sortMultisigApprovals.ErrorType
+    | Errors.GlobalErrorType
+}
+
 /**
  * Serializes a multisig transaction operation with selected owner approvals.
  *
@@ -277,7 +330,7 @@ export function serializeTransaction(
     value.transaction as TxEnvelopeTempo.Serialized,
   )
   const approvals = options.approvals.map((approval) =>
-    SignatureEnvelope.from(approval),
+    assertApproval(value.account, approval, value.config),
   )
   assertRetainedApprovals(value, approvals)
   const signatures = SignatureEnvelope.sortMultisigApprovals({
@@ -340,10 +393,6 @@ export function from<const operation extends Operation>(
 ): from.ReturnValue<operation> {
   try {
     const config = MultisigConfig.from(operation.config)
-    if (config.version !== operation.configVersion)
-      throw new InvalidOperationError({
-        reason: 'config.version must equal configVersion',
-      })
     if (
       typeof config.threshold !== 'number' ||
       config.owners.some((owner) => typeof owner.weight !== 'number')
@@ -393,22 +442,19 @@ export function fromRpc<const operation extends Rpc>(
   operation: operation,
 ): fromRpc.ReturnValue<operation> {
   try {
-    if (
-      typeof operation.configVersion !== 'string' ||
-      !Hex.validate(operation.configVersion)
-    )
+    const version = operation.config?.version
+    if (typeof version !== 'string' || !Hex.validate(version))
       throw new InvalidOperationError({
-        reason: 'configVersion must be a hexadecimal quantity',
+        reason: 'config.version must be a hexadecimal quantity',
       })
-    const configVersion = Hex.toBigInt(operation.configVersion)
-    if (Hex.fromNumber(configVersion) !== operation.configVersion)
+    const version_ = Hex.toBigInt(version)
+    if (Hex.fromNumber(version_) !== version)
       throw new InvalidOperationError({
-        reason: 'configVersion must use canonical quantity encoding',
+        reason: 'config.version must use canonical quantity encoding',
       })
     return from({
       ...operation,
       config: MultisigConfig.fromRpc(operation.config),
-      configVersion,
     } as Operation) as never
   } catch (cause) {
     if (cause instanceof InvalidOperationError) throw cause
@@ -448,7 +494,6 @@ export function toRpc<const operation extends Operation>(
   return {
     ...value,
     config: MultisigConfig.toRpc(value.config),
-    configVersion: Hex.fromNumber(value.configVersion),
   } as never
 }
 
@@ -460,7 +505,7 @@ export declare namespace toRpc {
       : KeyAuthorizationRpc
 
   /** Error type for `toRpc`. */
-  export type ErrorType = from.ErrorType | Hex.fromNumber.ErrorType
+  export type ErrorType = from.ErrorType | MultisigConfig.toRpc.ErrorType
 }
 
 /**
@@ -470,7 +515,6 @@ export declare namespace toRpc {
  */
 async function selectApprovals_internal(
   options: selectApprovals.Options,
-  path: readonly string[],
 ): Promise<selectApprovals.ReturnValue> {
   const owners = new Map(
     options.config.owners.map((owner) => [
@@ -481,17 +525,14 @@ async function selectApprovals_internal(
   const groups = new Map<string, ApprovalGroup>()
   for (const serialized of options.approvals) {
     const signature = SignatureEnvelope.from(serialized)
-    if (signature.type === 'keychain')
+    if (signature.type === 'keychain' || signature.type === 'multisig')
       throw new InvalidApprovalError({
-        reason: 'keychain signatures cannot approve a multisig operation',
+        reason: 'only primitive signatures can approve a multisig operation',
       })
-    const address =
-      signature.type === 'multisig'
-        ? signature.account
-        : SignatureEnvelope.extractAddress({
-            payload: options.hash,
-            signature,
-          })
+    const address = SignatureEnvelope.extractAddress({
+      payload: options.hash,
+      signature,
+    })
     const owner = owners.get(address.toLowerCase())
     if (!owner)
       throw new InvalidApprovalError({
@@ -511,78 +552,6 @@ async function selectApprovals_internal(
   const valid: SelectedApproval[] = []
   const retained: RetainedApproval[] = []
   for (const group of groups.values()) {
-    const nested = group.signatures.filter(
-      (signature) => signature.type === 'multisig',
-    )
-    if (nested.length > 0) {
-      if (nested.length !== group.signatures.length)
-        throw new InvalidApprovalError({
-          reason: `owner ${group.address} has conflicting signature types`,
-        })
-      if (
-        path.length >= MultisigConfig.maxNestingDepth ||
-        path.includes(group.address.toLowerCase())
-      )
-        throw new InvalidApprovalError({
-          reason: `nested multisig owner ${group.address} is invalid`,
-        })
-      if (!options.resolveConfig)
-        throw new InvalidApprovalError({
-          reason: `nested multisig owner ${group.address} requires a config resolver`,
-        })
-      const resolved = await options.resolveConfig({ account: group.address })
-      const config = MultisigConfig.from(resolved.config)
-      if (config.version !== resolved.version)
-        throw new InvalidApprovalError({
-          reason: `resolved config.version must equal version for nested multisig owner ${group.address}`,
-        })
-      const selected = await selectApprovals_internal(
-        {
-          account: group.address,
-          approvals: nested.flatMap((signature) =>
-            signature.signatures.map((approval) =>
-              SignatureEnvelope.serialize(approval),
-            ),
-          ),
-          config,
-          hash: MultisigConfig.getSignPayload({
-            account: group.address,
-            config,
-            payload: options.hash,
-          }),
-          resolveConfig: options.resolveConfig,
-        },
-        [...path, group.address.toLowerCase()],
-      )
-      retained.push({
-        address: group.address,
-        signature: SignatureEnvelope.serialize(
-          SignatureEnvelope.from({
-            account: group.address,
-            config,
-            signatures: selected.approvals.map((approval) =>
-              SignatureEnvelope.from(approval),
-            ),
-          }),
-        ),
-      })
-      if (selected.weight >= selected.threshold)
-        valid.push({
-          address: group.address,
-          signature: SignatureEnvelope.serialize(
-            SignatureEnvelope.from({
-              account: group.address,
-              config,
-              signatures: selected.selectedApprovals.map((approval) =>
-                SignatureEnvelope.from(approval),
-              ),
-            }),
-          ),
-          weight: group.weight,
-        })
-      continue
-    }
-
     const signatures = group.signatures.map((signature) => {
       if (
         !SignatureEnvelope.verify(signature, {
@@ -651,7 +620,7 @@ type ApprovalGroup = {
 type RetainedApproval = {
   /** Configured owner address. */
   address: Address.Address
-  /** Serialized primitive or normalized nested approval. */
+  /** Serialized primitive approval. */
   signature: SignatureEnvelope.Serialized
 }
 
@@ -692,16 +661,6 @@ function assertBase(operation: Operation, config: MultisigConfig.Config): void {
     throw new InvalidOperationError({ reason: 'account cannot be zero' })
   if (!Hash.validate(operation.hash))
     throw new InvalidOperationError({ reason: 'hash is invalid' })
-  if (typeof operation.init !== 'boolean')
-    throw new InvalidOperationError({ reason: 'init must be a boolean' })
-  if (
-    typeof operation.configVersion !== 'bigint' ||
-    operation.configVersion < 0n ||
-    operation.configVersion > maxConfigVersion
-  )
-    throw new InvalidOperationError({
-      reason: 'configVersion must be an unsigned 64-bit integer',
-    })
   assertInteger(operation.createdAt, 'createdAt')
   assertInteger(operation.updatedAt, 'updatedAt')
   if (operation.updatedAt < operation.createdAt)
@@ -781,19 +740,6 @@ function assertBase(operation: Operation, config: MultisigConfig.Config): void {
       reason:
         'weight is not reachable by signatureCount retained owner approvals',
     })
-  if (operation.init) {
-    if (operation.configVersion !== 0n)
-      throw new InvalidOperationError({
-        reason: 'bootstrap operations must use config version zero',
-      })
-    if (
-      MultisigConfig.getAddress(config).toLowerCase() !==
-      operation.account.toLowerCase()
-    )
-      throw new InvalidOperationError({
-        reason: 'bootstrap config does not derive the operation account',
-      })
-  }
 }
 
 /**
@@ -981,8 +927,12 @@ function assertApproval(
   account: Address.Address,
   serialized: SignatureEnvelope.Serialized,
   config: MultisigConfig.Config,
-): SignatureEnvelope.SignatureEnvelope {
+): SignatureEnvelope.Primitive {
   const approval = SignatureEnvelope.deserialize(serialized)
+  if (approval.type === 'keychain' || approval.type === 'multisig')
+    throw new InvalidOperationError({
+      reason: 'only primitive owner approvals are allowed',
+    })
   SignatureEnvelope.assert({
     account,
     config,
@@ -1010,8 +960,10 @@ function assertRetainedApprovals(
     SignatureEnvelope.deserialize(approval),
   )
   for (const approval of selected) {
-    const index = retained.findIndex((candidate) =>
-      includesApproval(candidate, approval),
+    const index = retained.findIndex(
+      (candidate) =>
+        SignatureEnvelope.serialize(candidate).toLowerCase() ===
+        SignatureEnvelope.serialize(approval).toLowerCase(),
     )
     if (index === -1)
       throw new InvalidOperationError({
@@ -1035,8 +987,10 @@ function assertSelectedApprovals(
     SignatureEnvelope.deserialize(approval),
   )
   for (const approval of selected) {
-    const index = retained.findIndex((candidate) =>
-      includesApproval(candidate, approval),
+    const index = retained.findIndex(
+      (candidate) =>
+        SignatureEnvelope.serialize(candidate).toLowerCase() ===
+        SignatureEnvelope.serialize(approval).toLowerCase(),
     )
     if (index === -1)
       throw new InvalidOperationError({
@@ -1067,36 +1021,6 @@ function assertSelectedApprovals(
   }
 }
 
-/**
- * Checks whether a selected approval is contained in a retained approval tree.
- *
- * @internal
- */
-function includesApproval(
-  retained: SignatureEnvelope.SignatureEnvelope,
-  selected: SignatureEnvelope.SignatureEnvelope,
-): boolean {
-  if (retained.type !== 'multisig' || selected.type !== 'multisig')
-    return (
-      SignatureEnvelope.serialize(retained).toLowerCase() ===
-      SignatureEnvelope.serialize(selected).toLowerCase()
-    )
-  if (retained.account.toLowerCase() !== selected.account.toLowerCase())
-    return false
-  if (!sameConfig(retained.config, selected.config)) return false
-  let index = 0
-  for (const approval of selected.signatures) {
-    while (
-      index < retained.signatures.length &&
-      !includesApproval(retained.signatures[index]!, approval)
-    )
-      index++
-    if (index === retained.signatures.length) return false
-    index++
-  }
-  return true
-}
-
 /**
  * Checks whether exactly `signatureCount` retained owners can produce `weight`.
  *

package/src/tempo/MultisigSimulation.test-d.ts

@@ -0,0 +1,33 @@
+import { expectTypeOf, test } from 'vp/test'
+import * as MultisigSimulation from './MultisigSimulation.js'
+
+const rpc = {
+  approvals: [
+    {
+      keyType: 'webAuthn',
+      keyData: '0x0102030405',
+      owner: '0x1111111111111111111111111111111111111111',
+    },
+  ],
+  config:
+    '0xf83ba000000000000000000000000000000000000000000000000000000000000000008001d7d694111111111111111111111111111111111111111101',
+} as const satisfies MultisigSimulation.Rpc
+
+test('fromRpc returns a domain spec', () => {
+  const spec = MultisigSimulation.fromRpc(rpc)
+
+  expectTypeOf(spec).toEqualTypeOf<MultisigSimulation.Spec>()
+  expectTypeOf(spec.config.version).toEqualTypeOf<bigint>()
+})
+
+test('RPC specs use encoded configurations', () => {
+  expectTypeOf<
+    MultisigSimulation.Rpc['config']
+  >().toEqualTypeOf<`0x${string}`>()
+})
+
+test('toRpc returns an RPC spec', () => {
+  expectTypeOf(
+    MultisigSimulation.toRpc(MultisigSimulation.fromRpc(rpc)),
+  ).toEqualTypeOf<MultisigSimulation.Rpc>()
+})