@did-btcr2/method 0.17.2 → 0.18.0

package/src/core/beacon/aggregation/cohort/messages/keygen/subscribe.ts

@@ -0,0 +1,35 @@
+import { Maybe } from '@did-btcr2/common';
+import { BaseMessage } from '../base.js';
+import { BEACON_COHORT_OPT_IN_ACCEPT } from '../constants.js';
+
+export interface CohortSubscribeMessage {
+  type?: typeof BEACON_COHORT_OPT_IN_ACCEPT;
+  to: string;
+  from: string;
+}
+
+/**
+ * Represents a message for subscribing to a cohort.
+ * This message is sent by a coordinator to a participant to indicate acceptance in the cohort.
+ * @class BeaconCohortSubscribeMessage
+ * @extends BaseMessage
+ * @type {BeaconCohortSubscribeMessage}
+ */
+export class BeaconCohortSubscribeMessage extends BaseMessage {
+  constructor({ to, from }: CohortSubscribeMessage) {
+    super({ to, from, type: BEACON_COHORT_OPT_IN_ACCEPT });
+  }
+
+  /**
+   * Initializes a BeaconCohortSubscribeMessage from a possible CohortSubscribeMessage object.
+   * @param {CohortSubscribeMessage} data The Subscribe object to initialize the SubscribeMessage.
+   * @returns {BeaconCohortSubscribeMessage} The serialized SubscribeMessage.
+   */
+  public static fromJSON(data: Maybe<CohortSubscribeMessage>): BeaconCohortSubscribeMessage {
+    const message = JSON.parse(data);
+    if (message.type != BEACON_COHORT_OPT_IN_ACCEPT) {
+      throw new Error(`Invalid type: ${message.type}`);
+    }
+    return new BeaconCohortSubscribeMessage(message);
+  }
+}

package/src/core/beacon/aggregation/cohort/messages/sign/aggregated-nonce.ts

@@ -0,0 +1,38 @@
+import { Maybe } from '@did-btcr2/common';
+import { BaseMessage } from '../base.js';
+import { BEACON_COHORT_AGGREGATED_NONCE } from '../constants.js';
+
+export interface CohortAggregatedNonceMessage {
+  to: string;
+  from: string;
+  cohortId: string;
+  sessionId: string;
+  aggregatedNonce: Uint8Array;
+}
+
+/**
+ * Represents a message containing an aggregated nonce for a cohort in the Beacon protocol.
+ * @class BeaconCohortAggregatedNonceMessage
+ * @extends BaseMessage
+ * @type {BeaconCohortAggregatedNonceMessage}
+ */
+export class BeaconCohortAggregatedNonceMessage extends BaseMessage {
+  constructor({ to, from, cohortId, sessionId, aggregatedNonce }: CohortAggregatedNonceMessage) {
+    const body = { cohortId, sessionId, aggregatedNonce };
+    const type = BEACON_COHORT_AGGREGATED_NONCE;
+    super({ to, from, body, type });
+  }
+
+  /**
+   * Initializes a BeaconCohortAggregatedNonceMessage from a given AggregatedNonce object.
+   * @param {CohortAggregatedNonceMessage} data The data object to initialize the BeaconCohortAggregatedNonceMessage.
+   * @returns {BeaconCohortAggregatedNonceMessage} The new BeaconCohortAggregatedNonceMessage.
+   */
+  public static fromJSON(data: Maybe<CohortAggregatedNonceMessage>): BeaconCohortAggregatedNonceMessage {
+    const message = JSON.parse(data);
+    if (message.type != BEACON_COHORT_AGGREGATED_NONCE) {
+      throw new Error(`Invalid type: ${message.type}`);
+    }
+    return new BeaconCohortAggregatedNonceMessage(message);
+  }
+}

package/src/core/beacon/aggregation/cohort/messages/sign/authorization-request.ts

