@did-btcr2/method 0.19.0 → 0.22.0

package/src/core/resolve.ts

@@ -1,12 +1,9 @@
 import {
   BitcoinNetworkConnection,
-  BlockV3,
-  GENESIS_TX_ID,
-  getNetwork,
-  RawTransactionV2,
-  TXIN_WITNESS_COINBASE
+  getNetwork
 } from '@did-btcr2/bitcoin';
 import {
+  Canonicalization,
   DateUtils,
   IdentifierHrp,
   INVALID_DID,
@@ -15,24 +12,24 @@ import {
   JSONPatch,
   JSONUtils,
   LATE_PUBLISHING_ERROR,
-  MethodError,
   MISSING_UPDATE_DATA,
   ResolveError
 } from '@did-btcr2/common';
 import {
   BIP340Cryptosuite,
   BIP340DataIntegrityProof,
-  BTCR2SignedUpdate,
-  BTCR2UnsignedUpdate,
-  SchnorrMultikey
+  SchnorrMultikey,
+  SignedBTCR2Update,
+  UnsignedBTCR2Update
 } from '@did-btcr2/cryptosuite';
 import { CompressedSecp256k1PublicKey } from '@did-btcr2/keypair';
 import { bytesToHex } from '@noble/hashes/utils';
-import { canonicalization, DidBtcr2 } from '../did-btcr2.js';
+import { DidBtcr2 } from '../did-btcr2.js';
 import { Appendix } from '../utils/appendix.js';
 import { DidDocument, ID_PLACEHOLDER_VALUE } from '../utils/did-document.js';
 import { BeaconFactory } from './beacon/factory.js';
-import { BeaconService, BeaconSignal, BlockMetadata } from './beacon/interfaces.js';
+import { BeaconService, BlockMetadata } from './beacon/interfaces.js';
+import { BeaconSignalDiscovery } from './beacon/signal-discovery.js';
 import { BeaconUtils } from './beacon/utils.js';
 import { DidComponents, Identifier } from './identifier.js';
 import { SMTProof } from './interfaces.js';
@@ -42,10 +39,13 @@ import { CASAnnouncement, Sidecar, SidecarData } from './types.js';
  * The response object for DID Resolution.
  */
 export interface DidResolutionResponse {
-  currentDocument: DidDocument;
-  confirmations: number;
-  versionId: string;
-  updated: string;
+  didDocument: DidDocument;
+  metadata: {
+    confirmations?: number;
+    versionId: string;
+    updated?: string;
+    deactivated?: boolean;
+  }
 }
 
 /**
@@ -58,79 +58,6 @@ export interface DidResolutionResponse {
  * @type {Resolve}
  */
 export class Resolve {
-  /**
-   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#process-sidecar-data | Process Sidecar Data}
-   * @param {Sidecar} sidecar The sidecar data to process.
-   * @returns {SidecarData} The processed sidecar data containing maps of updates, CAS announcements, and SMT proofs.
-   */
-  static processSidecarData(sidecar: Sidecar = {} as Sidecar): SidecarData {
-    // BTCR2 Signed Updates map
-    const updateMap = new Map<string, BTCR2SignedUpdate>();
-    if(sidecar.updates?.length)
-      for(const update of sidecar.updates) {
-        updateMap.set(canonicalization.process(update, { encoding: 'hex' }), update);
-      }
-
-    // CAS Announcements map
-    const casMap = new Map<string, CASAnnouncement>();
-    if(sidecar.casUpdates?.length)
-      for(const update of sidecar.casUpdates) {
-        casMap.set(canonicalization.process(update, { encoding: 'hex' }), update);
-      }
-
-    // SMT Proofs map
-    const smtMap = new Map<string, SMTProof>();
-    if(sidecar.smtProofs?.length)
-      for(const proof of sidecar.smtProofs) {
-        smtMap.set(proof.id, proof);
-      }
-
-    return { updateMap, casMap, smtMap };
-  }
-
-  /**
-   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#establish-current-document | 7.2.d Establish current_document}.
-   * Resolution begins by creating an Initial Did Document called current_document (Current DID Document).
-   * The current_document is iteratively patched with BTCR2 Signed Updates announced by Authorized Beacon Signals.
-   * @param {DidComponents} didComponents The decoded components of the did.
-   * @param {GenesisDocument} genesisDocument The genesis document for resolving the DID Document.
-   * @returns {Promise<DidDocument>} The resolved DID Document object.
-   * @throws {DidError} if the DID hrp is invalid, no sidecarData passed and hrp = "x".
-   */
-  static async establishCurrentDocument(
-    didComponents: DidComponents,
-    genesisDocument?: object,
-  ): Promise<DidDocument> {
-    // Deconstruct the hrp from the components
-    const { hrp, genesisBytes } = didComponents;
-
-    // If hrp `x`, perform external resolution
-    if (hrp === IdentifierHrp.x) {
-      if(!genesisDocument)
-        throw new ResolveError(
-          'External resolution requires genesisDocument',
-          MISSING_UPDATE_DATA, { didComponents }
-        );
-      return await this.external(didComponents, genesisDocument);
-    }
-
-    // Check for hrp `k`
-    if(hrp === IdentifierHrp.k){
-      // Validate genesis bytes as a compressed secp256k1 public key
-      if(!CompressedSecp256k1PublicKey.isValid(genesisBytes)) {
-        throw new ResolveError(
-          'Deterministic resolution requires valid secp256k1 public key',
-          INVALID_DID, { genesisBytes }
-        );
-      }
-      // Perform deterministic resolution
-      return this.deterministic(didComponents);
-    }
-
-    // Else, throw an error for unsupported hrp
-    throw new ResolveError(`Unsupported DID hrp ${hrp}`, INVALID_DID, { hrp });
-  }
-
   /**
    * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#if-genesis_bytes-is-a-secp256k1-public-key | 7.2.d.1 if genesis bytes is a secp256k1 Public Key}.
    * @param {DidComponents} didComponents The decoded components of the did.
@@ -156,7 +83,6 @@ export class Resolve {
 
     return new DidDocument({
       id                 : did,
-      controller         : [did],
       verificationMethod : [{
         id                 : `${did}#initialKey`,
         type               : 'Multikey',
@@ -172,21 +98,21 @@ export class Resolve {
    * @param {DidComponents} didComponents BTCR2 DID components used to resolve the DID Document
    * @param {GenesisDocument} genesisDocument The genesis document for resolving the DID Document.
    * @returns {Promise<DidDocument>} The resolved DID Document object
-   * @throws {MethodError} InvalidDidDocument if not conformant to DID Core v1.1
+   * @throws {ResolveError} InvalidDidDocument if not conformant to DID Core v1.1
    */
   static async external(
     didComponents: DidComponents,
     genesisDocument: object,
   ): Promise<DidDocument> {
     // Canonicalize and sha256 hash the currentDocument
-    const hashBytes = canonicalization.process(genesisDocument, { encoding: 'hex' });
+    const hashBytes = Canonicalization.process(genesisDocument, { encoding: 'hex' });
 
     // Compare the genesisBytes to the hashBytes
     const genesisBytes = bytesToHex(didComponents.genesisBytes);
 
     // If the genesisBytes do not match the hashBytes, throw an error
     if (genesisBytes !== hashBytes) {
-      throw new MethodError(
+      throw new ResolveError(
         `Initial document mismatch: genesisBytes ${genesisBytes} !== hashBytes ${hashBytes}`,
         INVALID_DID_DOCUMENT, { genesisBytes, hashBytes }
       );
@@ -204,54 +130,124 @@ export class Resolve {
     return new DidDocument(currentDocument);
   }
 
+  /**
+   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#process-sidecar-data | Process Sidecar Data}
+   * @param {Sidecar} sidecar The sidecar data to process.
+   * @returns {ProcessedSidecar} The processed sidecar data containing maps of updates, CAS announcements, and SMT proofs.
+   */
+  static sidecarData(sidecar: Sidecar = {} as Sidecar): SidecarData {
+    // BTCR2 Signed Updates map
+    const updateMap = new Map<string, SignedBTCR2Update>();
+    if(sidecar.updates?.length)
+      for(const update of sidecar.updates) {
+        updateMap.set(Canonicalization.process(update, { encoding: 'hex' }), update);
+      }
+
+    // CAS Announcements map
+    const casMap = new Map<string, CASAnnouncement>();
+    if(sidecar.casUpdates?.length)
+      for(const update of sidecar.casUpdates) {
+        casMap.set(Canonicalization.process(update, { encoding: 'hex' }), update);
+      }
+
+    // SMT Proofs map
+    const smtMap = new Map<string, SMTProof>();
+    if(sidecar.smtProofs?.length)
+      for(const proof of sidecar.smtProofs) {
+        smtMap.set(proof.id, proof);
+      }
+
+    return { updateMap, casMap, smtMap };
+  }
+
+  /**
+   * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#establish-current-document | 7.2.d Establish current_document}.
+   * Resolution begins by creating an Initial Did Document called current_document (Current DID Document).
+   * The current_document is iteratively patched with BTCR2 Signed Updates announced by Authorized Beacon Signals.
+   * @param {DidComponents} didComponents The decoded components of the did.
+   * @param {GenesisDocument} genesisDocument The genesis document for resolving the DID Document.
+   * @returns {Promise<DidDocument>} The resolved DID Document object.
+   * @throws {ResolveError} if the DID hrp is invalid, no sidecarData passed and hrp = "x".
+   */
+
+  static async currentDocument(
+    didComponents: DidComponents,
+    genesisDocument?: object,
+  ): Promise<DidDocument> {
+    // Deconstruct the hrp from the components
+    const { hrp, genesisBytes } = didComponents;
+
+    // If hrp `x`, perform external resolution
+    if (hrp === IdentifierHrp.x) {
+      if(!genesisDocument)
+        throw new ResolveError(
+          'External resolution requires genesisDocument',
+          MISSING_UPDATE_DATA, { didComponents }
+        );
+      return await this.external(didComponents, genesisDocument);
+    }
+
+    // Check for hrp `k`
+    if(hrp === IdentifierHrp.k){
+      // Validate genesis bytes as a compressed secp256k1 public key
+      if(!CompressedSecp256k1PublicKey.isValid(genesisBytes)) {
+        throw new ResolveError(
+          'Deterministic resolution requires valid secp256k1 public key',
+          INVALID_DID, { genesisBytes }
+        );
+      }
+      // Perform deterministic resolution
+      return this.deterministic(didComponents);
+    }
+
+    // Else, throw an error for unsupported hrp
+    throw new ResolveError(`Unsupported DID hrp ${hrp}`, INVALID_DID, { hrp });
+  }
+
   /**
    * Finds uses the beacon services in the currentDocument to scan for onchain Beacon Signals (transactions) containing
    * Signal Bytes (last output in OP_RETURN transaction).
    * @param {Array<BeaconService>} beaconServices The array of BeaconService objects to search for signals.
    * @param {SidecarData} sidecarData The sidecar data containing maps of updates, CAS announcements, and SMT proofs.
    * @param {BitcoinNetworkConnection} bitcoin The bitcoin network connection used to fetch beacon signals
-   * @param {boolean} [fullBlockchainTraversal=false] Whether to perform a full blockchain traversal or use an indexer
-   * @returns {Promise<Array<[BTCR2SignedUpdate, BlockMetadata]>>} The array of BTCR2 Signed Updates announced by the Beacon Signals.
+   * @returns {Promise<Array<[SignedBTCR2Update, BlockMetadata]>>} The array of BTCR2 Signed Updates announced by the Beacon Signals.
    */
-  static async processBeaconSignals(
+  static async beaconSignals(
     beaconServices: Array<BeaconService>,
     sidecarData: SidecarData,
-    bitcoin: BitcoinNetworkConnection,
-    fullBlockchainTraversal?: boolean
-  ): Promise<Array<[BTCR2SignedUpdate, BlockMetadata]>> {
-    // Query indexer or perform a full blockchain traversal for Beacon Signals
-    const beaconServicesSignals = !fullBlockchainTraversal
-      ? await this.queryBlockchainIndexer(beaconServices, bitcoin)
-      : await this.traverseFullBlockchain(beaconServices, bitcoin);
-
-
-    // Set updates to an empty array
-    const unsortedUpdates = new Array<[BTCR2SignedUpdate, BlockMetadata]>();
-
-    // Iterate over each beacon service and its signals
-    for(const [service, signals] of beaconServicesSignals) {
-      // Establish a beacon object
-      const beacon = BeaconFactory.establish(service, signals, sidecarData);
-      // Process its signals
-      const processed = await beacon.processSignals();
-      // Append the processed updates to the updates array
-      unsortedUpdates.push(...processed);
-    }
+    bitcoin: BitcoinNetworkConnection
+  ): Promise<Array<[SignedBTCR2Update, BlockMetadata]>> {
+    // Discover Beacon Signals via indexer server (esplora/electrs) or full node
+    const beaconServicesSignals = bitcoin.network.rest
+      ? await BeaconSignalDiscovery.indexer(beaconServices, bitcoin)
+      : await BeaconSignalDiscovery.fullnode(beaconServices, bitcoin);
+
+    // Process each beacon's signals in parallel
+    const promises = await Promise.all(
+      Array.from(beaconServicesSignals.entries()).map(
+        async ([service, signals]) => {
+          // Skip beacons with no signals
+          if (!signals.length) return [];
+          // Establish a typed beacon and process its signals
+          return BeaconFactory.establish(service).processSignals(signals, sidecarData);
+        }
+      )
+    );
 
-    return unsortedUpdates;
+    return promises.flat();
   }
 
   /**
    * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#process-updates | 7.2.f Process updates Array}.
    * @param {DidDocument} currentDocument The current DID Document to apply the updates to.
-   * @param {Array<[BTCR2SignedUpdate, BlockMetadata]>} unsortedUpdates The unsorted array of BTCR2 Signed Updates and their associated Block Metadata.
+   * @param {Array<[SignedBTCR2Update, BlockMetadata]>} unsortedUpdates The unsorted array of BTCR2 Signed Updates and their associated Block Metadata.
    * @param {string} [versionTime] The optional version time to limit updates to.
    * @param {string} [versionId] The optional version id to limit updates to.
    * @returns {Promise<DidResolutionResponse>} The updated DID Document, number of confirmations, and version id.
    */
-  static async processUpdatesArray(
+  static async updates(
     currentDocument: DidDocument,
-    unsortedUpdates: Array<[BTCR2SignedUpdate, BlockMetadata]>,
+    unsortedUpdates: Array<[SignedBTCR2Update, BlockMetadata]>,
     versionTime?: string,
     versionId?: string
   ): Promise<DidResolutionResponse> {
@@ -267,59 +263,62 @@ export class Resolve {
     );
 
     // Create a default response object
-    const response = {
-      currentDocument,
-      versionId     : `${currentVersionId}`,
-      confirmations : 0,
-      updated       : ''
+    const response: DidResolutionResponse = {
+      didDocument : currentDocument,
+      metadata    : {
+        versionId     : `${currentVersionId}`,
+        confirmations : 0,
+        updated       : '',
+        deactivated   : currentDocument.deactivated || false
+      }
     };
 
     // Iterate over each (update block) pair
     for(const [update, block] of updates) {
       // Get the hash of the current document
-      const currentDocumentHash = canonicalization.process(response.currentDocument, { encoding: 'base58' });
+      const currentDocumentHash = Canonicalization.process(response.didDocument, { encoding: 'base58' });
 
-      // Set confirmations to the block confirmations
-      response.confirmations = block.confirmations;
+      // Safely convert block.time to timestamp
+      const blocktime = DateUtils.blocktimeToTimestamp(block.time);
 
-      // Safely convert versionTime to timestamp
-      const vTime = DateUtils.dateStringToTimestamp(versionTime || '');
-      // Safely convert block.blocktime to timestamp
-      const bTime = DateUtils.blocktimeToTimestamp(block.time);
       // Set the updated field to the blocktime of the current update
-      response.updated = DateUtils.toISOStringNonFractional(bTime);
+      response.metadata.updated = DateUtils.toISOStringNonFractional(blocktime);
+
+      // Set confirmations to the block confirmations
+      response.metadata.confirmations = block.confirmations;
 
       // if resolutionOptions.versionTime is defined and the blocktime is more recent, return currentDocument
-      if(vTime < bTime) {
-        return response;
+      if(versionTime) {
+        // Safely convert versionTime to timestamp
+        if(blocktime > DateUtils.dateStringToTimestamp(versionTime)) {
+          return response;
+        }
       }
 
       // Check update.targetVersionId against currentVersionId
       // If update.targetVersionId <= currentVersionId, confirm duplicate update
       if(update.targetVersionId <= currentVersionId) {
         updateHashHistory.push(currentDocumentHash);
-        this.confirmDuplicateUpdate(update, updateHashHistory);
+        this.confirmDuplicate(update, updateHashHistory);
       }
 
       // If update.targetVersionId == currentVersionId + 1, apply the update
       else if (update.targetVersionId === currentVersionId + 1) {
-      // Prepend `z` to the sourceHash if it does not start with it
-        const sourceHash = update.sourceHash.startsWith('z') ? update.sourceHash : `z${update.sourceHash}`;
-
         // Check if update.sourceHash !== currentDocumentHash
-        if (sourceHash !== currentDocumentHash) {
+        if (update.sourceHash !== currentDocumentHash) {
           // Raise an INVALID_DID_UPDATE error if they do not match
           throw new ResolveError(
             `Hash mismatch: update.sourceHash !== currentDocumentHash`,
-            INVALID_DID_UPDATE, { sourceHash, currentDocumentHash }
+            INVALID_DID_UPDATE, { sourceHash: update.sourceHash, currentDocumentHash }
           );
         }
         // Apply the update to the currentDocument and set it in the response
-        response.currentDocument = await this.applyDidUpdate(response.currentDocument, update);
+        response.didDocument = await this.applyUpdate(response.didDocument, update);
+
         // Create unsigned_update by removing the proof property from update.
-        const unsignedUpdate = JSONUtils.deleteKeys(update, ['proof']) as BTCR2UnsignedUpdate;
+        const unsignedUpdate = JSONUtils.deleteKeys(update, ['proof']) as UnsignedBTCR2Update;
         // Push the canonicalized unsigned update hash to the updateHashHistory
-        updateHashHistory.push(canonicalization.process(unsignedUpdate, { encoding: 'base58' }));
+        updateHashHistory.push(Canonicalization.process(unsignedUpdate, { encoding: 'base58' }));
       }
 
       // If update.targetVersionId > currentVersionId + 1, throw LATE_PUBLISHING error
@@ -328,15 +327,16 @@ export class Resolve {
           `Version Id Mismatch: targetVersionId cannot be > currentVersionId + 1`,
           'LATE_PUBLISHING_ERROR', {
             targetVersionId  : update.targetVersionId,
-            currentVersionId : String(currentVersionId + 1)
+            currentVersionId : currentVersionId + 1
           }
         );
       }
 
       // Increment currentVersionId
       currentVersionId++;
-      // Set currentVersionId in response
-      response.versionId = `${currentVersionId}`;
+
+      // Set response.versionId to be the new  currentVersionId
+      response.metadata.versionId = `${currentVersionId}`;
 
       // If resolutionOptions.versionId is defined and <= currentVersionId, return currentDocument
       if(currentVersionId >= Number(versionId)) {
@@ -345,6 +345,9 @@ export class Resolve {
 
       // Check if the current document is deactivated before further processing
       if(currentDocument.deactivated) {
+        // Set the response deactivated flag to true
+        response.metadata.deactivated = currentDocument.deactivated;
+        // If deactivated, stop processing further updates and return the response
         return response;
       }
     }
@@ -353,250 +356,20 @@ export class Resolve {
     return response;
   }
 
-  /**
-   * Retrieves the beacon signals for the given array of BeaconService objects
-   * using a esplora/electrs REST API connection via a bitcoin I/O driver.
-   * @param {Array<BeaconService>} beaconServices Array of BeaconService objects to retrieve signals for
-   * @param {BitcoinNetworkConnection} bitcoin Bitcoin network connection to use for REST calls
-   * @returns {Promise<Array<BeaconSignal>>} Promise resolving to an array of BeaconSignal objects
-   */
-  static async queryBlockchainIndexer(
-    beaconServices: Array<BeaconService>,
-    bitcoin: BitcoinNetworkConnection
-  ): Promise<Map<BeaconService, Array<BeaconSignal>>> {
-    // Empty array of beaconSignals
-    const beaconServiceSignals = new Map<BeaconService, Array<BeaconSignal>>();
-
-    // Iterate over each beacon
-    for (const beaconService of beaconServices) {
-      beaconServiceSignals.set(beaconService, []);
-      // Get the transactions for the beacon address via REST
-      const beaconSignals = await bitcoin.network.rest.address.getTxs(
-        beaconService.serviceEndpoint as string
-      );
-
-      // If no signals are found, continue
-      if (!beaconSignals || !beaconSignals.length) {
-        continue;
-      }
-
-      // Iterate over each signal
-      for (const beaconSignal of beaconSignals) {
-        // Get the last vout in the transaction
-        const signalVout = beaconSignal.vout.slice(-1)[0];
-
-        /**
-         * Look for OP_RETURN in last vout scriptpubkey_asm
-         * Vout (rest) format:
-         * {
-         *  scriptpubkey: '6a20570f177c65e64fb5cf61180b664cdddf09ab76153c2b192e22006e5b22a3917a',
-         *  scriptpubkey_asm: 'OP_RETURN OP_PUSHBYTES_32 570f177c65e64fb5cf61180b664cdddf09ab76153c2b192e22006e5b22a3917a',
-         *  scriptpubkey_type: 'op_return',
-         *  value: 0
-         * }
-         */
-        if(!signalVout || !signalVout.scriptpubkey_asm.includes('OP_RETURN')) {
-          // If not found, continue to next signal
-          continue;
-        }
-
-        // Construct output map for easier access
-        const outputMap = new Map<string, string | number>(Object.entries(signalVout));
-
-        // Grab the signal vout scriptpubkey
-        const signalVoutScriptPubkey = outputMap.get('scriptpubkey_asm') as string;
-
-        // If the signal vout scriptpubkey does not exist, continue to next signal
-        if(!signalVoutScriptPubkey){
-          continue;
-        }
-
-        // Extract hex string hash of the signal bytes from the scriptpubkey
-        const updateHash = signalVoutScriptPubkey.split(' ').slice(-1)[0];
-        if(!updateHash) {
-          continue;
-        }
-
-        const confirmations = await bitcoin.network.rest.block.count() - beaconSignal.status.block_height + 1;
-        // Push the beacon signal object to the signals array for the beacon service
-        beaconServiceSignals.get(beaconService)?.push({
-          tx            : beaconSignal,
-          signalBytes   : updateHash,
-          blockMetadata : {
-            confirmations,
-            height : beaconSignal.status.block_height,
-            time   : beaconSignal.status.block_time,
-          }
-        });
-      }
-    }
-
-
-    // Return the beaconSignals
-    return beaconServiceSignals;
-  }
-
-  /**
-   * Traverse the full blockchain from genesis to chain top looking for beacon signals.
-   * @param {Array<BeaconService>} beaconServices Array of BeaconService objects to search for signals.
-   * @param {BitcoinNetworkConnection} bitcoin Bitcoin network connection to use for RPC calls.
-   * @returns {Promise<Array<BeaconSignal>>} Promise resolving to an array of BeaconSignal objects.
-   */
-  static async traverseFullBlockchain(
-    beaconServices: Array<BeaconService>,
-    bitcoin: BitcoinNetworkConnection
-  ): Promise<Map<BeaconService, Array<BeaconSignal>>> {
-    const beaconServiceSignals = new Map<BeaconService, Array<BeaconSignal>>();
-
-    for(const beaconService of beaconServices) {
-      beaconServiceSignals.set(beaconService, []);
-    }
-
-    // Get the RPC connection from the bitcoin network
-    const rpc = bitcoin.network.rpc;
-
-    // Ensure that the RPC connection is available
-    if(!rpc) {
-      throw new ResolveError('RPC connection is not available', 'RPC_CONNECTION_ERROR', bitcoin);
-    }
-
-    // Get the current block height
-    const targetHeight = await rpc.getBlockCount();
-
-    // Set genesis height
-    let height = 0;
-
-    // Opt into rpc connection to get the block data at the blockhash
-    let block = await bitcoin.network.rpc!.getBlock({ height }) as BlockV3;
-
-    console.info(`Searching for beacon signals, please wait ...`);
-    while (block.height <= targetHeight) {
-      // Iterate over each transaction in the block
-      for (const tx of block.tx) {
-        // If the txid is a coinbase, continue ...
-        if (tx.txid === GENESIS_TX_ID) {
-          continue;
-        }
-
-        // Iterate over each input in the transaction
-        for (const vin of tx.vin) {
-
-          // If the vin is a coinbase transaction, continue ...
-          if (vin.coinbase) {
-            continue;
-          }
-
-          // If the vin txinwitness contains a coinbase did, continue ...
-          if (vin.txinwitness && vin.txinwitness.length === 1 && vin.txinwitness[0] === TXIN_WITNESS_COINBASE) {
-            continue;
-          }
-
-          // If the txid from the vin is undefined, continue ...
-          if (!vin.txid) {
-            continue;
-          }
-
-          // If the vout from the vin is undefined, continue ...
-          if (vin.vout === undefined) {
-            continue;
-          }
-
-          // Get the previous output transaction data
-          const prevout = await rpc.getRawTransaction(vin.txid, 2) as RawTransactionV2;
-
-          // If the previous output vout at the vin.vout index is undefined, continue ...
-          if (!prevout.vout[vin.vout]) {
-            continue;
-          }
-
-          // Get the address from the scriptPubKey from the prevvout (previous output's input at the vout index)
-          const scriptPubKey = prevout.vout[vin.vout].scriptPubKey;
-
-          // If the scriptPubKey.address is undefined, continue ...
-          if (!scriptPubKey.address) {
-            continue;
-          }
-
-          // If the beaconAddress from prevvout scriptPubKey is not a beacon service endpoint address, continue ...
-          const beaconService = BeaconUtils.getBeaconServicesMap(beaconServices).get(scriptPubKey.address);
-          if (!beaconService) {
-            continue;
-          }
-
-          /**
-           * Look for 'OP_RETURN' in prevout.vout[vin.vout].scriptPubKey.asm, else continue ...
-           *
-           * TxOut (rpc) format:
-           * {
-           *  value: 0,
-           *  n: 1,
-           *  scriptPubKey: {
-           *    asm: 'OP_RETURN 570f177c65e64fb5cf61180b664cdddf09ab76153c2b192e22006e5b22a3917a',
-           *    desc: 'raw(6a20570f177c65e64fb5cf61180b664cdddf09ab76153c2b192e22006e5b22a3917a)#cdgj3pm4',
-           *    hex: '6a20570f177c65e64fb5cf61180b664cdddf09ab76153c2b192e22006e5b22a3917a',
-           *    type: 'nulldata'
-           *  }
-           * }
-           */
-          const txVoutScriptPubkeyAsm = prevout.vout[vin.vout].scriptPubKey.asm;
-          if(!txVoutScriptPubkeyAsm.includes('OP_RETURN')) {
-            continue;
-          }
-
-          // Log the found txid and beacon
-          console.info(`Tx ${tx.txid} contains beacon service address ${scriptPubKey.address} and OP_RETURN!`, tx);
-
-          // Extract hex string hash of the signal bytes from the scriptpubkey
-          const updateHash = txVoutScriptPubkeyAsm.split(' ').slice(-1)[0];
-          if(!updateHash) {
-            continue;
-          }
-
-          // Push the beacon signal object to the beacon signals array for that beacon service
-          beaconServiceSignals.get(beaconService)?.push({
-            tx,
-            signalBytes   : updateHash,
-            blockMetadata : {
-              height        : block.height,
-              time          : block.time,
-              confirmations : block.confirmations
-            }
-          });
-        };
-      }
-
-      // Increment the height
-      height += 1;
-
-      // Check if we've reached the chain tip
-      const tip = await rpc.getBlockCount();
-      if(height > tip) {
-        // If so, break the loop
-        console.info(`Chain tip reached ${height}, breaking ...`);
-        break;
-      }
-
-      // Reset the block var to the next block data
-      block = await rpc.getBlock({ height }) as BlockV3;
-    }
-
-    return beaconServiceSignals;
-  }
-
   /**
    * Implements subsection {@link https://dcdpr.github.io/did-btcr2/#confirm-duplicate-update | 7.2.f.1 Confirm Duplicate Update}.
    * This step confirms that an update with a lower-than-expected targetVersionId is a true duplicate.
-   * @param {BTCR2SignedUpdate} update The BTCR2 Signed Update to confirm as a duplicate.
+   * @param {SignedBTCR2Update} update The BTCR2 Signed Update to confirm as a duplicate.
    * @returns {void} Does not return a value, but throws an error if the update is not a valid duplicate.
    */
-  static confirmDuplicateUpdate(update: BTCR2SignedUpdate, updateHashHistory: string[]): void {
+  static confirmDuplicate(update: SignedBTCR2Update, updateHashHistory: string[]): void {
     // Create unsigned_update by removing the proof property from update.
-    const unsignedUpdate = JSONUtils.deleteKeys(update, ['proof']) as BTCR2UnsignedUpdate;
+    const { proof: _, ...unsignedUpdate } = update;
 
     // Hash unsignedUpdate with JSON Document Hashing algorithm
-    const unsignedUpdateHash = canonicalization.process(unsignedUpdate);
+    const unsignedUpdateHash = Canonicalization.process(unsignedUpdate);
 
-    // 5. Let historicalUpdateHash equal updateHashHistory[updateHashIndex].
+    // Let historicalUpdateHash equal updateHashHistory[updateHashIndex].
     const historicalUpdateHash = updateHashHistory[update.targetVersionId - 2];
 
     // Check if the updateHash matches the historical hash
@@ -611,13 +384,13 @@ export class Resolve {
   /**
    * Implements subsection {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#apply-update | 7.2.f.3 Apply Update}.
    * @param {DidDocument} currentDocument The current DID Document to apply the update to.
-   * @param {BTCR2SignedUpdate} update The BTCR2 Signed Update to apply.
+   * @param {SignedBTCR2Update} update The BTCR2 Signed Update to apply.
    * @returns {Promise<DidDocument>} The updated DID Document after applying the update.
    * @throws {ResolveError} If the update is invalid or cannot be applied.
    */
-  static async applyDidUpdate(
+  static async applyUpdate(
     currentDocument: DidDocument,
-    update: BTCR2SignedUpdate
+    update: SignedBTCR2Update
   ): Promise<DidDocument> {
     // Get the capability id from the to update proof.
     const capabilityId = update.proof?.capability;
@@ -652,19 +425,14 @@ export class Resolve {
     // Get the verificationMethod from the DID Document using the verificationMethodId.
     const vm = DidBtcr2.getSigningMethod(currentDocument, verificationMethodId);
 
-    // Split the vmId by the `#` to get the id and controller.
-    const [vmController, vmId] = vm.id.split('#');
-
     // Construct a new SchnorrMultikey.
-    const multikey = SchnorrMultikey.fromPublicKeyMultibase(
-      `#${vmId}`, vmController, vm.publicKeyMultibase
-    );
+    const multikey = SchnorrMultikey.fromVerificationMethod(vm);
 
     // Construct a new BIP340Cryptosuite with the SchnorrMultikey.
     const cryptosuite = new BIP340Cryptosuite(multikey);
 
     // Canonicalize the update
-    const canonicalUpdate = canonicalization.canonicalize(update);
+    const canonicalUpdate = Canonicalization.canonicalize(update);
 
     // Construct a DataIntegrityProof with the cryptosuite
     const diProof = new BIP340DataIntegrityProof(cryptosuite);
@@ -674,7 +442,7 @@ export class Resolve {
 
     // If the result is not verified, throw INVALID_DID_UPDATE error
     if (!verificationResult.verified) {
-      throw new MethodError(
+      throw new ResolveError(
         'Invalid update: proof not verified',
         INVALID_DID_UPDATE, verificationResult
       );
@@ -687,7 +455,7 @@ export class Resolve {
     DidDocument.validate(updatedDocument);
 
     // Canonicalize and hash the updatedDocument to get the currentDocumentHash.
-    const currentDocumentHash = canonicalization.process(currentDocument, { encoding: 'base58' });
+    const currentDocumentHash = Canonicalization.process(updatedDocument, { encoding: 'base58' });
 
     // Prepare the update targetHash for comparison with currentDocumentHash.
     const updateTargetHash = update.targetHash.startsWith('z') ? update.targetHash : `z${update.targetHash}`;
@@ -695,7 +463,7 @@ export class Resolve {
     // Make sure the update.targetHash equals currentDocumentHash.
     if (updateTargetHash !== currentDocumentHash) {
       // If they do not match, throw INVALID_DID_UPDATE error.
-      throw new MethodError(
+      throw new ResolveError(
         `Invalid update: updateTargetHash !== currentDocumentHash`,
         INVALID_DID_UPDATE, { updateTargetHash, currentDocumentHash }
       );