@did-btcr2/method 0.13.1

package/src/btcr2/beacon/aggregation/protocol/nostr.ts

@@ -0,0 +1,81 @@
+import { SchnorrKeyPair, SecretKey } from '@did-btcr2/keypair';
+import { Filter } from 'nostr-tools';
+import { SimplePool, } from 'nostr-tools/pool';
+import { Btc1Identifier } from '../../../../utils/identifier.js';
+import { ProtocolService } from './service.js';
+
+export interface NostrAdapterConfig {
+  keys: {
+    secret?: Uint8Array;
+    public?: Uint8Array;
+  };
+  did?: string;
+  components: {
+    idType?: string;
+    version?: number;
+    network?: string;
+  };
+  relays: string[];
+  [key: string]: any;
+}
+
+export class NostrAdapter implements ProtocolService {
+  public name: string = 'nostr';
+  private config: NostrAdapterConfig;
+  private handlers: Map<string, (msg: any) => Promise<void>> = new Map();
+
+  constructor(config: NostrAdapterConfig = { keys: {}, components: {}, relays: ['wss://relay.damus.io'] }) {
+    this.config = config;
+    this.config.keys = this.config.keys || SchnorrKeyPair.generate().raw;
+    this.config.did = config.did || Btc1Identifier.encode({
+      idType       : config.components.idType || 'KEY',
+      version      : config.components.version || 1,
+      network      : config.components.network || 'signet',
+      genesisBytes : this.config.keys.public!
+    });
+  }
+
+  async start(): Promise<void> {
+    const pool = new SimplePool();
+    pool.subscribe(this.config.relays, { pubkey: this.config.did, kinds: [1059] } as Filter, {
+      onclose : (reasons: string[]) => console.log('Subscription closed for reasons:', reasons),
+      onevent : async (event: any) => {
+        console.log('Received event:', event);
+      }
+    });
+  }
+
+  registerMessageHandler(messageType: string, handler: (msg: any) => Promise<void>): 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 message
+   * @param recipient
+   * @param sender
+   */
+  async sendMessage(message: object, recipient: string, sender: string): Promise<void> {
+    // TODO: Implement message sending logic via Nostr
+    console.log(`Sending message to ${recipient} from ${sender}:`, message);
+  }
+
+  /**
+   * Generates a Nostr identity using the SecretKey and Btc1Identifier classes.
+   * @returns {string} A BTCR2 DID used for communication over the nostr protocol
+   */
+  public generateIdentity(): string {
+    this.config.keys.secret = SecretKey.random();
+    this.config.keys.public = SecretKey.getPublicKey(this.config.keys.secret);
+    this.config.did = Btc1Identifier.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.did;
+  }
+}

package/src/btcr2/beacon/aggregation/protocol/service.ts

@@ -0,0 +1,6 @@
+export interface ProtocolService {
+  start(): Promise<void>;
+  registerMessageHandler(messageType: string, handler: (msg: any) => Promise<void>): void;
+  sendMessage(message: object, recipient: string, sender: string): Promise<void>;
+  generateIdentity(): string;
+}

package/src/btcr2/beacon/cid-aggregate.ts