@@ -0,0 +1,39 @@
+import { Maybe } from '@did-btcr2/common';
+import { BaseMessage } from '../base.js';
+import { BEACON_COHORT_AUTHORIZATION_REQUEST } from '../constants.js';
+
+export interface CohortAuthorizationRequestMessage {
+  to: string;
+  from: string;
+  cohortId: string;
+  sessionId: string;
+  pendingTx: string;
+}
+
+/**
+ * Sends the unsigned PSBT that spends the Beacon UTXO (plus any SMT proofs).
+ * Asks the cohort to begin a MuSig2 signing session.
+ * @class BeaconCohortAuthorizationRequestMessage
+ * @extends BaseMessage
+ * @type {CohortAuthorizationRequestMessage}
+ */
+export class BeaconCohortAuthorizationRequestMessage extends BaseMessage {
+  constructor({ to, from, cohortId, sessionId, pendingTx }: CohortAuthorizationRequestMessage) {
+    const body = { cohortId, sessionId, pendingTx };
+    const type = BEACON_COHORT_AUTHORIZATION_REQUEST;
+    super({ to, from, body, type });
+  }
+
+  /**
+   * Initializes a BeaconCohortAuthorizationRequestMessage from a given AuthorizationRequest object.
+   * @param {CohortAuthorizationRequestMessage} data The data object to initialize the BeaconCohortAuthorizationRequestMessage.
+   * @returns {BeaconCohortAuthorizationRequestMessage} The serialized BeaconCohortAuthorizationRequestMessage.
+   */
+  public static fromJSON(data: Maybe<CohortAuthorizationRequestMessage>): BeaconCohortAuthorizationRequestMessage {
+    const message = JSON.parse(data);
+    if (message.type != BEACON_COHORT_AUTHORIZATION_REQUEST) {
+      throw new Error(`Invalid type: ${message.type}`);
+    }
+    return new BeaconCohortAuthorizationRequestMessage(message);
+  }
+}

package/src/core/beacon/aggregation/cohort/messages/sign/nonce-contribution.ts

@@ -0,0 +1,39 @@
+import { Maybe } from '@did-btcr2/common';
+import { BaseMessage } from '../base.js';
+import { BEACON_COHORT_NONCE_CONTRIBUTION } from '../constants.js';
+
+export interface CohortNonceContributionMessage {
+  to: string;
+  from: string;
+  cohortId: string;
+  sessionId: string;
+  nonceContribution: Uint8Array;
+}
+
+/**
+ * Represents a message containing a nonce contribution for a cohort participant.
+ * Participant → Coordinator. Participant sending their public nonce points for the ongoing signing session.
+ * @class BeaconCohortNonceContributionMessage
+ * @extends BaseMessage
+ * @type {BeaconCohortNonceContributionMessage}
+ */
+export class BeaconCohortNonceContributionMessage extends BaseMessage {
+  constructor({ to, from, cohortId, sessionId, nonceContribution }: CohortNonceContributionMessage) {
+    const body = { cohortId, sessionId, nonceContribution };
+    const type = BEACON_COHORT_NONCE_CONTRIBUTION;
+    super({ to, from, body, type });
+  }
+
+  /**
+   * Initializes a NonceContributionMessage from a given CohortNonceContributionMessage object.
+   * @param {CohortNonceContributionMessage} data The data object to initialize the BeaconCohortNonceContributionMessage.
+   * @returns {BeaconCohortNonceContributionMessage} The new BeaconCohortNonceContributionMessage.
+   */
+  public static fromJSON(data: Maybe<CohortNonceContributionMessage>): BeaconCohortNonceContributionMessage {
+    const message = JSON.parse(data);
+    if (message.type != BEACON_COHORT_NONCE_CONTRIBUTION) {
+      throw new Error(`Invalid type: ${message.type}`);
+    }
+    return new BeaconCohortNonceContributionMessage(message);
+  }
+}

package/src/core/beacon/aggregation/cohort/messages/sign/request-signature.ts

@@ -0,0 +1,39 @@
+import { Maybe } from '@did-btcr2/common';
+import { BaseMessage } from '../base.js';
+import { BEACON_COHORT_REQUEST_SIGNATURE } from '../constants.js';
+
+export type CohortRequestSignatureMessage = {
+  to: string;
+  from: string;
+  cohortId: string;
+  sessionId?: string;
+  data: string;
+}
+
+/**
+ * Coordinator → Participants. Returns the aggregation of all participant nonces
+ * so each participant can produce a correct partial signature.
+ * @class BeaconCohortRequestSignatureMessage
+ * @extends BaseMessage
+ * @type {BeaconCohortRequestSignatureMessage}
+ */
+export class BeaconCohortRequestSignatureMessage extends BaseMessage {
+  constructor({ to, from, cohortId, sessionId, data }: CohortRequestSignatureMessage) {
+    const body = { cohortId, sessionId, data };
+    const type = BEACON_COHORT_REQUEST_SIGNATURE;
+    super({ to, from, body, type });
+  }
+
+  /**
+   * Initializes an BeaconCohortRequestSignatureMessage from a possible CohortRequestSignatureMessage object.
+   * @param {CohortRequestSignatureMessage} data The data object to initialize the BeaconCohortRequestSignatureMessage.
+   * @returns {BeaconCohortRequestSignatureMessage} The new BeaconCohortRequestSignatureMessage.
+   */
+  public static fromJSON(data: Maybe<CohortRequestSignatureMessage>): BeaconCohortRequestSignatureMessage {
+    const message = JSON.parse(data);
+    if (message.type != BEACON_COHORT_REQUEST_SIGNATURE) {
+      throw new Error(`Invalid type: ${message.type}`);
+    }
+    return new BeaconCohortRequestSignatureMessage(message);
+  }
+}

