@did-btcr2/method 0.17.2 → 0.18.0

package/src/core/beacon/aggregation/communication/error.ts

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

package/src/core/beacon/aggregation/communication/factory.ts

@@ -0,0 +1,25 @@
+import { NotImplementedError } from '@did-btcr2/common';
+import { NostrAdapter } from './adapter/nostr.js';
+import { CommunicationServiceError } from './error.js';
+import { CommunicationService, Service } from './service.js';
+
+/**
+ * Communication Factory pattern to create Communication Service instances.
+ * @class CommunicationFactory
+ * @type {CommunicationFactory}
+ */
+export class CommunicationFactory {
+  static establish(service: Service): CommunicationService {
+    switch (service.type) {
+      case 'nostr':
+        return new NostrAdapter();
+      case 'didcomm':
+        throw new NotImplementedError('DID Comm service not implemented yet.');
+      default:
+        throw new CommunicationServiceError(
+          `Invalid service type ${service.type}`,
+          'INVALID_BEACON_ERROR', { service }
+        );
+    }
+  }
+}

package/src/core/beacon/aggregation/communication/service.ts

@@ -0,0 +1,42 @@
+import { Maybe } from '@did-btcr2/common';
+import { AggregateBeaconMessageType } from '../cohort/messages/index.js';
+import { RawSchnorrKeyPair } from '@did-btcr2/keypair';
+
+/**
+ * ServiceAdapterConfig defines the configuration structure for the Nostr communication service.
+ * It includes relay URLs, key pairs, and components for identity generation.
+ * @interface ServiceAdapterConfig
+ * @extends {Record<string, any>}
+ * @type {ServiceAdapterConfig}
+ */
+export interface ServiceAdapterConfig extends Record<string, any> {
+  keys: ServiceAdapterIdentity<any>;
+  did: string;
+}
+
+export type SyncMessageHandler = (msg: any) => void;
+export type AsyncMessageHandler = (msg: any) => Promise<void>;
+export type MessageHandler = SyncMessageHandler | AsyncMessageHandler;
+
+export type CommunicationServiceType = 'nostr' | 'didcomm';
+export type ServiceAdapterConfigType<T extends ServiceAdapterConfig> = T;
+export interface Service {
+  type: CommunicationServiceType;
+  keys: ServiceAdapterIdentity<RawSchnorrKeyPair>;
+  did: string;
+  name?: string;
+}
+export type ServiceAdapter<T extends CommunicationService> = T;
+export type ServiceAdapterIdentity<T extends RawSchnorrKeyPair> = T;
+export interface CommunicationService {
+  name: string;
+  start(): void;
+  setKeys(keys: ServiceAdapterIdentity<RawSchnorrKeyPair>): void;
+  registerMessageHandler(messageType: string, handler: MessageHandler): void;
+  sendMessage(
+    message: Maybe<AggregateBeaconMessageType>,
+    sender: string,
+    recipient?: string
+  ): Promise<void | Promise<string>[]>;
+  generateIdentity(keys?: RawSchnorrKeyPair): ServiceAdapterConfigType<ServiceAdapterConfig>;
+}

package/src/core/beacon/aggregation/coordinator.ts

