@did-btcr2/method 0.26.0 → 0.27.0

package/src/core/aggregation/cohort.ts

@@ -0,0 +1,247 @@
+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 { hexToBytes, randomBytes } from '@noble/hashes/utils';
+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';
+
+export type AggregationCohortParams = {
+  id?: string;
+  serviceDid?: string;
+  minParticipants?: number;
+  network: string;
+  beaconType?: string;
+};
+
+/**
+ * Represents an Aggregation Cohort — a set of Aggregation Participants who
+ * submitted cryptographic material to an Aggregation Service to coordinate
+ * signing of a shared n-of-n MuSig2 Bitcoin transaction.
+ *
+ * This is a pure data class — it holds cohort state and provides computation
+ * helpers (key aggregation, CAS Announcement building, SMT tree building).
+ * It performs no I/O and emits no messages. Both AggregationService and
+ * AggregationParticipant create their own AggregationCohort instances to
+ * track their respective views of the cohort state.
+ *
+ * @class AggregationCohort
+ */
+export class AggregationCohort {
+  /** Unique identifier for the cohort. */
+  id: string;
+
+  /** DID of the Aggregation Service managing this cohort. */
+  serviceDid: string;
+
+  /** Minimum number of participants required to finalize the cohort. */
+  minParticipants: number;
+
+  /** Network on which the cohort operates (mainnet, mutinynet, etc.). */
+  network: string;
+
+  /** Type of beacon used in the cohort: 'CASBeacon' or 'SMTBeacon'. */
+  beaconType: string;
+
+  /** List of participant DIDs that have been accepted into the cohort. */
+  participants: Array<string> = [];
+
+  /** Sorted list of cohort participants' compressed public keys. */
+  #cohortKeys: Array<Uint8Array> = [];
+
+  /** Taproot tweak (BIP-341 key-path-only). */
+  trMerkleRoot: Uint8Array = new Uint8Array();
+
+  /** The n-of-n MuSig2 Taproot beacon address. */
+  beaconAddress: string = '';
+
+  /** Pending DID updates submitted by participants, keyed by DID. */
+  pendingUpdates: Map<string, SignedBTCR2Update> = new Map();
+
+  /** CAS Beacon Announcement Map (DID → updateHash), set by buildCASAnnouncement(). */
+  casAnnouncement?: CASAnnouncement;
+
+  /** Per-participant SMT proofs, set by buildSMTTree(). */
+  smtProofs?: Map<string, SerializedSMTProof>;
+
+  /** Signal bytes (32 bytes) for OP_RETURN: SHA-256 of CAS announcement OR SMT root. */
+  signalBytes?: Uint8Array;
+
+  /** Set of participant DIDs that have approved the aggregated data. */
+  validationAcks: Set<string> = new Set();
+
+  /** Set of participant DIDs that have rejected the aggregated data. */
+  validationRejections: Set<string> = new Set();
+
+  constructor({ id, minParticipants, serviceDid, network, beaconType }: AggregationCohortParams) {
+    this.id = id || crypto.randomUUID();
+    this.minParticipants = minParticipants || 2;
+    this.serviceDid = serviceDid || '';
+    this.network = network;
+    this.beaconType = beaconType || 'CASBeacon';
+  }
+
+  /** Sorted cohort keys (sorted on assignment per BIP-327). */
+  get cohortKeys(): Array<Uint8Array> {
+    return this.#cohortKeys;
+  }
+
+  set cohortKeys(keys: Array<Uint8Array>) {
+    this.#cohortKeys = sortKeys(keys);
+  }
+
+  /**
+   * Computes the n-of-n MuSig2 Taproot beacon address from cohort keys.
+   * Sets `trMerkleRoot` to the BIP-341 key-path-only tweak.
+   */
+  public computeBeaconAddress(): string {
+    if(this.#cohortKeys.length === 0) {
+      throw new AggregationCohortError(
+        'Cannot compute beacon address: no cohort keys.',
+        'NO_COHORT_KEYS', { cohortId: this.id }
+      );
+    }
+    const keyAggContext = keyAggregate(this.#cohortKeys);
+    const aggPubkey = keyAggExport(keyAggContext);
+    const payment = payments.p2tr({ internalPubkey: 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);
+
+    if(!payment.address) {
+      throw new AggregationCohortError(
+        'Failed to compute Taproot address',
+        'BEACON_ADDRESS_ERROR', { cohortId: this.id }
+      );
+    }
+    this.beaconAddress = payment.address;
+    return payment.address;
+  }
+
+  /**
+   * Validates that the participant's key is in the cohort and the beacon address
+   * matches the locally-computed one. Used by participants to verify cohort ready
+   * messages from the service.
+   */
+  public validateMembership(
+    participantPkHex: string,
+    cohortKeysHex: Array<string>,
+    expectedBeaconAddress: string
+  ): void {
+    if(!cohortKeysHex.includes(participantPkHex)) {
+      throw new AggregationCohortError(
+        `Participant key not found in cohort ${this.id}.`,
+        'COHORT_VALIDATION_ERROR', { cohortId: this.id, participantPkHex }
+      );
+    }
+    this.cohortKeys = cohortKeysHex.map(k => hexToBytes(k));
+    const computed = this.computeBeaconAddress();
+    if(computed !== expectedBeaconAddress) {
+      throw new AggregationCohortError(
+        `Computed beacon address ${computed} does not match expected ${expectedBeaconAddress}.`,
+        'BEACON_ADDRESS_MISMATCH', { cohortId: this.id, computed, expected: expectedBeaconAddress }
+      );
+    }
+  }
+
+  public addUpdate(participantDid: string, signedUpdate: SignedBTCR2Update): void {
+    if(!this.participants.includes(participantDid)) {
+      throw new AggregationCohortError(
+        `Participant ${participantDid} is not in cohort ${this.id}.`,
+        'UNKNOWN_PARTICIPANT', { cohortId: this.id, participantDid }
+      );
+    }
+    this.pendingUpdates.set(participantDid, signedUpdate);
+  }
+
+  public hasAllUpdates(): boolean {
+    return this.pendingUpdates.size === this.participants.length;
+  }
+
+  /**
+   * Builds a CAS Announcement Map from collected updates.
+   * Maps each participant DID → base64url canonical hash of their signed update.
+   * Computes signal bytes as SHA-256 of canonicalized announcement.
+   */
+  public buildCASAnnouncement(): CASAnnouncement {
+    if(!this.hasAllUpdates()) {
+      throw new AggregationCohortError(
+        'Cannot build CAS Announcement: not all updates collected.',
+        'INCOMPLETE_UPDATES', { cohortId: this.id, collected: this.pendingUpdates.size, total: this.participants.length }
+      );
+    }
+    const announcement: CASAnnouncement = {};
+    for(const [did, signedUpdate] of this.pendingUpdates) {
+      announcement[did] = canonicalHash(signedUpdate);
+    }
+    this.casAnnouncement = announcement;
+    this.signalBytes = hash(canonicalize(announcement));
+    return announcement;
+  }
+
+  /**
+   * Builds an SMT tree from collected updates.
+   * Each entry uses a random 32-byte nonce + canonicalized signed update bytes.
+   * Stores per-participant proofs and the SMT root as signalBytes.
+   */
+  public buildSMTTree(): Map<string, SerializedSMTProof> {
+    if(!this.hasAllUpdates()) {
+      throw new AggregationCohortError(
+        'Cannot build SMT tree: not all updates collected.',
+        'INCOMPLETE_UPDATES', { cohortId: this.id }
+      );
+    }
+    const tree = new BTCR2MerkleTree();
+    const entries: TreeEntry[] = [];
+    const encoder = new TextEncoder();
+
+    for(const [did, signedUpdate] of this.pendingUpdates) {
+      const canonicalBytes = encoder.encode(canonicalize(signedUpdate));
+      const nonce = randomBytes(32);
+      entries.push({ did, nonce, signedUpdate: canonicalBytes });
+    }
+
+    tree.addEntries(entries);
+    tree.finalize();
+
+    this.signalBytes = tree.rootHash;
+    this.smtProofs = new Map();
+    for(const [did] of this.pendingUpdates) {
+      this.smtProofs.set(did, tree.proof(did));
+    }
+    return this.smtProofs;
+  }
+
+  public addValidation(participantDid: string, approved: boolean): void {
+    if(!this.participants.includes(participantDid)) {
+      throw new AggregationCohortError(
+        `Unknown participant ${participantDid} in cohort ${this.id}.`,
+        'UNKNOWN_PARTICIPANT', { cohortId: this.id, participantDid }
+      );
+    }
+    if(approved) {
+      this.validationAcks.add(participantDid);
+    } else {
+      this.validationRejections.add(participantDid);
+    }
+  }
+
+  /**
+   * True when every participant has either approved or rejected the aggregated data.
+   */
+  public hasAllValidationResponses(): boolean {
+    return this.validationAcks.size + this.validationRejections.size === this.participants.length;
+  }
+
+  /**
+   * True when all participants approved. Note: differs from {@link hasAllValidationResponses} —
+   * this returns false if any participant rejected, even if all responses are in.
+   */
+  public isFullyValidated(): boolean {
+    return this.validationRejections.size === 0
+      && this.validationAcks.size === this.participants.length;
+  }
+}

package/src/core/aggregation/errors.ts

@@ -0,0 +1,25 @@
+import { MethodError } from '@did-btcr2/common';
+
+export class AggregationServiceError extends MethodError {
+  constructor(message: string, type: string = 'AggregationServiceError', data?: Record<string, any>) {
+    super(message, type, data);
+  }
+}
+
+export class AggregationParticipantError extends MethodError {
+  constructor(message: string, type: string = 'AggregationParticipantError', data?: Record<string, any>) {
+    super(message, type, data);
+  }
+}
+
+export class AggregationCohortError extends MethodError {
+  constructor(message: string, type: string = 'AggregationCohortError', data?: Record<string, any>) {
+    super(message, type, data);
+  }
+}
+
+export class SigningSessionError extends MethodError {
+  constructor(message: string, type: string = 'SigningSessionError', data?: Record<string, any>) {
+    super(message, type, data);
+  }
+}

package/src/core/{beacon/aggregation/cohort → aggregation}/messages/base.ts

@@ -1,5 +1,3 @@
-export const MESSAGE_PREFIX = 'https://btcr2.tools/';
-
 export type BaseBody = {
   cohortId: string;
   cohortSize?: number;
@@ -12,8 +10,15 @@ export type BaseBody = {
   nonceContribution?: Uint8Array;
   partialSignature?: Uint8Array;
   pendingTx?: string;
+  prevOutValue?: string;
+  communicationPk?: Uint8Array;
   beaconType?: string;
   data?: string;
+  signedUpdate?: Record<string, unknown>;
+  casAnnouncement?: Record<string, string>;
+  smtProof?: Record<string, unknown>;
+  signalBytesHex?: string;
+  approved?: boolean;
 };
 
 export type Base = {
@@ -48,4 +53,4 @@ export class BaseMessage {
       body : this.body
     };
   }
-}
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Message type URLs for the did:btcr2 Aggregate Beacon protocol.
+ *
+ * Naming follows the spec (https://dcdpr.github.io/did-btcr2/beacons/aggregate-beacons.html):
+ * - Step 1 (Cohort Formation): COHORT_ADVERT, COHORT_OPT_IN, COHORT_OPT_IN_ACCEPT, COHORT_READY
+ * - Step 2 (Update Submission): SUBMIT_UPDATE
+ * - Step 3 (Aggregate & Validate): DISTRIBUTE_AGGREGATED_DATA, VALIDATION_ACK
+ * - Step 4 (Sign & Broadcast): AUTHORIZATION_REQUEST, NONCE_CONTRIBUTION,
+ *   AGGREGATED_NONCE, SIGNATURE_AUTHORIZATION
+ */
+export const AGGREGATION_MESSAGE_PREFIX = 'https://btcr2.dev/aggregation';
+
+// Step 1: Cohort Formation
+export const COHORT_ADVERT = `${AGGREGATION_MESSAGE_PREFIX}/keygen/cohort_advert`;
+export const COHORT_OPT_IN = `${AGGREGATION_MESSAGE_PREFIX}/keygen/cohort_opt_in`;
+export const COHORT_OPT_IN_ACCEPT = `${AGGREGATION_MESSAGE_PREFIX}/keygen/cohort_opt_in_accept`;
+export const COHORT_READY = `${AGGREGATION_MESSAGE_PREFIX}/keygen/cohort_ready`;
+
+// Step 2 + 3: Update Submission, Aggregation, Validation
+export const SUBMIT_UPDATE = `${AGGREGATION_MESSAGE_PREFIX}/update/submit_update`;
+export const DISTRIBUTE_AGGREGATED_DATA = `${AGGREGATION_MESSAGE_PREFIX}/update/distribute_aggregated_data`;
+export const VALIDATION_ACK = `${AGGREGATION_MESSAGE_PREFIX}/update/validation_ack`;
+
+// Step 4: Signing
+export const AUTHORIZATION_REQUEST = `${AGGREGATION_MESSAGE_PREFIX}/sign/authorization_request`;
+export const NONCE_CONTRIBUTION = `${AGGREGATION_MESSAGE_PREFIX}/sign/nonce_contribution`;
+export const AGGREGATED_NONCE = `${AGGREGATION_MESSAGE_PREFIX}/sign/aggregated_nonce`;
+export const SIGNATURE_AUTHORIZATION = `${AGGREGATION_MESSAGE_PREFIX}/sign/signature_authorization`;

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

@@ -0,0 +1,240 @@
+import { 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';
+
+/**
+ * Step 1: Cohort Formation
+ * Factory functions for creating messages related to the cohort formation step, where cohorts are
+ * formed and participants opt in to join the cohort.
+ */
+type CohortAdvertMessage = {
+  from: string;
+  cohortId: string;
+  cohortSize: number;
+  beaconType: string;
+  network: string;
+  communicationPk: Uint8Array;
+};
+type CohortOptInMessage = {
+  from: string;
+  to: string;
+  cohortId: string;
+  participantPk: Uint8Array;
+  communicationPk: Uint8Array;
+};
+type CohortOptInAcceptMessage = {
+  from: string;
+  to: string;
+  cohortId: string;
+};
+type CohortReadyMessage = {
+  from: string;
+  to: string;
+  cohortId: string;
+  beaconAddress: string;
+  cohortKeys: Array<Uint8Array>;
+};
+
+/**
+ * Factory function for creating a Cohort Advert message, which is used to announce the formation of
+ * a new cohort and invite participants to join.
+ * @param {CohortAdvertMessage} fields - The fields required to create a Cohort Advert message.
+ * @returns {BaseMessage} The created Cohort Advert message.
+ */
+export function createCohortAdvertMessage(fields: CohortAdvertMessage): BaseMessage {
+  const { from, ...body } = fields;
+  return new BaseMessage({ type: COHORT_ADVERT, from, body });
+}
+
+/**
+ * Factory function for creating a Cohort Opt-In message, which is sent by a participant to express
+ * interest in joining a cohort.
+ * @param {CohortOptInMessage} fields - The fields required to create a Cohort Opt-In message, which
+ * is sent by a participant to express interest in joining a cohort.
+ * @returns {BaseMessage} The created Cohort Opt-In message.
+ */
+export function createCohortOptInMessage(fields: CohortOptInMessage): BaseMessage {
+  const { from, to, ...body } = fields;
+  return new BaseMessage({ type: COHORT_OPT_IN, from, to, body });
+}
+
+export function createCohortOptInAcceptMessage(fields: CohortOptInAcceptMessage): BaseMessage {
+  const { from, to, ...body } = fields;
+  return new BaseMessage({ type: COHORT_OPT_IN_ACCEPT, from, to, body });
+}
+
+export function createCohortReadyMessage(fields: CohortReadyMessage): BaseMessage {
+  const { from, to, ...body } = fields;
+  return new BaseMessage({ type: COHORT_READY, from, to, body });
+}
+
+/**
+ * Step 2: Update Submission
+ * Factory functions for creating messages related to the update submission step, where participants
+ * submit their signed updates for aggregation.
+ */
+type SubmitUpdateMessage = {
+  from: string;
+  to: string;
+  cohortId: string;
+  signedUpdate: Record<string, unknown>;
+};
+
+/**
+ * Factory function for creating a Submit Update message, which is sent by a participant to submit
+ * their signed update for aggregation.
+ * @param {SubmitUpdateMessage} fields - The fields required to create a Submit Update message,
+ * which is sent by a participant to submit their signed update for aggregation.
+ * @returns {BaseMessage} The created Submit Update message.
+ */
+export function createSubmitUpdateMessage(fields: SubmitUpdateMessage): BaseMessage {
+  const { from, to, ...body } = fields;
+  return new BaseMessage({ type: SUBMIT_UPDATE, from, to, body });
+}
+
+/**
+ * Step 3: Aggregate & Validate
+ * Factory functions for creating messages related to the aggregate and validate step, where
+ * participants aggregate their updates and validate the aggregated data.
+ */
+
+type DistributeAggregatedDataMessage = {
+  from: string;
+  to: string;
+  cohortId: string;
+  beaconType: string;
+  signalBytesHex: string;
+  casAnnouncement?: Record<string, string>;
+  smtProof?: Record<string, unknown>;
+};
+type ValidationAckMessage = {
+  from: string;
+  to: string;
+  cohortId: string;
+  approved: boolean;
+};
+
+/**
+ * Factory function for creating a Distribute Aggregated Data message, which is sent by the
+ * aggregator to distribute the aggregated data to participants for validation.
+ * @param {DistributeAggregatedDataMessage} fields - The fields required to create a Distribute
+ * Aggregated Data message, which is sent by the aggregator to distribute the aggregated data to
+ * participants for validation.
+ * @returns {BaseMessage} The created Distribute Aggregated Data message.
+ */
+export function createDistributeAggregatedDataMessage(
+  fields: DistributeAggregatedDataMessage
+): BaseMessage {
+  const { from, to, ...body } = fields;
+  return new BaseMessage({ type: DISTRIBUTE_AGGREGATED_DATA, from, to, body });
+}
+
+/**
+ * Factory function for creating a Validation Acknowledgment message, which is sent by a participant
+ * to acknowledge.
+ * @param {ValidationAckMessage} fields - The fields required to create a Validation Acknowledgment
+ * message, which is sent by a participant to acknowledge the validation of the aggregated data.
+ * @returns {BaseMessage} The created Validation Acknowledgment message.
+ */
+export function createValidationAckMessage(fields: ValidationAckMessage): BaseMessage {
+  const { from, to, ...body } = fields;
+  return new BaseMessage({ type: VALIDATION_ACK, from, to, body });
+}
+
+/**
+ * Step 4: Signing
+ * Factory functions for creating messages related to the signing step, where participants request
+ * signatures, contribute nonces, and authorize signatures.
+ */
+
+type AuthorizationRequestMessage = {
+  from: string;
+  to: string;
+  cohortId: string;
+  sessionId: string;
+  pendingTx: string;
+  prevOutValue: string;
+};
+type NonceContributionMessage = {
+  from: string;
+  to: string;
+  cohortId: string;
+  sessionId: string;
+  nonceContribution: Uint8Array;
+};
+type AggregatedNonceMessage = {
+  from: string;
+  to: string;
+  cohortId: string;
+  sessionId: string;
+  aggregatedNonce: Uint8Array;
+};
+type SignatureAuthorizationMessage = {
+  from: string;
+  to: string;
+  cohortId: string;
+  sessionId: string;
+  partialSignature: Uint8Array;
+};
+
+/**
+ * Factory function for creating an Authorization Request message, which is sent by a participant to
+ * request authorization for their signature.
+ * @param {AuthorizationRequestMessage} fields - The fields required to create an Authorization
+ * Request message, which is sent by a participant to request authorization for their signature.
+ * @returns {BaseMessage} The created Authorization Request message.
+ */
+export function createAuthorizationRequestMessage(fields: AuthorizationRequestMessage): BaseMessage {
+  const { from, to, ...body } = fields;
+  return new BaseMessage({ type: AUTHORIZATION_REQUEST, from, to, body });
+}
+
+/**
+ * Factory function for creating a Nonce Contribution message, which is sent by a participant to
+ * contribute their nonce for the signature aggregation process.
+ * @param {NonceContributionMessage} fields - The fields required to create a Nonce Contribution
+ * message, which is sent by a participant to contribute their nonce for the signature aggregation
+ * process.
+ * @returns {BaseMessage} The created Nonce Contribution message.
+ */
+export function createNonceContributionMessage(fields: NonceContributionMessage): BaseMessage {
+  const { from, to, ...body } = fields;
+  return new BaseMessage({ type: NONCE_CONTRIBUTION, from, to, body });
+}
+
+/**
+ * Factory function for creating an Aggregated Nonce message, which is sent by the aggregator to
+ * distribute the aggregated nonce to participants for the signature aggregation process.
+ * @param {AggregatedNonceMessage} fields - The fields required to create an Aggregated Nonce
+ * message, which is sent by the aggregator to distribute the aggregated nonce to participants for
+ * the signature aggregation process.
+ * @returns {BaseMessage} The created Aggregated Nonce message.
+ */
+export function createAggregatedNonceMessage(fields: AggregatedNonceMessage): BaseMessage {
+  const { from, to, ...body } = fields;
+  return new BaseMessage({ type: AGGREGATED_NONCE, from, to, body });
+}
+
+/**
+ * Factory function for creating a Signature Authorization message, which is sent by a participant
+ * to authorize their partial signature for the signature aggregation process.
+ * @param {SignatureAuthorizationMessage} fields - The fields required to create a Signature
+ * Authorization message, which is sent by a participant to authorize their partial signature for
+ * the signature aggregation process.
+ * @returns {BaseMessage} The created Signature Authorization message.
+ */
+export function createSignatureAuthorizationMessage(fields: SignatureAuthorizationMessage): BaseMessage {
+  const { from, to, ...body } = fields;
+  return new BaseMessage({ type: SIGNATURE_AUTHORIZATION, from, to, body });
+}

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

@@ -0,0 +1,55 @@
+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';
+
+const KEYGEN_VALUES: Set<string> = new Set([
+  COHORT_ADVERT,
+  COHORT_OPT_IN,
+  COHORT_OPT_IN_ACCEPT,
+  COHORT_READY,
+]);
+
+const UPDATE_VALUES: Set<string> = new Set([
+  SUBMIT_UPDATE,
+  DISTRIBUTE_AGGREGATED_DATA,
+  VALIDATION_ACK,
+]);
+
+const SIGN_VALUES: Set<string> = new Set([
+  AUTHORIZATION_REQUEST,
+  NONCE_CONTRIBUTION,
+  AGGREGATED_NONCE,
+  SIGNATURE_AUTHORIZATION,
+]);
+
+/**
+ * Checks if the provided type is a valid aggregation message type.
+ */
+export function isAggregationMessageType(type: string): boolean {
+  return KEYGEN_VALUES.has(type) || UPDATE_VALUES.has(type) || SIGN_VALUES.has(type);
+}
+
+/** Checks if the message type belongs to the keygen phase. */
+export function isKeygenMessageType(type: string): boolean {
+  return KEYGEN_VALUES.has(type);
+}
+
+/** Checks if the message type belongs to the update phase. */
+export function isUpdateMessageType(type: string): boolean {
+  return UPDATE_VALUES.has(type);
+}
+
+/** Checks if the message type belongs to the signing phase. */
+export function isSignMessageType(type: string): boolean {
+  return SIGN_VALUES.has(type);
+}

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

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