@did-btcr2/method 0.18.1 → 0.19.0

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

@@ -1,3 +1,5 @@
+// TODO: Finish nostr adapter implementation. Rethink patterns used.
+
 import { Did, Maybe } from '@did-btcr2/common';
 import { CompressedSecp256k1PublicKey, RawSchnorrKeyPair, SchnorrKeyPair, Secp256k1SecretKey } from '@did-btcr2/keypair';
 import { nonceGen } from '@scure/btc-signer/musig2';
@@ -20,6 +22,7 @@ import { CommunicationAdapterError } from '../error.js';
 import { CommunicationService, MessageHandler, ServiceAdapter, ServiceAdapterConfig, ServiceAdapterIdentity } from '../service.js';
 
 /**
+ * TODO: Determine set of default Nostr relays to use.
  * 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
@@ -49,30 +52,37 @@ export interface NostrAdapterConfig {
   [key: string]: any;
 }
 
+/**
+ * NostrAdapter implements the CommunicationService interface for Nostr protocol communication.
+ * It provides methods for starting the service, sending messages, and handling incoming events.
+ * @class NostrAdapter
+ * @type {NostrAdapter}
+ * @implements {CommunicationService}
+ */
 export class NostrAdapter implements CommunicationService {
   /**
    * The name of the NostrAdapter service.
    * @type {string}
    */
-  public name: string = 'nostr';
+  name: string = 'nostr';
 
   /**
    * The configuration for the NostrAdapter.
    * @type {NostrAdapterConfig}
    */
-  public config: NostrAdapterConfig;
+  config: NostrAdapterConfig;
 
   /**
    * A map of message handlers for different message types.
    * @type {Map<string, MessageHandler>}
    */
-  private handlers: Map<string, MessageHandler> = new Map();
+  #handlers: Map<string, MessageHandler> = new Map();
 
   /**
    * The SimplePool instance for managing Nostr subscriptions.
    * @type {SimplePool}
    */
-  public pool?: SimplePool;
+  pool?: SimplePool;
 
   /**
    * Constructs a new NostrAdapter instance with the given configuration.
@@ -101,6 +111,7 @@ export class NostrAdapter implements CommunicationService {
 
 
   /**
+   * TODO: Complete this method. Figure out best subscription patterns.
    * Starts the Nostr communication service by subscribing to relays.
    * @returns {ServiceAdapter<NostrAdapter>} Returns the NostrAdapter instance for method chaining.
    */
@@ -123,6 +134,7 @@ export class NostrAdapter implements CommunicationService {
 
 
   /**
+   * TODO: Complete this method. Figure out best way to filter incoming nostr events.
    * Handles incoming Nostr events and dispatches them to the appropriate message handler.
    * @param {Event} event The Nostr event received from the relay.
    */
@@ -171,11 +183,12 @@ export class NostrAdapter implements CommunicationService {
    * @param {MessageHandler} handler The handler function that processes the message.
    */
   public registerMessageHandler(messageType: string, handler: MessageHandler): void {
-    this.handlers.set(messageType, handler);
+    this.#handlers.set(messageType, handler);
   }
 
 
   /**
+   * TODO: Clean up and complete this method.
    * 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.
@@ -184,13 +197,13 @@ export class NostrAdapter implements CommunicationService {
    * @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
+    // Check if the sender and recipient DIDs are valid identifiers
     if(
       [from, to]
         .filter(did => !!did)
         .every(did => !Identifier.isValid(did!))
     ) {
-      console.error(`Invalid Btc1 identifiers: sender ${from}, recipient ${to}`);
+      console.error(`Invalid identifiers: sender ${from}, recipient ${to}`);
       throw new CommunicationAdapterError(
         `Invalid identifiers: sender ${from}, recipient ${to}`,
         'SEND_MESSAGE_ERROR', { adapter: this.name }
@@ -209,20 +222,28 @@ export class NostrAdapter implements CommunicationService {
       const recipient = new CompressedSecp256k1PublicKey(Identifier.decode(to).genesisBytes);
       tags.push(['p', Buffer.from(recipient.x).toString('hex')]);
     }
+    const { type } = message as any ?? {};
+    if(!type) {
+      console.error('Message type is undefined:', message);
+      throw new CommunicationAdapterError(
+        'Message type is undefined',
+        'SEND_MESSAGE_ERROR', { adapter: this.name }
+      );
+    }
 
-    if(AggregateBeaconMessage.isKeyGenMessageValue(message.type)) {
-      switch(message.type) {
+    if(AggregateBeaconMessage.isKeyGenMessageValue(type)) {
+      switch(type) {
         case BEACON_COHORT_ADVERT:
-          console.info('Add tag', ['BEACON_COHORT_ADVERT', message.type]);
+          console.info('Add tag', ['BEACON_COHORT_ADVERT', type]);
           break;
         case BEACON_COHORT_OPT_IN:
-          console.info('Add tag', ['BEACON_COHORT_OPT_IN', message.type]);
+          console.info('Add tag', ['BEACON_COHORT_OPT_IN', type]);
           break;
         case BEACON_COHORT_OPT_IN_ACCEPT:
-          console.info('Add tag', ['BEACON_COHORT_OPT_IN_ACCEPT', message.type]);
+          console.info('Add tag', ['BEACON_COHORT_OPT_IN_ACCEPT', type]);
           break;
         case BEACON_COHORT_READY:
-          console.info('Add tag', ['BEACON_COHORT_READY', message.type]);
+          console.info('Add tag', ['BEACON_COHORT_READY', type]);
           break;
       }
       const event = finalizeEvent({
@@ -235,22 +256,22 @@ export class NostrAdapter implements CommunicationService {
       return this.pool?.publish(this.config.relays, event);
     }
 
-    if(AggregateBeaconMessage.isSignMessageValue(message.type)) {
-      switch(message.type) {
+    if(AggregateBeaconMessage.isSignMessageValue(type)) {
+      switch(type) {
         case BEACON_COHORT_REQUEST_SIGNATURE:
-          console.info('Add tag', ['BEACON_COHORT_REQUEST_SIGNATURE', message.type]);
+          console.info('Add tag', ['BEACON_COHORT_REQUEST_SIGNATURE', type]);
           break;
         case BEACON_COHORT_AUTHORIZATION_REQUEST:
-          console.info('Add tag', ['BEACON_COHORT_AUTHORIZATION_REQUEST', message.type]);
+          console.info('Add tag', ['BEACON_COHORT_AUTHORIZATION_REQUEST', type]);
           break;
         case BEACON_COHORT_NONCE_CONTRIBUTION:
-          console.info('Add tag', ['BEACON_COHORT_NONCE_CONTRIBUTION', message.type]);
+          console.info('Add tag', ['BEACON_COHORT_NONCE_CONTRIBUTION', type]);
           break;
         case BEACON_COHORT_AGGREGATED_NONCE:
-          console.info('Add tag', ['BEACON_COHORT_AGGREGATED_NONCE', message.type]);
+          console.info('Add tag', ['BEACON_COHORT_AGGREGATED_NONCE', type]);
           break;
         case BEACON_COHORT_SIGNATURE_AUTHORIZATION:
-          console.info('Add tag', ['BEACON_COHORT_SIGNATURE_AUTHORIZATION', message.type]);
+          console.info('Add tag', ['BEACON_COHORT_SIGNATURE_AUTHORIZATION', type]);
           break;
       }
       const { publicKey, secretKey } = SchnorrKeyPair.generate();
@@ -263,10 +284,11 @@ export class NostrAdapter implements CommunicationService {
       return this.pool?.publish(this.config.relays, event);
     }
 
-    console.error(`Unsupported message type: ${message.type}`);
+    console.error(`Unsupported message type: ${type}`);
   }
 
   /**
+   * TODO: Determine if this method is needed.
    * 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.

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

@@ -23,7 +23,15 @@ import { CommunicationService, Service, ServiceAdapterIdentity } from './communi
 import { BeaconCohortSigningSession } from './session/index.js';
 import { SIGNING_SESSION_STATUS } from './session/status.js';
 
-type BeaconCoordinatorParams = {
+/**
+ * Parameters for initializing a BeaconCoordinator.
+ * @type {BeaconCoordinatorParams}
+ * @property {CommunicationService} [protocol] - The communication protocol to be used.
+ * @property {string} did - The Decentralized Identifier (DID) for the coordinator.
+ * @property {ServiceAdapterIdentity<RawSchnorrKeyPair>} keys - The keys used for cryptographic operations.
+ * @property {string} [name] - Optional name for the coordinator.
+ */
+export type BeaconCoordinatorParams = {
   protocol?: CommunicationService;
   did: string;
   keys: ServiceAdapterIdentity<RawSchnorrKeyPair>
@@ -34,37 +42,36 @@ type BeaconCoordinatorParams = {
  * @class BeaconCoordinator
  * @type {BeaconCoordinator}
  */
-
 export class BeaconCoordinator {
   /**
    * The name of the BeaconCoordinator service.
    * @type {string}
    */
-  public name: string;
+  name: string;
 
   /**
    * The DID of the BeaconCoordinator.
    * @type {Array<string>}
    */
-  public did: string;
+  did: string;
 
   /**
    * The communication protocol used by the BeaconCoordinator.
    * @type {CommunicationService}
    */
-  public protocol: CommunicationService;
+  protocol: CommunicationService;
 
   /**
    * List of subscribers engaged in a Musig2 Cohort signing session with the BeaconCoordinator.
    * @type {Array<string>}
    */
-  public cohorts: Array<AggregateBeaconCohort> = [];
+  cohorts: Array<AggregateBeaconCohort> = [];
 
   /**
    * Active signing sessions for the BeaconCoordinator.
    * @type {Record<string, BeaconCohortSigningSession>}
    */
-  public activeSigningSessions: Map<string, BeaconCohortSigningSession> = new Map();
+  activeSigningSessions: Map<string, BeaconCohortSigningSession> = new Map();
 
   /**
    * Constructs a new BeaconCoordinator instance.
@@ -74,23 +81,28 @@ export class BeaconCoordinator {
    * @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(params: BeaconCoordinatorParams) {
-    this.name = params.name || `btcr2-beacon-coordinator-${crypto.randomUUID()}`;
+  constructor(params: {
+    did: string;
+    keys: ServiceAdapterIdentity<RawSchnorrKeyPair>
+    protocol?: CommunicationService;
+    name?: string;
+  }) {
     this.did = params.did;
     this.protocol = params.protocol || new NostrAdapter();
     this.protocol.setKeys(params.keys);
+    this.name = params.name || `btcr2-beacon-coordinator-${crypto.randomUUID()}`;
   }
 
   /**
    * Setup and start the BeaconCoordinator communication protocol.
    * @returns {void}
    */
-  public start(): void {
+  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.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();
   }
 
@@ -99,7 +111,7 @@ export class BeaconCoordinator {
    * @param {OptInMessage} message The message containing the opt-in request.
    * @returns {Promise<void>}
    */
-  private async _handleOptIn(message: CohortOptInMessage): Promise<void> {
+  async #handleOptIn(message: CohortOptInMessage): Promise<void> {
     const optIn = BeaconCohortOptInMessage.fromJSON(message);
     const cohortId = optIn.body?.cohortId;
     const participant = optIn.from;
@@ -126,7 +138,7 @@ export class BeaconCoordinator {
    * @param {CohortRequestSignatureMessage} message The message containing the request signature.
    * @returns {Promise<void>}
    */
-  private async _handleRequestSignature(message: Maybe<CohortRequestSignatureMessage>): Promise<void> {
+  async #handleRequestSignature(message: Maybe<CohortRequestSignatureMessage>): Promise<void> {
     const signatureRequest = BeaconCohortRequestSignatureMessage.fromJSON(message);
     const cohortId = signatureRequest.body?.cohortId;
     if (!cohortId) {
@@ -147,7 +159,7 @@ export class BeaconCoordinator {
    * @param {CohortNonceContributionMessage} message The message containing the nonce contribution.
    * @returns {Promise<void>}
    */
-  private async _handleNonceContribution(message: CohortNonceContributionMessage): Promise<void> {
+  async #handleNonceContribution(message: CohortNonceContributionMessage): Promise<void> {
     // Cast message to NonceContributionMessage type.
     const nonceContribMessage = BeaconCohortNonceContributionMessage.fromJSON(message);
     const cohortId = nonceContribMessage.body?.cohortId;
@@ -195,7 +207,7 @@ export class BeaconCoordinator {
    * @param {Maybe<CohortSignatureAuthorizationMessage>} message The message containing the signature authorization request.
    * @returns {Promise<void>}
    */
-  private async _handleSignatureAuthorization(message: Maybe<CohortSignatureAuthorizationMessage>): Promise<void> {
+  async #handleSignatureAuthorization(message: Maybe<CohortSignatureAuthorizationMessage>): Promise<void> {
     const sigAuthMessage = BeaconCohortSignatureAuthorizationMessage.fromJSON(message);
     const cohortId = sigAuthMessage.body?.cohortId;
     if (!cohortId) {
@@ -216,14 +228,14 @@ export class BeaconCoordinator {
     if(signingSession.id !== sessionId) {
       throw new BeaconCoordinatorError(
         `Signature authorization for wrong session: ${signingSession.id} != ${sessionId}`,
-        'SIGNATURE_AUTHORIZATION_ERROR', message
+        'SIGNATURE_AUTHORIZATION_ERROR', { original: message, converted: sigAuthMessage }
       );
     }
 
     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
+        'SIGNATURE_AUTHORIZATION_ERROR', { original: message, converted: sigAuthMessage }
       );
     }
     const partialSignature = sigAuthMessage.body?.partialSignature;
@@ -241,7 +253,7 @@ export class BeaconCoordinator {
 
     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}`);
+      Logger.info(`Final signature ${Buffer.from(signature).toString('hex')} generated for session ${signingSession.id}`);
     }
   }
 
@@ -266,7 +278,7 @@ export class BeaconCoordinator {
    * @param {string} participant The DID of the participant requesting the subscription.
    * @returns {Promise<void>}
    */
-  public async acceptSubscription(participant: string): Promise<void> {
+  async acceptSubscription(participant: string): Promise<void> {
     Logger.info(`Accepting subscription from ${participant}`);
     const message = {
       type : BEACON_COHORT_OPT_IN_ACCEPT,
@@ -281,7 +293,7 @@ export class BeaconCoordinator {
    * @param {BeaconCohortSigningSession} session The session containing the aggregated nonce.
    * @returns {Promise<void>}
    */
-  public async sendAggregatedNonce(session: BeaconCohortSigningSession): Promise<void> {
+  async sendAggregatedNonce(session: BeaconCohortSigningSession): Promise<void> {
     const aggregatedNonce = session.generateAggregatedNonce();
     Logger.info(`Aggregated Nonces for session ${session.id}:`, aggregatedNonce);
 
@@ -304,13 +316,13 @@ export class BeaconCoordinator {
    * 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').
+   * @param {string} [beaconType='SMTBeacon'] The type of beacon to be used (default is 'SMTBeacon').
    * @returns {Promise<AggregateBeaconCohort>} The newly created cohort.
    */
-  public async advertiseCohort(
+  async advertiseCohort(
     minParticipants: number,
     network: string = 'mutinynet',
-    beaconType: string = 'SMTAggregateBeacon'
+    beaconType: string = 'SMTBeacon'
   ): Promise<AggregateBeaconCohort> {
     const cohort = new AggregateBeaconCohort({ minParticipants, network, beaconType });
     Logger.info(`Advertising new cohort ${cohort.id} ...`);
@@ -334,7 +346,7 @@ export class BeaconCoordinator {
    * @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> {
+  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.`);
@@ -366,7 +378,7 @@ export class BeaconCoordinator {
    * @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> {
+  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) {
@@ -393,7 +405,7 @@ export class BeaconCoordinator {
    * @param {Service} service The communication service configuration.
    * @returns {BeaconCoordinator} Initialized BeaconCoordinator instance.
    */
-  public static initialize(service: Service): BeaconCoordinator {
+  static initialize(service: Service): BeaconCoordinator {
     const communicationService = CommunicationFactory.establish(service);
     const coordinator = new BeaconCoordinator({
       protocol : communicationService,

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

@@ -275,11 +275,12 @@ export class BeaconParticipant {
       return;
     }
     this.finalizeUnsetCohortKey(cohortId);
-    const participantPk = this.getCohortKey(cohortId).publicKey?.toHex();
-    if(!participantPk) {
+    const participantPkBytes = this.getCohortKey(cohortId).publicKey;
+    if(!participantPkBytes) {
       Logger.error(`Failed to derive public key for cohort ${cohortId}`);
       return;
     }
+    const participantPk = Buffer.from(participantPkBytes).toString('hex');
     const beaconAddress = cohortSetMessage.body?.beaconAddress;
     if(!beaconAddress) {
       Logger.error(`Beacon address not provided in cohort set message for ${cohortId}`);
@@ -290,7 +291,7 @@ export class BeaconParticipant {
       Logger.error(`Cohort keys not provided in cohort set message for ${cohortId}`);
       return;
     }
-    const keys = cohortKeys.map(key => key.toHex());
+    const keys = cohortKeys.map(key => Buffer.from(key).toString('hex'));
     cohort.validateCohort([participantPk], keys, beaconAddress);
     Logger.info(`BeaconParticipant w/ pk ${participantPk} successfully joined cohort ${cohortId} with beacon address ${beaconAddress}.`);
     Logger.info(`Cohort status: ${cohort.status}`);

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

@@ -268,7 +268,7 @@ export class BeaconCohortSigningSession implements SigningSession {
    * @returns {BeaconCohortSigningSession} The JSON object representation of the signing session.
    */
   public json(): BeaconCohortSigningSession {
-    return Object.json(this) as BeaconCohortSigningSession;
+    return Object.fromEntries(Object.entries(this)) as BeaconCohortSigningSession;
   }
 
   /**

package/src/core/beacon/cas-beacon.ts

@@ -0,0 +1,67 @@
+import { BitcoinNetworkConnection } from '@did-btcr2/bitcoin';
+import { HexString, MethodError } from '@did-btcr2/common';
+import { SidecarData } from '../types.js';
+import { AggregateBeacon, BeaconService, BeaconSignal, BlockMetadata } from './interfaces.js';
+import { BTCR2SignedUpdate } from '@did-btcr2/cryptosuite';
+
+/**
+ * Implements {@link https://dcdpr.github.io/did-btcr2/terminology.html#cas-beacon | CAS Beacon}.
+ *
+ * @class CASBeacon
+ * @type {CASBeacon}
+ * @extends {AggregateBeacon}
+ */
+export class CASBeacon extends AggregateBeacon {
+  /**
+   * Creates an instance of CASBeacon.
+   * @param {BeaconService} service The service of the Beacon.
+   * @param {?BeaconSidecarData} [sidecar] The sidecar data of the Beacon.
+   */
+  constructor(
+    service: BeaconService,
+    signals: Array<BeaconSignal>,
+    sidecar: SidecarData,
+    bitcoin?: BitcoinNetworkConnection
+  ) {
+    super({ ...service, type: 'CASBeacon' }, signals, sidecar, bitcoin);
+  }
+
+  /**
+   * Establish a CASBeacon instance based on the provided service and sidecar data.
+   * @param {BeaconService} service - The beacon service configuration.
+   * @param {SidecarData} sidecar - The sidecar data.
+   * @returns {CASBeacon} The established CASBeacon instance.
+   */
+  static establish(service: BeaconService, signals: Array<BeaconSignal>, sidecar: SidecarData): CASBeacon {
+    return new CASBeacon(service, signals, sidecar);
+  }
+
+  /**
+   * TODO: Figure out if this is necessary or not.
+   * @param {HexString} updateHash The hash of the update to generate the signal for.
+   * @returns {BeaconSignal} The generated signal.
+   * @throws {MethodError} if the signal is invalid.
+   */
+  generateSignal(updateHash: HexString): BeaconSignal {
+    throw new Error('Method not implemented.' + updateHash);
+  }
+
+  /**
+   * Implements {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#process-cas-beacon | 7.2.e.1 Process CAS Beacon}.
+   * @returns {Promise<BTCR2SignedUpdate | undefined>} The processed signed update or undefined.
+   * @throws {MethodError} if the signal processing fails.
+   */
+  processSignals(): Promise<Array<[BTCR2SignedUpdate, BlockMetadata]>> {
+    throw new MethodError('Method not implemented.', `METHOD_NOT_IMPLEMENTED`);
+  }
+
+  /**
+   * TODO: Finish implementation
+   * @param {HexString} updateHash The hash of the update to broadcast.
+   * @returns {Promise<{ spentTx: string; signedUpdate: BTCR2SignedUpdate }>} The result of the broadcast.
+   * @throws {MethodError} if the broadcast fails.
+   */
+  async broadcastSignal(updateHash: HexString): Promise<HexString> {
+    throw new MethodError('Method not implemented.', `METHOD_NOT_IMPLEMENTED`, {updateHash});
+  }
+}

package/src/core/beacon/factory.ts

@@ -1,9 +1,9 @@
 import { MethodError } from '@did-btcr2/common';
-import { Beacon, BeaconService } from '../../interfaces/beacon.js';
-import { CIDAggregateSidecar, SidecarData, SMTAggregateSidecar } from '../../utils/types.js';
-import { CIDAggregateBeacon } from './cid-aggregate.js';
+import { SidecarData } from '../types.js';
+import { CASBeacon } from './cas-beacon.js';
+import { AggregateBeacon, BeaconService, BeaconSignal } from './interfaces.js';
 import { SingletonBeacon } from './singleton.js';
-import { SMTAggregateBeacon } from './smt-aggregate.js';
+import { SMTBeacon } from './smt-beacon.js';
 
 /**
  * Beacon Factory pattern to create Beacon instances.
@@ -14,22 +14,20 @@ export class BeaconFactory {
   /**
    * Establish a Beacon instance based on the provided service and optional sidecar data.
    * @param {BeaconService} service - The beacon service configuration.
-   * @param {SidecarData} [sidecar] - The optional sidecar data.
+   * @param {Array<BeaconSignal>} signals - The array of beacon signals.
+   * @param {SidecarData} sidecar - The sidecar data associated with the beacon.
    * @returns {Beacon} The established Beacon instance.
    */
-  static establish(service: BeaconService, sidecar?: SidecarData): Beacon {
+  static establish(service: BeaconService, signals: Array<BeaconSignal>, sidecar: SidecarData): AggregateBeacon {
     switch (service.type) {
       case 'SingletonBeacon':
-        return new SingletonBeacon(service, sidecar);
-      case 'CIDAggregateBeacon':
-        return new CIDAggregateBeacon(service, sidecar as CIDAggregateSidecar);
-      case 'SMTAggregateBeacon':
-        return new SMTAggregateBeacon(service, sidecar as SMTAggregateSidecar);
+        return new SingletonBeacon(service, signals, sidecar);
+      case 'CASBeacon':
+        return new CASBeacon(service, signals, sidecar);
+      case 'SMTBeacon':
+        return new SMTBeacon(service, signals, sidecar);
       default:
-        throw new MethodError(
-          'Invalid Beacon Type',
-          'INVALID_BEACON_ERROR', { service, sidecar }
-        );
+        throw new MethodError('Invalid Beacon Type', 'INVALID_BEACON_ERROR', service);
     }
   }
 }

package/src/core/beacon/interfaces.ts

@@ -0,0 +1,124 @@
+import { BitcoinNetworkConnection, RawTransactionRest, RawTransactionV2 } from '@did-btcr2/bitcoin';
+import { HexString, UnixTimestamp } from '@did-btcr2/common';
+import { DidServiceEndpoint, DidService as IDidService } from '@web5/dids';
+import { SidecarData } from '../types.js';
+import { BTCR2SignedUpdate } from '@did-btcr2/cryptosuite';
+
+/**
+ * Represents a Beacon Service, which extends the DID Service with a service endpoint.
+ * @interface BeaconService
+ * @extends IDidService
+ */
+export interface BeaconService extends IDidService {
+    serviceEndpoint: DidServiceEndpoint;
+}
+
+/**
+ * Represents a parsed Beacon Service, which extends the Beacon Service with a Bitcoin address.
+ * @interface ParsedBeaconService
+ * @extends BeaconService
+ */
+export interface ParsedBeaconService extends BeaconService {
+    /**
+     * The Bitcoin address associated with this Beacon Service.
+     */
+    address: string;
+}
+
+/**
+ * Metadata about a Bitcoin block containing a Beacon Signal.
+ * @interface BlockMetadata
+ */
+export interface BlockMetadata {
+   /**
+   * The block height at which the Beacon Signal was included.
+   */
+  height: number;
+
+  /**
+   * The timestamp of the block containing the Beacon Signal.
+   */
+  time: UnixTimestamp;
+
+  /**
+   * The number of confirmations for the block containing the Beacon Signal.
+   */
+  confirmations: number;
+}
+
+/**
+ * Represents a Beacon Signal, which is a transaction broadcasted by a Beacon to announce a DID update.
+ * @interface BeaconSignal
+ */
+export interface BeaconSignal {
+  /**
+   * The raw Bitcoin transaction representing the Beacon Signal.
+   */
+  tx: RawTransactionRest | RawTransactionV2;
+
+  /**
+   * The beacon signal bytes hash (i.e. the hash of the BTCR2 update included in the Beacon Signal tx).
+   */
+  signalBytes: string;
+
+  /**
+   * Metadata about the block containing the Beacon Signal.
+   */
+  blockMetadata: BlockMetadata;
+}
+
+/**
+ * Abstract class representing an AggregateBeacon.
+ * @abstract
+ * @class AggregateBeacon
+ * @type {AggregateBeacon}
+ */
+export abstract class AggregateBeacon {
+  /**
+   * The Beacon service object parsed from the DID Document.
+   */
+  service: BeaconService;
+
+  /**
+   * The array of Beacon Signals associated with this Beacon service.
+   */
+  signals: Array<BeaconSignal>;
+
+  /**
+   * The sidecar data associated with this Beacon service.
+   * TODO: Make this more specific to Beacon type.
+   */
+  sidecar: SidecarData;
+
+  /**
+   * The Bitcoin network connection associated with this Beacon service.
+   */
+  bitcoin: BitcoinNetworkConnection;
+
+  constructor(
+    service: BeaconService,
+    signals: Array<BeaconSignal>,
+    sidecar: SidecarData,
+    bitcoin?: BitcoinNetworkConnection
+  ) {
+    this.service = service;
+    this.signals = signals;
+    this.sidecar = sidecar;
+    this.bitcoin = bitcoin!;
+  }
+
+  /**
+   * Generates an unsigned update in a Beacon Signal (implemented by subclasses).
+   */
+  abstract generateSignal(updateHash: HexString): BeaconSignal;
+
+  /**
+   * Processes a Beacon Signal (implemented by subclasses).
+   */
+  abstract processSignals(): Promise<Array<[BTCR2SignedUpdate, BlockMetadata]>>;
+
+  /**
+   * Broadcasts a signed update in a Beacon Signal (implemented by subclasses).
+   */
+  abstract broadcastSignal(updateHash: HexString): Promise<HexString>;
+}