@@ -0,0 +1,154 @@
+import { Btcr2Error, DidUpdateInvocation, DidUpdatePayload } from '@did-btcr2/common';
+import { DidServiceEndpoint } from '@web5/dids';
+import { Beacon } from '../../interfaces/beacon.js';
+import { BeaconService, BeaconSignal } from '../../interfaces/ibeacon.js';
+import { RawTransactionV2 } from '../../types/bitcoin.js';
+import { BeaconSidecarData, CIDAggregateSidecar, SignalsMetadata } from '../../types/crud.js';
+
+/**
+ * Implements {@link https://dcdpr.github.io/did-btcr2/#cidaggregate-beacon | 5.2 CIDAggregate Beacon}.
+ *
+ * A Beacon of the type CIDAggregatoBeacon is a Beacon that publishes Bitcoin transactions containing a Content
+ * Identifier (CID) announcing an Aggregated DID Update Bundle. An Aggregated DID Update Bundle is a JSON object that
+ * maps did:btcr2 identifiers to CID values for the individual DID Update Payloads. The Aggregated DID Update Bundle CID
+ * (bundleCID) SHOULD be resolvable against a Content Addressable Storage (CAS) system such as IPFS, while the CID for
+ * the DID Update Payload (payloadCID) MAY be resolvable against a CAS or provided through a Sidecar mechanism. It is
+ * RECOMMENDED that this type of Beacon is only included in a DID document if the DID controller is REQUIRED to
+ * participate in authorizing Bitcoin transactions from this Beacon. In other words, this Beacon SHOULD identify an
+ * n-of-n P2TR Bitcoin address where n is the number of unique DID controllers submitting updates through the Beacon.
+ *
+ * @class CIDAggregateBeacon
+ * @type {CIDAggregateBeacon}
+ * @extends {Beacon}
+ */
+export class CIDAggregateBeacon extends Beacon {
+  /**
+   * Creates an instance of CIDAggregateBeacon.
+   * @param {BeaconService} service The service of the Beacon.
+   * @param {?BeaconSidecarData} [sidecar] The sidecar data of the Beacon.
+   */
+  constructor(service: BeaconService, sidecar?: BeaconSidecarData<CIDAggregateSidecar>) {
+    super({ ...service, type: 'CIDAggregateBeacon' }, sidecar);
+  }
+  get service(): BeaconService {
+    return {
+      type            : this.type,
+      id              : this.id,
+      serviceEndpoint : this.serviceEndpoint
+    };
+  }
+
+
+  /**
+   * TODO: Finish implementation
+   *
+   * Implements {@link https://dcdpr.github.io/did-btcr2/#establish-cidaggregate-beacon | 5.2.1 Establish CIDAggregate Beacon}.
+   *
+   * To establish a CIDAggregatorBeacon, a cohort of cooperating parties SHOULD generate an n-of-n P2TR Bitcoin address
+   * where each party contributes a public key. Furthermore, each party SHOULD verify that their key is part of the
+   * address and all other keys that are part of the address are keys with controllers able to produce valid signatures.
+   * To establish a Beacon there are two roles. One is the cohort participant, they want to join a Beacon cohort and
+   * submit a request to do so with a key and proof of control over that key. The other is the Beacon coordinator, they
+   * advertise and curate Beacon cohorts by combining Beacon participants into cohorts, verifying proofs of control, and
+   * producing Beacon addresses.
+   *
+   * @param {string} id The identifier of the Beacon.
+   * @param {string} type The type of the Beacon.
+   * @param {DidServiceEndpoint} serviceEndpoint The service endpoint of the Beacon.
+   * @returns {CIDAggregateBeacon} The established CIDAggregate Beacon.
+   */
+  static establish(id: string, type: string, serviceEndpoint: DidServiceEndpoint): CIDAggregateBeacon {
+    return new CIDAggregateBeacon({ id, type, serviceEndpoint });
+  }
+
+
+  /**
+   * TODO: Figure out if this is necessary or not.
+   * @param {string} didUpdatePayload The DID Update Payload to generate the signal for.
+   * @returns {BeaconSignal} The generated signal.
+   * @throws {Btcr2Error} if the signal is invalid.
+   */
+  generateSignal(didUpdatePayload: string): BeaconSignal {
+    throw new Btcr2Error('Method not implemented.', `METHOD_NOT_IMPLEMENTED`, {didUpdatePayload});
+  }
+
+
+  /**
+   * TODO: Finish implementation
+   *
+   * Implements {@link https://dcdpr.github.io/did-btcr2/#process-cidaggregate-beacon-signal | 5.2.3 Process CIDAggregate Beacon Signal}.
+   *
+   * A Beacon Signal from a CIDAggregate Beacon is a Bitcoin transaction that contains the hashBytes of a DID Update
+   * Bundle in its first transaction output. The corresponding DID Update Bundle MUST either be provided through Sidecar
+   * Data or by converting hashBytes into a IPFS v1 Content Identifier and attempting to retrieve it from Content
+   * Addressable Storage. The DID Update Bundle maps from did:btcr2 identifiers to hashes of DID Update payloads
+   * applicable for that identifier. Again this algorithm attempts to retrieve and validate the DID Update Payload
+   * identified for the identifier being resolved. If successful, the DID Update Payload is returned.
+   *
+   * The Process CIDAggregate Beacon Signal algorithm is called by the Process Beacon Signals algorithm as part of the
+   * Read operation.
+   *
+   * It takes as inputs a did:btcr2 identifier, btc1Identifier, a Beacon Signal, tx, and a optional
+   * object, signalSidecarData, containing any sidecar data provided to the resolver for the Beacon Signal identified by
+   * the Bitcoin transaction identifier.
+   *
+   * It returns the DID Update payload announced by the Beacon Signal for the
+   * did:btcr2 identifier being resolved or throws an error.
+   *
+   * @param {RawTransactionV2} signal Bitcoin transaction representing a Beacon Signal.
+   * @param {SignalsMetadata} signalsMetadata Optional sidecar data for the Beacon Signal.
+   * @returns {Promise<DidUpdatePayload | undefined>} The DID Update payload announced by the Beacon Signal.
+   * @throws {DidError} if the signalTx is invalid or the signalsMetadata is invalid.
+   */
+  processSignal(signal: RawTransactionV2, signalsMetadata: SignalsMetadata): Promise<DidUpdateInvocation | undefined> {
+    throw new Btcr2Error('Method not implemented.', `METHOD_NOT_IMPLEMENTED`, {signal, signalsMetadata});
+  }
+
+  /**
+   * TODO: Finish implementation
+   *
+   * Implements {@link https://dcdpr.github.io/did-btcr2/#broadcast-cidaggregate-beacon-signal | 5.2.2 Broadcast CIDAggregate Beacon Signal}.
+   *
+   * The Broadcast CIDAggregate Beacon Signal algorithm involving two roles: a set of cohort participants and a Beacon
+   * coordinator. The Beacon coordinator collects individual DID Update Payload Content Identifiers (CIDs) for specific
+   * did:btc1s and aggregates them into a DID Update Bundle, which is then published to a Content Addressable Storage
+   * (CAS). The CID for the DID Update Bundle is included in a Partially Signed Bitcoin Transaction (PSBT) transaction
+   * output spent from the Beacon’s n-of-n address. Each of the n cohort participants in the Beacon MUST sign the
+   * transaction before it can be broadcast to the network. It is RECOMMENDED that cohort participants keep a copy of
+   * the DID Update Bundle and separately pin it to the CAS.
+   *
+   * @param {DidUpdatePayload} didUpdatePayload The verificationMethod object to be used for signing.
+   * @returns {SignalsMetadata} Successful output of a bitcoin transaction.
+   * @throws {SingletonBeaconError} if the bitcoin address is invalid or unfunded.
+   */
+  broadcastSignal(didUpdatePayload: DidUpdatePayload): Promise<SignalsMetadata> {
+    throw new Btcr2Error('Method not implemented.', `METHOD_NOT_IMPLEMENTED`, didUpdatePayload);
+  }
+
+  /**
+   * TODO: Finish implementation
+   *
+   * 5.2.1.1 Create CIDAggregate Beacon Advertisement
+   * Any entity MAY act in the role of Beacon coordinator, creating a Beacon advertisement that they can broadcast across any medium. A Beacon advertisement specifies the properties of the Beacon that
+   * the coordinator intends to establish, including the Beacon Type, cohort size, update frequency, and response latency. Once the advertisement has been created and broadcast, the coordinator waits
+   * for enough participants to opt in before establishing the Beacon.
+   *
+   * 5.2.1.2 CIDAggregate Beacon Opt-in
+   * DID controllers who wish to participate in a Beacon cohort first find potential Beacon advertisements that meet their needs. This includes checking the Beacon terms and update frequency, etc. If
+   * satisfied, they create a secp256k1 cohort keypair and send an Opt-In request to the endpoint specified in the advertisement.
+   *
+   * 5.2.1.3 Cohort Set
+   * Once a Beacon Aggregator has received enough opt-in responses from participants to satisfy the Beacon properties, they generate the n-of-n P2TR Bitcoin address for the Beacon. The address and all
+   * the cohort public keys the address is constructed from are then sent to all participants in a CohortSet message.
+   *
+   * 5.2.1.4 Add Beacon Service Endpoint to DID Document
+   * A participant receiving a CohortSet message first verifies their cohort key is included in the cohort, then calculates the P2TR Beacon address for themselves and verifies it matches the address
+   * provided. They MAY wait until the Beacon address is funded before adding the Beacon as a service in the DID document. The following is an example of the Beacon service endpoint the DID controller
+   * adds into their DID document, the Beacon address is converted into a URI following BIP21:
+   * {
+   *    "id": "#cidAggregateBeacon",
+   *    "type": "CIDAggregateBeacon",
+   *    "serviceEndpoint": "bitcoin:tb1pfdnyc8vxeca2zpsg365sn308dmrpka4e0n9c5axmp2nptdf7j6ts7eqhr8"
+   * }
+   */
+}

