@did-btcr2/method 0.17.2 → 0.18.0

package/src/core/beacon/aggregation/cohort/index.ts

@@ -0,0 +1,292 @@
+import { keyAggExport, keyAggregate, sortKeys } from '@scure/btc-signer/musig2';
+import { payments, Transaction } from 'bitcoinjs-lib';
+import { BeaconCoordinatorError } from '../../error.js';
+import { BeaconCohortSigningSession } from '../session/index.js';
+import { BeaconCohortReadyMessage } from './messages/keygen/cohort-ready.js';
+import { BeaconCohortRequestSignatureMessage } from './messages/sign/request-signature.js';
+import { COHORT_STATUS, COHORT_STATUS_TYPE } from './status.js';
+
+export type Musig2CohortObject = {
+    id?: string;
+    coordinatorDid?: string;
+    minParticipants?: number;
+    status?: COHORT_STATUS_TYPE;
+    network: string;
+    beaconType?: string;
+}
+
+export interface BeaconCohort {
+  id?: string;
+  coordinatorDid: string;
+  minParticipants: number;
+  status: COHORT_STATUS_TYPE;
+  network: string;
+  pendingSignatureRequests?: Record<string, string>;
+  participants?: Array<string>;
+  cohortKeys?: Array<Uint8Array>;
+  trMerkleRoot?: Uint8Array;
+  beaconAddress?: string;
+}
+
+export class AggregateBeaconCohort implements BeaconCohort {
+  /**
+   * Unique identifier for the cohort.
+   * @type {string}
+   */
+  public id: string;
+
+  /**
+   * DID of the coordinator.
+   * @type {string}
+   */
+  public coordinatorDid: string;
+
+  /**
+   * Minimum number of participants required to finalize the cohort.
+   * @type {number}
+   */
+  public minParticipants: number;
+
+  /**
+   * Status of the cohort.
+   * @type {string}
+   */
+  public status: COHORT_STATUS_TYPE;
+
+  /**
+   * Network on which the cohort operates (e.g., 'mainnet', 'testnet').
+   * @type {string}
+   */
+  public network: string;
+
+  /**
+   * Pending signature requests, mapping participant DIDs to their pending signatures.
+   * @type {Record<string, string>}
+   */
+  public pendingSignatureRequests: Record<string, string> = {};
+
+  /**
+   * List of participant DIDs.
+   * @type {Array<string>}
+   */
+  public participants: Array<string> = new Array<string>();
+
+  /**
+   * List of cohort keys.
+   * @type {Array<Uint8Array>}
+   */
+  public _cohortKeys: Array<Uint8Array> = new Array<Uint8Array>();
+
+  /**
+   * Taproot Merkle root for the cohort.
+   * @type {Uint8Array}
+   */
+  public trMerkleRoot: Uint8Array = new Uint8Array();
+
+  /**
+   * Beacon address for the cohort, calculated from the Taproot multisig.
+   * @type {string}
+   */
+  public beaconAddress: string = '';
+
+  /**
+   * Type of beacon used in the cohort (default is 'SMTAggregateBeacon').
+   * @type {string}
+   */
+  public beaconType: string;
+
+  /**
+   * Creates a new Musig2Cohort instance.
+   * @param {Musig2CohortObject} params Parameters for initializing the cohort.
+   * @param {string} [params.id] Optional unique identifier for the cohort. If not provided, a random UUID will be generated.
+   * @param {number} params.minParticipants Minimum number of participants required to finalize the cohort.
+   * @param {string} [params.coordinatorDid] DID of the coordinator managing the cohort.
+   * @param {string} params.status Initial status of the cohort (e.g., 'PENDING', 'COHORT_SET').
+   * @param {string} params.network Network on which the cohort operates (e.g., 'mainnet', 'testnet').
+   */
+  constructor({ id, minParticipants, coordinatorDid, status, network, beaconType }: Musig2CohortObject) {
+    this.id = id || crypto.randomUUID();
+    this.minParticipants = minParticipants || 2;
+    this.coordinatorDid = coordinatorDid || '';
+    this.status = status as COHORT_STATUS_TYPE || COHORT_STATUS.COHORT_ADVERTISED;
+    this.network = network;
+    this.beaconType = beaconType || 'SMTAggregateBeacon';
+  }
+
+  set cohortKeys(keys: Array<Uint8Array>) {
+    this.cohortKeys = sortKeys(keys);
+  }
+
+  public validateCohort(participantKeys: Array<string>, cohortKeys: Array<string>, beaconAddress: string): void {
+    for(const key of participantKeys){
+      if(!cohortKeys.includes(key)) {
+        this.status = COHORT_STATUS.COHORT_FAILED;
+        throw new BeaconCoordinatorError(
+          `Participant key ${key} not found in cohort ${this.id}.`,
+          'COHORT_VALIDATION_ERROR',
+          {
+            cohortId        : this.id,
+            participantKeys : participantKeys,
+            cohortKeys      : cohortKeys,
+            beaconAddress   : beaconAddress
+          }
+        );
+      }
+    }
+    this.cohortKeys = cohortKeys.map(key => Buffer.from(key, 'hex'));
+    const calculatedAddress = this.calulateBeaconAddress();
+    if (calculatedAddress !== beaconAddress) {
+      this.status = COHORT_STATUS.COHORT_FAILED;
+      throw new BeaconCoordinatorError(
+        `Calculated beacon address ${calculatedAddress} does not match provided address ${beaconAddress}.`,
+        'COHORT_ADDRESS_MISMATCH_ERROR',
+        {
+          cohortId        : this.id,
+          calculatedAddress,
+          providedAddress : beaconAddress
+        }
+      );
+    }
+    this.beaconAddress = beaconAddress;
+    this.status = COHORT_STATUS.COHORT_SET_STATUS;
+  }
+
+  /**
+   * Finalizes the cohort by checking if the minimum number of participants is met.
+   * If the minimum is met, it sets the status to 'COHORT_SET_STATUS' and calculates the beacon address.
+   * @throws {BeaconCoordinatorError} If the number of participants is less than the minimum required.
+   * @returns {void}
+   */
+  public finalize(): void {
+    if(this.participants.length < this.minParticipants) {
+      throw new BeaconCoordinatorError(
+        'Not enough participants to finalize the cohort',
+        'FINALIZE_COHORT_ERROR',
+        {
+          cohortId        : this.id,
+          participants    : this.participants,
+          minParticipants : this.minParticipants
+        }
+      );
+    }
+    this.status = COHORT_STATUS.COHORT_SET_STATUS;
+    this.beaconAddress = this.calulateBeaconAddress();
+  }
+
+  /**
+   * Calculates the beacon Taproot multisig address for the cohort using participant keys.
+   * @returns {string} The Taproot address for the cohort.
+   * @throws {BeaconCoordinatorError} If the Taproot address cannot be calculated.
+   */
+  public calulateBeaconAddress(): string {
+    const keyAggContext = keyAggregate(this.cohortKeys);
+    const aggPubkey = keyAggExport(keyAggContext);
+    const payment = payments.p2tr({ internalPubkey: aggPubkey });
+    if(!payment.hash) {
+      throw new BeaconCoordinatorError(
+        'Failed to calculate Taproot Merkle root',
+        'CALCULATE_BEACON_MERKLE_ROOT_ERROR',
+        {
+          cohortId        : this.id,
+          cohortKeys      : this.cohortKeys,
+          minParticipants : this.minParticipants
+        }
+      );
+    }
+    this.trMerkleRoot = payment.hash;
+    if(!payment.address) {
+      throw new BeaconCoordinatorError(
+        'Failed to calculate Taproot address',
+        'CALCULATE_BEACON_ADDRESS_ERROR',
+        {
+          cohortId        : this.id,
+          cohortKeys      : this.cohortKeys,
+          minParticipants : this.minParticipants
+        }
+      );
+    }
+    return payment.address;
+  }
+
+  /**
+   * Generates a CohortReadyMessage to be sent to participants when the cohort is set.
+   * @param {string} to The DID of the participant to whom the message is sent.
+   * @param {string} from The DID of the coordinator sending the message.
+   * @returns {BeaconCohortReadyMessage} The CohortReadyMessage containing the cohort details.
+   */
+  public getCohortReadyMessage(to: string, from: string): BeaconCohortReadyMessage {
+    if(this.status !== COHORT_STATUS.COHORT_SET_STATUS) {
+      throw new BeaconCoordinatorError('Cohort status not "COHORT_SET".');
+    }
+    return new BeaconCohortReadyMessage({
+      to,
+      from,
+      cohortId      : this.id,
+      beaconAddress : this.beaconAddress,
+      cohortKeys    : this.cohortKeys,
+    });
+  }
+
+  /**
+   * Adds a signature request to the pending requests for the cohort.
+   * @param {BeaconCohortRequestSignatureMessage} message The signature request message to add.
+   * @throws {Error} If a signature request from the same participant already exists.
+   */
+  public addSignatureRequest(message: BeaconCohortRequestSignatureMessage): void {
+    if(!this.validateSignatureRequest(message)) {
+      throw new BeaconCoordinatorError(`No signature request from ${message.from} in cohort ${this.id}.`);
+    }
+
+    if(!message.body?.data) {
+      throw new BeaconCoordinatorError(`No signature data in request from ${message.from} in cohort ${this.id}.`);
+    }
+
+    this.pendingSignatureRequests[message.from] = message.body.data;
+  }
+
+  /**
+   * Validates a signature request message to ensure it is from a participant in the cohort.
+   * @param {BeaconCohortRequestSignatureMessage} message The signature request message to validate.
+   * @returns {boolean} True if the message is valid, false otherwise.
+   */
+  public validateSignatureRequest(message: BeaconCohortRequestSignatureMessage): boolean {
+    const cohortId = message.body?.cohortId;
+    if(cohortId !== this.id) {
+      console.info(`Signature request for wrong cohort: ${cohortId}.`);
+      return false;
+    }
+
+    if(!this.participants.includes(message.from)) {
+      console.info(`Participant ${message.from} not in cohort ${this.id}.`);
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+   * Starts a signing session for the cohort.
+   * @returns {BeaconCohortSigningSession} The request signature message for the signing session.
+   */
+  public startSigningSession(): BeaconCohortSigningSession {
+    console.debug(`Starting signing session for cohort ${this.id} with status ${this.status}`);
+    if(this.status !== COHORT_STATUS.COHORT_SET_STATUS) {
+      throw new BeaconCoordinatorError(`Cohort ${this.id} is not set.`);
+    }
+    // const smtRootBytes = new Uint8Array(32).map(() => Math.floor(Math.random() * 256));
+    const cohort = new AggregateBeaconCohort(this);
+    return new BeaconCohortSigningSession({
+      cohort,
+      pendingTx         : new Transaction(),
+      processedRequests : this.pendingSignatureRequests,
+    });
+  }
+
+  /**
+   * Converts the cohort instance to a JSON object representation.
+   * @returns {BeaconCohort} The JSON object representation of the cohort.
+   */
+  public json(): BeaconCohort {
+    return Object.json(this) as BeaconCohort;
+  }
+}

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

@@ -9,34 +9,38 @@ export type BaseBody = {
   participantPk?: Uint8Array;
   beaconAddress?: string;
   cohortKeys?: Array<Uint8Array>;
+  sessionId?: string;
+  aggregatedNonce?: Uint8Array;
+  nonceContribution?: Uint8Array;
+  partialSignature?: Uint8Array;
+  pendingTx?: string;
+  beaconType?: string;
+  data?: string;
 };
 
 export type Base = {
   type: string;
-  to: string;
+  to?: string;
   from: string;
-  threadId?: string;
-  body: BaseBody;
+  body?: BaseBody;
 };
 
 export class BaseMessage {
   public type: string;
-  public to: string;
+  public to?: string;
   public from: string;
-  public threadId?: string;
-  public body: BaseBody;
+  public body?: BaseBody;
 
-  constructor({ type, to, from, threadId, body }: Base) {
+  constructor({ type, to, from, body }: Base) {
     this.type = type;
     this.to = to;
     this.from = from;
-    this.threadId = threadId;
     this.body = body;
   }
 
   /**
    * Creates a BaseMessage from a JSON object.
-   * @param {Maybe<Base>} data - The JSON object to initialize the BaseMessage.
+   * @param {Maybe<Base>} data The JSON object to initialize the BaseMessage.
    * @returns {BaseMessage} The initialized BaseMessage.
    */
   public static fromJSON(data: Maybe<Base>): BaseMessage {
@@ -48,12 +52,6 @@ export class BaseMessage {
    * @returns {Base} The JSON representation of the BaseMessage.
    */
   public json(): Base {
-    return {
-      type     : this.type,
-      to       : this.to,
-      from     : this.from,
-      threadId : this.threadId,
-      body     : this.body ?? {}
-    };
+    return Object.json(this) as Base;
   }
 }

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

@@ -0,0 +1,12 @@
+export const BEACON_COHORT_MESSAGE_PREFIX = 'https://btcr2.dev';
+
+export const BEACON_COHORT_ADVERT = `${BEACON_COHORT_MESSAGE_PREFIX}/musig2/keygen/beacon/cohort_advert`;
+export const BEACON_COHORT_OPT_IN = `${BEACON_COHORT_MESSAGE_PREFIX}/musig2/keygen/beacon/cohort_opt_in`;
+export const BEACON_COHORT_OPT_IN_ACCEPT = `${BEACON_COHORT_MESSAGE_PREFIX}/musig2/keygen/beacon/cohort_opt_in_accept`;
+export const BEACON_COHORT_READY = `${BEACON_COHORT_MESSAGE_PREFIX}/musig2/keygen/beacon/cohort_ready`;
+
+export const BEACON_COHORT_REQUEST_SIGNATURE = `${BEACON_COHORT_MESSAGE_PREFIX}/musig2/sign/beacon/cohort_request_signature`;
+export const BEACON_COHORT_AUTHORIZATION_REQUEST = `${BEACON_COHORT_MESSAGE_PREFIX}/musig2/sign/beacon/cohort_authorization_request`;
+export const BEACON_COHORT_NONCE_CONTRIBUTION = `${BEACON_COHORT_MESSAGE_PREFIX}/musig2/sign/beacon/cohort_nonce_contribution`;
+export const BEACON_COHORT_AGGREGATED_NONCE = `${BEACON_COHORT_MESSAGE_PREFIX}/musig2/sign/beacon/cohort_aggregated_nonce`;
+export const BEACON_COHORT_SIGNATURE_AUTHORIZATION = `${BEACON_COHORT_MESSAGE_PREFIX}/musig2/sign/beacon/cohort_signature_authorization`;

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

@@ -0,0 +1,143 @@
+import {
+  BEACON_COHORT_ADVERT,
+  BEACON_COHORT_AGGREGATED_NONCE,
+  BEACON_COHORT_AUTHORIZATION_REQUEST,
+  BEACON_COHORT_NONCE_CONTRIBUTION,
+  BEACON_COHORT_OPT_IN,
+  BEACON_COHORT_OPT_IN_ACCEPT,
+  BEACON_COHORT_READY,
+  BEACON_COHORT_REQUEST_SIGNATURE,
+  BEACON_COHORT_SIGNATURE_AUTHORIZATION
+} from './constants.js';
+import { CohortAdvertMessage } from './keygen/cohort-advert.js';
+import { CohortReadyMessage } from './keygen/cohort-ready.js';
+import { CohortOptInAcceptMessage } from './keygen/opt-in-accept.js';
+import { CohortOptInMessage } from './keygen/opt-in.js';
+import { CohortSubscribeMessage } from './keygen/subscribe.js';
+import { CohortAggregatedNonceMessage } from './sign/aggregated-nonce.js';
+import { CohortAuthorizationRequestMessage } from './sign/authorization-request.js';
+import { CohortNonceContributionMessage } from './sign/nonce-contribution.js';
+import { CohortRequestSignatureMessage } from './sign/request-signature.js';
+import { CohortSignatureAuthorizationMessage } from './sign/signature-authorization.js';
+
+export type KeyGenMessageType =
+  | CohortAdvertMessage
+  | CohortReadyMessage
+  | CohortOptInMessage
+  | CohortOptInAcceptMessage
+  | CohortSubscribeMessage;
+
+export type SignMessageType =
+  | CohortAggregatedNonceMessage
+  | CohortAuthorizationRequestMessage
+  | CohortNonceContributionMessage
+  | CohortRequestSignatureMessage
+  | CohortSignatureAuthorizationMessage;
+
+export type AggregateBeaconMessageType = KeyGenMessageType | SignMessageType;
+
+/**
+ * AggregateBeaconMessage is a utility class that provides constants and type checks
+ * for various message types used in the aggregate beacon communication protocol.
+ * It includes methods to validate message types and retrieve message types from objects.
+ * @class AggregateBeaconMessage
+ * @type {AggregateBeaconMessageType}
+ */
+export class AggregateBeaconMessage {
+  static BEACON_COHORT_ADVERT = BEACON_COHORT_ADVERT;
+  static BEACON_COHORT_OPT_IN = BEACON_COHORT_OPT_IN;
+  static BEACON_COHORT_READY = BEACON_COHORT_READY;
+  static BEACON_COHORT_OPT_IN_ACCEPT = BEACON_COHORT_OPT_IN_ACCEPT;
+
+  static BEACON_COHORT_KEY_GEN_MESSAGES: Map<string, string> = new Map([
+    ['BEACON_COHORT_ADVERT', 'BEACON_COHORT_ADVERT'],
+    ['BEACON_COHORT_OPT_IN', 'BEACON_COHORT_OPT_IN'],
+    ['BEACON_COHORT_READY', 'BEACON_COHORT_READY'],
+    ['BEACON_COHORT_OPT_IN_ACCEPT', 'BEACON_COHORT_OPT_IN_ACCEPT'],
+  ]);
+
+  static BEACON_COHORT_REQUEST_SIGNATURE = BEACON_COHORT_REQUEST_SIGNATURE;
+  static BEACON_COHORT_AUTHORIZATION_REQUEST = BEACON_COHORT_AUTHORIZATION_REQUEST;
+  static BEACON_COHORT_NONCE_CONTRIBUTION = BEACON_COHORT_NONCE_CONTRIBUTION;
+  static BEACON_COHORT_AGGREGATED_NONCE = BEACON_COHORT_AGGREGATED_NONCE;
+  static BEACON_COHORT_SIGNATURE_AUTHORIZATION = BEACON_COHORT_SIGNATURE_AUTHORIZATION;
+
+  static BEACON_COHORT_SIGN_MESSAGES: Map<string, string> = new Map([
+    ['BEACON_COHORT_REQUEST_SIGNATURE', 'BEACON_COHORT_REQUEST_SIGNATURE'],
+    ['BEACON_COHORT_AUTHORIZATION_REQUEST', 'BEACON_COHORT_AUTHORIZATION_REQUEST'],
+    ['BEACON_COHORT_NONCE_CONTRIBUTION', 'BEACON_COHORT_NONCE_CONTRIBUTION'],
+    ['BEACON_COHORT_AGGREGATED_NONCE', 'BEACON_COHORT_AGGREGATED_NONCE'],
+    ['BEACON_COHORT_SIGNATURE_AUTHORIZATION', 'BEACON_COHORT_SIGNATURE_AUTHORIZATION'],
+  ]);
+
+  static ALL_MESSAGES: string[] = [
+    BEACON_COHORT_ADVERT,
+    BEACON_COHORT_OPT_IN,
+    BEACON_COHORT_READY,
+    BEACON_COHORT_OPT_IN_ACCEPT,
+    BEACON_COHORT_REQUEST_SIGNATURE,
+    BEACON_COHORT_AUTHORIZATION_REQUEST,
+    BEACON_COHORT_NONCE_CONTRIBUTION,
+    BEACON_COHORT_AGGREGATED_NONCE,
+    BEACON_COHORT_SIGNATURE_AUTHORIZATION
+  ];
+
+  /**
+   * Checks if the name provided is a valid message name.
+   * @param {string} type - The type of the message.
+   * @returns
+   */
+  static isValidType(type: string): boolean {
+    return this.BEACON_COHORT_KEY_GEN_MESSAGES.has(type) || this.BEACON_COHORT_SIGN_MESSAGES.has(type);
+  }
+
+  /**
+   * Get the message value based on the type.
+   * @param {string} type - The type (or name) of the message.
+   * @returns {string | undefined} - The corresponding type value.
+   */
+  static getMessageValueByType(type: string): string | undefined {
+    if(!this.isValidType(type)) {
+      return undefined;
+    }
+    return this.BEACON_COHORT_KEY_GEN_MESSAGES.get(type) || this.BEACON_COHORT_SIGN_MESSAGES.get(type);
+  }
+
+  /**
+   * Checks if the provided type is a valid AggregateBeaconMessageType.
+   * @param {string} type - The message type to check.
+   * @returns {boolean} - Returns true if the type is valid, otherwise false.
+   */
+  static isValidValue(type: string): boolean {
+    return this.ALL_MESSAGES.includes(type);
+  }
+
+  /**
+   * Checks if the provided type is a valid KeyGenMessageType.
+   * @param {string} value - The message type to check.
+   * @returns {boolean} - Returns true if the type is a key generation message type, otherwise false.
+   */
+  static isKeyGenMessageValue(value: string): boolean {
+    return this.isValidValue(value) && [
+      BEACON_COHORT_ADVERT,
+      BEACON_COHORT_READY,
+      BEACON_COHORT_OPT_IN,
+      BEACON_COHORT_OPT_IN_ACCEPT,
+    ].includes(value);
+  }
+
+  /**
+   * Checks if the provided type is a valid SignMessageType.
+   * @param {string} value - The message type to check.
+   * @returns {boolean} - Returns true if the type is a sign message type, otherwise false.
+   */
+  static isSignMessageValue(value: string): boolean {
+    return this.isValidValue(value) && [
+      BEACON_COHORT_AGGREGATED_NONCE,
+      BEACON_COHORT_AUTHORIZATION_REQUEST,
+      BEACON_COHORT_NONCE_CONTRIBUTION,
+      BEACON_COHORT_REQUEST_SIGNATURE,
+      BEACON_COHORT_SIGNATURE_AUTHORIZATION
+    ].includes(value);
+  }
+}

package/src/core/beacon/aggregation/cohort/messages/keygen/cohort-advert.ts

@@ -0,0 +1,43 @@
+import { Maybe } from '@did-btcr2/common';
+import { BaseMessage } from '../base.js';
+import { BEACON_COHORT_ADVERT } from '../constants.js';
+
+export interface CohortAdvertMessage {
+  type?: typeof BEACON_COHORT_ADVERT;
+  id?: string;
+  from: string;
+  cohortId: string;
+  cohortSize: number;
+  beaconType: string;
+  network: string;
+}
+
+/**
+ * Represents a message advertising a cohort to potential participants.
+ * @class BeaconCohortAdvertMessage
+ * @extends BaseMessage
+ * @type {BeaconCohortAdvertMessage}
+ */
+export class BeaconCohortAdvertMessage extends BaseMessage {
+  public id: string;
+
+  constructor({ from, id, cohortId, cohortSize, beaconType, network }: CohortAdvertMessage) {
+    const body = { cohortId, cohortSize, beaconType, network };
+    const type = BEACON_COHORT_ADVERT;
+    super({ from, body, type });
+    this.id = id || `${type}/${cohortId}`;
+  }
+
+  /**
+   * Initializes a BeaconCohortAdvertMessage from a possible CohortAdvertMessage object.
+   * @param {CohortAdvertMessage} data The CohortAdvertMessage object to initialize the BeaconCohortAdvertMessage.
+   * @returns {BeaconCohortAdvertMessage} The new BeaconCohortAdvertMessage.
+   */
+  public static fromJSON(data: Maybe<CohortAdvertMessage>): BeaconCohortAdvertMessage {
+    const message = JSON.parse(data);
+    if (message.type !== BEACON_COHORT_ADVERT){
+      throw new Error(`Invalid type: ${message.type}`);
+    }
+    return new BeaconCohortAdvertMessage(message);
+  }
+}

package/src/core/beacon/aggregation/cohort/messages/keygen/cohort-ready.ts

@@ -0,0 +1,39 @@
+import { Maybe } from '@did-btcr2/common';
+import { BaseMessage } from '../base.js';
+import { BEACON_COHORT_READY } from '../constants.js';
+
+export interface CohortReadyMessage {
+  type?: typeof BEACON_COHORT_READY;
+  to: string;
+  from: string;
+  cohortId: string;
+  beaconAddress: string;
+  cohortKeys: Array<Uint8Array>;
+}
+
+/**
+ * Represents a message indicating that a cohort has met the required conditions.
+ * @class BeaconCohortReadyMessage
+ * @extends BaseMessage
+ * @type {BeaconCohortReadyMessage}
+ */
+export class BeaconCohortReadyMessage extends BaseMessage {
+  constructor({ from, to, cohortId, beaconAddress, cohortKeys }: CohortReadyMessage) {
+    const body = { cohortId, beaconAddress, cohortKeys };
+    const type = BEACON_COHORT_READY;
+    super({ from, to, body, type });
+  }
+
+  /**
+   * Initializes an BeaconCohortReadyMessage from a given OptIn object.
+   * @param {CohortReadyMessage} data The CohortReadyMessage object to initialize the BeaconCohortReadyMessage.
+   * @returns {BeaconCohortReadyMessage} The new BeaconCohortReadyMessage.
+   */
+  public static fromJSON(data: Maybe<CohortReadyMessage>): BeaconCohortReadyMessage {
+    const message = JSON.parse(data);
+    if (message.type !== BEACON_COHORT_READY) {
+      throw new Error(`Invalid type: ${message.type}`);
+    }
+    return new BeaconCohortReadyMessage(message);
+  }
+}

package/src/core/beacon/aggregation/cohort/messages/keygen/opt-in-accept.ts

@@ -0,0 +1,34 @@
+import { Maybe } from '@did-btcr2/common';
+import { BaseMessage } from '../base.js';
+import { BEACON_COHORT_OPT_IN_ACCEPT } from '../constants.js';
+
+export interface CohortOptInAcceptMessage {
+  type?: typeof BEACON_COHORT_OPT_IN_ACCEPT;
+  to: string;
+  from: string;
+}
+
+/**
+ * Represents a message for a coordinator accepting a participant subscribe to a cohort.
+ * @class BeaconCohortOptInAcceptMessage
+ * @extends BaseMessage
+ * @type {BeaconCohortOptInAcceptMessage}
+ */
+export class BeaconCohortOptInAcceptMessage extends BaseMessage {
+  constructor({ to, from }: CohortOptInAcceptMessage) {
+    super({ to, from, type: BEACON_COHORT_OPT_IN_ACCEPT });
+  }
+
+  /**
+   * Initializes a BeaconCohortOptInAcceptMessage from a possible CohortOptInAcceptMessage object.
+   * @param {CohortOptInAcceptMessage} data The CohortOptInAcceptMessage object to initialize the BeaconCohortOptInAcceptMessage.
+   * @returns {BeaconCohortOptInAcceptMessage} The new BeaconCohortOptInAcceptMessage.
+   */
+  public static fromJSON(data: Maybe<CohortOptInAcceptMessage>): BeaconCohortOptInAcceptMessage {
+    const message = JSON.parse(data);
+    if (message.type != BEACON_COHORT_OPT_IN_ACCEPT) {
+      throw new Error(`Invalid type: ${message.type}`);
+    }
+    return new BeaconCohortOptInAcceptMessage(message);
+  }
+}

package/src/core/beacon/aggregation/cohort/messages/keygen/opt-in.ts

@@ -0,0 +1,33 @@
+import { Maybe } from '@did-btcr2/common';
+import { BaseMessage } from '../base.js';
+import { BEACON_COHORT_OPT_IN } from '../constants.js';
+
+export interface CohortOptInMessage {
+  type?: typeof BEACON_COHORT_OPT_IN;
+  to: string;
+  from: string;
+  cohortId: string;
+  participantPk: Uint8Array;
+}
+
+export class BeaconCohortOptInMessage extends BaseMessage {
+
+  constructor({ from, to, cohortId, participantPk }: CohortOptInMessage) {
+    const body = { cohortId, participantPk };
+    const type = BEACON_COHORT_OPT_IN;
+    super({ from, to, body, type });
+  }
+
+  /**
+   * Initializes a BeaconCohortOptInMessage from a possible CohortOptInMessage object.
+   * @param {CohortOptInMessage} data The CohortOptInMessage object to initialize the BeaconCohortOptInMessage.
+   * @returns {BeaconCohortOptInMessage} The new BeaconCohortOptInMessage.
+   */
+  public static fromJSON(data: Maybe<CohortOptInMessage>): BeaconCohortOptInMessage {
+    const message = JSON.parse(data);
+    if (message.type != BEACON_COHORT_OPT_IN) {
+      throw new Error(`Invalid type: ${message.type}`);
+    }
+    return new BeaconCohortOptInMessage(message);
+  }
+}