package/src/core/beacon/aggregation/cohort/messages/sign/signature-authorization.ts

@@ -0,0 +1,40 @@
+import { Maybe } from '@did-btcr2/common';
+import { BaseMessage } from '../base.js';
+import { BEACON_COHORT_SIGNATURE_AUTHORIZATION } from '../constants.js';
+
+export type CohortSignatureAuthorizationMessage = {
+  to: string;
+  from: string;
+  cohortId: string;
+  sessionId: string;
+  partialSignature: Uint8Array;
+}
+
+/**
+ * Participant → Coordinator. Delivers the participant’s partial signature over
+ * the PSBT, authorizing the final Beacon signal (transaction) once all signatures
+ * are collected.
+ * @class BeaconCohortSignatureAuthorizationMessage
+ * @extends BaseMessage
+ * @type {BeaconCohortSignatureAuthorizationMessage}
+ */
+export class BeaconCohortSignatureAuthorizationMessage extends BaseMessage {
+  constructor({ to, from, cohortId, sessionId, partialSignature }: CohortSignatureAuthorizationMessage) {
+    const body = { cohortId, sessionId, partialSignature };
+    const type = BEACON_COHORT_SIGNATURE_AUTHORIZATION;
+    super({ to, from, body, type });
+  }
+
+  /**
+   * Initializes an BeaconCohortSignatureAuthorizationMessage from a given CohortSignatureAuthorizationMessage object.
+   * @param {CohortSignatureAuthorizationMessage} data The data object to initialize the BeaconCohortSignatureAuthorizationMessage.
+   * @returns {BeaconCohortSignatureAuthorizationMessage} The serialized BeaconCohortSignatureAuthorizationMessage.
+   */
+  public static fromJSON(data: Maybe<CohortSignatureAuthorizationMessage>): BeaconCohortSignatureAuthorizationMessage {
+    const message = JSON.parse(data);
+    if (message.type != BEACON_COHORT_SIGNATURE_AUTHORIZATION) {
+      throw new Error(`Invalid type: ${message.type}`);
+    }
+    return new BeaconCohortSignatureAuthorizationMessage(message);
+  }
+}

package/src/core/beacon/aggregation/communication/adapter/did-comm.ts