package/src/btcr2/beacon/factory.ts

@@ -0,0 +1,36 @@
+import { Btcr2Error } from '@did-btcr2/common';
+import { Beacon } from '../../interfaces/beacon.js';
+import { BeaconService } from '../../interfaces/ibeacon.js';
+import { CIDAggregateSidecar, SidecarData, SMTAggregateSidecar } from '../../types/crud.js';
+import { CIDAggregateBeacon } from './cid-aggregate.js';
+import { SingletonBeacon } from './singleton.js';
+import { SMTAggregateBeacon } from './smt-aggregate.js';
+
+/**
+ * Beacon Factory pattern to create Beacon instances.
+ * @class BeaconFactory
+ * @type {BeaconFactory}
+ */
+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.
+   * @returns {Beacon} The established Beacon instance.
+   */
+  static establish(service: BeaconService, sidecar?: SidecarData): Beacon {
+    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);
+      default:
+        throw new Btcr2Error(
+          'Invalid Beacon Type',
+          'INVALID_BEACON_ERROR', { service, sidecar }
+        );
+    }
+  }
+}

package/src/btcr2/beacon/singleton.ts

@@ -0,0 +1,257 @@
+import { DidUpdatePayload, INVALID_SIDECAR_DATA, LATE_PUBLISHING_ERROR, SingletonBeaconError } from '@did-btcr2/common';
+import { opcodes, Psbt, script } from 'bitcoinjs-lib';
+import { base58btc } from 'multiformats/bases/base58';
+import bitcoinNetwork, { Bitcoin } from '../../bitcoin/index.js';
+import { AddressUtxo, RawTransactionRest, Vout } from '../../bitcoin/rest-client.js';
+import { Beacon } from '../../interfaces/beacon.js';
+import { BeaconService, BeaconSignal } from '../../interfaces/ibeacon.js';
+import { RawTransactionV2, TxOut } from '../../types/bitcoin.js';
+import { BeaconSidecarData, Metadata, SignalsMetadata, SingletonSidecar } from '../../types/crud.js';
+import { Btc1Appendix } from '../../utils/appendix.js';
+import { Btc1KeyManager, Signer } from '../key-manager/index.js';
+
+/**
+ * Implements {@link https://dcdpr.github.io/did-btcr2/#singleton-beacon | 5.1 Singleton Beacon}.
+ *
+ * A Singleton Beacon enables a single entity to independently post a DID Update Payload in a Beacon Signal. Its is a
+ * Beacon that can be used to publish a single DID Update Payload targeting a single DID document. The serviceEndpoint
+ * for this Beacon Type is a Bitcoin address represented as a URI following the BIP21 scheme. It is recommended that
+ * this Bitcoin address be under the sole control of the DID controller. How the Bitcoin address and the cryptographic
+ * material that controls it are generated is left to the implementation.
+ *
+ * @class SingletonBeacon
+ * @type {SingletonBeacon}
+ * @extends {Beacon}
+ */
+export class SingletonBeacon extends Beacon {
+
+  /**
+   * Creates an instance of SingletonBeacon.
+   * @param {BeaconService} service The Beacon service.
+   * @param {?BeaconSidecarData} [sidecar] Optional sidecar data.
+   */
+  constructor(service: BeaconService, sidecar?: BeaconSidecarData<SingletonSidecar>) {
+    super({ ...service, type: 'SingletonBeacon' }, sidecar);
+  }
+
+  /**
+   * Get the Beacon service.
+   * @readonly
+   * @type {BeaconService} The Beacon service.
+   */
+  get service(): BeaconService {
+    return {
+      type            : this.type,
+      id              : this.id,
+      serviceEndpoint : this.serviceEndpoint
+    };
+  }
+
+  /**
+   * Implements {@link https://dcdpr.github.io/did-btcr2/#establish-singleton-beacon | 5.1.1 Establish Singleton Beacon}.
+   *
+   * Static, convenience method for establishing a Beacon object.
+   *
+   * A Singleton Beacon is a Beacon that can be used to publish a single DID Update Payload targeting a single DID
+   * document. The serviceEndpoint for this Beacon Type is a Bitcoin address represented as a URI following the BIP21
+   * scheme. It is RECOMMENDED that this Bitcoin address be under the sole control of the DID controller. How the
+   * Bitcoin address and the cryptographic material that controls it are generated is left to the implementation.
+   * The Establish Singleton Beacon algorithm takes in a Bitcoin address and a serviceId and returns a Singleton Beacon service.
+   * It returns a SignletonBeacon object with the given id, type, and serviceEndpoint.
+   *
+   * @param {string} service The Beacon service.
+   * @param {BeaconSidecarData<SingletonSidecar>} sidecar The sidecar data.
+   * @returns {SingletonBeacon} The Singleton Beacon.
+   */
+  public static establish(service: BeaconService, sidecar: BeaconSidecarData<SingletonSidecar>): SingletonBeacon {
+    return new SingletonBeacon(service, sidecar);
+  }
+
+  /**
+   * TODO: Figure out if this is necessary or not.
+   * @param {string} didUpdatePayload The DID Update Payload to generate the signal for.
+   * @returns {BeaconSignal} The generated signal.
+   * @throws {Btcr2Error} if the signal is invalid.
+   */
+  public generateSignal(didUpdatePayload: string): BeaconSignal {
+    throw new Error('Method not implemented.' + didUpdatePayload);
+  }
+
+  /**
+   * TODO: Finish implementation per spec
+   *
+   * Implements {@link https://dcdpr.github.io/did-btcr2/#process-singleton-beacon-signal | 5.1.3 Process Singleton Beacon Signal}.
+   * See {@link Beacon.processSignal | Abstract Beacon Interface Method processSignal} for more details.
+   *
+   * The Process Singleton Beacon Signal algorithm is called by the Process Beacon Signals algorithm as part of the Read
+   * operation. It takes a Bitcoin transaction representing a Beacon Signal and optional signalSidecarData containing
+   * any sidecar data provided to the resolver for the Beacon Signal identified by the Bitcoin transaction identifier.
+   * It returns the DID Update payload announced by the Beacon Signal or throws an error.
+   *
+   * @param {RawTransactionV2} signal Bitcoin transaction representing a Beacon Signal.
+   * @param {SignalsMetadata} signalsMetadata: SignalsMetadata Optional sidecar data for the Beacon Signal.
+   * @returns {Promise<DidUpdatePayload | undefined>} The DID Update payload announced by the Beacon Signal.
+   * @throws {DidError} if the signalTx is invalid or the signalSidecarData is invalid.
+   */
+  public async processSignal(signal: RawTransactionV2 | RawTransactionRest, signalsMetadata: SignalsMetadata): Promise<DidUpdatePayload | undefined> {
+    // 1. Initialize a txOut variable to the 0th transaction output of the tx.
+    const output = signal.vout.filter((vout) => ((vout as Vout)['scriptpubkey_asm'] as string || (vout as TxOut)['scriptPubKey'].asm as string).includes('OP_RETURN'))?.[0];
+    if(!output) {
+      throw new SingletonBeaconError('No OP_RETURN output found in transaction outputs.', 'NO_OP_RETURN', { signal });
+    }
+    const outputMap = new Map(Object.entries(output));
+
+    // 2. Set didUpdatePayload to null.
+    let didUpdatePayload: DidUpdatePayload | undefined = undefined;
+
+    // 3. Check txout is of the format [OP_RETURN, OP_PUSH32, <32bytes>], if not, then return didUpdatePayload.
+    //    The Bitcoin transaction is not a Beacon Signal.
+    const UPDATE_PAYLOAD_HASH = (outputMap.get('scriptpubkey_asm') ?? outputMap.get('scriptPubKey').asm).split(' ').last() as string;
+    if(!UPDATE_PAYLOAD_HASH) {
+      return undefined;
+    }
+    // 4. Set hashBytes to the 32 bytes in the txout.
+    const hashBytes = JSON.canonicalization.encode(Buffer.fromHex(UPDATE_PAYLOAD_HASH), 'base58');
+
+    // Convert signalsMetadata to a Map for easier access
+    const signalsMetadataMap = new Map<string, Metadata>(Object.entries(signalsMetadata));
+
+    // 5. If signalsMetadata:
+    if (signalsMetadata) {
+      // 5.1 Set didUpdatePayload to signalsMetadata.updatePayload
+      didUpdatePayload = signalsMetadataMap.get(signal.txid)?.btc1Update;
+
+      if(!didUpdatePayload) {
+        throw new SingletonBeaconError('Update Payload not found in signal metadata.', 'PROCESS_SIGNAL_ERROR');
+      }
+
+      // 5.2 Set updateHashBytes to the result of passing didUpdatePayload to the JSON Canonicalization and Hash algorithm.
+      const updateHashBytes = await JSON.canonicalization.process(didUpdatePayload, 'base58');
+
+      // 5.3 If updateHashBytes does not equal hashBytes, MUST throw an invalidSidecarData error.
+      if (updateHashBytes !== hashBytes) {
+        throw new SingletonBeaconError(
+          `Hash mismatch: updateHashBytes ${updateHashBytes} !== hashBytes ${hashBytes}.`,
+          INVALID_SIDECAR_DATA,
+          { UPDATE_PAYLOAD_HASH, didUpdatePayload }
+        );
+      }
+      // 7. Return didUpdatePayload.
+      return didUpdatePayload;
+    }
+
+    // 6. Else:
+    //  6.1 Set didUpdatePayload to the result of passing hashBytes into the Fetch Content from Addressable Storage algorithm.
+    const didUpdatePayloadString = await Btc1Appendix.fetchFromCas(base58btc.decode(hashBytes));
+    if(!didUpdatePayloadString || !JSON.parse(didUpdatePayloadString)) {
+      throw new SingletonBeaconError('Update payload not found in addressable storage.', INVALID_SIDECAR_DATA);
+    }
+    didUpdatePayload = JSON.parse(didUpdatePayloadString) as DidUpdatePayload;
+
+    //  6.2 If didUpdatePayload is null, MUST raise a latePublishingError. MAY identify Beacon Signal to resolver and request additional Sidecar data be provided.
+    if (!didUpdatePayload) {
+      throw new SingletonBeaconError('Update payload hash does not match transaction hash.', LATE_PUBLISHING_ERROR);
+    }
+
+    // 7. Return didUpdatePayload.
+    return didUpdatePayload;
+  }
+
+
+  /**
+   * Implements {@link https://dcdpr.github.io/did-btcr2/#broadcast-singleton-beacon-signal | 5.1.2 Broadcast Singleton Beacon Signal}.
+   *
+   * The Broadcast Singleton Beacon Signal algorithm is called by the Announce DID Update algorithm as part of the
+   * Update operation, if the Beacon being used is of the type SingletonBeacon. It takes as input a Beacon service and a
+   * secured didUpdatePayload. The algorithm constructs a Bitcoin transaction that spends from the Beacon address
+   * identified in the service and contains a transaction output of the format [OP_RETURN, OP_PUSH32, <hashBytes>],
+   * where hashBytes is the SHA256 hash of the canonical didUpdatePayload. The Bitcoin transaction is then signed and
+   * broadcast to the Bitcoin network, thereby publicly announcing a DID update in a Beacon Signal. It returns a
+   * signalMetadata object mapping the Bitcoin transaction identifier of the Beacon Signal to the necessary data needed
+   * to verify the signal announces a specific DID Update Payload.
+   *
+   * TODO: Design and implement a way to construct, sign and send via RPC
+   *
+   * @param {DidUpdatePayload} didUpdatePayload The verificationMethod object to be used for signing.
+   * @returns {SignedRawTx} Successful output of a bitcoin transaction.
+   * @throws {SingletonBeaconError} if the bitcoin address is invalid or unfunded.
+   */
+  public async broadcastSignal(didUpdatePayload: DidUpdatePayload): Promise<SignalsMetadata> {
+    // Grab the connection configuration from the environment variable or default to the rpc config
+    const bitcoin = bitcoinNetwork ?? new Bitcoin();
+
+    // 1. Initialize an addressURI variable to beacon.serviceEndpoint.
+    // 2. Set bitcoinAddress to the decoding of addressURI following BIP21.
+    const bitcoinAddress = this.service.serviceEndpoint.replace('bitcoin:', '');
+
+    // 3. Ensure bitcoinAddress is funded, if not, fund this address.
+    // let inputs: Array<CreateRawTxInputs> = [];
+
+    const utxos = await bitcoin.rest.address.getUtxos(bitcoinAddress);
+    if(!utxos.length) {
+      // TODO: Discuss what to do here because sending to a beacon address does not allow you to spend from it immediately.
+      throw new SingletonBeaconError('No UTXOs found, please fund address!', 'UNFUNDED_BEACON_ADDRESS', { bitcoinAddress });
+    }
+
+    const utxo: AddressUtxo = utxos.sort((a, b) => b.status.block_height - a.status.block_height)[0];
+    if(!utxo) {
+      throw new SingletonBeaconError(
+        'Beacon bitcoin address unfunded or utxos unconfirmed.',
+        'UNFUNDED_BEACON_ADDRESS', { bitcoinAddress });
+    }
+
+    // 4. Set hashBytes to the result of passing didUpdatePayload to the JSON Canonicalization and Hash algorithm.
+    const hashBytes = Buffer.fromHex(await JSON.canonicalization.process(didUpdatePayload));
+    if (hashBytes.length !== 32) throw new SingletonBeaconError('Hash must be 32 bytes');
+
+    // 5. Initialize spendTx to a Bitcoin transaction that spends a transaction controlled by the bitcoinAddress and
+    //    contains at least one transaction output. This output MUST have the following format
+    //    [OP_RETURN, OP_PUSH32, hashBytes]
+    const {txid, vout} = utxo;
+    const prevTx = await bitcoin.rest.transaction.getHex(txid);
+    const input = {
+      hash           : txid,
+      index          : vout,
+      nonWitnessUtxo : Buffer.fromHex(prevTx)
+    };
+    // TODO: Figure out a good way to estimate fees
+    const spendTx  = new Psbt({ network: bitcoin.network.data })
+      .addInput(input)
+      .addOutput({ address: bitcoinAddress, value: BigInt(utxo.value) - BigInt(500) })
+      .addOutput({ script: script.compile([opcodes.OP_RETURN, hashBytes]), value: 0n });
+
+    // 6. Retrieve the cryptographic material, e.g private key or signing capability, associated with the bitcoinAddress
+    //    or service. How this is done is left to the implementer.
+    // TODO: Determine how we want to handle this. Currently, this code uses the RPC to handle signing.
+    console.log('Btc1KeyManager', Btc1KeyManager.instance);
+    console.log('this.service.id', this.service.id);
+    const multikey = await Btc1KeyManager.getKeyPair(this.service.id);
+    console.log('multikey', multikey);
+    if (!multikey) {
+      throw new Error('Key pair not found.');
+    }
+
+    const signer = new Signer({ multikey, network: bitcoin.network.name });
+
+    // 7. Sign the spendTx.
+    const signedTx = spendTx.signInput(0, signer)
+      .finalizeAllInputs()
+      .extractTransaction()
+      .toHex();
+    if(!spendTx) {
+      throw new SingletonBeaconError('Failed to sign raw transaction.', 'RAW_TX_SIGN_FAILED', { spendTx });
+    }
+
+    // 8. Broadcast spendTx to the Bitcoin network.
+    const spentTx = await bitcoin.rest.transaction.send(signedTx);
+    if(!spentTx) {
+      throw new SingletonBeaconError('Failed to send raw transaction.', 'SEND_FAILED', { spentTx });
+    }
+
+    // 9. Set signalId to the Bitcoin transaction identifier of spendTx.
+    // 10. Initialize signalMetadata to an empty object.
+    // 11. Set signalMetadata.updatePayload to didUpdatePayload.
+    // 12. Return the object {<signalId>: { updatePayload: DidUpdatePayload; proofs?: any; }}.
+    return { [spentTx]: { btc1Update: didUpdatePayload } };
+  }
+}