@did-btcr2/method 0.20.0 → 0.23.0

package/src/core/resolve.ts

@@ -1,8 +1,9 @@
 import {
-  BitcoinNetworkConnection,
+  BitcoinConnection,
   getNetwork
 } from '@did-btcr2/bitcoin';
 import {
+  Canonicalization,
   DateUtils,
   IdentifierHrp,
   INVALID_DID,
@@ -23,7 +24,7 @@ import {
 } 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';
@@ -38,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;
+  }
 }
 
 /**
@@ -60,12 +64,12 @@ export class Resolve {
    * @returns {DidDocument} The resolved DID Document object.
    */
   static deterministic(didComponents: DidComponents): DidDocument {
-    // Encode the did from the didComponents
-    const did = Identifier.encode(didComponents);
-
     // Deconstruct the bytes from the given components
     const { genesisBytes } = didComponents;
 
+    // Encode the did from the didComponents
+    const did = Identifier.encode(genesisBytes, didComponents);
+
     // Construct a new CompressedSecp256k1PublicKey and deconstruct the publicKey and publicKeyMultibase
     const { multibase: publicKeyMultibase } = new CompressedSecp256k1PublicKey(genesisBytes);
 
@@ -79,7 +83,6 @@ export class Resolve {
 
     return new DidDocument({
       id                 : did,
-      controller         : [did],
       verificationMethod : [{
         id                 : `${did}#initialKey`,
         type               : 'Multikey',
@@ -102,21 +105,20 @@ export class Resolve {
     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);
+    const { genesisBytes } = didComponents;
 
     // If the genesisBytes do not match the hashBytes, throw an error
-    if (genesisBytes !== hashBytes) {
+    if (bytesToHex(genesisBytes) !== hashBytes) {
       throw new ResolveError(
-        `Initial document mismatch: genesisBytes ${genesisBytes} !== hashBytes ${hashBytes}`,
+        `Initial document mismatch: genesisBytes ${bytesToHex(genesisBytes)} !== hashBytes ${hashBytes}`,
         INVALID_DID_DOCUMENT, { genesisBytes, hashBytes }
       );
     }
 
     // Encode the did from the didComponents
-    const did = Identifier.encode(didComponents);
+    const did = Identifier.encode(genesisBytes, didComponents);
 
     // Replace the placeholder did with the did throughout the currentDocument.
     const currentDocument = JSON.parse(
@@ -137,14 +139,14 @@ export class Resolve {
     const updateMap = new Map<string, SignedBTCR2Update>();
     if(sidecar.updates?.length)
       for(const update of sidecar.updates) {
-        updateMap.set(canonicalization.process(update, { encoding: 'hex' }), update);
+        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);
+        casMap.set(Canonicalization.process(update, { encoding: 'hex' }), update);
       }
 
     // SMT Proofs map
@@ -206,30 +208,32 @@ export class Resolve {
    * 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 {BitcoinConnection} bitcoin The bitcoin network connection used to fetch beacon signals
    * @returns {Promise<Array<[SignedBTCR2Update, BlockMetadata]>>} The array of BTCR2 Signed Updates announced by the Beacon Signals.
    */
   static async beaconSignals(
     beaconServices: Array<BeaconService>,
     sidecarData: SidecarData,
-    bitcoin: BitcoinNetworkConnection
+    bitcoin: BitcoinConnection
   ): Promise<Array<[SignedBTCR2Update, BlockMetadata]>> {
     // Discover Beacon Signals via indexer server (esplora/electrs) or full node
-    const beaconServicesSignals = bitcoin.network.rest
+    const beaconServicesSignals = bitcoin.rest
       ? await BeaconSignalDiscovery.indexer(beaconServices, bitcoin)
       : await BeaconSignalDiscovery.fullnode(beaconServices, bitcoin);
 
     // Process each beacon's signals in parallel
-    const promises = 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);
-      }
+    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 (await Promise.all(promises)).flat();
+    return promises.flat();
   }
 
   /**
@@ -258,31 +262,36 @@ 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: 'base58btc' });
 
-      // 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
@@ -294,23 +303,21 @@ export class Resolve {
 
       // 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.applyUpdate(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 UnsignedBTCR2Update;
         // Push the canonicalized unsigned update hash to the updateHashHistory
-        updateHashHistory.push(canonicalization.process(unsignedUpdate, { encoding: 'base58' }));
+        updateHashHistory.push(Canonicalization.process(unsignedUpdate, { encoding: 'base58btc' }));
       }
 
       // If update.targetVersionId > currentVersionId + 1, throw LATE_PUBLISHING error
@@ -319,15 +326,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)) {
@@ -336,6 +344,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;
       }
     }
@@ -352,12 +363,12 @@ export class Resolve {
    */
   static confirmDuplicate(update: SignedBTCR2Update, updateHashHistory: string[]): void {
     // Create unsigned_update by removing the proof property from update.
-    const unsignedUpdate = JSONUtils.deleteKeys(update, ['proof']) as UnsignedBTCR2Update;
+    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
@@ -420,7 +431,7 @@ export class Resolve {
     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);
@@ -443,16 +454,16 @@ 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: 'base58btc' });
 
     // Prepare the update targetHash for comparison with currentDocumentHash.
-    const updateTargetHash = update.targetHash.startsWith('z') ? update.targetHash : `z${update.targetHash}`;
+    const updateTargetHash = update.targetHash;
 
     // Make sure the update.targetHash equals currentDocumentHash.
-    if (updateTargetHash !== currentDocumentHash) {
+    if (update.targetHash !== currentDocumentHash) {
       // If they do not match, throw INVALID_DID_UPDATE error.
       throw new ResolveError(
-        `Invalid update: updateTargetHash !== currentDocumentHash`,
+        `Invalid update: update.targetHash !== currentDocumentHash`,
         INVALID_DID_UPDATE, { updateTargetHash, currentDocumentHash }
       );
     }

package/src/core/update.ts

@@ -1,4 +1,5 @@
 import {
+  Canonicalization,
   INVALID_DID_UPDATE,
   JSONPatch,
   KeyBytes,
@@ -11,11 +12,10 @@ import {
   SignedBTCR2Update,
   UnsignedBTCR2Update
 } from '@did-btcr2/cryptosuite';
-import { canonicalization } from '../did-btcr2.js';
 import { Btcr2DidDocument, DidDocument, DidVerificationMethod } from '../utils/did-document.js';
 import { BeaconFactory } from './beacon/factory.js';
 import { BeaconService } from './beacon/interfaces.js';
-import { BitcoinNetworkConnection } from '@did-btcr2/bitcoin';
+import { BitcoinConnection } from '@did-btcr2/bitcoin';
 
 /**
  * Implements {@link https://dcdpr.github.io/did-btcr2/operations/update.html | 7.3 Update}.
@@ -56,7 +56,7 @@ export class Update {
       patch           : patches,
       targetHash      : '',
       targetVersionId : sourceVersionId + 1,
-      sourceHash      : canonicalization.process(sourceDocument, { encoding: 'base58' }),
+      sourceHash      : Canonicalization.process(sourceDocument, { encoding: 'base58btc' }),
     };
 
     // Apply all JSON patches to sourceDocument.
@@ -74,7 +74,7 @@ export class Update {
     }
 
     // Set the targetHash by canonicalizing the targetDocument and encoding it in base58.
-    unsignedUpdate.targetHash = canonicalization.process(targetDocument, { encoding: 'base58' });
+    unsignedUpdate.targetHash = Canonicalization.process(targetDocument, { encoding: 'base58btc' });
 
     // Return unsignedUpdate.
     return unsignedUpdate;
@@ -140,7 +140,7 @@ export class Update {
     beaconService: BeaconService,
     update: SignedBTCR2Update,
     secretKey: KeyBytes,
-    bitcoin: BitcoinNetworkConnection
+    bitcoin: BitcoinConnection
   ): Promise<SignedBTCR2Update> {
     // Establish a beacon object
     const beacon = BeaconFactory.establish(beaconService);

package/src/did-btcr2.ts

@@ -1,6 +1,5 @@
-import { BitcoinNetworkConnection } from '@did-btcr2/bitcoin';
+import { BitcoinConnection } from '@did-btcr2/bitcoin';
 import {
-  Canonicalization,
   DocumentBytes,
   HexString,
   IdentifierHrp,
@@ -9,6 +8,7 @@ import {
   KeyBytes,
   METHOD_NOT_SUPPORTED,
   MethodError,
+  MISSING_RESOLUTION_OPTIONS,
   MISSING_UPDATE_DATA,
   PatchOperation,
   ResolveError,
@@ -34,14 +34,11 @@ import { Update } from './core/update.js';
 import { Appendix } from './utils/appendix.js';
 import { Btcr2DidDocument, DidVerificationMethod } from './utils/did-document.js';
 
-// TODO: convert to API driver?
-export const canonicalization = new Canonicalization();
-
 export type Btcr2Identifier = string;
 
 export interface DidCreateOptions {
   /** Type of identifier to create (key or external) */
-  idType: 'KEY' | 'EXTERNAL';
+  idType: string;
   /** DID BTCR2 Version Number */
   version?: number;
   /** Bitcoin Network */
@@ -81,11 +78,13 @@ export class DidBtcr2 implements DidMethod {
    * @param {string} options.network The Bitcoin network to use for the identifier, e.g. 'bitcoin', 'testnet', etc. Defaults to 'bitcoin'.
    * @returns {Promise<Btcr2Identifier>} Promise resolving to a Btcr2Identifier string.
    * @throws {MethodError} if any of the checks fail
+   * @example
+   * ```ts
+   * const genesisBytes = SchnorrKeyPair.generate().publicKey.compressed;
+   * const did = DidBtcr2.create(genesisBytes, { idType: 'KEY', network: 'regtest' });
+   * ```
    */
-  static async create(
-    genesisBytes: KeyBytes | DocumentBytes,
-    options?: DidCreateOptions
-  ): Promise<Btcr2Identifier> {
+  static create(genesisBytes: KeyBytes | DocumentBytes, options?: DidCreateOptions): Btcr2Identifier {
     // Deconstruct the idType, version and network from the options, setting defaults if not given
     const { idType, version = 1, network = 'bitcoin' } = options || {};
 
@@ -97,7 +96,7 @@ export class DidBtcr2 implements DidMethod {
     }
 
     // Call identifier encoding algorithm
-    return Identifier.encode({ idType, genesisBytes, version, network });
+    return Identifier.encode(genesisBytes, { idType, version, network });
   }
 
   /**
@@ -117,24 +116,26 @@ export class DidBtcr2 implements DidMethod {
    * @example
    * ```ts
    * const resolution = await DidBtcr2.resolve(
-   *  'did:btcr2:k1q0dygyp3gz969tp46dychzy4q78c2k3js68kvyr0shanzg67jnuez2cfplh'
+   *  'did:btcr2:k1qgpr45cheptyjekl3cex80xfnkwhxnlclecwwf92gvdjrszm2uwhzlcxu5xte'
    * )
    * ```
    */
   static async resolve(
     did: string,
-    resolutionOptions: ResolutionOptions = { drivers: {} }
+    resolutionOptions: ResolutionOptions = {}
   ): Promise<DidResolutionResult> {
     try {
+      // Set versionId from resolutionOptions
+      const versionId = resolutionOptions.versionId;
 
       // Initialize an empty DID Resolution Result
       const didResolutionResult: DidResolutionResult = {
         '@context'            : 'https://w3id.org/did-resolution/v1',
         didResolutionMetadata : { contentType: 'application/ld+json' },
         didDocumentMetadata   : {
+          versionId,
           deactivated   : false,
           updated       : undefined,
-          versionId     : resolutionOptions.versionId,
           confirmations : undefined,
         },
         didDocument : null,
@@ -146,25 +147,16 @@ export class DidBtcr2 implements DidMethod {
       // Process sidecar if provided
       const sidecarData = Resolve.sidecarData(resolutionOptions.sidecar);
 
-      // Check if bitcoin driver provided
-      if(!resolutionOptions?.drivers?.bitcoin) {
-        // If not, initialize default drivers
-        resolutionOptions.drivers = resolutionOptions.drivers || {};
-        // Set bitcoin driver to default BitcoinNetworkConnection
-        resolutionOptions.drivers.bitcoin = new BitcoinNetworkConnection();
-        // Set the network based on the decoded identifier
-        resolutionOptions.drivers.bitcoin.setActiveNetwork(didComponents.network);
-      }
-
       // Parse the genesis document from the resolution options if provided
       const genesisDocument = resolutionOptions.sidecar?.genesisDocument;
+
       // Since genesisDocument is optional, check if it exists
       if(!genesisDocument) {
         // If no genesisDocument and x HRP, throw MISSING_UPDATE_DATA error
         if(didComponents.hrp === IdentifierHrp.x)
           throw new ResolveError(
             'External resolution requires genesisDocument',
-            MISSING_UPDATE_DATA, { resolutionOptions }
+            MISSING_UPDATE_DATA, resolutionOptions
           );
       }
 
@@ -176,23 +168,32 @@ export class DidBtcr2 implements DidMethod {
         .filter(BeaconUtils.isBeaconService)
         .map(BeaconUtils.parseBeaconServiceEndpoint);
 
-      console.log('beaconServices', beaconServices);
+      // Check if bitcoin driver provided
+      if(!resolutionOptions?.drivers?.bitcoin) {
+        throw new ResolveError(
+          'Bitcoin connection required for resolve. Pass a configured driver via '
+          + 'resolutionOptions.drivers.bitcoin or use DidBtcr2Api which injects it automatically.',
+          MISSING_RESOLUTION_OPTIONS, resolutionOptions
+        );
+      }
+
+      // Get the bitcoin driver from the resolution options
+      const bitcoin = resolutionOptions.drivers.bitcoin;
 
       // Process the Beacon Signals to get the required updates
       const unsortedUpdates = await Resolve.beaconSignals(
         beaconServices,
         sidecarData,
-        resolutionOptions.drivers.bitcoin
+        bitcoin
       );
-      console.log('unsortedUpdates', unsortedUpdates);
 
       // If no updates found, return the current document
       if(!unsortedUpdates.length) {
-        // Set the current document in the didResolutionResult
+        // Set the didDocument in didResolutionResult based on currentDocument
         didResolutionResult.didDocument = currentDocument;
-
-        // Set the deactivated status in the didDocumentMetadata
+        // Set other required fields in the didResolutionResult
         didResolutionResult.didDocumentMetadata.deactivated = !!currentDocument.deactivated;
+        didResolutionResult.didDocumentMetadata.versionId = versionId ?? '1';
 
         // Return the didResolutionResult early
         return didResolutionResult;
@@ -203,21 +204,18 @@ export class DidBtcr2 implements DidMethod {
         currentDocument,
         unsortedUpdates,
         resolutionOptions.versionTime,
-        resolutionOptions.versionId
+        versionId
       );
 
       // Set all of the required fields in the didResolutionResult
-      didResolutionResult.didDocument = result.currentDocument;
-      didResolutionResult.didDocumentMetadata.confirmations = result.confirmations;
-      didResolutionResult.didDocumentMetadata.versionId = result.versionId;
-      didResolutionResult.didDocumentMetadata.deactivated = !!result.currentDocument.deactivated;
+      didResolutionResult.didDocument = result.didDocument;
+      didResolutionResult.didDocumentMetadata = result.metadata;
 
       // Return didResolutionResult;
       return didResolutionResult;
     } catch (error: any) {
-      console.error(error);
       // Rethrow any unexpected errors that are not a `ResolveError`.
-      if (!(error instanceof ResolveError)) throw new Error(error);
+      if (!(error instanceof ResolveError)) throw new Error(error.message ?? error, { cause: error });
 
       // Return a DID Resolution Result with the appropriate error code.
       return {
@@ -245,7 +243,7 @@ export class DidBtcr2 implements DidMethod {
    * @param {string} params.verificationMethodId The verificationMethod ID to sign the update with.
    * @param {string} params.beaconId The beacon ID associated with the update.
    * @param {KeyBytes | HexString} [params.signingMaterial] Optional signing material (key bytes or hex string).
-   * @param {BitcoinNetworkConnection} [params.bitcoin] Optional Bitcoin network connection for announcing the update. If not provided, a default connection will be initialized.
+   * @param {BitcoinConnection} [params.bitcoin] Optional Bitcoin network connection for announcing the update. If not provided, a default connection will be initialized.
    * @return {Promise<SignedBTCR2Update>} Promise resolving to the signed BTCR2 update.
    * @throws {UpdateError} if no verificationMethod, verificationMethod type is not `Multikey` or the publicKeyMultibase
    * header is not `zQ3s`
@@ -265,7 +263,7 @@ export class DidBtcr2 implements DidMethod {
     verificationMethodId: string;
     beaconId: string;
     signingMaterial?: KeyBytes | HexString;
-    bitcoin?: BitcoinNetworkConnection;
+    bitcoin?: BitcoinConnection;
   }): Promise<SignedBTCR2Update> {
     // TODO: provide KMS as alternative
     // If no signingMaterial provided, throw an UpdateError with INVALID_DID_UPDATE.
@@ -335,11 +333,17 @@ export class DidBtcr2 implements DidMethod {
         INVALID_DID_UPDATE, {sourceDocument, beaconId}
       );
     }
-    // If no bitcoin network connection provided, initialize default
-    bitcoin ??= new BitcoinNetworkConnection();
+    // Require an explicit bitcoin connection — no silent env-var fallback
+    if (!bitcoin) {
+      throw new UpdateError(
+        'Bitcoin connection required for update. Pass a configured `bitcoin` parameter '
+        + 'or use DidBtcr2Api which injects it automatically.',
+        INVALID_DID_UPDATE, { beaconId }
+      );
+    }
 
     // Announce the signed update to the blockchain using the specified beacon(s)
-    // await Update.announce(beaconService, signed, secretKey, bitcoin);
+    await Update.announce(beaconService, signed, secretKey, bitcoin);
 
     // Return signed update if announced successfully
     return signed;

package/src/utils/did-document-builder.ts

@@ -22,13 +22,6 @@ export class DidDocumentBuilder {
     }
   }
 
-  withController(controller?: Array<string>): this {
-    if (controller) {
-      this.document.controller = controller ?? [this.document.id!];
-    }
-    return this;
-  }
-
   withAuthentication(authentication: Array<string | DidVerificationMethod>): this {
     if (authentication) {
       this.document.authentication = authentication;