@did-btcr2/method 0.22.0 → 0.24.1

package/src/core/beacon/signal-discovery.ts

@@ -1,5 +1,5 @@
 import {
-  BitcoinNetworkConnection,
+  BitcoinConnection,
   BlockV3,
   GENESIS_TX_ID,
   RawTransactionV2,
@@ -21,23 +21,23 @@ export class BeaconSignalDiscovery {
    * Retrieves the beacon signals for the given array of BeaconService objects
    * using an 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
+   * @param {BitcoinConnection} bitcoin Bitcoin network connection to use for REST calls
    * @returns {Promise<Map<BeaconService, Array<BeaconSignal>>>} Map of beacon service to its discovered signals
    */
   static async indexer(
     beaconServices: Array<BeaconService>,
-    bitcoin: BitcoinNetworkConnection
+    bitcoin: BitcoinConnection
   ): Promise<Map<BeaconService, Array<BeaconSignal>>> {
     const beaconServiceSignals = new Map<BeaconService, Array<BeaconSignal>>();
 
     // Fetch the current block count once before the loop
-    const currentBlockCount = await bitcoin.network.rest.block.count();
+    const currentBlockCount = await bitcoin.rest.block.count();
 
     // 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(
+      const beaconSignals = await bitcoin.rest.address.getTxs(
         beaconService.serviceEndpoint as string
       );
 
@@ -104,12 +104,12 @@ export class BeaconSignalDiscovery {
   /**
    * 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.
+   * @param {BitcoinConnection} bitcoin Bitcoin network connection to use for RPC calls.
    * @returns {Promise<Map<BeaconService, Array<BeaconSignal>>>} Map of beacon service to its discovered signals.
    */
   static async fullnode(
     beaconServices: Array<BeaconService>,
-    bitcoin: BitcoinNetworkConnection
+    bitcoin: BitcoinConnection
   ): Promise<Map<BeaconService, Array<BeaconSignal>>> {
     const beaconServiceSignals = new Map<BeaconService, Array<BeaconSignal>>();
 
@@ -118,7 +118,7 @@ export class BeaconSignalDiscovery {
     }
 
     // Get the RPC connection from the bitcoin network
-    const rpc = bitcoin.network.rpc;
+    const rpc = bitcoin.rpc;
 
     // Ensure that the RPC connection is available
     if(!rpc) {
@@ -135,7 +135,7 @@ export class BeaconSignalDiscovery {
     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;
+    let block = await bitcoin.rpc!.getBlock({ height }) as BlockV3;
 
     console.info(`Searching for beacon signals, please wait ...`);
     while (block.height <= targetHeight) {

package/src/core/beacon/singleton.ts

@@ -1,10 +1,9 @@
-import { AddressUtxo, BitcoinNetworkConnection } from '@did-btcr2/bitcoin';
-import { Canonicalization, INVALID_SIDECAR_DATA, KeyBytes, MISSING_UPDATE_DATA } from '@did-btcr2/common';
+import { AddressUtxo, BitcoinConnection } from '@did-btcr2/bitcoin';
+import { canonicalHash, canonicalize, hash, INVALID_SIDECAR_DATA, KeyBytes, MISSING_UPDATE_DATA } from '@did-btcr2/common';
 import { SignedBTCR2Update } from '@did-btcr2/cryptosuite';
 import { SchnorrKeyPair } from '@did-btcr2/keypair';
-import { Signer } from '@did-btcr2/kms';
+import { base64urlnopad } from '@scure/base';
 import { opcodes, Psbt, script } from 'bitcoinjs-lib';
-import { base58btc } from 'multiformats/bases/base58';
 import { SidecarData } from '../types.js';
 import { Beacon } from './beacon.js';
 import { SingletonBeaconError } from './error.js';
@@ -21,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' });
@@ -55,11 +53,12 @@ export class SingletonBeacon extends Beacon {
         );
       }
 
-      // Canonicalize, hash and encode to base58 the signed update object found in sidecar or CAS
-      const encodedUpdate = Canonicalization.process(signedUpdate, { encoding: 'base58' });
+      // TODO: Review for simplification how we are encoding and comparing
+      // Canonicalize, hash and encode to base64url the signed update object found in sidecar or CAS
+      const encodedUpdate = canonicalHash(signedUpdate, { encoding: 'base64url' });
 
-      // Encode the signal bytes hex string to base58
-      const signalBytes = base58btc.encode(Buffer.from(updateHash, 'hex'));
+      // Encode the signal bytes hex string to base64url
+      const signalBytes = base64urlnopad.encode(Buffer.from(updateHash, 'hex'));
 
       // Check for mismatch between found sidecar/cas update hash and onchain beacon signal hash
       if (encodedUpdate !== signalBytes) {
@@ -81,20 +80,20 @@ export class SingletonBeacon extends Beacon {
    * Broadcasts a SingletonBeacon signal to the Bitcoin network.
    * @param {SignedBTCR2Update} signedUpdate The signed BTCR2 update to broadcast.
    * @param {KeyBytes} secretKey The secret key for signing the Bitcoin transaction.
-   * @param {BitcoinNetworkConnection} bitcoin The Bitcoin network connection.
+   * @param {BitcoinConnection} bitcoin The Bitcoin network connection.
    * @returns {Promise<SignedBTCR2Update>} The signed update that was broadcast.
    * @throws {SingletonBeaconError} if the bitcoin address is invalid or unfunded.
    */
   async broadcastSignal(
     signedUpdate: SignedBTCR2Update,
     secretKey: KeyBytes,
-    bitcoin: BitcoinNetworkConnection
+    bitcoin: BitcoinConnection
   ): Promise<SignedBTCR2Update> {
     // 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.network.rest.address.getUtxos(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) {
@@ -118,13 +117,13 @@ export class SingletonBeacon extends Beacon {
     }
 
     // Get the previous tx to the utxo being spent
-    const prevTx = await bitcoin.network.rest.transaction.getHex(utxo.txid);
+    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.network.data })
+    const spendTx = new Psbt({ network: bitcoin.data })
       // Spend tx contains the utxo as its input
       .addInput({
         hash           : utxo.txid,
@@ -137,11 +136,12 @@ export class SingletonBeacon extends Beacon {
       // Add an OP_RETURN output containing the update hash
       .addOutput({ script: script.compile([opcodes.OP_RETURN, updateHash]), value: 0n });
 
-    // Construct a Schnorr key pair from the secret key
+    // Construct a key pair and PSBT signer from the secret key
     const keyPair = SchnorrKeyPair.fromSecret(secretKey);
-
-    // Construct a signer object from the key pair and bitcoin network
-    const signer = new Signer({ keyPair, network: bitcoin.network.name });
+    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)
@@ -150,7 +150,7 @@ export class SingletonBeacon extends Beacon {
       .toHex();
 
     // Broadcast spendTx to the Bitcoin network.
-    const txid = await bitcoin.network.rest.transaction.send(signedTx);
+    const txid = await bitcoin.rest.transaction.send(signedTx);
 
     // Log the txid of the broadcasted transaction
     console.info(`Singleton Beacon Signal Broadcasted with txid: ${txid}`);

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

@@ -1,4 +1,4 @@
-import { BitcoinNetworkConnection } from '@did-btcr2/bitcoin';
+import { BitcoinConnection } from '@did-btcr2/bitcoin';
 import { KeyBytes } from '@did-btcr2/common';
 import { SignedBTCR2Update } from '@did-btcr2/cryptosuite';
 import { SidecarData } from '../types.js';
@@ -39,14 +39,14 @@ export class SMTBeacon extends Beacon {
    * Broadcast CAS Beacon signal to the Bitcoin network.
    * @param {SignedBTCR2Update} signedUpdate The signed BTCR2 update to broadcast.
    * @param {KeyBytes} secretKey The secret key for signing the Bitcoin transaction.
-   * @param {BitcoinNetworkConnection} bitcoin The Bitcoin network connection.
+   * @param {BitcoinConnection} bitcoin The Bitcoin network connection.
    * @return {Promise<SignedBTCR2Update>} The signed update that was broadcasted.
    * @throws {SMTBeaconError} if broadcasting fails.
    */
   async broadcastSignal(
     signedUpdate: SignedBTCR2Update,
     secretKey: KeyBytes,
-    bitcoin: BitcoinNetworkConnection
+    bitcoin: BitcoinConnection
   ): Promise<SignedBTCR2Update> {
     throw new SMTBeaconError('Method not implemented.', `METHOD_NOT_IMPLEMENTED`, {signedUpdate, secretKey, bitcoin});
   }

package/src/core/identifier.ts

@@ -1,24 +1,32 @@
-import { BitcoinNetworkNames, Bytes, IdentifierError, IdentifierTypes, INVALID_DID, METHOD_NOT_SUPPORTED } from '@did-btcr2/common';
+import { BitcoinNetworkNames, Bytes, DocumentBytes, IdentifierError, IdentifierTypes, INVALID_DID, KeyBytes, METHOD_NOT_SUPPORTED, SchnorrKeyPairObject } from '@did-btcr2/common';
 import { CompressedSecp256k1PublicKey, SchnorrKeyPair } from '@did-btcr2/keypair';
 import { bech32m } from '@scure/base';
+import { DidCreateOptions } from '../did-btcr2.js';
 
 /**
  * Components of a did:btcr2 identifier.
  * @interface DidComponents
+ * @extends {IdentifierComponents}
  * @property {string} hrp The human-readable part of the Bech32m encoding.
+ */
+export interface DidComponents extends IdentifierComponents {
+    hrp: string;
+};
+
+/**
+ * Components of a did:btcr2 identifier.
+ * @interface IdentifierComponents
  * @property {string} idType Identifier type (key or external).
  * @property {number} version Identifier version.
- * @property {string | number} network Bitcoin network name or number.
+ * @property {string} network Bitcoin network name or number.
  * @property {Bytes} genesisBytes Public key or an intermediate document bytes.
  */
-export interface DidComponents {
-    hrp: string;
+export interface IdentifierComponents {
     idType: string;
     version: number;
     network: string;
     genesisBytes: Bytes;
-};
-
+}
 /**
  * Implements {@link https://dcdpr.github.io/did-btcr2/#syntax | 3 Syntax}.
  * A did:btcr2 DID consists of a did:btcr2 prefix, followed by an id-bech32 value, which is a Bech32m encoding of:
@@ -41,20 +49,15 @@ export class Identifier {
    *    - a key-value representing a secp256k1 public key; or
    *    - a hash-value representing the hash of an initiating external DID document.
    *
-   * @param {DidComponents} params See {@link DidComponents} for details.
-   * @param {IdentifierTypes} params.idType Identifier type (key or external).
-   * @param {string} params.network Bitcoin network name.
-   * @param {number} params.version Identifier version.
-   * @param {KeyBytes | DocumentBytes} params.genesisBytes Public key or an intermediate document bytes.
+   * @param {KeyBytes | DocumentBytes} genesisBytes The genesis bytes (public key or document bytes).
+   * @param {DidCreateOptions} options The DID creation options.
    * @returns {string} The new did:btcr2 identifier.
    */
-  static encode({ idType, version, network, genesisBytes }: {
-    idType: string;
-    version: number;
-    network: string;
-    genesisBytes: Bytes;
-  }): string {
-    // 1. If idType is not a valid value per above, raise invalidDid error.
+  static encode(genesisBytes: KeyBytes | DocumentBytes, options: DidCreateOptions): string {
+    // Deconstruct the options
+    const { idType, version = 1, network } = options;
+
+    // If idType is not a valid value per above, raise invalidDid error.
     if (!(idType in IdentifierTypes)) {
       throw new IdentifierError('Expected "idType" to be "KEY" or "EXTERNAL"', INVALID_DID, {idType});
     }
@@ -275,16 +278,16 @@ export class Identifier {
    * Generates a new did:btcr2 identifier based on a newly generated key pair.
    * @returns {string} The new did:btcr2 identifier.
    */
-  static generate(): { keys: SchnorrKeyPair; identifier: { controller: string; id: string } } {
-    const keys = SchnorrKeyPair.generate();
-    const did = this.encode({
-      idType       : IdentifierTypes.KEY,
-      version      : 1,
-      network      : 'bitcoin',
-      genesisBytes : keys.publicKey.compressed
-    });
-
-    return { keys, identifier: { controller: did, id: '#initialKey'} };
+  static generate(): { keyPair: SchnorrKeyPairObject; did: string } {
+    const keyPair  = SchnorrKeyPair.generate();
+    const did = this.encode(keyPair.publicKey.compressed,
+      {
+        idType       : 'KEY',
+        version      : 1,
+        network      : 'regtest'
+      }
+    );
+    return { keyPair: keyPair.exportJSON(), did };
   }
 
   /**

package/src/core/interfaces.ts

@@ -1,4 +1,4 @@
-import { BitcoinNetworkConnection } from '@did-btcr2/bitcoin';
+import { BitcoinConnection } from '@did-btcr2/bitcoin';
 import { DidResolutionOptions } from '@web5/dids';
 import { Sidecar } from './types.js';
 
@@ -44,7 +44,7 @@ export interface ResolutionOptions extends ResolutionOptionsCore {
    * Drivers for interacting with external systems, such as the Bitcoin network.
    */
   drivers?: {
-    bitcoin?: BitcoinNetworkConnection;
+    bitcoin?: BitcoinConnection;
   };
 }
 

package/src/core/resolve.ts

@@ -1,9 +1,10 @@
 import {
-  BitcoinNetworkConnection,
+  BitcoinConnection,
   getNetwork
 } from '@did-btcr2/bitcoin';
 import {
-  Canonicalization,
+  canonicalHash,
+  canonicalize,
   DateUtils,
   IdentifierHrp,
   INVALID_DID,
@@ -23,7 +24,7 @@ import {
   UnsignedBTCR2Update
 } from '@did-btcr2/cryptosuite';
 import { CompressedSecp256k1PublicKey } from '@did-btcr2/keypair';
-import { bytesToHex } from '@noble/hashes/utils';
+import { hex } from '@scure/base';
 import { DidBtcr2 } from '../did-btcr2.js';
 import { Appendix } from '../utils/appendix.js';
 import { DidDocument, ID_PLACEHOLDER_VALUE } from '../utils/did-document.js';
@@ -64,12 +65,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);
 
@@ -104,22 +105,25 @@ export class Resolve {
     didComponents: DidComponents,
     genesisDocument: object,
   ): Promise<DidDocument> {
-    // Canonicalize and sha256 hash the currentDocument
-    const hashBytes = Canonicalization.process(genesisDocument, { encoding: 'hex' });
+    // Get the genesis bytes from the did components
+    const { genesisBytes } = didComponents;
+
+    // Convert the genesis bytes to a hex string
+    const genesisHex = hex.encode(genesisBytes);
 
-    // Compare the genesisBytes to the hashBytes
-    const genesisBytes = bytesToHex(didComponents.genesisBytes);
+    // Canonicalize and sha256 hash the currentDocument
+    const hashBytes = canonicalHash(genesisDocument);
 
     // If the genesisBytes do not match the hashBytes, throw an error
-    if (genesisBytes !== hashBytes) {
+    if (genesisHex !== hashBytes) {
       throw new ResolveError(
-        `Initial document mismatch: genesisBytes ${genesisBytes} !== hashBytes ${hashBytes}`,
+        `Initial document mismatch: genesisBytes ${genesisHex} !== 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(
@@ -140,14 +144,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(canonicalHash(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(canonicalHash(update, { encoding: 'hex' }), update);
       }
 
     // SMT Proofs map
@@ -209,16 +213,16 @@ 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);
 
@@ -276,11 +280,13 @@ export class Resolve {
     // Iterate over each (update block) pair
     for(const [update, block] of updates) {
       // Get the hash of the current document
-      const currentDocumentHash = Canonicalization.process(response.didDocument, { encoding: 'base58' });
+      const currentDocumentHash = canonicalHash(response.didDocument, { encoding: 'base64url' });
 
       // Safely convert block.time to timestamp
       const blocktime = DateUtils.blocktimeToTimestamp(block.time);
 
+      // TODO: How to detect if block is unconfirmed and exit gracefully or return without it
+
       // Set the updated field to the blocktime of the current update
       response.metadata.updated = DateUtils.toISOStringNonFractional(blocktime);
 
@@ -318,7 +324,7 @@ export class Resolve {
         // 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(canonicalHash(unsignedUpdate, { encoding: 'base64url' }));
       }
 
       // If update.targetVersionId > currentVersionId + 1, throw LATE_PUBLISHING error
@@ -367,7 +373,7 @@ export class Resolve {
     const { proof: _, ...unsignedUpdate } = update;
 
     // Hash unsignedUpdate with JSON Document Hashing algorithm
-    const unsignedUpdateHash = Canonicalization.process(unsignedUpdate);
+    const unsignedUpdateHash = canonicalHash(unsignedUpdate);
 
     // Let historicalUpdateHash equal updateHashHistory[updateHashIndex].
     const historicalUpdateHash = updateHashHistory[update.targetVersionId - 2];
@@ -432,7 +438,7 @@ export class Resolve {
     const cryptosuite = new BIP340Cryptosuite(multikey);
 
     // Canonicalize the update
-    const canonicalUpdate = Canonicalization.canonicalize(update);
+    const canonicalUpdate = canonicalize(update);
 
     // Construct a DataIntegrityProof with the cryptosuite
     const diProof = new BIP340DataIntegrityProof(cryptosuite);
@@ -455,16 +461,16 @@ export class Resolve {
     DidDocument.validate(updatedDocument);
 
     // Canonicalize and hash the updatedDocument to get the currentDocumentHash.
-    const currentDocumentHash = Canonicalization.process(updatedDocument, { encoding: 'base58' });
+    const currentDocumentHash = canonicalHash(updatedDocument, { encoding: 'base64url' });
 
     // 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,5 +1,5 @@
 import {
-  Canonicalization,
+  canonicalHash,
   INVALID_DID_UPDATE,
   JSONPatch,
   KeyBytes,
@@ -15,7 +15,7 @@ import {
 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      : canonicalHash(sourceDocument, { encoding: 'base64url' }),
     };
 
     // Apply all JSON patches to sourceDocument.
@@ -73,8 +73,8 @@ export class Update {
       );
     }
 
-    // Set the targetHash by canonicalizing the targetDocument and encoding it in base58.
-    unsignedUpdate.targetHash = Canonicalization.process(targetDocument, { encoding: 'base58' });
+    // Set the targetHash by canonicalizing the targetDocument and encoding it in base64url.
+    unsignedUpdate.targetHash = canonicalHash(targetDocument, { encoding: 'base64url' });
 
     // 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,4 +1,4 @@
-import { BitcoinNetworkConnection } from '@did-btcr2/bitcoin';
+import { BitcoinConnection } from '@did-btcr2/bitcoin';
 import {
   DocumentBytes,
   HexString,
@@ -8,6 +8,7 @@ import {
   KeyBytes,
   METHOD_NOT_SUPPORTED,
   MethodError,
+  MISSING_RESOLUTION_OPTIONS,
   MISSING_UPDATE_DATA,
   PatchOperation,
   ResolveError,
@@ -37,14 +38,13 @@ 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 */
   network?: string;
 }
 
-// TODO: convert to API driver?
 /** Initialize tiny secp256k1 */
 initEccLib(tinysecp);
 
@@ -83,10 +83,7 @@ export class DidBtcr2 implements DidMethod {
    * const did = DidBtcr2.create(genesisBytes, { idType: 'KEY', network: 'regtest' });
    * ```
    */
-  static create(
-    genesisBytes: KeyBytes | DocumentBytes,
-    options?: DidCreateOptions
-  ): 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 || {};
 
@@ -98,7 +95,7 @@ export class DidBtcr2 implements DidMethod {
     }
 
     // Call identifier encoding algorithm
-    return Identifier.encode({ idType, genesisBytes, version, network });
+    return Identifier.encode(genesisBytes, { idType, version, network });
   }
 
   /**
@@ -172,12 +169,11 @@ export class DidBtcr2 implements DidMethod {
 
       // 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);
+        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
@@ -217,9 +213,8 @@ export class DidBtcr2 implements DidMethod {
       // 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 {
@@ -247,7 +242,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`
@@ -267,9 +262,8 @@ 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.
     if (!signingMaterial) {
       throw new UpdateError(
@@ -337,8 +331,14 @@ 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);

package/src/index.ts

@@ -46,6 +46,5 @@ export * from './core/update.js';
 export * from './utils/appendix.js';
 export * from './utils/did-document-builder.js';
 export * from './utils/did-document.js';
-export * from './utils/general.js';
 
 export * from './did-btcr2.js';