@@ -1,135 +1,406 @@
-import { Base } from './messages/base.js';
-import { OptInMessage } from './messages/opt-in.js';
-import { OPT_IN, SUBSCRIBE, SUBSCRIBE_ACCEPT } from './messages/keygen.js';
-import { Musig2Cohort } from './models/cohort/index.js';
-import { NostrAdapter } from './protocol/nostr.js';
-import { ProtocolService } from './protocol/service.js';
-import { NONCE_CONTRIBUTION, REQUEST_SIGNATURE, SIGNATURE_AUTHORIZATION } from './messages/sign.js';
+import { Logger, Maybe } from '@did-btcr2/common';
+import { RawSchnorrKeyPair } from '@did-btcr2/keypair';
+import { BeaconCoordinatorError } from '../error.js';
+import { AggregateBeaconCohort } from './cohort/index.js';
+import {
+  BEACON_COHORT_ADVERT,
+  BEACON_COHORT_NONCE_CONTRIBUTION,
+  BEACON_COHORT_OPT_IN,
+  BEACON_COHORT_OPT_IN_ACCEPT,
+  BEACON_COHORT_REQUEST_SIGNATURE,
+  BEACON_COHORT_SIGNATURE_AUTHORIZATION
+} from './cohort/messages/constants.js';
+import { BeaconCohortAdvertMessage } from './cohort/messages/keygen/cohort-advert.js';
+import { BeaconCohortReadyMessage } from './cohort/messages/keygen/cohort-ready.js';
+import { BeaconCohortOptInMessage, CohortOptInMessage } from './cohort/messages/keygen/opt-in.js';
+import { BeaconCohortAggregatedNonceMessage } from './cohort/messages/sign/aggregated-nonce.js';
+import { BeaconCohortNonceContributionMessage, CohortNonceContributionMessage } from './cohort/messages/sign/nonce-contribution.js';
+import { BeaconCohortRequestSignatureMessage, CohortRequestSignatureMessage } from './cohort/messages/sign/request-signature.js';
+import { BeaconCohortSignatureAuthorizationMessage, CohortSignatureAuthorizationMessage } from './cohort/messages/sign/signature-authorization.js';
+import { NostrAdapter } from './communication/adapter/nostr.js';
+import { CommunicationFactory } from './communication/factory.js';
+import { CommunicationService, Service, ServiceAdapterIdentity } from './communication/service.js';
+import { BeaconCohortSigningSession } from './session/index.js';
+import { SIGNING_SESSION_STATUS } from './session/status.js';
 
+type BeaconCoordinatorParams = {
+  protocol?: CommunicationService;
+  did: string;
+  keys: ServiceAdapterIdentity<RawSchnorrKeyPair>
+  name?: string;
+}
 /**
  * The BeaconCoordinator class is responsible for managing the coordination of beacon aggregation.
  * @class BeaconCoordinator
  * @type {BeaconCoordinator}
  */