@@ -0,0 +1,153 @@
+import { Maybe, NotImplementedError } from '@did-btcr2/common';
+import { RawSchnorrKeyPair, SchnorrKeyPair, Secp256k1SecretKey } from '@did-btcr2/keypair';
+import { Identifier } from '../../../../identifier.js';
+import { AggregateBeaconMessageType } from '../../cohort/messages/index.js';
+import { CommunicationService, MessageHandler, ServiceAdapterConfig, ServiceAdapterIdentity } from '../service.js';
+
+/**
+ * DidCommAdapterConfig is a configuration class for the DidCommAdapter.
+ * It holds the necessary parameters to connect to Nostr relays and manage keys.
+ * @class DidCommAdapterConfig
+ * @implements {ServiceAdapterConfig}
+ * @type {DidCommAdapterConfig}
+ */
+export class DidCommAdapterConfig implements ServiceAdapterConfig {
+  public keys: RawSchnorrKeyPair;
+  public components: {
+    idType: string;
+    version: number;
+    network: string;
+  };
+  public did: string;
+  public coordinatorDids: string[];
+
+  /**
+   * Constructs a new DidCommAdapterConfig instance.
+   * @param {Partial<ServiceAdapterConfig>} [config] Optional configuration parameters to initialize the adapter.
+   * @constructor
+   * @type {DidCommAdapterConfig}
+   */
+  constructor(config?: Partial<ServiceAdapterConfig>) {
+    this.keys = config?.keys || SchnorrKeyPair.generate().raw,
+    this.components = config?.components || {
+      version : 1,
+      idType  : 'KEY',
+      network : 'mutinynet'
+    };
+    this.did = config?.did || Identifier.encode(
+      {
+        ...this.components,
+        genesisBytes : this.keys.public
+      }
+    );
+    this.coordinatorDids = config?.coordinatorDids || [];
+  }
+}
+
+/**
+ * DidCommAdapter implements the CommunicationService interface for DidComm protocol.
+ * It handles message sending, receiving, and identity generation using DidComm.
+ * @class DidCommAdapter
+ * @implements {CommunicationService}
+ * @type {DidCommAdapter}
+ */
+export class DidCommAdapter implements CommunicationService {
+  /**
+   * The name of the communication service.
+   * @type {string}
+   */
+  public name: string = 'didcomm';
+
+  /**
+   * The configuration for the DidComm adapter.
+   * @type {DidCommAdapterConfig}
+   */
+  public config: DidCommAdapterConfig;
+
+  /**
+   * A map of message handlers for different message types.
+   * @type {Map<string, MessageHandler>}
+   */
+  private handlers: Map<string, MessageHandler> = new Map();
+
+  /**
+   * Constructs a new DidCommAdapter instance with the provided configuration.
+   * @param {DidCommAdapterConfig} [config] The configuration for the Nostr adapter.
+   */
+  constructor(config: DidCommAdapterConfig = {} as DidCommAdapterConfig) {
+    this.config = new DidCommAdapterConfig(config);
+  }
+
+  /**
+   * Starts the DidComm service.
+   * @returns {void} Returns the DidCommAdapter instance for method chaining.
+   */
+  public start(): void {
+    throw new NotImplementedError('DidCommAdapter is not implemented. Use NostrAdapter instead.');
+  }
+
+  /**
+   * Sets the keys used for Nostr communication.
+   * @param {ServiceAdapterIdentity<NostrKeys>} keys The keys to set.
+   */
+  public setKeys(keys: ServiceAdapterIdentity<RawSchnorrKeyPair>): void {
+    this.config.keys = keys;
+  }
+
+  /**
+   * Registers a message handler for a specific message type.
+   * @param {string} messageType The type of message to handle.
+   * @param {MessageHandler} handler The handler function that processes the message.
+   */
+  public registerMessageHandler(messageType: string, handler: MessageHandler): void {
+    this.handlers.set(messageType, handler);
+  }
+
+  /**
+   * Sends a message to a recipient using the Nostr protocol.
+   * This method is a placeholder and should be implemented with actual Nostr message sending logic.
+   * @param {Maybe<AggregateBeaconMessageType>} _message The message to send, typically containing the content and metadata.
+   * @param {string} _recipient The public key or identifier of the recipient.
+   * @param {string} _sender The public key or identifier of the sender.
+   * @returns {Promise<void>} A promise that resolves when the message is sent.
+   */
+  public async sendMessage(
+    _message: Maybe<AggregateBeaconMessageType>,
+    _recipient: string,
+    _sender: string
+  ): Promise<void | Promise<string>[]> {
+    throw new NotImplementedError('DidCommAdapter.start() is not implemented. Use NostrAdapter instead.');
+  }
+
+  /**
+   * Generates a DidComm identity.
+   * @param {RawKeyPair} [keys] Optional keys to use for identity generation.
+   * @returns {ServiceAdapterConfig} The generated DidComm identity configuration.
+   */
+  public generateIdentity(keys?: RawSchnorrKeyPair): ServiceAdapterConfig {
+    if(!keys) {
+      this.config.keys.secret = Secp256k1SecretKey.random();
+      this.config.keys.public = Secp256k1SecretKey.getPublicKey(this.config.keys.secret).compressed;
+      this.config.did = Identifier.encode(
+        {
+          idType       : this.config.components.idType  || 'KEY',
+          version      : this.config.components.version || 1,
+          network      : this.config.components.network || 'signet',
+          genesisBytes : this.config.keys.public
+        }
+      );
+      return this.config as ServiceAdapterConfig;
+    }
+
+    this.config.keys = keys;
+    this.config.did = Identifier.encode(
+      {
+        idType       : this.config.components.idType  || 'KEY',
+        version      : this.config.components.version || 1,
+        network      : this.config.components.network || 'signet',
+        genesisBytes : this.config.keys.public
+      }
+    );
+    return this.config as ServiceAdapterConfig;
+  }
+}

