@did-btcr2/method 0.22.0 → 0.23.0

package/src/core/beacon/aggregation/cohort/messages/base.ts

@@ -40,7 +40,12 @@ export class BaseMessage {
    * Converts a BaseMessage to a JSON object.
    * @returns {Base} The JSON representation of the BaseMessage.
    */
-  public json(): Base {
-    return Object.fromEntries(Object.entries(this)) as Base;
+  public toJSON(): Base {
+    return {
+      type : this.type,
+      to   : this.to,
+      from : this.from,
+      body : this.body
+    };
   }
 }

package/src/core/beacon/aggregation/communication/adapter/did-comm.ts

@@ -34,12 +34,7 @@ export class DidCommAdapterConfig implements ServiceAdapterConfig {
       idType  : 'KEY',
       network : 'mutinynet'
     };
-    this.did = config?.did || Identifier.encode(
-      {
-        ...this.components,
-        genesisBytes : this.keys.public
-      }
-    );
+    this.did = config?.did || Identifier.encode(this.keys.public, this.components);
     this.coordinatorDids = config?.coordinatorDids || [];
   }
 }
@@ -128,24 +123,22 @@ export class DidCommAdapter implements CommunicationService {
     if(!keys) {
       this.config.keys.secret = Secp256k1SecretKey.random();
       this.config.keys.public = Secp256k1SecretKey.getPublicKey(this.config.keys.secret).compressed;
-      this.config.did = Identifier.encode(
+      this.config.did = Identifier.encode(this.config.keys.public,
         {
           idType       : this.config.components.idType  || 'KEY',
           version      : this.config.components.version || 1,
-          network      : this.config.components.network || 'signet',
-          genesisBytes : this.config.keys.public
+          network      : this.config.components.network || 'regtest',
         }
       );
       return this.config as ServiceAdapterConfig;
     }
 
     this.config.keys = keys;
-    this.config.did = Identifier.encode(
+    this.config.did = Identifier.encode(this.config.keys.public,
       {
         idType       : this.config.components.idType  || 'KEY',
         version      : this.config.components.version || 1,
-        network      : this.config.components.network || 'signet',
-        genesisBytes : this.config.keys.public
+        network      : this.config.components.network || 'regtest',
       }
     );
     return this.config as ServiceAdapterConfig;

package/src/core/beacon/aggregation/communication/adapter/nostr.ts

@@ -93,11 +93,10 @@ export class NostrAdapter implements CommunicationService {
   constructor(config: NostrAdapterConfig = { keys: {} as RawSchnorrKeyPair, components: {}, relays: DEFAULT_NOSTR_RELAYS }) {
     this.config = config;
     this.config.keys = this.config.keys || SchnorrKeyPair.generate().raw;
-    this.config.did = config.did || Identifier.encode({
-      idType       : config.components.idType || 'KEY',
+    this.config.did = config.did || Identifier.encode(this.config.keys.public!, {
+      idType       : config.components.idType  || 'KEY',
       version      : config.components.version || 1,
-      network      : config.components.network || 'signet',
-      genesisBytes : this.config.keys.public!
+      network      : config.components.network || 'signet'
     });
   }
 
@@ -297,24 +296,22 @@ export class NostrAdapter implements CommunicationService {
     if(!keys) {
       this.config.keys.secret = Secp256k1SecretKey.random();
       this.config.keys.public = Secp256k1SecretKey.getPublicKey(this.config.keys.secret).compressed;
-      this.config.did = Identifier.encode(
+      this.config.did = Identifier.encode(this.config.keys.public,
         {
           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 as ServiceAdapterConfig;
     }
 
     this.config.keys = keys;
-    this.config.did = Identifier.encode(
+    this.config.did = Identifier.encode(this.config.keys.public,
       {
         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 as ServiceAdapterConfig;

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

@@ -188,7 +188,7 @@ export class BeaconCohortSigningSession implements SigningSession {
         `Missing ${missing} nonce contributions. ` +
         `Received ${this.cohort?.participants.length} of ${this.nonceContributions.size} nonce contributions. ` +
         `Current status: ${this.status}`,
-        'NONCE_CONTRIBUTION_ERROR', this.json()
+        'NONCE_CONTRIBUTION_ERROR', this.toJSON()
       );
     }
     const sortedPubkeys = musig2.sortKeys(this.cohort.cohortKeys);
@@ -267,8 +267,20 @@ export class BeaconCohortSigningSession implements SigningSession {
    * Converts the signing session instance to a JSON object representation.
    * @returns {BeaconCohortSigningSession} The JSON object representation of the signing session.
    */
-  public json(): BeaconCohortSigningSession {
-    return Object.fromEntries(Object.entries(this)) as BeaconCohortSigningSession;
+  public toJSON(): Partial<BeaconCohortSigningSession> {
+    return {
+      id                 : this.id,
+      cohort             : this.cohort,
+      pendingTx          : this.pendingTx,
+      nonceContributions : this.nonceContributions,
+      aggregatedNonce    : this.aggregatedNonce,
+      partialSignatures  : this.partialSignatures,
+      signature          : this.signature,
+      status             : this.status,
+      processedRequests  : this.processedRequests,
+      nonceSecrets       : this.nonceSecrets,
+      musig2Session      : this.musig2Session
+    };
   }
 
   /**

package/src/core/beacon/beacon.ts

@@ -1,5 +1,5 @@
 import { KeyBytes } from '@did-btcr2/common';
-import { BitcoinNetworkConnection } from '../../../../bitcoin/dist/types/bitcoin.js';
+import { BitcoinConnection } from '@did-btcr2/bitcoin';
 import { SignedBTCR2Update } from '../../../../cryptosuite/dist/types/data-integrity-proof/interface.js';
 import { SidecarData } from '../types.js';
 import { BeaconService, BeaconSignal, BlockMetadata } from './interfaces.js';
@@ -47,12 +47,12 @@ export abstract class Beacon {
    * Used during the update path.
    * @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.
    */
   abstract broadcastSignal(
     signedUpdate: SignedBTCR2Update,
     secretKey: KeyBytes,
-    bitcoin: BitcoinNetworkConnection
+    bitcoin: BitcoinConnection
   ): Promise<SignedBTCR2Update>;
 }

package/src/core/beacon/cas-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 CASBeacon 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 {CASBeaconError} if broadcasting fails.
    */
   async broadcastSignal(
     signedUpdate: SignedBTCR2Update,
     secretKey: KeyBytes,
-    bitcoin: BitcoinNetworkConnection
+    bitcoin: BitcoinConnection
   ): Promise<SignedBTCR2Update> {
     throw new CASBeaconError('Method not implemented.', `METHOD_NOT_IMPLEMENTED`, {signedUpdate, secretKey, bitcoin});
   }

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,8 +1,7 @@
-import { AddressUtxo, BitcoinNetworkConnection } from '@did-btcr2/bitcoin';
+import { AddressUtxo, BitcoinConnection } from '@did-btcr2/bitcoin';
 import { Canonicalization, 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 { opcodes, Psbt, script } from 'bitcoinjs-lib';
 import { base58btc } from 'multiformats/bases/base58';
 import { SidecarData } from '../types.js';
@@ -55,10 +54,10 @@ 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' });
+      // Canonicalize, hash and encode to base58btc the signed update object found in sidecar or CAS
+      const encodedUpdate = Canonicalization.process(signedUpdate, { encoding: 'base58btc' });
 
-      // Encode the signal bytes hex string to base58
+      // Encode the signal bytes hex string to base58btc
       const signalBytes = base58btc.encode(Buffer.from(updateHash, 'hex'));
 
       // Check for mismatch between found sidecar/cas update hash and onchain beacon signal hash
@@ -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);
 
     // 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.toJSON(), 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,5 +1,5 @@
 import {
-  BitcoinNetworkConnection,
+  BitcoinConnection,
   getNetwork
 } from '@did-btcr2/bitcoin';
 import {
@@ -64,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);
 
@@ -107,19 +107,18 @@ export class Resolve {
     // Canonicalize and sha256 hash the currentDocument
     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(
@@ -209,16 +208,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,7 +275,7 @@ 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 = Canonicalization.process(response.didDocument, { encoding: 'base58btc' });
 
       // Safely convert block.time to timestamp
       const blocktime = DateUtils.blocktimeToTimestamp(block.time);
@@ -318,7 +317,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(Canonicalization.process(unsignedUpdate, { encoding: 'base58btc' }));
       }
 
       // If update.targetVersionId > currentVersionId + 1, throw LATE_PUBLISHING error
@@ -455,16 +454,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 = 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

@@ -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      : 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);