+
 export class BeaconCoordinator {
   /**
    * The name of the BeaconCoordinator service.
    * @type {string}
    */
-  public name: string = 'BeaconCoordinator';
+  public name: string;
 
   /**
    * The DID of the BeaconCoordinator.
    * @type {Array<string>}
    */
-  public did: string = '';
+  public did: string;
 
   /**
-   * The protocol service used for communication.
-   * @type {ProtocolService}
+   * The communication protocol used by the BeaconCoordinator.
+   * @type {CommunicationService}
    */
-  public protocol: ProtocolService;
+  public protocol: CommunicationService;
 
   /**
-   * List of subscribers to the BeaconCoordinator service.
+   * List of subscribers engaged in a Musig2 Cohort signing session with the BeaconCoordinator.
    * @type {Array<string>}
    */
-  public cohorts: Array<Musig2Cohort> = [];
+  public cohorts: Array<AggregateBeaconCohort> = [];
 
   /**
-   * List of subscribers to the BeaconCoordinator service.
-   * @type {Array<string>}
+   * Active signing sessions for the BeaconCoordinator.
+   * @type {Record<string, BeaconCohortSigningSession>}
    */
-  private subscribers: string[] = [];
+  public activeSigningSessions: Map<string, BeaconCohortSigningSession> = new Map();
 
   /**
    * Constructs a new BeaconCoordinator instance.
-   * @param {ProtocolService} protocol The protocol service used for communication.
-   * @param {string} [did] Optional DID to use for the coordinator. If not provided, a new DID will be generated.
+   * @param {BeaconCoordinatorParams} params The parameters for the coordinator.
+   * @param {CommunicationService} params.protocol The protocol service used for communication.
+   * @param {string} [params.name] Optional name for the coordinator. If not provided, a default name will be generated.
+   * @param {string} [params.did] Optional DID to use for the coordinator. If not provided, a new DID will be generated.
+   * @param {ServiceAdapterIdentity<RawKeyPair>} params.keys The keys used for cryptographic operations.
    */
-
-  constructor(protocol: ProtocolService, did?: string) {
-    this.protocol = protocol ?? new NostrAdapter();
-    this.setup(did);
+  constructor(params: BeaconCoordinatorParams) {
+    this.name = params.name || `btcr2-beacon-coordinator-${crypto.randomUUID()}`;
+    this.did = params.did;
+    this.protocol = params.protocol || new NostrAdapter();
+    this.protocol.setKeys(params.keys);
   }
 
   /**
-   * Sets up the BeaconCoordinator by registering message handlers and optionally generating a DID.
+   * Setup and start the BeaconCoordinator communication protocol.
    * @returns {void}
    */
-  public setup(did?: string): void {
-    this.did = did || this.protocol.generateIdentity();
-    this.protocol.registerMessageHandler(SUBSCRIBE, this._handleSubscribe.bind(this));
-    this.protocol.registerMessageHandler(OPT_IN, this._handleOptIn.bind(this));
-    this.protocol.registerMessageHandler(REQUEST_SIGNATURE, this._handleSubscribe.bind(this));
-    this.protocol.registerMessageHandler(NONCE_CONTRIBUTION, this._handleSubscribe.bind(this));
-    this.protocol.registerMessageHandler(SIGNATURE_AUTHORIZATION, this._handleSubscribe.bind(this));
-  }
-
-  /**
-   * Initializes the BeaconCoordinator by setting up the protocol and starting it.
-   * @param {string} [did] Optional DID to use for the coordinator. If not provided, the existing DID will be used.
-   */
-  async initialize(did?: string): Promise<void> {
-    this.setup(did);
-    await this.protocol.start();
-  }
-
-  /**
-   * Handles subscription requests from other participants.
-   * @param {Base} message The message containing the subscription request.
-   * @returns {Promise<void>}
-   */
-  private async _handleSubscribe(message: Base): Promise<void> {
-    const sender = message.from;
-    if (!this.subscribers.includes(sender)) {
-      this.subscribers.push(sender);
-      await this.acceptSubscription(sender);
-    }
+  public start(): void {
+    Logger.info(`Setting up BeaconCoordinator ${this.name} (${this.did}) on ${this.protocol.name} ...`);
+    this.protocol.registerMessageHandler(BEACON_COHORT_OPT_IN, this._handleOptIn.bind(this));
+    this.protocol.registerMessageHandler(BEACON_COHORT_REQUEST_SIGNATURE, this._handleRequestSignature.bind(this));
+    this.protocol.registerMessageHandler(BEACON_COHORT_NONCE_CONTRIBUTION, this._handleNonceContribution.bind(this));
+    this.protocol.registerMessageHandler(BEACON_COHORT_SIGNATURE_AUTHORIZATION, this._handleSignatureAuthorization.bind(this));
+    this.protocol.start();
   }
 
   /**
    * Handles opt-in requests from participants to join a cohort.
-   * @param {any} message The message containing the opt-in request.
+   * @param {OptInMessage} message The message containing the opt-in request.
    * @returns {Promise<void>}
    */
-  private async _handleOptIn(message: any): Promise<void> {
-    const optIn = OptInMessage.fromJSON(message);
-    const cohortId = optIn.cohortId;
+  private async _handleOptIn(message: CohortOptInMessage): Promise<void> {
+    const optIn = BeaconCohortOptInMessage.fromJSON(message);
+    const cohortId = optIn.body?.cohortId;
     const participant = optIn.from;
-    const participantPk = optIn.participantPk;
+    const participantPk = optIn.body?.participantPk;
+    if(!cohortId || !participant || !participantPk) {
+      Logger.warn(`Invalid opt-in message from ${participant}: missing cohortId, participant or participantPk`);
+      return;
+    }
     const cohort = this.cohorts.find(c => c.id === cohortId);
     if (cohort && !cohort.participants.includes(participant)) {
       cohort.participants.push(participant);
       cohort.cohortKeys.push(participantPk);
       await this.acceptSubscription(participant);
+      // If the cohort has enough participants, start the key generation process.
       if (cohort.participants.length >= cohort.minParticipants) {
         await this._startKeyGeneration(cohort);
       }
     }
   }
 
+  /**
+   * Handles request signature messages from participants.
+   * @private
+   * @param {CohortRequestSignatureMessage} message The message containing the request signature.
+   * @returns {Promise<void>}
+   */
+  private async _handleRequestSignature(message: Maybe<CohortRequestSignatureMessage>): Promise<void> {
+    const signatureRequest = BeaconCohortRequestSignatureMessage.fromJSON(message);
+    const cohortId = signatureRequest.body?.cohortId;
+    if (!cohortId) {
+      Logger.warn(`Signature request missing cohort ID from ${signatureRequest.from}`);
+      return;
+    }
+    const cohort = this.cohorts.find(c => c.id === cohortId);
+    if (!cohort) {
+      Logger.error(`Cohort with ID ${cohortId} not found.`);
+      return;
+    }
+    cohort.addSignatureRequest(signatureRequest);
+    Logger.info(`Received signature request from ${signatureRequest.from} for cohort ${cohortId}.`);
+  }
+
+  /**
+   * Handles nonce contribution messages from participants.
+   * @param {CohortNonceContributionMessage} message The message containing the nonce contribution.
+   * @returns {Promise<void>}
+   */
+  private async _handleNonceContribution(message: CohortNonceContributionMessage): Promise<void> {
+    // Cast message to NonceContributionMessage type.
+    const nonceContribMessage = BeaconCohortNonceContributionMessage.fromJSON(message);
+    const cohortId = nonceContribMessage.body?.cohortId;
+    if (!cohortId) {
+      Logger.warn(`Nonce contribution message missing cohort ID from ${nonceContribMessage.from}`);
+      return;
+    }
+    const sessionId = nonceContribMessage.body?.sessionId;
+    if (!sessionId) {
+      Logger.warn(`Nonce contribution message missing session ID from ${nonceContribMessage.from}`);
+      return;
+    }
+    // Get the signing session using the cohort ID from the message.
+    const signingSession = this.activeSigningSessions.get(cohortId || sessionId);
+
+    // If the signing session does not exist, log an error and return.
+    if(!signingSession) {
+      Logger.error(`Session ${cohortId || sessionId} not found.`);
+      return;
+    }
+
+    // If the message.cohortId does not match the signingSession.cohortId, throw an error.
+    if(cohortId !== signingSession.cohort.id) {
+      throw new BeaconCoordinatorError(
+        `Nonce contribution for wrong cohort: ${signingSession.cohort.id} != ${cohortId}`,
+        'NONCE_CONTRIBUTION_ERROR', message
+      );
+    }
+    const nonceContribution = nonceContribMessage.body?.nonceContribution;
+    if(!nonceContribution) {
+      Logger.warn(`Nonce contribution message missing nonce contribution from ${nonceContribMessage.from}`);
+      return;
+    }
+    // Add the nonce contribution to the signing session.
+    signingSession.addNonceContribution(nonceContribMessage.from, nonceContribution);
+    Logger.info(`Nonce contribution received from ${nonceContribMessage.from} for session ${sessionId}.`);
+
+    if (signingSession.status !== SIGNING_SESSION_STATUS.NONCE_CONTRIBUTIONS_RECEIVED) {
+      await this.sendAggregatedNonce(signingSession);
+    }
+  }
+
+  /**
+   * Handles signature authorization messages from participants.
+   * @param {Maybe<CohortSignatureAuthorizationMessage>} message The message containing the signature authorization request.
+   * @returns {Promise<void>}
+   */
+  private async _handleSignatureAuthorization(message: Maybe<CohortSignatureAuthorizationMessage>): Promise<void> {
+    const sigAuthMessage = BeaconCohortSignatureAuthorizationMessage.fromJSON(message);
+    const cohortId = sigAuthMessage.body?.cohortId;
+    if (!cohortId) {
+      Logger.warn(`Signature authorization message missing cohort ID from ${sigAuthMessage.from}`);
+      return;
+    }
+    const sessionId = sigAuthMessage.body?.sessionId;
+    if (!sessionId) {
+      Logger.warn(`Signature authorization message missing session ID from ${sigAuthMessage.from}`);
+      return;
+    }
+    const signingSession = this.activeSigningSessions.get(cohortId || sessionId);
+    if (!signingSession) {
+      Logger.error(`Session ${sessionId} not found.`);
+      return;
+    }
+
+    if(signingSession.id !== sessionId) {
+      throw new BeaconCoordinatorError(
+        `Signature authorization for wrong session: ${signingSession.id} != ${sessionId}`,
+        'SIGNATURE_AUTHORIZATION_ERROR', message
+      );
+    }
+
+    if(signingSession.status !== SIGNING_SESSION_STATUS.AWAITING_PARTIAL_SIGNATURES) {
+      throw new BeaconCoordinatorError(
+        `Partial signature received but not expected. Current status: ${signingSession.status}`,
+        'SIGNATURE_AUTHORIZATION_ERROR', message
+      );
+    }
+    const partialSignature = sigAuthMessage.body?.partialSignature;
+    if (!partialSignature) {
+      Logger.warn(`Signature authorization message missing partial signature from ${sigAuthMessage.from}`);
+      return;
+    }
+    // Add the signature authorization to the signing session.
+    signingSession.addPartialSignature(sigAuthMessage.from, partialSignature);
+    Logger.info(`Received partial signature from ${sigAuthMessage.from} for session ${sessionId}.`);
+
+    if(signingSession.partialSignatures.size === signingSession.cohort.participants.length) {
+      signingSession.status = SIGNING_SESSION_STATUS.PARTIAL_SIGNATURES_RECEIVED;
+    }
+
+    if (signingSession.status === SIGNING_SESSION_STATUS.PARTIAL_SIGNATURES_RECEIVED) {
+      const signature = await signingSession.generateFinalSignature();
+      Logger.info(`Final signature ${signature.toHex()} generated for session ${signingSession.id}`);
+    }
+  }
+
   /**
    * Starts the key generation process for a cohort once it has enough participants.
    * @param {Musig2Cohort} cohort The cohort for which to start key generation.
    * @returns {Promise<void>}
    */
-  private async _startKeyGeneration(cohort: Musig2Cohort): Promise<void> {
+  private async _startKeyGeneration(cohort: AggregateBeaconCohort): Promise<void> {
+    Logger.info(`Starting key generation for cohort ${cohort.id} with participants: ${cohort.participants.join(', ')}`);
     cohort.finalize();
+    for(const participant of cohort.participants) {
+      const message = cohort.getCohortReadyMessage(participant, this.did);
+      Logger.info(`Sending BEACON_COHORT_READY message to ${participant}`);
+      await this.protocol.sendMessage(message, participant, this.did);
+    }
+    Logger.info(`Finished sending BEACON_COHORT_READY message to ${cohort.participants.length} participants`);
   }
 
   /**
    * Accepts a subscription request from a participant.
-   * @param {string} sender The DID of the participant requesting the subscription.
+   * @param {string} participant The DID of the participant requesting the subscription.
    * @returns {Promise<void>}
    */
-  public async acceptSubscription(sender: string): Promise<void> {
-    console.log(`Accepting subscription from ${sender}`);
-    const response = {
-      type : SUBSCRIBE_ACCEPT,
-      to   : sender,
+  public async acceptSubscription(participant: string): Promise<void> {
+    Logger.info(`Accepting subscription from ${participant}`);
+    const message = {
+      type : BEACON_COHORT_OPT_IN_ACCEPT,
+      to   : participant,
       from : this.did
     };
-    await this.protocol.sendMessage(response, sender, this.did);
+    await this.protocol.sendMessage(message, this.did, participant);
   }
-}
+
+  /**
+   * Sends the aggregated nonce to all participants in the session.
+   * @param {BeaconCohortSigningSession} session The session containing the aggregated nonce.
+   * @returns {Promise<void>}
+   */
+  public async sendAggregatedNonce(session: BeaconCohortSigningSession): Promise<void> {
+    const aggregatedNonce = session.generateAggregatedNonce();
+    Logger.info(`Aggregated Nonces for session ${session.id}:`, aggregatedNonce);
+
+    session.status = SIGNING_SESSION_STATUS.AWAITING_PARTIAL_SIGNATURES;
+    for (const participant of session.cohort.participants) {
+      const message = new BeaconCohortAggregatedNonceMessage({
+        to              : participant,
+        from            : this.did,
+        cohortId        : session.cohort.id,
+        sessionId       : session.id,
+        aggregatedNonce : aggregatedNonce
+      });
+      Logger.info(`Sending AGGREGATED_NONCE message to ${participant}`);
+      await this.protocol.sendMessage(message, participant, this.did);
+    }
+    Logger.info(`Successfully sent aggregated nonce message to all participants in session ${session.id}.`);
+  }
+
+  /**
+   * Announces a new cohort to all subscribers.
+   * @param {number} minParticipants The minimum number of participants required for the cohort.
+   * @param {string} [network='mutinynet'] The network on which the cohort operates (default is 'signet').
+   * @param {string} [beaconType='SMTAggregateBeacon'] The type of beacon to be used (default is 'SMTAggregateBeacon').
+   * @returns {Promise<AggregateBeaconCohort>} The newly created cohort.
+   */
+  public async advertiseCohort(
+    minParticipants: number,
+    network: string = 'mutinynet',
+    beaconType: string = 'SMTAggregateBeacon'
+  ): Promise<AggregateBeaconCohort> {
+    const cohort = new AggregateBeaconCohort({ minParticipants, network, beaconType });
+    Logger.info(`Advertising new cohort ${cohort.id} ...`);
+    this.cohorts.push(cohort);
+    const message = new BeaconCohortAdvertMessage({
+      from       : this.did,
+      cohortId   : cohort.id,
+      cohortSize : cohort.minParticipants,
+      network    : cohort.network,
+      beaconType
+    });
+    Logger.info(`Sending ${BEACON_COHORT_ADVERT} message to network ...`, message);
+    await this.protocol.sendMessage(message, this.did);
+    Logger.info(`Cohort ${cohort.id} advertised successfully.`);
+    return cohort;
+  }
+
+
+  /**
+   * Announces to all subscribers a cohort is ready for signing.
+   * @param {string} cohortId The minimum number of participants required for the cohort.
+   * @returns {Promise<AggregateBeaconCohort>} The newly created cohort.
+   */
+  public async announceCohortReady(cohortId: string): Promise<AggregateBeaconCohort> {
+    const cohort = this.cohorts.find(c => c.id === cohortId);
+    if (!cohort) {
+      Logger.error(`Cohort with ID ${cohortId} not found.`);
+      throw new BeaconCoordinatorError(
+        `Cohort with ID ${cohortId} not found.`,
+        'COHORT_NOT_FOUND', { cohortId }
+      );
+    }
+    Logger.info(`Announcing cohort ${cohort.id} to ${cohort.participants.length} subscribers...`);
+    this.cohorts.push(cohort);
+    for (const participant of cohort.participants) {
+      const message = new BeaconCohortReadyMessage({
+        to            : participant,
+        from          : this.did,
+        cohortId      : cohort.id,
+        beaconAddress : cohort.beaconAddress,
+        cohortKeys    : cohort.cohortKeys,
+      });
+      Logger.info(`Sending ${BEACON_COHORT_ADVERT} message to ${participant}`);
+
+      await this.protocol.sendMessage(message, this.did, participant);
+    }
+    return cohort;
+  }
+
+  /**
+   * Starts a signing session for a given cohort.
+   * @param {string} cohortId The ID of the cohort for which to start a signing session.
+   * @returns {Promise<BeaconCohortSigningSession>} The started signing session.
+   * @throws {BeaconCoordinatorError} If the cohort with the given ID is not found.
+   */
+  public async startSigningSession(cohortId: string): Promise<BeaconCohortSigningSession> {
+    Logger.info(`Attempting to start signing session for cohort ${cohortId}`);
+    const cohort = this.cohorts.find(c => c.id === cohortId);
+    if (!cohort) {
+      Logger.error(`Cohort with ID ${cohortId} not found.`);
+      throw new BeaconCoordinatorError(`Cohort with ID ${cohortId} not found.`, 'COHORT_NOT_FOUND');
+    }
+    Logger.info(`Cohort ${cohortId} found. Starting signing session.`);
+    const signingSession = cohort.startSigningSession();
+    Logger.info(`Starting signing session ${signingSession.id} for cohort ${cohortId}`);
+    for (const participant of cohort.participants) {
+      const msg = signingSession.getAuthorizationRequest(participant, this.did);
+      Logger.info(`Sending authorization request to ${participant}`);
+      await this.protocol.sendMessage(msg, this.did, participant).catch(error => {
+        Logger.error(`Error sending authorization request to ${participant}: ${error.message}`);
+      });
+    }
+    this.activeSigningSessions.set(cohortId, signingSession);
+    Logger.info(`Signing session ${signingSession.id} started for cohort ${cohortId}`);
+    return signingSession;
+  }
+
+  /**
+   * Static initialization method for the BeaconCoordinator.
+   * @param {Service} service The communication service configuration.
+   * @returns {BeaconCoordinator} Initialized BeaconCoordinator instance.
+   */
+  public static initialize(service: Service): BeaconCoordinator {
+    const communicationService = CommunicationFactory.establish(service);
+    const coordinator = new BeaconCoordinator({
+      protocol : communicationService,
+      did      : service.did,
+      keys     : service.keys,
+    });
+    Logger.info(`BeaconCoordinator ${coordinator.name} initialized with DID ${coordinator.did}. Run .start() to listen for messages`);
+    return coordinator;
+  }
+}