@did-btcr2/method 0.23.0 → 0.25.0

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

@@ -1,4 +1,4 @@
-import { KeyBytes, Logger, Maybe } from '@did-btcr2/common';
+import { KeyBytes, Maybe } from '@did-btcr2/common';
 import { HDKey } from '@scure/bip32';
 import { mnemonicToSeedSync } from '@scure/bip39';
 import * as musig2 from '@scure/btc-signer/musig2';
@@ -130,7 +130,7 @@ export class BeaconParticipant {
     this.protocol = protocol || new NostrAdapter();
     this.protocol.setKeys({ public: pk, secret });
     this.cohortKeyState.set('__UNSET__', this.beaconKeyIndex);
-    Logger.debug(`BeaconParticipant initialized with DID: ${this.did}, Name: ${this.name}, Key Index: ${this.beaconKeyIndex}`);
+    console.debug(`BeaconParticipant initialized with DID: ${this.did}, Name: ${this.name}, Key Index: ${this.beaconKeyIndex}`);
   }
 
   /**
@@ -138,7 +138,7 @@ export class BeaconParticipant {
    * @returns {void}
    */
   public start(): void {
-    Logger.info(`Setting up BeaconParticipant ${this.name} (${this.did}) on ${this.protocol.name} ...`);
+    console.info(`Setting up BeaconParticipant ${this.name} (${this.did}) on ${this.protocol.name} ...`);
     this.protocol.registerMessageHandler(BEACON_COHORT_ADVERT, this._handleCohortAdvert.bind(this));
     this.protocol.registerMessageHandler(BEACON_COHORT_OPT_IN_ACCEPT, this._handleSubscribeAccept.bind(this));
     this.protocol.registerMessageHandler(BEACON_COHORT_READY, this._handleCohortReady.bind(this));
@@ -171,10 +171,10 @@ export class BeaconParticipant {
       this.beaconKeyIndex = this.cohortKeyState.size + 1;
     }
     if(this.cohortKeyState.has(cohortId)) {
-      Logger.warn(`Cohort key state for cohort ${cohortId} already exists. Updating key index.`);
+      console.warn(`Cohort key state for cohort ${cohortId} already exists. Updating key index.`);
     }
     this.cohortKeyState.set(cohortId, this.beaconKeyIndex);
-    Logger.info(`Cohort key state updated. Next beacon key index: ${this.beaconKeyIndex + 1}`);
+    console.info(`Cohort key state updated. Next beacon key index: ${this.beaconKeyIndex + 1}`);
   }
 
   /**
@@ -196,7 +196,7 @@ export class BeaconParticipant {
     }
 
     if (this.cohortKeyState.has(cohortId)) {
-      Logger.warn(`Cohort key state already exists for ${cohortId}. Skipping migration from '__UNSET__'.`);
+      console.warn(`Cohort key state already exists for ${cohortId}. Skipping migration from '__UNSET__'.`);
       this.cohortKeyState.delete(unsetKey);
       return;
     }
@@ -204,7 +204,7 @@ export class BeaconParticipant {
     this.setCohortKey(cohortId);
     this.cohortKeyState.delete(unsetKey);
 
-    Logger.info(`Finalized '__UNSET__' CohortKeyState with ${cohortId} for ${this.did}`);
+    console.info(`Finalized '__UNSET__' CohortKeyState with ${cohortId} for ${this.did}`);
   }
 
   /**
@@ -226,25 +226,25 @@ export class BeaconParticipant {
    * @returns {Promise<void>}
    */
   public async _handleCohortAdvert(message: Maybe<CohortAdvertMessage>): Promise<void> {
-    Logger.debug('_handleCohortAdvert', message);
+    console.debug('_handleCohortAdvert', message);
     const cohortAdvertMessage = BeaconCohortAdvertMessage.fromJSON(message);
-    Logger.info(`Received new cohort announcement from ${cohortAdvertMessage.from}`, cohortAdvertMessage);
+    console.info(`Received new cohort announcement from ${cohortAdvertMessage.from}`, cohortAdvertMessage);
 
     const cohortId = cohortAdvertMessage.body?.cohortId;
     if (!cohortId) {
-      Logger.warn('Received malformed cohort advert message: missing cohortId', cohortAdvertMessage);
+      console.warn('Received malformed cohort advert message: missing cohortId', cohortAdvertMessage);
       return;
     }
 
     const network = cohortAdvertMessage.body?.network;
     if (!network) {
-      Logger.warn('Received malformed cohort advert message: missing network', cohortAdvertMessage);
+      console.warn('Received malformed cohort advert message: missing network', cohortAdvertMessage);
       return;
     }
 
     const minParticipants = cohortAdvertMessage.body?.cohortSize;
     if (!cohortId || !network || !minParticipants) {
-      Logger.warn('Received malformed cohort advert message: missing minParticipants', cohortAdvertMessage);
+      console.warn('Received malformed cohort advert message: missing minParticipants', cohortAdvertMessage);
       return;
     }
 
@@ -271,30 +271,30 @@ export class BeaconParticipant {
     const cohortId = cohortSetMessage.body?.cohortId;
     const cohort = this.cohorts.find(c => c.id === cohortId);
     if (!cohortId || !cohort) {
-      Logger.warn(`Cohort with ID ${cohortId} not found or not joined by participant ${this.did}.`);
+      console.warn(`Cohort with ID ${cohortId} not found or not joined by participant ${this.did}.`);
       return;
     }
     this.finalizeUnsetCohortKey(cohortId);
     const participantPkBytes = this.getCohortKey(cohortId).publicKey;
     if(!participantPkBytes) {
-      Logger.error(`Failed to derive public key for cohort ${cohortId}`);
+      console.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}`);
+      console.error(`Beacon address not provided in cohort set message for ${cohortId}`);
       return;
     }
     const cohortKeys = cohortSetMessage.body?.cohortKeys;
     if(!cohortKeys) {
-      Logger.error(`Cohort keys not provided in cohort set message for ${cohortId}`);
+      console.error(`Cohort keys not provided in cohort set message for ${cohortId}`);
       return;
     }
     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}`);
+    console.info(`BeaconParticipant w/ pk ${participantPk} successfully joined cohort ${cohortId} with beacon address ${beaconAddress}.`);
+    console.info(`Cohort status: ${cohort.status}`);
   }
 
   /**
@@ -306,17 +306,17 @@ export class BeaconParticipant {
     const authRequest = BeaconCohortAuthorizationRequestMessage.fromJSON(message);
     const cohort = this.cohorts.find(c => c.id === authRequest.body?.cohortId);
     if (!cohort) {
-      Logger.warn(`Authorization request for unknown cohort ${authRequest.body?.cohortId} from ${authRequest.from}`);
+      console.warn(`Authorization request for unknown cohort ${authRequest.body?.cohortId} from ${authRequest.from}`);
       return;
     }
     const id = authRequest.body?.sessionId;
     if (!id) {
-      Logger.warn(`Authorization request missing session ID from ${authRequest.from}`);
+      console.warn(`Authorization request missing session ID from ${authRequest.from}`);
       return;
     }
     const pendingTx = authRequest.body?.pendingTx;
     if (!pendingTx) {
-      Logger.warn(`Authorization request missing pending transaction from ${authRequest.from}`);
+      console.warn(`Authorization request missing pending transaction from ${authRequest.from}`);
       return;
     }
     const session = new BeaconCohortSigningSession({
@@ -338,23 +338,23 @@ export class BeaconParticipant {
     const aggNonceMessage = BeaconCohortAggregatedNonceMessage.fromJSON(message);
     const sessionId = aggNonceMessage.body?.sessionId;
     if (!sessionId) {
-      Logger.warn(`Aggregated nonce message missing session ID from ${aggNonceMessage.from}`);
+      console.warn(`Aggregated nonce message missing session ID from ${aggNonceMessage.from}`);
       return;
     }
     const session = this.activeSigningSessions.get(sessionId);
     if (!session) {
-      Logger.warn(`Aggregated nonce message received for unknown session ${sessionId}`);
+      console.warn(`Aggregated nonce message received for unknown session ${sessionId}`);
       return;
     }
     const aggregatedNonce = aggNonceMessage.body?.aggregatedNonce;
     if (!aggregatedNonce) {
-      Logger.warn(`Aggregated nonce message missing aggregated nonce from ${aggNonceMessage.from}`);
+      console.warn(`Aggregated nonce message missing aggregated nonce from ${aggNonceMessage.from}`);
       return;
     }
     session.aggregatedNonce = aggregatedNonce;
     const participantSk = this.getCohortKey(session.cohort.id).privateKey;
     if(!participantSk) {
-      Logger.error(`Failed to derive secret key for cohort ${session.cohort.id}`);
+      console.error(`Failed to derive secret key for cohort ${session.cohort.id}`);
       return;
     }
     const partialSig = session.generatePartialSignature(participantSk);
@@ -368,7 +368,7 @@ export class BeaconParticipant {
    */
   public async subscribeToCoordinator(coordinatorDid: string): Promise<any> {
     if(this.coordinatorDids.includes(coordinatorDid)) {
-      Logger.info(`Already subscribed to coordinator ${coordinatorDid}`);
+      console.info(`Already subscribed to coordinator ${coordinatorDid}`);
       return;
     }
     const subMessage = new BeaconCohortSubscribeMessage({ to: coordinatorDid, from: this.did });
@@ -382,16 +382,16 @@ export class BeaconParticipant {
    * @returns {Promise<void>}
    */
   public async joinCohort(cohortId: string, coordinatorDid: string): Promise<void> {
-    Logger.info(`BeaconParticipant ${this.did} joining cohort ${cohortId} with coordinator ${coordinatorDid}`);
+    console.info(`BeaconParticipant ${this.did} joining cohort ${cohortId} with coordinator ${coordinatorDid}`);
     this.finalizeUnsetCohortKey(cohortId);
     const cohort = this.cohorts.find(c => c.id === cohortId);
     if (!cohort) {
-      Logger.warn(`Cohort with ID ${cohortId} not found.`);
+      console.warn(`Cohort with ID ${cohortId} not found.`);
       return;
     }
     const pk = this.getCohortKey(cohortId).publicKey;
     if(!pk) {
-      Logger.error(`Failed to derive public key for cohort ${cohortId} at index ${this.beaconKeyIndex}`);
+      console.error(`Failed to derive public key for cohort ${cohortId} at index ${this.beaconKeyIndex}`);
       return;
     }
     this.setCohortKey(cohortId);
@@ -415,11 +415,11 @@ export class BeaconParticipant {
   public async requestCohortSignature(cohortId: string, data: string): Promise<boolean> {
     const cohort = this.cohorts.find(c => c.id === cohortId);
     if (!cohort) {
-      Logger.warn(`Cohort with ID ${cohortId} not found.`);
+      console.warn(`Cohort with ID ${cohortId} not found.`);
       return false;
     }
     if(cohort.status !== COHORT_STATUS.COHORT_SET_STATUS) {
-      Logger.warn(`Cohort ${cohortId} not in a set state. Current status: ${cohort.status}`);
+      console.warn(`Cohort ${cohortId} not in a set state. Current status: ${cohort.status}`);
       return false;
     }
     const reqSigMessage = new BeaconCohortRequestSignatureMessage({
@@ -469,16 +469,14 @@ export class BeaconParticipant {
     session: BeaconCohortSigningSession
   ): Promise<void> {
     const nonceContributionMessage = BeaconCohortNonceContributionMessage.fromJSON({
-      to        : cohort.coordinatorDid,
-      from      : this.did,
-      body : {
-        sessionId : session.id,
-        cohortId  : cohort.id,
-        nonceContribution
-      }
+      to                : cohort.coordinatorDid,
+      from              : this.did,
+      sessionId         : session.id,
+      cohortId          : cohort.id,
+      nonceContribution
     });
     await this.protocol.sendMessage(nonceContributionMessage, this.did, cohort.coordinatorDid);
-    Logger.info(`Nonce contribution sent for session ${session.id} in cohort ${cohort.id} by participant ${this.did}`);
+    console.info(`Nonce contribution sent for session ${session.id} in cohort ${cohort.id} by participant ${this.did}`);
   }
 
   /**
@@ -496,7 +494,7 @@ export class BeaconParticipant {
       partialSignature : partialSig,
     });
     await this.protocol.sendMessage(sigAuthMessage, this.did, session.cohort.coordinatorDid);
-    Logger.info(`Partial signature sent for session ${session.id} in cohort ${session.cohort.id} by participant ${this.did}`);
+    console.info(`Partial signature sent for session ${session.id} in cohort ${session.cohort.id} by participant ${this.did}`);
   }
 
   /**

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

@@ -1,4 +1,3 @@
-import { Logger } from '@did-btcr2/common';
 import * as musig2 from '@scure/btc-signer/musig2';
 import { Transaction } from 'bitcoinjs-lib';
 import { AggregateBeaconError } from '../../error.js';
@@ -166,7 +165,7 @@ export class BeaconCohortSigningSession implements SigningSession {
     }
 
     if (this.nonceContributions.get(from)) {
-      Logger.warn(`WARNING: Nonce contribution already received from ${from}.`);
+      console.warn(`WARNING: Nonce contribution already received from ${from}.`);
     }
 
     this.nonceContributions.set(from, nonceContribution);
@@ -210,7 +209,7 @@ export class BeaconCohortSigningSession implements SigningSession {
     }
 
     if(this.partialSignatures.get(from)) {
-      Logger.warn(`WARNING: Partial signature already received from ${from}.`);
+      console.warn(`WARNING: Partial signature already received from ${from}.`);
     }
 
     this.partialSignatures.set(from, partialSignature);
@@ -236,7 +235,7 @@ export class BeaconCohortSigningSession implements SigningSession {
     }
 
     const sigSum = [...this.partialSignatures.values()].reduce((sum, sig) => sum + bigEndianToInt(sig), 0n);
-    Logger.info(`Aggregated Signature computed: ${sigSum}`);
+    console.info(`Aggregated Signature computed: ${sigSum}`);
 
     this.aggregatedNonce ??= this.generateAggregatedNonce();
 

package/src/core/beacon/beacon.ts

@@ -1,8 +1,9 @@
 import { KeyBytes } from '@did-btcr2/common';
 import { BitcoinConnection } from '@did-btcr2/bitcoin';
-import { SignedBTCR2Update } from '../../../../cryptosuite/dist/types/data-integrity-proof/interface.js';
+import { SignedBTCR2Update } from '@did-btcr2/cryptosuite';
+import type { BeaconProcessResult } from '../resolver.js';
 import { SidecarData } from '../types.js';
-import { BeaconService, BeaconSignal, BlockMetadata } from './interfaces.js';
+import { BeaconService, BeaconSignal } from './interfaces.js';
 
 /**
  * Abstract base class for all BTCR2 Beacon types.
@@ -32,15 +33,18 @@ export abstract class Beacon {
   /**
    * Processes an array of Beacon Signals to extract BTCR2 Signed Updates.
    * Used during the resolve path.
+   *
+   * Returns successfully resolved updates and any data needs that must be
+   * satisfied before remaining signals can be processed.
+   *
    * @param {Array<BeaconSignal>} signals The beacon signals discovered on-chain.
    * @param {SidecarData} sidecar The processed sidecar data containing update/CAS/SMT maps.
-   * @returns {Promise<Array<[SignedBTCR2Update, BlockMetadata]>>} The updates announced by the signals.
+   * @returns {BeaconProcessResult} The updates and any data needs.
    */
   abstract processSignals(
     signals: Array<BeaconSignal>,
     sidecar: SidecarData,
-  ): Promise<Array<[SignedBTCR2Update, BlockMetadata]>>;
-
+  ): BeaconProcessResult;
 
   /**
    * Broadcasts a signed update as a Beacon Signal to the Bitcoin network.

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

@@ -1,6 +1,9 @@
-import { BitcoinConnection } from '@did-btcr2/bitcoin';
-import { KeyBytes } from '@did-btcr2/common';
+import { AddressUtxo, BitcoinConnection } from '@did-btcr2/bitcoin';
+import { canonicalHash, canonicalize, decode, encode, hash, KeyBytes } from '@did-btcr2/common';
 import { SignedBTCR2Update } from '@did-btcr2/cryptosuite';
+import { SchnorrKeyPair } from '@did-btcr2/keypair';
+import { opcodes, Psbt, script } from 'bitcoinjs-lib';
+import type { BeaconProcessResult, DataNeed } from '../resolver.js';
 import { SidecarData } from '../types.js';
 import { Beacon } from './beacon.js';
 import { CASBeaconError } from './error.js';
@@ -8,6 +11,13 @@ import { BeaconService, BeaconSignal, BlockMetadata } from './interfaces.js';
 
 /**
  * Implements {@link https://dcdpr.github.io/did-btcr2/terminology.html#cas-beacon | CAS Beacon}.
+ *
+ * A CAS (Content-Addressed Store) Beacon aggregates updates for multiple DIDs
+ * into a single CAS Announcement — a mapping of DIDs to their update hashes.
+ * The hash of the CAS Announcement is broadcast on-chain via OP_RETURN.
+ * During resolution, the CAS Announcement is retrieved from the sidecar (or CAS)
+ * and used to look up the individual signed update for the DID being resolved.
+ *
  * @class CASBeacon
  * @type {CASBeacon}
  * @extends {Beacon}
@@ -23,31 +33,167 @@ export class CASBeacon extends Beacon {
 
   /**
    * Implements {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#process-cas-beacon | 7.2.e.1 Process CAS Beacon}.
+   *
+   * For each signal, the signalBytes contain the hex-encoded hash of a CAS Announcement.
+   * The CAS Announcement maps DIDs to their base64url-encoded update hashes.
+   * This method looks up the CAS Announcement from the sidecar, extracts the update
+   * hash for the DID being resolved, and retrieves the corresponding signed update.
+   *
    * @param {Array<BeaconSignal>} signals The array of Beacon Signals to process.
    * @param {SidecarData} sidecar The sidecar data associated with the CAS Beacon.
-   * @returns {Promise<Array<[SignedBTCR2Update, BlockMetadata]>>} The processed signals.
-   * @throws {CASBeaconError} if processing fails.
+   * @returns {BeaconProcessResult} Successfully resolved updates and any data needs.
+   * @throws {CASBeaconError} if hash verification fails (validation errors only).
    */
   processSignals(
     signals: Array<BeaconSignal>,
     sidecar: SidecarData
-  ): Promise<Array<[SignedBTCR2Update, BlockMetadata]>> {
-    throw new CASBeaconError('Method not implemented.', `METHOD_NOT_IMPLEMENTED`, { signals, sidecar });
+  ): BeaconProcessResult {
+    const updates = new Array<[SignedBTCR2Update, BlockMetadata]>();
+    const needs = new Array<DataNeed>();
+
+    // Extract the DID from the beacon service id (strip the #fragment)
+    const did = this.service.id.split('#')[0];
+
+    for(const signal of signals) {
+      // Decode signal bytes from hex and re-encode to base64url for sidecar lookup
+      const announcementHash = encode(decode(signal.signalBytes, 'hex'));
+
+      // Look up the CAS Announcement in sidecar casMap
+      const casAnnouncement = sidecar.casMap.get(announcementHash);
+
+      if(!casAnnouncement) {
+        // CAS Announcement not available — emit a need
+        needs.push({
+          kind              : 'NeedCASAnnouncement',
+          announcementHash,
+          beaconServiceId   : this.service.id
+        });
+        continue;
+      }
+
+      // Look up this DID's update hash in the CAS Announcement
+      const updateHash = casAnnouncement[did];
+
+      // If no entry for this DID, this announcement doesn't contain an update for us — skip
+      if(!updateHash) {
+        continue;
+      }
+
+      // Look up the signed update in sidecar updateMap
+      const signedUpdate = sidecar.updateMap.get(updateHash);
+
+      if(!signedUpdate) {
+        // Signed update not available — emit a need
+        needs.push({
+          kind             : 'NeedSignedUpdate',
+          updateHash,
+          beaconServiceId  : this.service.id
+        });
+        continue;
+      }
+
+      updates.push([signedUpdate, signal.blockMetadata]);
+    }
+
+    return { updates, needs };
   }
 
   /**
-   * Broadcast CAS Beacon signal to the Bitcoin network.
+   * Broadcasts a CAS Beacon signal to the Bitcoin network.
+   *
+   * Creates a CAS Announcement mapping the DID to the update hash, then broadcasts
+   * the hash of the announcement via OP_RETURN. The CAS Announcement is distributed
+   * to resolvers via sidecar data.
+   *
    * @param {SignedBTCR2Update} signedUpdate The signed BTCR2 update to broadcast.
    * @param {KeyBytes} secretKey The secret key for signing the Bitcoin transaction.
    * @param {BitcoinConnection} bitcoin The Bitcoin network connection.
-   * @return {Promise<SignedBTCR2Update>} The signed update that was broadcasted.
-   * @throws {CASBeaconError} if broadcasting fails.
+   * @returns {Promise<SignedBTCR2Update>} The signed update that was broadcast.
+   * @throws {CASBeaconError} if the bitcoin address is invalid or unfunded.
    */
   async broadcastSignal(
     signedUpdate: SignedBTCR2Update,
     secretKey: KeyBytes,
     bitcoin: BitcoinConnection
   ): Promise<SignedBTCR2Update> {
-    throw new CASBeaconError('Method not implemented.', `METHOD_NOT_IMPLEMENTED`, {signedUpdate, secretKey, bitcoin});
+    // Extract the DID from the beacon service id (strip the #fragment)
+    const did = this.service.id.split('#')[0];
+
+    // Hash the signed update (base64url for the CAS Announcement entry)
+    const updateHash = canonicalHash(signedUpdate);
+
+    // Create the CAS Announcement mapping this DID to its update hash
+    const casAnnouncement = { [did]: updateHash };
+
+    // TODO: Publish CAS Announcement to content-addressed store (e.g., IPFS via Helia)
+
+    // Canonicalize and hash the CAS Announcement for the OP_RETURN output
+    const announcementHash = hash(canonicalize(casAnnouncement));
+
+    // Convert the serviceEndpoint to a bitcoin address by removing the 'bitcoin:' prefix
+    const bitcoinAddress = this.service.serviceEndpoint.replace('bitcoin:', '');
+
+    // Query the Bitcoin network for UTXOs associated with the bitcoinAddress
+    const utxos = await bitcoin.rest.address.getUtxos(bitcoinAddress);
+
+    // If no utxos are found, throw an error indicating the address is unfunded.
+    if(!utxos.length) {
+      throw new CASBeaconError(
+        'No UTXOs found, please fund address!',
+        'UNFUNDED_BEACON_ADDRESS', { bitcoinAddress }
+      );
+    }
+
+    // Sort utxos by block height and take the most recent one
+    const utxo: AddressUtxo | undefined = utxos.sort(
+      (a, b) => b.status.block_height - a.status.block_height
+    ).shift();
+
+    // If no utxos are found, throw an error.
+    if(!utxo) {
+      throw new CASBeaconError(
+        'Beacon bitcoin address unfunded or utxos unconfirmed.',
+        'UNFUNDED_BEACON_ADDRESS', { bitcoinAddress }
+      );
+    }
+
+    // Get the previous tx to the utxo being spent
+    const prevTx = await bitcoin.rest.transaction.getHex(utxo.txid);
+
+    // Construct a spend transaction
+    const spendTx = new Psbt({ network: bitcoin.data })
+      // Spend tx contains the utxo as its input
+      .addInput({
+        hash           : utxo.txid,
+        index          : utxo.vout,
+        nonWitnessUtxo : Buffer.from(prevTx, 'hex')
+      })
+      // Add a change output minus a fee of 500 sats
+      // TODO: calculate fee based on transaction vsize and current fee rates
+      .addOutput({ address: bitcoinAddress, value: BigInt(utxo.value) - BigInt(500) })
+      // Add an OP_RETURN output containing the CAS Announcement hash
+      .addOutput({ script: script.compile([opcodes.OP_RETURN, announcementHash]), value: 0n });
+
+    // Construct a key pair and PSBT signer from the secret key
+    const keyPair = SchnorrKeyPair.fromSecret(secretKey);
+    const signer = {
+      publicKey : keyPair.publicKey.compressed,
+      sign      : (hash: Uint8Array) => keyPair.secretKey.sign(hash, { scheme: 'ecdsa' }),
+    };
+
+    // Sign 0th input, finalize extract to hex in prep for broadcast
+    const signedTx = spendTx.signInput(0, signer)
+      .finalizeAllInputs()
+      .extractTransaction()
+      .toHex();
+
+    // Broadcast spendTx to the Bitcoin network.
+    const txid = await bitcoin.rest.transaction.send(signedTx);
+
+    // Log the txid of the broadcasted transaction
+    console.info(`CAS Beacon Signal Broadcasted with txid: ${txid}`);
+
+    // Return the signed update
+    return signedUpdate;
   }
 }

package/src/core/beacon/factory.ts

@@ -2,7 +2,7 @@ import { MethodError } from '@did-btcr2/common';
 import { Beacon } from './beacon.js';
 import { CASBeacon } from './cas-beacon.js';
 import { BeaconService } from './interfaces.js';
-import { SingletonBeacon } from './singleton.js';
+import { SingletonBeacon } from './singleton-beacon.js';
 import { SMTBeacon } from './smt-beacon.js';
 
 /**

package/src/core/beacon/{singleton.ts → singleton-beacon.ts}

@@ -1,9 +1,9 @@
 import { AddressUtxo, BitcoinConnection } from '@did-btcr2/bitcoin';
-import { Canonicalization, INVALID_SIDECAR_DATA, KeyBytes, MISSING_UPDATE_DATA } from '@did-btcr2/common';
+import { canonicalize, decode, encode, hash, KeyBytes } from '@did-btcr2/common';
 import { SignedBTCR2Update } from '@did-btcr2/cryptosuite';
 import { SchnorrKeyPair } from '@did-btcr2/keypair';
 import { opcodes, Psbt, script } from 'bitcoinjs-lib';
-import { base58btc } from 'multiformats/bases/base58';
+import type { BeaconProcessResult, DataNeed } from '../resolver.js';
 import { SidecarData } from '../types.js';
 import { Beacon } from './beacon.js';
 import { SingletonBeaconError } from './error.js';
@@ -20,7 +20,6 @@ export class SingletonBeacon extends Beacon {
   /**
    * Creates an instance of SingletonBeacon.
    * @param {BeaconService} service The BeaconService object representing the funded beacon to announce the update to.
-   *
    */
   constructor(service: BeaconService) {
     super({ ...service, type: 'SingletonBeacon' });
@@ -28,53 +27,38 @@ export class SingletonBeacon extends Beacon {
 
   /**
    * Processes an array of Beacon Signals associated with a Singleton Beacon Service.
-   * @returns {Promise<SignedBTCR2Update | undefined>} The DID Update payload announced by the Beacon Signal.
-   * @throws {SingletonBeaconError} if the signalTx is invalid or the signalSidecarData is invalid.
+   * @param {Array<BeaconSignal>} signals The beacon signals discovered on-chain.
+   * @param {SidecarData} sidecar The processed sidecar data.
+   * @returns {BeaconProcessResult} Successfully resolved updates and any data needs.
    */
-  async processSignals(
+  processSignals(
     signals: Array<BeaconSignal>,
     sidecar: SidecarData
-  ): Promise<Array<[SignedBTCR2Update, BlockMetadata]>> {
-    // Initialize an empty array to hold the BTCR2 signed updates
+  ): BeaconProcessResult {
     const updates = new Array<[SignedBTCR2Update, BlockMetadata]>();
+    const needs = new Array<DataNeed>();
 
-    // Loop through each signal in signals
     for(const signal of signals) {
-      // Grab the beacon signal bytes hash from the signal
-      const updateHash = signal.signalBytes;
+      // Decode signal bytes from hex and re-encode to base64url for sidecar lookup
+      const updateHash = encode(decode(signal.signalBytes, 'hex'));
 
-      // Use the updateHash as the sidecar data lookup key to retrieve the btcr2 update
+      // Look up the signed update in sidecar updateMap
       const signedUpdate = sidecar.updateMap.get(updateHash);
 
-      // If no btcr2 update is found in sidecar data maps, throw missingUpdateData error.
       if(!signedUpdate) {
-        throw new SingletonBeaconError(
-          `BTCR2 Signed Update not found for update hash ${updateHash}.`,
-          MISSING_UPDATE_DATA, signal
-        );
+        // Data not available — emit a need instead of throwing
+        needs.push({
+          kind             : 'NeedSignedUpdate',
+          updateHash,
+          beaconServiceId  : this.service.id
+        });
+        continue;
       }
 
-      // Canonicalize, hash and encode to base58btc the signed update object found in sidecar or CAS
-      const encodedUpdate = Canonicalization.process(signedUpdate, { encoding: 'base58btc' });
-
-      // Encode the signal bytes hex string to base58btc
-      const signalBytes = base58btc.encode(Buffer.from(updateHash, 'hex'));
-
-      // Check for mismatch between found sidecar/cas update hash and onchain beacon signal hash
-      if (encodedUpdate !== signalBytes) {
-        // If mismatch, throw invalidSidecarData error.
-        throw new SingletonBeaconError(
-          `Hash mismatch: sidecar update ${encodedUpdate} !== signal bytes ${signalBytes}.`,
-          INVALID_SIDECAR_DATA, { encodedUpdate, signalBytes }
-        );
-      }
-
-      // Push signedUpdate to updates array
       updates.push([signedUpdate, signal.blockMetadata]);
     }
 
-    // Return the array of signed updates
-    return updates;
+    return { updates, needs };
   }
   /**
    * Broadcasts a SingletonBeacon signal to the Bitcoin network.
@@ -120,7 +104,7 @@ export class SingletonBeacon extends Beacon {
     const prevTx = await bitcoin.rest.transaction.getHex(utxo.txid);
 
     // Canonicalize and hash the signed update for OP_RETURN output
-    const updateHash = Canonicalization.andHash(signedUpdate);
+    const updateHash = hash(canonicalize(signedUpdate));
 
     // Construct a spend transaction
     const spendTx = new Psbt({ network: bitcoin.data })

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

@@ -1,10 +1,11 @@
 import { BitcoinConnection } from '@did-btcr2/bitcoin';
 import { KeyBytes } from '@did-btcr2/common';
 import { SignedBTCR2Update } from '@did-btcr2/cryptosuite';
+import type { BeaconProcessResult } from '../resolver.js';
 import { SidecarData } from '../types.js';
 import { Beacon } from './beacon.js';
 import { SMTBeaconError } from './error.js';
-import { BeaconService, BeaconSignal, BlockMetadata } from './interfaces.js';
+import { BeaconService, BeaconSignal } from './interfaces.js';
 
 /**
  * Implements {@link https://dcdpr.github.io/did-btcr2/terminology.html#smt-beacon | SMTBeacon}.
@@ -25,13 +26,13 @@ export class SMTBeacon extends Beacon {
    * Implements {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#process-smt-beacon | 7.2.e.1 Process SMT Beacon}.
    * @param {Array<BeaconSignal>} signals The array of Beacon Signals to process.
    * @param {SidecarData} sidecar The sidecar data associated with the SMT Beacon.
-   * @returns {Promise<Array<[SignedBTCR2Update, BlockMetadata]>>} The processed signals.
+   * @returns {BeaconProcessResult} The processed signals.
    * @throws {SMTBeaconError} if processing fails.
    */
   processSignals(
     signals: Array<BeaconSignal>,
     sidecar: SidecarData
-  ): Promise<Array<[SignedBTCR2Update, BlockMetadata]>> {
+  ): BeaconProcessResult {
     throw new SMTBeaconError('Method not implemented.', `METHOD_NOT_IMPLEMENTED`, {signals, sidecar});
   }
 

package/src/core/identifier.ts

@@ -287,7 +287,7 @@ export class Identifier {
         network      : 'regtest'
       }
     );
-    return { keyPair: keyPair.toJSON(), did };
+    return { keyPair: keyPair.exportJSON(), did };
   }
 
   /**