package/src/core/beacon/aggregation/communication/adapter/nostr.ts

@@ -0,0 +1,300 @@
+import { Did, Maybe } from '@did-btcr2/common';
+import { CompressedSecp256k1PublicKey, RawSchnorrKeyPair, SchnorrKeyPair, Secp256k1SecretKey } from '@did-btcr2/keypair';
+import { nonceGen } from '@scure/btc-signer/musig2';
+import { Event, EventTemplate, Filter, finalizeEvent, nip44 } from 'nostr-tools';
+import { SimplePool } from 'nostr-tools/pool';
+import { Identifier } from '../../../../identifier.js';
+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 '../../cohort/messages/constants.js';
+import { AggregateBeaconMessage, AggregateBeaconMessageType } from '../../cohort/messages/index.js';
+import { CommunicationAdapterError } from '../error.js';
+import { CommunicationService, MessageHandler, ServiceAdapter, ServiceAdapterConfig, ServiceAdapterIdentity } from '../service.js';
+
+/**
+ * DEFAULT_NOSTR_RELAYS provides a list of default Nostr relay URLs for communication.
+ * These relays are used to connect to the Nostr network for sending and receiving messages.
+ * @constant {Array<string>} DEFAULT_NOSTR_RELAYS
+ */
+export const DEFAULT_NOSTR_RELAYS = [
+  'wss://relay.damus.io',
+  // 'wss://nos.lol',
+  // 'wss://relay.snort.social',
+  // 'wss://nostr-pub.wellorder.net',
+];
+
+/**
+ * NostrAdapterConfig defines the configuration structure for the Nostr communication adapter.
+ * It includes relay URLs, key pairs, and components for identity generation.
+ * @interface NostrAdapterConfig
+ * @type {NostrAdapterConfig}
+ */
+export interface NostrAdapterConfig {
+  keys: RawSchnorrKeyPair;
+  did?: string;
+  components: {
+    idType?: string;
+    version?: number;
+    network?: string;
+  };
+  relays: string[];
+  [key: string]: any;
+}
+
+export class NostrAdapter implements CommunicationService {
+  /**
+   * The name of the NostrAdapter service.
+   * @type {string}
+   */
+  public name: string = 'nostr';
+
+  /**
+   * The configuration for the NostrAdapter.
+   * @type {NostrAdapterConfig}
+   */
+  public config: NostrAdapterConfig;
+
+  /**
+   * A map of message handlers for different message types.
+   * @type {Map<string, MessageHandler>}
+   */
+  private handlers: Map<string, MessageHandler> = new Map();
+
+  /**
+   * The SimplePool instance for managing Nostr subscriptions.
+   * @type {SimplePool}
+   */
+  public pool?: SimplePool;
+
+  /**
+   * Constructs a new NostrAdapter instance with the given configuration.
+   * @param {NostrAdapterConfig} config - The configuration for the NostrAdapter.
+   * If no configuration is provided, a new key pair is generated and default relays are used.
+   * @constructor
+   */
+  constructor(config: NostrAdapterConfig = { keys: {} as RawSchnorrKeyPair, components: {}, relays: DEFAULT_NOSTR_RELAYS }) {
+    this.config = config;
+    this.config.keys = this.config.keys || SchnorrKeyPair.generate().raw;
+    this.config.did = config.did || Identifier.encode({
+      idType       : config.components.idType || 'KEY',
+      version      : config.components.version || 1,
+      network      : config.components.network || 'signet',
+      genesisBytes : this.config.keys.public!
+    });
+  }
+
+  /**
+   * Sets the keys for the NostrAdapter.
+   * @param {ServiceAdapterIdentity<RawSchnorrKeyPair>} keys - The key pair to set.
+   */
+  public setKeys(keys: ServiceAdapterIdentity<RawSchnorrKeyPair>): void {
+    this.config.keys = keys;
+  }
+
+
+  /**
+   * Starts the Nostr communication service by subscribing to relays.
+   * @returns {ServiceAdapter<NostrAdapter>} Returns the NostrAdapter instance for method chaining.
+   */
+  public start(): ServiceAdapter<NostrAdapter> {
+    this.pool = new SimplePool();
+
+    this.pool.subscribe(this.config.relays, { kinds: [1] } as Filter, {
+      onclose : (reasons: string[]) => console.log('Subscription to kind 1 closed', reasons),
+      onevent : this.onEvent.bind(this),
+    });
+
+    // this.pool.subscribe(this.config.relays, { kinds: [1059] } as Filter, {
+    //   onclose : (reasons: string[]) => console.log('Subscription to kind 1059 closed for reasons:', reasons),
+    //   onevent : this.onEvent.bind(this),
+    //   oneose  : () => { Logger.info('EOSE kinds 1059'); }
+    // });
+
+    return this;
+  }
+
+
+  /**
+   * Handles incoming Nostr events and dispatches them to the appropriate message handler.
+   * @param {Event} event The Nostr event received from the relay.
+   */
+  private async onEvent(event: Event): Promise<void> {
+    // Logger.debug('nostr.onEvent: event.tags', event.tags);
+    // Dispatch the event to the registered handler
+    const ptags = event.tags.filter(([name, _]) => name === 'p') ?? [];
+    // Logger.debug('nostr.onEvent: event.tags.find => ptags', ptags);
+
+    for(const [p, pk] of ptags ){
+      if(pk === 'b71d3052dcdc8ba4564388948b655b58aaa7f37497ef1fc98829f9191adc8f85') {
+        console.debug('nostr.onEvent: event.tags.find => p, pk', p, pk);
+      }
+    }
+    // if(!type && !value) {
+    //   // Logger.warn(`Event ${event.id} does not have a valid tag, skipping handler dispatch.`);
+    //   return;
+    // }
+    // Logger.debug('nostr.onEvent: event.tags.find => type, value', type, value);
+
+    // Logger.debug('nostr.onEvent: event', event);
+    // Logger.debug('nostr.onEvent: event.tags', event.tags);
+
+    // if(event.kind === 1 && !AggregateBeaconMessage.isKeyGenMessageValue(value)) {
+    //   Logger.warn(`Event ${event.id} is not a key generation message type: ${value}, skipping handler dispatch.`);
+    //   return;
+    // }
+
+    // if(event.kind === 1059 && !AggregateBeaconMessage.isSignMessageValue(value)) {
+    //   Logger.warn(`Event ${event.id} has an invalid title tag: ${value}, skipping handler dispatch.`);
+    //   return;
+    // }
+
+    // const handler = this.handlers.get(value);
+    // if (!handler) {
+    //   Logger.warn(`No handler found for message with tag value: ${value}`);
+    //   return;
+    // }
+
+    // await handler(event);
+  }
+
+  /**
+   * Registers a message handler for a specific message type.
+   * @param {string} messageType The type of message to handle.
+   * @param {MessageHandler} handler The handler function that processes the message.
+   */
+  public registerMessageHandler(messageType: string, handler: MessageHandler): void {
+    this.handlers.set(messageType, handler);
+  }
+
+
+  /**
+   * Sends a message to a recipient using the Nostr protocol.
+   * This method is a placeholder and should be implemented with actual Nostr message sending logic.
+   * @param {Maybe<AggregateBeaconMessageType>} message The message to send, typically containing the content and metadata.
+   * @param {Did} from The identifier of the sender.
+   * @param {Did} [to] The identifier of the recipient.
+   * @returns {Promise<void>} A promise that resolves when the message is sent.
+   */
+  public async sendMessage(message: Maybe<AggregateBeaconMessageType>, from: Did, to?: Did): Promise<void | Promise<string>[]> {
+    // Check if the sender and recipient DIDs are valid Btc1 identifiers
+    if(
+      [from, to]
+        .filter(did => !!did)
+        .every(did => !Identifier.isValid(did!))
+    ) {
+      console.error(`Invalid Btc1 identifiers: sender ${from}, recipient ${to}`);
+      throw new CommunicationAdapterError(
+        `Invalid identifiers: sender ${from}, recipient ${to}`,
+        'SEND_MESSAGE_ERROR', { adapter: this.name }
+      );
+    }
+    // Decode the sender and recipient DIDs to get their genesis bytes in hex
+    const sender = new CompressedSecp256k1PublicKey(Identifier.decode(from).genesisBytes);
+    console.info(`Sending message from ${sender}:`, message);
+
+    // if(message.type === BEACON_COHORT_SUBSCRIBE_ACCEPT) {
+    //   this.config.coordinatorDids.push(recipient);
+    // }
+
+    const tags = [['p', Buffer.from(sender.x).toString('hex')]];
+    if(to) {
+      const recipient = new CompressedSecp256k1PublicKey(Identifier.decode(to).genesisBytes);
+      tags.push(['p', Buffer.from(recipient.x).toString('hex')]);
+    }
+
+    if(AggregateBeaconMessage.isKeyGenMessageValue(message.type)) {
+      switch(message.type) {
+        case BEACON_COHORT_ADVERT:
+          console.info('Add tag', ['BEACON_COHORT_ADVERT', message.type]);
+          break;
+        case BEACON_COHORT_OPT_IN:
+          console.info('Add tag', ['BEACON_COHORT_OPT_IN', message.type]);
+          break;
+        case BEACON_COHORT_OPT_IN_ACCEPT:
+          console.info('Add tag', ['BEACON_COHORT_OPT_IN_ACCEPT', message.type]);
+          break;
+        case BEACON_COHORT_READY:
+          console.info('Add tag', ['BEACON_COHORT_READY', message.type]);
+          break;
+      }
+      const event = finalizeEvent({
+        kind       : 1,
+        created_at : Math.floor(Date.now() / 1000),
+        tags,
+        content    : JSON.stringify(message)
+      } as EventTemplate, this.config.keys.secret!);
+      console.info(`Sending message kind 1 event ...`, event);
+      return this.pool?.publish(this.config.relays, event);
+    }
+
+    if(AggregateBeaconMessage.isSignMessageValue(message.type)) {
+      switch(message.type) {
+        case BEACON_COHORT_REQUEST_SIGNATURE:
+          console.info('Add tag', ['BEACON_COHORT_REQUEST_SIGNATURE', message.type]);
+          break;
+        case BEACON_COHORT_AUTHORIZATION_REQUEST:
+          console.info('Add tag', ['BEACON_COHORT_AUTHORIZATION_REQUEST', message.type]);
+          break;
+        case BEACON_COHORT_NONCE_CONTRIBUTION:
+          console.info('Add tag', ['BEACON_COHORT_NONCE_CONTRIBUTION', message.type]);
+          break;
+        case BEACON_COHORT_AGGREGATED_NONCE:
+          console.info('Add tag', ['BEACON_COHORT_AGGREGATED_NONCE', message.type]);
+          break;
+        case BEACON_COHORT_SIGNATURE_AUTHORIZATION:
+          console.info('Add tag', ['BEACON_COHORT_SIGNATURE_AUTHORIZATION', message.type]);
+          break;
+      }
+      const { publicKey, secretKey } = SchnorrKeyPair.generate();
+      const content = nip44.encrypt(JSON.stringify(message), secretKey.bytes, nonceGen(publicKey.x).public);
+      console.debug('NostrAdapter content:', content);
+
+      const event = finalizeEvent({ content, tags, kind: 1059 } as EventTemplate, this.config.keys.secret!);
+      console.debug('NostrAdapter event:', event);
+
+      return this.pool?.publish(this.config.relays, event);
+    }
+
+    console.error(`Unsupported message type: ${message.type}`);
+  }
+
+  /**
+   * Generates a Nostr identity using the Secp256k1SecretKey and Identifier classes.
+   * @param {RawSchnorrKeyPair} [keys] Optional keys to use for identity generation.
+   * @returns {ServiceAdapterConfig} The generated Nostr identity configuration.
+   */
+  public generateIdentity(keys?: RawSchnorrKeyPair): ServiceAdapterConfig {
+    if(!keys) {
+      this.config.keys.secret = Secp256k1SecretKey.random();
+      this.config.keys.public = Secp256k1SecretKey.getPublicKey(this.config.keys.secret).compressed;
+      this.config.did = Identifier.encode(
+        {
+          idType       : this.config.components.idType  || 'KEY',
+          version      : this.config.components.version || 1,
+          network      : this.config.components.network || 'signet',
+          genesisBytes : this.config.keys.public
+        }
+      );
+      return this.config as ServiceAdapterConfig;
+    }
+
+    this.config.keys = keys;
+    this.config.did = Identifier.encode(
+      {
+        idType       : this.config.components.idType  || 'KEY',
+        version      : this.config.components.version || 1,
+        network      : this.config.components.network || 'signet',
+        genesisBytes : this.config.keys.public
+      }
+    );
+    return this.config as ServiceAdapterConfig;
+  }
+}