@did-btcr2/method 0.28.0 → 0.32.0

package/dist/types/core/updater.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"updater.d.ts","sourceRoot":"","sources":["../../../src/core/updater.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"updater.d.ts","sourceRoot":"","sources":["../../../src/core/updater.ts"],"names":[],"mappings":"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"}

package/dist/types/did-btcr2.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"did-btcr2.d.ts","sourceRoot":"","sources":["../../src/did-btcr2.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,QAAQ,EACR,cAAc,EAAC,MAAM,mBAAmB,CAAC;AAS3C,OAAO,KAAK,EACV,SAAS,EAAC,MAAM,YAAY,CAAC;AAU/B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEvF,MAAM,WAAW,gBAAgB;IAC/B,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;IACf,+BAA+B;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sBAAsB;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAKD;;;;;;;;;;;;GAYG;AACH,qBAAa,QAAS,YAAW,SAAS;IACxC;;OAEG;IACH,MAAM,CAAC,UAAU,EAAE,MAAM,CAAW;IAEpC;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,QAAQ,GAAG,aAAa,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM;IAezF;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,OAAO,CACZ,GAAG,EAAE,MAAM,EACX,iBAAiB,GAAE,iBAAsB,GACxC,QAAQ;IAsBX;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CAAC,MAAM,CAAC,EACZ,cAAc,EACd,OAAO,EACP,eAAe,EACf,oBAAoB,EACpB,QAAQ,GACT,EAAE;QACD,cAAc,EAAE,gBAAgB,CAAC;QACjC,OAAO,EAAE,cAAc,EAAE,CAAC;QAC1B,eAAe,EAAE,MAAM,CAAC;QACxB,oBAAoB,EAAE,MAAM,CAAC;QAC7B,QAAQ,EAAE,MAAM,CAAC;KAClB,GAAG,OAAO;IA2DX;;;;;;;;;OASG;IACH,MAAM,CAAC,gBAAgB,CAAC,WAAW,EAAE,gBAAgB,EAAG,QAAQ,CAAC,EAAE,MAAM,GAAG,qBAAqB;CA0BlG"}
+{"version":3,"file":"did-btcr2.d.ts","sourceRoot":"","sources":["../../src/did-btcr2.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,QAAQ,EACR,cAAc,EAAC,MAAM,mBAAmB,CAAC;AAS3C,OAAO,KAAK,EACV,SAAS,EAAC,MAAM,YAAY,CAAC;AAQ/B,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAC9D,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAE5C,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,yBAAyB,CAAC;AAEvF,MAAM,WAAW,gBAAgB;IAC/B,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;IACf,+BAA+B;IAC/B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sBAAsB;IACtB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,QAAS,YAAW,SAAS;IACxC;;OAEG;IACH,MAAM,CAAC,UAAU,EAAE,MAAM,CAAW;IAEpC;;;;;;;;;;;;;;;OAeG;IACH,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,QAAQ,GAAG,aAAa,EAAE,OAAO,CAAC,EAAE,gBAAgB,GAAG,MAAM;IAezF;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,MAAM,CAAC,OAAO,CACZ,GAAG,EAAE,MAAM,EACX,iBAAiB,GAAE,iBAAsB,GACxC,QAAQ;IAsBX;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,MAAM,CAAC,MAAM,CAAC,EACZ,cAAc,EACd,OAAO,EACP,eAAe,EACf,oBAAoB,EACpB,QAAQ,GACT,EAAE;QACD,cAAc,EAAE,gBAAgB,CAAC;QACjC,OAAO,EAAE,cAAc,EAAE,CAAC;QAC1B,eAAe,EAAE,MAAM,CAAC;QACxB,oBAAoB,EAAE,MAAM,CAAC;QAC7B,QAAQ,EAAE,MAAM,CAAC;KAClB,GAAG,OAAO;IA2DX;;;;;;;;;OASG;IACH,MAAM,CAAC,gBAAgB,CAAC,WAAW,EAAE,gBAAgB,EAAG,QAAQ,CAAC,EAAE,MAAM,GAAG,qBAAqB;CA0BlG"}

package/dist/types/index.d.ts

@@ -4,6 +4,8 @@ export * from './core/aggregation/cohort.js';
 export * from './core/aggregation/signing-session.js';
 export * from './core/aggregation/phases.js';
 export * from './core/aggregation/errors.js';
+export * from './core/aggregation/beacon-strategy.js';
+export * from './core/aggregation/logger.js';
 export * from './core/aggregation/messages/index.js';
 export * from './core/aggregation/transport/index.js';
 export * from './core/aggregation/runner/index.js';

package/dist/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uCAAuC,CAAC;AACtD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sCAAsC,CAAC;AACrD,cAAc,uCAAuC,CAAC;AACtD,cAAc,oCAAoC,CAAC;AAGnD,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC;AAClD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AAGvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAGlC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iCAAiC,CAAC;AAChD,cAAc,yBAAyB,CAAC;AAGxC,cAAc,gBAAgB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC;AAClD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uCAAuC,CAAC;AACtD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,8BAA8B,CAAC;AAC7C,cAAc,uCAAuC,CAAC;AACtD,cAAc,8BAA8B,CAAC;AAC7C,cAAc,sCAAsC,CAAC;AACrD,cAAc,uCAAuC,CAAC;AACtD,cAAc,oCAAoC,CAAC;AAGnD,cAAc,yBAAyB,CAAC;AACxC,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AACvC,cAAc,0BAA0B,CAAC;AACzC,cAAc,gCAAgC,CAAC;AAC/C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,mCAAmC,CAAC;AAClD,cAAc,mCAAmC,CAAC;AAClD,cAAc,6BAA6B,CAAC;AAC5C,cAAc,wBAAwB,CAAC;AAGvC,cAAc,sBAAsB,CAAC;AACrC,cAAc,sBAAsB,CAAC;AACrC,cAAc,oBAAoB,CAAC;AACnC,cAAc,iBAAiB,CAAC;AAChC,cAAc,mBAAmB,CAAC;AAGlC,cAAc,qBAAqB,CAAC;AACpC,cAAc,iCAAiC,CAAC;AAChD,cAAc,yBAAyB,CAAC;AAGxC,cAAc,gBAAgB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@did-btcr2/method",
-  "version": "0.28.0",
+  "version": "0.32.0",
   "type": "module",
   "description": "Reference implementation for the did:btcr2 DID method written in TypeScript and JavaScript. did:btcr2 is a censorship resistant DID Method using the Bitcoin blockchain as a Verifiable Data Registry to announce changes to the DID document. This is the core method implementation for the did-btcr2-js monorepo.",
   "main": "./dist/cjs/index.js",
@@ -64,7 +64,6 @@
     "bitcoin"
   ],
   "dependencies": {
-    "@bitcoinerlab/secp256k1": "^1.2.0",
     "@helia/strings": "^4.1.0",
     "@noble/curves": "^1.9.7",
     "@noble/hashes": "^1.8.0",
@@ -76,17 +75,16 @@
     "@web5/common": "^1.1.0",
     "@web5/crypto": "^1.0.6",
     "@web5/dids": "^1.2.0",
-    "bitcoinjs-lib": "7.0.0-rc.0",
     "canonicalize": "^2.1.0",
     "dotenv": "^16.6.1",
     "helia": "^5.5.1",
     "multiformats": "^13.4.2",
     "nostr-tools": "^2.23.3",
-    "@did-btcr2/bitcoin": "^0.5.3",
-    "@did-btcr2/cryptosuite": "^6.0.6",
+    "@did-btcr2/bitcoin": "^0.6.0",
+    "@did-btcr2/common": "^9.1.0",
+    "@did-btcr2/cryptosuite": "^8.0.0",
     "@did-btcr2/smt": "^0.2.4",
-    "@did-btcr2/keypair": "^0.11.4",
-    "@did-btcr2/common": "^9.0.0"
+    "@did-btcr2/keypair": "^0.13.0"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.4",

package/src/core/aggregation/beacon-strategy.ts

@@ -0,0 +1,123 @@
+import { canonicalize } from '@did-btcr2/common';
+import type { SignedBTCR2Update } from '@did-btcr2/cryptosuite';
+import type { SerializedSMTProof } from '@did-btcr2/smt';
+import { blockHash, didToIndex, hashToHex, hexToHash, verifySerializedProof } from '@did-btcr2/smt';
+import type { AggregationCohort } from './cohort.js';
+import type { BaseBody } from './messages/base.js';
+
+/** Validation result returned to the participant for a distribute-data message. */
+export interface BeaconValidationResult {
+  matches: boolean;
+  casAnnouncement?: Record<string, string>;
+  smtProof?: SerializedSMTProof;
+}
+
+/** Per-participant body attached to DISTRIBUTE_AGGREGATED_DATA by the service. */
+export interface BeaconDistributePayload {
+  casAnnouncement?: Record<string, string>;
+  smtProof?: Record<string, unknown>;
+}
+
+/**
+ * Pluggable strategy for beacon-type-specific aggregation, distribution, and
+ * participant-side validation. Lets new beacon types be added without
+ * modifying the service or participant state machines: register a new strategy
+ * via {@link registerBeaconStrategy}.
+ */
+export interface AggregateBeaconStrategy {
+  /** String constant used as `beaconType` on CohortConfig / BaseMessage bodies. */
+  readonly type: string;
+
+  /**
+   * Service: build the aggregated data on the cohort after all updates are
+   * collected. Implementation should mutate the cohort (set signalBytes,
+   * casAnnouncement, smtProofs, etc.).
+   */
+  buildAggregatedData(cohort: AggregationCohort): void;
+
+  /**
+   * Service: produce the body fields to attach to DISTRIBUTE_AGGREGATED_DATA
+   * for a specific participant. Called once per cohort member.
+   */
+  getDistributePayload(cohort: AggregationCohort, participantDid: string): BeaconDistributePayload;
+
+  /**
+   * Participant: verify the aggregated data they received reflects their own
+   * submitted update. Pure function — returns matches + sidecar fields for
+   * the caller to store.
+   */
+  validateParticipantView(params: {
+    participantDid: string;
+    submittedUpdate: SignedBTCR2Update;
+    expectedHash: string;
+    body: BaseBody;
+  }): BeaconValidationResult;
+}
+
+const CAS_STRATEGY: AggregateBeaconStrategy = {
+  type : 'CASBeacon',
+
+  buildAggregatedData(cohort) {
+    cohort.buildCASAnnouncement();
+  },
+
+  getDistributePayload(cohort) {
+    return { casAnnouncement: cohort.casAnnouncement };
+  },
+
+  validateParticipantView({ participantDid, expectedHash, body }) {
+    const casAnnouncement = body.casAnnouncement;
+    if(!casAnnouncement) return { matches: false };
+    return {
+      matches : casAnnouncement[participantDid] === expectedHash,
+      casAnnouncement,
+    };
+  },
+};
+
+const SMT_STRATEGY: AggregateBeaconStrategy = {
+  type : 'SMTBeacon',
+
+  buildAggregatedData(cohort) {
+    cohort.buildSMTTree();
+  },
+
+  getDistributePayload(cohort, participantDid) {
+    const proof = cohort.smtProofs?.get(participantDid);
+    return { smtProof: proof as unknown as Record<string, unknown> | undefined };
+  },
+
+  validateParticipantView({ participantDid, submittedUpdate, body }) {
+    const smtProof = body.smtProof as unknown as SerializedSMTProof | undefined;
+    if(!smtProof?.updateId || !smtProof?.nonce) return { matches: false };
+    // Verify updateId matches the canonicalized update hash
+    const canonicalBytes = new TextEncoder().encode(canonicalize(submittedUpdate as unknown as Record<string, unknown>));
+    const expectedUpdateId = hashToHex(blockHash(canonicalBytes));
+    if(smtProof.updateId !== expectedUpdateId) {
+      return { matches: false, smtProof };
+    }
+    // Verify Merkle inclusion
+    const index = didToIndex(participantDid);
+    const candidateHash = blockHash(blockHash(hexToHash(smtProof.nonce)), hexToHash(smtProof.updateId));
+    return {
+      matches : verifySerializedProof(smtProof, index, candidateHash),
+      smtProof,
+    };
+  },
+};
+
+/** Registered strategies keyed by `beaconType` string. */
+const STRATEGIES: Map<string, AggregateBeaconStrategy> = new Map([
+  [CAS_STRATEGY.type, CAS_STRATEGY],
+  [SMT_STRATEGY.type, SMT_STRATEGY],
+]);
+
+/** Register a custom beacon strategy. Overwrites any existing entry with the same type. */
+export function registerBeaconStrategy(strategy: AggregateBeaconStrategy): void {
+  STRATEGIES.set(strategy.type, strategy);
+}
+
+/** Look up a registered beacon strategy by type, or undefined if not registered. */
+export function getBeaconStrategy(type: string): AggregateBeaconStrategy | undefined {
+  return STRATEGIES.get(type);
+}

package/src/core/aggregation/cohort.ts

@@ -2,9 +2,10 @@ import { canonicalHash, canonicalize, hash } from '@did-btcr2/common';
 import type { SignedBTCR2Update } from '@did-btcr2/cryptosuite';
 import type { SerializedSMTProof, TreeEntry } from '@did-btcr2/smt';
 import { BTCR2MerkleTree } from '@did-btcr2/smt';
+import { schnorr } from '@noble/curves/secp256k1.js';
 import { hexToBytes, randomBytes } from '@noble/hashes/utils';
+import { p2tr } from '@scure/btc-signer';
 import { keyAggExport, keyAggregate, sortKeys } from '@scure/btc-signer/musig2';
-import { crypto as btcCrypto, payments } from 'bitcoinjs-lib';
 import type { CASAnnouncement } from '../types.js';
 import { AggregationCohortError } from './errors.js';
 
@@ -48,11 +49,23 @@ export class AggregationCohort {
   /** List of participant DIDs that have been accepted into the cohort. */
   participants: Array<string> = [];
 
+  /**
+   * Mapping from participant DID → their compressed secp256k1 public key.
+   * Distinct from {@link cohortKeys} (which is sorted per BIP-327) — this lets
+   * callers look up a participant's key without knowing their position in the
+   * sorted array. Populated by the service at `acceptParticipant` time.
+   */
+  participantKeys: Map<string, Uint8Array> = new Map();
+
   /** Sorted list of cohort participants' compressed public keys. */
   #cohortKeys: Array<Uint8Array> = [];
 
-  /** Taproot tweak (BIP-341 key-path-only). */
-  trMerkleRoot: Uint8Array = new Uint8Array();
+  /**
+   * BIP-341 TapTweak — `taggedHash("TapTweak", internalPubkey)` for a key-path-only
+   * Taproot output. Despite prior naming, this is NOT a Merkle root: key-path-only
+   * spends have no script tree.
+   */
+  tapTweak: Uint8Array = new Uint8Array();
 
   /** The n-of-n MuSig2 Taproot beacon address. */
   beaconAddress: string = '';
@@ -94,7 +107,7 @@ export class AggregationCohort {
 
   /**
    * Computes the n-of-n MuSig2 Taproot beacon address from cohort keys.
-   * Sets `trMerkleRoot` to the BIP-341 key-path-only tweak.
+   * Sets `tapTweak` to the BIP-341 key-path-only tweak.
    */
   public computeBeaconAddress(): string {
     if(this.#cohortKeys.length === 0) {
@@ -105,11 +118,11 @@ export class AggregationCohort {
     }
     const keyAggContext = keyAggregate(this.#cohortKeys);
     const aggPubkey = keyAggExport(keyAggContext);
-    const payment = payments.p2tr({ internalPubkey: aggPubkey });
+    const payment = p2tr(aggPubkey);
 
-    // BIP-341: key-path-only P2TR has no script tree, so payment.hash is null.
-    // Compute the tweak: taggedHash("TapTweak", internalPubkey).
-    this.trMerkleRoot = payment.hash ?? btcCrypto.taggedHash('TapTweak', aggPubkey);
+    // BIP-341: key-path-only P2TR has no script tree. Compute the tweak:
+    // taggedHash("TapTweak", internalPubkey).
+    this.tapTweak = schnorr.utils.taggedHash('TapTweak', aggPubkey);
 
     if(!payment.address) {
       throw new AggregationCohortError(
@@ -147,6 +160,19 @@ export class AggregationCohort {
     }
   }
 
+  /**
+   * Returns the position of a participant's public key in the sorted
+   * {@link cohortKeys} array, or -1 if the participant is not in the cohort.
+   * Required by MuSig2 partial-sig verification which indexes by signer position.
+   */
+  public indexOfParticipant(did: string): number {
+    const pk = this.participantKeys.get(did);
+    if(!pk) return -1;
+    return this.#cohortKeys.findIndex(k =>
+      k.length === pk.length && k.every((b, i) => b === pk[i])
+    );
+  }
+
   public addUpdate(participantDid: string, signedUpdate: SignedBTCR2Update): void {
     if(!this.participants.includes(participantDid)) {
       throw new AggregationCohortError(

package/src/core/aggregation/logger.ts

@@ -0,0 +1,33 @@
+/**
+ * Minimal injectable logger for the aggregation subsystem.
+ *
+ * Each runner and transport adapter accepts a `Logger` option; the default is
+ * {@link CONSOLE_LOGGER}, which forwards to `console.*`. Pass
+ * {@link SILENT_LOGGER} to suppress output (useful for tests) or a custom
+ * implementation to route logs to pino, winston, Sentry, etc.
+ *
+ * The interface is intentionally small — we don't want production code taking
+ * a hard dependency on any specific logger library.
+ */
+export interface Logger {
+  debug(message: string, ...args: unknown[]): void;
+  info(message: string, ...args: unknown[]): void;
+  warn(message: string, ...args: unknown[]): void;
+  error(message: string, ...args: unknown[]): void;
+}
+
+/** Console-backed logger. Default for runners and transports. */
+export const CONSOLE_LOGGER: Logger = {
+  debug : (msg, ...args) => console.debug(msg, ...args),
+  info  : (msg, ...args) => console.info(msg, ...args),
+  warn  : (msg, ...args) => console.warn(msg, ...args),
+  error : (msg, ...args) => console.error(msg, ...args),
+};
+
+/** No-op logger. Useful for tests and production environments with own logging pipeline. */
+export const SILENT_LOGGER: Logger = {
+  debug : () => {},
+  info  : () => {},
+  warn  : () => {},
+  error : () => {},
+};

package/src/core/aggregation/messages/base.ts

@@ -1,3 +1,12 @@
+/**
+ * Current on-the-wire protocol version.
+ *
+ * Receivers reject messages with an unknown (mismatched) version. Bumping this
+ * requires coordinated updates across all participants and any intermediate
+ * relays that inspect message content.
+ */
+export const AGGREGATION_WIRE_VERSION = 1;
+
 export type BaseBody = {
   cohortId: string;
   cohortSize?: number;
@@ -10,6 +19,8 @@ export type BaseBody = {
   nonceContribution?: Uint8Array;
   partialSignature?: Uint8Array;
   pendingTx?: string;
+  /** Hex-encoded scriptPubKey of the UTXO being spent. Required for BIP-341 sighash. */
+  prevOutScriptHex?: string;
   prevOutValue?: string;
   communicationPk?: Uint8Array;
   beaconType?: string;
@@ -23,6 +34,7 @@ export type BaseBody = {
 
 export type Base = {
   type: string;
+  version?: number;
   to?: string;
   from: string;
   body?: BaseBody;
@@ -30,12 +42,14 @@ export type Base = {
 
 export class BaseMessage {
   public type: string;
+  public version: number;
   public to?: string;
   public from: string;
   public body?: BaseBody;
 
-  constructor({ type, to, from, body }: Base) {
+  constructor({ type, version, to, from, body }: Base) {
     this.type = type;
+    this.version = version ?? AGGREGATION_WIRE_VERSION;
     this.to = to;
     this.from = from;
     this.body = body;
@@ -47,10 +61,11 @@ export class BaseMessage {
    */
   public toJSON(): Base {
     return {
-      type : this.type,
-      to   : this.to,
-      from : this.from,
-      body : this.body
+      type    : this.type,
+      version : this.version,
+      to      : this.to,
+      from    : this.from,
+      body    : this.body
     };
   }
 }

package/src/core/aggregation/messages/bodies.ts

@@ -0,0 +1,223 @@
+/**
+ * Per-message-type body interfaces and a discriminated {@link AggregationMessage}
+ * union.
+ *
+ * {@link BaseBody} remains the superset-of-all-fields body type used by the
+ * raw {@link BaseMessage} class (see `base.ts`). The narrow interfaces here
+ * describe what each specific message type is *required* to carry and are
+ * exposed alongside type guards for consumers who want compile-time narrowing.
+ *
+ * Guards validate both `type` and the presence of required body fields so they
+ * are safe to use on messages that have round-tripped through JSON / a relay.
+ */
+
+import type { SerializedSMTProof } from '@did-btcr2/smt';
+import type { BaseMessage } from './base.js';
+import {
+  AGGREGATED_NONCE,
+  AUTHORIZATION_REQUEST,
+  COHORT_ADVERT,
+  COHORT_OPT_IN,
+  COHORT_OPT_IN_ACCEPT,
+  COHORT_READY,
+  DISTRIBUTE_AGGREGATED_DATA,
+  NONCE_CONTRIBUTION,
+  SIGNATURE_AUTHORIZATION,
+  SUBMIT_UPDATE,
+  VALIDATION_ACK,
+} from './constants.js';
+
+// ── Cohort formation (Step 1) ─────────────────────────────────────────────
+
+export interface CohortAdvertBody {
+  cohortId: string;
+  cohortSize: number;
+  beaconType: string;
+  network: string;
+  communicationPk: Uint8Array;
+}
+
+export interface CohortOptInBody {
+  cohortId: string;
+  participantPk: Uint8Array;
+  communicationPk: Uint8Array;
+}
+
+export interface CohortOptInAcceptBody {
+  cohortId: string;
+}
+
+export interface CohortReadyBody {
+  cohortId: string;
+  beaconAddress: string;
+  cohortKeys: Array<Uint8Array>;
+}
+
+// ── Update / aggregation (Steps 2-3) ──────────────────────────────────────
+
+export interface SubmitUpdateBody {
+  cohortId: string;
+  signedUpdate: Record<string, unknown>;
+}
+
+export interface DistributeAggregatedDataBody {
+  cohortId: string;
+  beaconType: string;
+  signalBytesHex: string;
+  casAnnouncement?: Record<string, string>;
+  smtProof?: Record<string, unknown> | SerializedSMTProof;
+}
+
+export interface ValidationAckBody {
+  cohortId: string;
+  approved: boolean;
+}
+
+// ── Signing (Step 4) ──────────────────────────────────────────────────────
+
+export interface AuthorizationRequestBody {
+  cohortId: string;
+  sessionId: string;
+  pendingTx: string;
+  prevOutScriptHex: string;
+  prevOutValue: string;
+}
+
+export interface NonceContributionBody {
+  cohortId: string;
+  sessionId: string;
+  nonceContribution: Uint8Array;
+}
+
+export interface AggregatedNonceBody {
+  cohortId: string;
+  sessionId: string;
+  aggregatedNonce: Uint8Array;
+}
+
+export interface SignatureAuthorizationBody {
+  cohortId: string;
+  sessionId: string;
+  partialSignature: Uint8Array;
+}
+
+// ── Narrow message types (BaseMessage & { type, body }) ──────────────────
+
+export type CohortAdvertMessage = BaseMessage & { type: typeof COHORT_ADVERT; body: CohortAdvertBody };
+export type CohortOptInMessage = BaseMessage & { type: typeof COHORT_OPT_IN; body: CohortOptInBody };
+export type CohortOptInAcceptMessage = BaseMessage & { type: typeof COHORT_OPT_IN_ACCEPT; body: CohortOptInAcceptBody };
+export type CohortReadyMessage = BaseMessage & { type: typeof COHORT_READY; body: CohortReadyBody };
+export type SubmitUpdateMessage = BaseMessage & { type: typeof SUBMIT_UPDATE; body: SubmitUpdateBody };
+export type DistributeAggregatedDataMessage = BaseMessage & { type: typeof DISTRIBUTE_AGGREGATED_DATA; body: DistributeAggregatedDataBody };
+export type ValidationAckMessage = BaseMessage & { type: typeof VALIDATION_ACK; body: ValidationAckBody };
+export type AuthorizationRequestMessage = BaseMessage & { type: typeof AUTHORIZATION_REQUEST; body: AuthorizationRequestBody };
+export type NonceContributionMessage = BaseMessage & { type: typeof NONCE_CONTRIBUTION; body: NonceContributionBody };
+export type AggregatedNonceMessage = BaseMessage & { type: typeof AGGREGATED_NONCE; body: AggregatedNonceBody };
+export type SignatureAuthorizationMessage = BaseMessage & { type: typeof SIGNATURE_AUTHORIZATION; body: SignatureAuthorizationBody };
+
+/** Discriminated union of every well-formed aggregation message. */
+export type AggregationMessage =
+  | CohortAdvertMessage
+  | CohortOptInMessage
+  | CohortOptInAcceptMessage
+  | CohortReadyMessage
+  | SubmitUpdateMessage
+  | DistributeAggregatedDataMessage
+  | ValidationAckMessage
+  | AuthorizationRequestMessage
+  | NonceContributionMessage
+  | AggregatedNonceMessage
+  | SignatureAuthorizationMessage;
+
+// ── Type guards ───────────────────────────────────────────────────────────
+// Each guard validates `type` plus required body fields so it's safe to use
+// on messages that have round-tripped through JSON / a relay.
+
+const hasStr = (b: unknown, k: string): boolean =>
+  !!b && typeof (b as Record<string, unknown>)[k] === 'string';
+const hasNum = (b: unknown, k: string): boolean =>
+  !!b && typeof (b as Record<string, unknown>)[k] === 'number';
+const hasBool = (b: unknown, k: string): boolean =>
+  !!b && typeof (b as Record<string, unknown>)[k] === 'boolean';
+const hasBytes = (b: unknown, k: string): boolean =>
+  !!b && (b as Record<string, unknown>)[k] instanceof Uint8Array;
+const hasBytesArray = (b: unknown, k: string): boolean => {
+  const v = b ? (b as Record<string, unknown>)[k] : undefined;
+  return Array.isArray(v) && v.every(x => x instanceof Uint8Array);
+};
+
+export function isCohortAdvertMessage(m: BaseMessage): m is CohortAdvertMessage {
+  return m.type === COHORT_ADVERT
+    && hasStr(m.body, 'cohortId')
+    && hasNum(m.body, 'cohortSize')
+    && hasStr(m.body, 'beaconType')
+    && hasStr(m.body, 'network')
+    && hasBytes(m.body, 'communicationPk');
+}
+
+export function isCohortOptInMessage(m: BaseMessage): m is CohortOptInMessage {
+  return m.type === COHORT_OPT_IN
+    && hasStr(m.body, 'cohortId')
+    && hasBytes(m.body, 'participantPk')
+    && hasBytes(m.body, 'communicationPk');
+}
+
+export function isCohortOptInAcceptMessage(m: BaseMessage): m is CohortOptInAcceptMessage {
+  return m.type === COHORT_OPT_IN_ACCEPT && hasStr(m.body, 'cohortId');
+}
+
+export function isCohortReadyMessage(m: BaseMessage): m is CohortReadyMessage {
+  return m.type === COHORT_READY
+    && hasStr(m.body, 'cohortId')
+    && hasStr(m.body, 'beaconAddress')
+    && hasBytesArray(m.body, 'cohortKeys');
+}
+
+export function isSubmitUpdateMessage(m: BaseMessage): m is SubmitUpdateMessage {
+  return m.type === SUBMIT_UPDATE
+    && hasStr(m.body, 'cohortId')
+    && !!m.body && typeof (m.body as Record<string, unknown>).signedUpdate === 'object';
+}
+
+export function isDistributeAggregatedDataMessage(m: BaseMessage): m is DistributeAggregatedDataMessage {
+  return m.type === DISTRIBUTE_AGGREGATED_DATA
+    && hasStr(m.body, 'cohortId')
+    && hasStr(m.body, 'beaconType')
+    && hasStr(m.body, 'signalBytesHex');
+}
+
+export function isValidationAckMessage(m: BaseMessage): m is ValidationAckMessage {
+  return m.type === VALIDATION_ACK
+    && hasStr(m.body, 'cohortId')
+    && hasBool(m.body, 'approved');
+}
+
+export function isAuthorizationRequestMessage(m: BaseMessage): m is AuthorizationRequestMessage {
+  return m.type === AUTHORIZATION_REQUEST
+    && hasStr(m.body, 'cohortId')
+    && hasStr(m.body, 'sessionId')
+    && hasStr(m.body, 'pendingTx')
+    && hasStr(m.body, 'prevOutScriptHex')
+    && hasStr(m.body, 'prevOutValue');
+}
+
+export function isNonceContributionMessage(m: BaseMessage): m is NonceContributionMessage {
+  return m.type === NONCE_CONTRIBUTION
+    && hasStr(m.body, 'cohortId')
+    && hasStr(m.body, 'sessionId')
+    && hasBytes(m.body, 'nonceContribution');
+}
+
+export function isAggregatedNonceMessage(m: BaseMessage): m is AggregatedNonceMessage {
+  return m.type === AGGREGATED_NONCE
+    && hasStr(m.body, 'cohortId')
+    && hasStr(m.body, 'sessionId')
+    && hasBytes(m.body, 'aggregatedNonce');
+}
+
+export function isSignatureAuthorizationMessage(m: BaseMessage): m is SignatureAuthorizationMessage {
+  return m.type === SIGNATURE_AUTHORIZATION
+    && hasStr(m.body, 'cohortId')
+    && hasStr(m.body, 'sessionId')
+    && hasBytes(m.body, 'partialSignature');
+}

package/src/core/aggregation/messages/factories.ts

@@ -164,6 +164,7 @@ type AuthorizationRequestMessage = {
   cohortId: string;
   sessionId: string;
   pendingTx: string;
+  prevOutScriptHex: string;
   prevOutValue: string;
 };
 type NonceContributionMessage = {

package/src/core/aggregation/messages/index.ts

@@ -1,4 +1,5 @@
 export * from './base.js';
+export * from './bodies.js';
 export * from './constants.js';
 export * from './factories.js';
 export * from './guards.js';