@did-btcr2/method 0.22.0 → 0.23.0

package/dist/browser.mjs

@@ -57529,8 +57529,9 @@ var MethodErrorCode;
   MethodErrorCode2["MISSING_UPDATE_DATA"] = "MISSING_UPDATE_DATA";
   MethodErrorCode2["INVALID_UPDATE"] = "INVALID_UPDATE";
   MethodErrorCode2["INVALID_DOMAIN_ERROR"] = "INVALID_DOMAIN_ERROR";
+  MethodErrorCode2["MISSING_RESOLUTION_OPTIONS"] = "MISSING_RESOLUTION_OPTIONS";
 })(MethodErrorCode || (MethodErrorCode = {}));
-var { INVALID_DID, METHOD_NOT_SUPPORTED, INTERNAL_ERROR, INVALID_DID_DOCUMENT, INVALID_DID_UPDATE, INVALID_DID_DOCUMENT_LENGTH, INVALID_DID_URL, INVALID_PREVIOUS_DID_PROOF, INVALID_PUBLIC_KEY, INVALID_PUBLIC_KEY_MULTIBASE, INVALID_PUBLIC_KEY_LENGTH, INVALID_PUBLIC_KEY_TYPE, INVALID_SIGNATURE, NOT_FOUND, REPRESENTATION_NOT_SUPPORTED, UNSUPPORTED_PUBLIC_KEY_TYPE, PROOF_VERIFICATION_ERROR, PROOF_GENERATION_ERROR, PROOF_SERIALIZATION_ERROR, PROOF_PARSING_ERROR, VERIFICATION_METHOD_ERROR, LATE_PUBLISHING_ERROR, INVALID_SIDECAR_DATA, MISSING_UPDATE_DATA, INVALID_UPDATE, INVALID_DOMAIN_ERROR } = MethodErrorCode;
+var { INVALID_DID, METHOD_NOT_SUPPORTED, INTERNAL_ERROR, INVALID_DID_DOCUMENT, INVALID_DID_UPDATE, INVALID_DID_DOCUMENT_LENGTH, INVALID_DID_URL, INVALID_PREVIOUS_DID_PROOF, INVALID_PUBLIC_KEY, INVALID_PUBLIC_KEY_MULTIBASE, INVALID_PUBLIC_KEY_LENGTH, INVALID_PUBLIC_KEY_TYPE, INVALID_SIGNATURE, NOT_FOUND, REPRESENTATION_NOT_SUPPORTED, UNSUPPORTED_PUBLIC_KEY_TYPE, PROOF_VERIFICATION_ERROR, PROOF_GENERATION_ERROR, PROOF_SERIALIZATION_ERROR, PROOF_PARSING_ERROR, VERIFICATION_METHOD_ERROR, LATE_PUBLISHING_ERROR, INVALID_SIDECAR_DATA, MISSING_UPDATE_DATA, INVALID_UPDATE, INVALID_DOMAIN_ERROR, MISSING_RESOLUTION_OPTIONS } = MethodErrorCode;
 var NotImplementedError = class _NotImplementedError extends Error {
   name = "NotImplementedError";
   type = "NotImplementedError";
@@ -57620,6 +57621,40 @@ var CanonicalizationError = class extends DidMethodError {
   }
 };
 
+// ../../node_modules/.pnpm/multiformats@13.4.1/node_modules/multiformats/dist/src/bases/base64.js
+var base64_exports = {};
+__export(base64_exports, {
+  base64: () => base64,
+  base64pad: () => base64pad,
+  base64url: () => base64url,
+  base64urlpad: () => base64urlpad
+});
+init_shim();
+var base64 = rfc4648({
+  prefix: "m",
+  name: "base64",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+  bitsPerChar: 6
+});
+var base64pad = rfc4648({
+  prefix: "M",
+  name: "base64pad",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
+  bitsPerChar: 6
+});
+var base64url = rfc4648({
+  prefix: "u",
+  name: "base64url",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
+  bitsPerChar: 6
+});
+var base64urlpad = rfc4648({
+  prefix: "U",
+  name: "base64urlpad",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=",
+  bitsPerChar: 6
+});
+
 // ../common/dist/esm/canonicalization.js
 var Canonicalization = class _Canonicalization {
   /**
@@ -57643,7 +57678,7 @@ var Canonicalization = class _Canonicalization {
    */
   static normalizeEncoding(encoding) {
     const normalized = encoding.toLowerCase();
-    if (normalized !== "hex" && normalized !== "base58") {
+    if (!["hex", "base58btc", "base64url"].includes(normalized)) {
       throw new CanonicalizationError(`Unsupported encoding: ${encoding}`, "ENCODING_ERROR");
     }
     return normalized;
@@ -57659,7 +57694,7 @@ var Canonicalization = class _Canonicalization {
    *
    * @param {Record<any, any>} object The object to process.
    * @param {Object} [options] Options for processing.
-   * @param {CanonicalizationEncoding} [options.encoding='hex'] The encoding format ('hex' or 'base58').
+   * @param {CanonicalizationEncoding} [options.encoding='hex'] The encoding format ('hex' or 'base58btc').
    * @param {CanonicalizationAlgorithm} [options.algorithm] The canonicalization algorithm to use.
    * @returns {string} The final SHA-256 hash bytes as a hex string.
    */
@@ -57702,9 +57737,9 @@ var Canonicalization = class _Canonicalization {
     return sha256(canonicalized);
   }
   /**
-   * Step 3: Encodes SHA-256 hashed, canonicalized object as a hex or base58 string.
+   * Step 3: Encodes SHA-256 hashed, canonicalized object as a hex or base58btc string.
    * @param {string} canonicalizedhash The canonicalized object to encode.
-   * @param {CanonicalizationEncoding} encoding The encoding format ('hex' or 'base58').
+   * @param {CanonicalizationEncoding} encoding The encoding format ('hex' or 'base58btc').
    * @throws {CanonicalizationError} If the encoding format is not supported.
    * @returns {string} The encoded string.
    */
@@ -57713,15 +57748,18 @@ var Canonicalization = class _Canonicalization {
     if (normalized === "hex") {
       return this.toHex(canonicalizedhash);
     }
-    if (normalized === "base58") {
+    if (normalized === "base58btc") {
       return this.toBase58(canonicalizedhash);
     }
+    if (normalized === "base64url") {
+      return this.toBase64Url(canonicalizedhash);
+    }
     throw new CanonicalizationError(`Unsupported encoding: ${encoding}`, "ENCODING_ERROR");
   }
   /**
-   * Decodes SHA-256 hashed, canonicalized object as a hex or base58 string.
+   * Decodes SHA-256 hashed, canonicalized object as a hex or base58btc string.
    * @param {string} canonicalizedhash The canonicalized object to encode.
-   * @param {CanonicalizationEncoding} encoding The encoding format ('hex' or 'base58').
+   * @param {CanonicalizationEncoding} encoding The encoding format ('hex' or 'base58btc').
    * @throws {CanonicalizationError} If the encoding format is not supported.
    * @returns {string} The encoded string.
    */
@@ -57730,9 +57768,12 @@ var Canonicalization = class _Canonicalization {
     if (normalized === "hex") {
       return this.fromHex(canonicalizedhash);
     }
-    if (normalized === "base58") {
+    if (normalized === "base58btc") {
       return this.fromBase58(canonicalizedhash);
     }
+    if (normalized === "base64url") {
+      return this.fromBase64Url(canonicalizedhash);
+    }
     throw new CanonicalizationError(`Unsupported encoding: ${encoding}`, "DECODING_ERROR");
   }
   /**
@@ -57760,13 +57801,29 @@ var Canonicalization = class _Canonicalization {
     return base58btc.encode(hashBytes);
   }
   /**
-   * Decodes a base58 string to HashBytes (Uint8Array).
-   * @param {string} b58str The hash as a base58 string.
+   * Decodes a base58btc string to HashBytes (Uint8Array).
+   * @param {string} b58str The hash as a base58btc string.
    * @returns {HashBytes} The hash bytes.
    */
   static fromBase58(b58str) {
     return base58btc.decode(b58str);
   }
+  /**
+   * Step 3.2: Encodes HashBytes (Uint8Array) to a base64url string.
+   * @param {HashBytes} hashBytes The hash as a Uint8Array.
+   * @returns {string} The hash as a base64url string.
+   */
+  static toBase64Url(hashBytes) {
+    return base64url.encode(hashBytes);
+  }
+  /**
+   * Decodes a base64url string to HashBytes (Uint8Array).
+   * @param {string} b64urlstr The hash as a base64url string.
+   * @returns {HashBytes} The hash bytes.
+   */
+  static fromBase64Url(b64urlstr) {
+    return base64url.decode(b64urlstr);
+  }
   /**
    * Canonicalizes an object, hashes it and returns it as hash bytes.
    * Step 1-2: Canonicalize → Hash.
@@ -57790,13 +57847,22 @@ var Canonicalization = class _Canonicalization {
     return hexed;
   }
   /**
-   * Computes the SHA-256 hashes of canonicalized object and encodes it as a base58 string.
-   * Step 2-3: Hash → Encode(base58).
+   * Computes the SHA-256 hashes of canonicalized object and encodes it as a base58btc string.
+   * Step 2-3: Hash → Encode(base58btc).
    * @param {string} canonicalized The canonicalized object to hash.
-   * @returns {string} The SHA-256 hash as a base58 string.
+   * @returns {string} The SHA-256 hash as a base58btc string.
    */
   static andHashToBase58(canonicalized) {
-    return this.encode(this.toHash(canonicalized), "base58");
+    return this.encode(this.toHash(canonicalized), "base58btc");
+  }
+  /**
+   * Computes the SHA-256 hashes of canonicalized object and encodes it as a base64url string.
+   * Step 2-3: Hash → Encode(base64url).
+   * @param {string} canonicalized The canonicalized object to hash.
+   * @returns {string} The SHA-256 hash as a base64url string.
+   */
+  static andHashToBase64Url(canonicalized) {
+    return this.toBase64Url(this.toHash(canonicalized));
   }
 };
 
@@ -57880,9 +57946,6 @@ var BTCR2_DID_UPDATE_PAYLOAD_CONTEXT = [
   CONTEXT_URL_MAP.w3c.jsonldpatch.v1
 ];
 
-// ../common/dist/esm/interfaces.js
-init_shim();
-
 // ../common/dist/esm/json-patch.js
 init_shim();
 
@@ -59551,51 +59614,6 @@ init_shim();
 
 // ../common/dist/esm/utils/string.js
 init_shim();
-var StringUtils = class {
-  /**
-   * Escape special characters in a string for use in a regular expression.
-   * @param {string} value - The string to escape.
-   * @returns {string} The escaped string.
-   */
-  static escapeRegExp(value3) {
-    return value3.replace(/[-/\\^$*+?.()|[\]{}]/g, "\\$&");
-  }
-  /**
-   * Convert a camelCase string to snake_case.
-   * @param {string} value - The camelCase string to convert.
-   * @returns {string} The converted snake_case string.
-   */
-  static toSnake(value3) {
-    return value3.replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
-  }
-  /**
-   * Convert a string to SNAKE_SCREAMING_CASE.
-   * @param {string} value - The string to convert.
-   * @returns {string} The converted SNAKE_SCREAMING_CASE string.
-   */
-  static toSnakeScream(value3) {
-    return this.toSnake(value3).toUpperCase();
-  }
-  /**
-   * Remove the last character from a string.
-   * @param {string} value - The string to chop.
-   * @returns {string} The chopped string.
-   */
-  static chop(value3) {
-    return value3.length > 0 ? value3.slice(0, -1) : "";
-  }
-  /**
-   * Replace the end of a string if it matches a given pattern.
-   * @param {string} value - The string to modify.
-   * @param {string | RegExp} pattern - The pattern to match at the end of the string.
-   * @param {string} [replacement=''] - The replacement string.
-   * @returns {string} The modified string.
-   */
-  static replaceEnd(value3, pattern, replacement = "") {
-    const regex3 = pattern instanceof RegExp ? new RegExp(pattern.source.endsWith("$") ? pattern.source : `${pattern.source}$`, pattern.flags.replace(/g/g, "")) : new RegExp(`${this.escapeRegExp(pattern)}$`);
-    return value3.replace(regex3, replacement);
-  }
-};
 
 // src/core/beacon/error.ts
 var BeaconError = class extends MethodError {
@@ -59658,8 +59676,13 @@ var BaseMessage = class {
    * Converts a BaseMessage to a JSON object.
    * @returns {Base} The JSON representation of the BaseMessage.
    */
-  json() {
-    return Object.fromEntries(Object.entries(this));
+  toJSON() {
+    return {
+      type: this.type,
+      to: this.to,
+      from: this.from,
+      body: this.body
+    };
   }
 };
 
@@ -59843,7 +59866,7 @@ var BeaconCohortSigningSession = class {
       throw new AggregateBeaconError(
         `Missing ${missing} nonce contributions. Received ${this.cohort?.participants.length} of ${this.nonceContributions.size} nonce contributions. Current status: ${this.status}`,
         "NONCE_CONTRIBUTION_ERROR",
-        this.json()
+        this.toJSON()
       );
     }
     const sortedPubkeys = sortKeys(this.cohort.cohortKeys);
@@ -59910,8 +59933,20 @@ var BeaconCohortSigningSession = class {
    * Converts the signing session instance to a JSON object representation.
    * @returns {BeaconCohortSigningSession} The JSON object representation of the signing session.
    */
-  json() {
-    return Object.fromEntries(Object.entries(this));
+  toJSON() {
+    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
+    };
   }
   /**
    * Checks if the signing session is a completed state.
@@ -60195,8 +60230,19 @@ var AggregateBeaconCohort = class _AggregateBeaconCohort {
    * Converts the cohort instance to a JSON object representation.
    * @returns {BeaconCohort} The JSON object representation of the cohort.
    */
-  json() {
-    return Object.fromEntries(Object.entries(this));
+  toJSON() {
+    return {
+      id: this.id,
+      coordinatorDid: this.coordinatorDid,
+      minParticipants: this.minParticipants,
+      status: this.status,
+      network: this.network,
+      pendingSignatureRequests: this.pendingSignatureRequests,
+      participants: this.participants,
+      cohortKeys: this.cohortKeys,
+      trMerkleRoot: this.trMerkleRoot,
+      beaconAddress: this.beaconAddress
+    };
   }
 };
 
@@ -60587,7 +60633,7 @@ var Secp256k1SecretKey = class _Secp256k1SecretKey {
    * Converts the secret key to a JSON object.
    * @returns {SecretKeyObject} The secret key as a JSON object
    */
-  json() {
+  toJSON() {
     return {
       bytes: Array.from(this.bytes),
       seed: this.seed.toString(),
@@ -60732,9 +60778,13 @@ var Secp256k1SecretKey = class _Secp256k1SecretKey {
 
 // ../keypair/dist/esm/public.js
 var CompressedSecp256k1PublicKey = class _CompressedSecp256k1PublicKey {
-  /** @type {KeyBytes} The public key bytes */
+  /**
+   * The public key bytes
+   **/
   #bytes;
-  /** @type {MultibaseObject} The public key as a MultibaseObject */
+  /**
+   * The public key as a MultibaseObject
+   */
   #multibase = {
     prefix: BIP340_PUBLIC_KEY_MULTIBASE_PREFIX,
     key: [],
@@ -60906,7 +60956,7 @@ var CompressedSecp256k1PublicKey = class _CompressedSecp256k1PublicKey {
    * JSON representation of a CompressedSecp256k1PublicKey object.
    * @returns {PublicKeyObject} The CompressedSecp256k1PublicKey as a JSON object.
    */
-  json() {
+  toJSON() {
     return {
       hex: this.hex,
       multibase: this.multibase,
@@ -61135,10 +61185,10 @@ var SchnorrKeyPair = class _SchnorrKeyPair {
    * JSON representation of a Keys.
    * @returns {SchnorrKeyPairObject} The Keys as a JSON object
    */
-  json() {
+  toJSON() {
     return {
-      secretKey: this.secretKey.json(),
-      publicKey: this.publicKey.json()
+      secretKey: this.secretKey.toJSON(),
+      publicKey: this.publicKey.toJSON()
     };
   }
   /**
@@ -61231,14 +61281,12 @@ var Identifier = class {
    *    - 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: version3, network, genesisBytes }) {
+  static encode(genesisBytes, options2) {
+    const { idType, version: version3 = 1, network } = options2;
     if (!(idType in IdentifierTypes)) {
       throw new IdentifierError('Expected "idType" to be "KEY" or "EXTERNAL"', INVALID_DID, { idType });
     }
@@ -61367,14 +61415,16 @@ var Identifier = class {
    * @returns {string} The new did:btcr2 identifier.
    */
   static generate() {
-    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" } };
+    const keyPair = SchnorrKeyPair.generate();
+    const did = this.encode(
+      keyPair.publicKey.compressed,
+      {
+        idType: "KEY",
+        version: 1,
+        network: "regtest"
+      }
+    );
+    return { keyPair: keyPair.toJSON(), did };
   }
   /**
    * Validates a did:btcr2 identifier.
@@ -61409,12 +61459,7 @@ var DidCommAdapterConfig = class {
       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 || [];
   }
 };
@@ -61484,22 +61529,22 @@ var DidCommAdapter = class {
       this.config.keys.secret = Secp256k1SecretKey.random();
       this.config.keys.public = Secp256k1SecretKey.getPublicKey(this.config.keys.secret).compressed;
       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;
     }
     this.config.keys = keys;
     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;
@@ -64140,8 +64185,8 @@ var base16 = chain2(radix22(4), alphabet2("0123456789ABCDEF"), join2(""));
 var base32 = chain2(radix22(5), alphabet2("ABCDEFGHIJKLMNOPQRSTUVWXYZ234567"), padding2(5), join2(""));
 var base32hex = chain2(radix22(5), alphabet2("0123456789ABCDEFGHIJKLMNOPQRSTUV"), padding2(5), join2(""));
 var base32crockford = chain2(radix22(5), alphabet2("0123456789ABCDEFGHJKMNPQRSTVWXYZ"), join2(""), normalize2((s2) => s2.toUpperCase().replace(/O/g, "0").replace(/[IL]/g, "1")));
-var base64 = chain2(radix22(6), alphabet2("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), padding2(6), join2(""));
-var base64url = chain2(radix22(6), alphabet2("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), padding2(6), join2(""));
+var base642 = chain2(radix22(6), alphabet2("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"), padding2(6), join2(""));
+var base64url2 = chain2(radix22(6), alphabet2("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"), padding2(6), join2(""));
 var genBase582 = (abc) => chain2(radix3(58), alphabet2(abc), join2(""));
 var base582 = genBase582("123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz");
 var base58flickr2 = genBase582("123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ");
@@ -64263,8 +64308,8 @@ var CODERS = {
   hex: hex2,
   base16,
   base32,
-  base64,
-  base64url,
+  base64: base642,
+  base64url: base64url2,
   base58: base582,
   base58xmr
 };
@@ -66473,8 +66518,8 @@ function encrypt2(secretKey, pubkey, text) {
   let iv = Uint8Array.from(randomBytes4(16));
   let plaintext = utf8Encoder.encode(text);
   let ciphertext = cbc(normalizedKey, iv).encrypt(plaintext);
-  let ctb64 = base64.encode(new Uint8Array(ciphertext));
-  let ivb64 = base64.encode(new Uint8Array(iv.buffer));
+  let ctb64 = base642.encode(new Uint8Array(ciphertext));
+  let ivb64 = base642.encode(new Uint8Array(iv.buffer));
   return `${ctb64}?iv=${ivb64}`;
 }
 function decrypt2(secretKey, pubkey, data) {
@@ -66482,8 +66527,8 @@ function decrypt2(secretKey, pubkey, data) {
   let [ctb64, ivb64] = data.split("?iv=");
   let key = secp256k12.getSharedSecret(privkey, "02" + pubkey);
   let normalizedKey = getNormalizedX(key);
-  let iv = base64.decode(ivb64);
-  let ciphertext = base64.decode(ctb64);
+  let iv = base642.decode(ivb64);
+  let ciphertext = base642.decode(ctb64);
   let plaintext = cbc(normalizedKey, iv).decrypt(ciphertext);
   return utf8Decoder.decode(plaintext);
 }
@@ -66793,7 +66838,7 @@ function decodePayload(payload) {
     throw new Error("unknown encryption version");
   let data;
   try {
-    data = base64.decode(payload);
+    data = base642.decode(payload);
   } catch (error) {
     throw new Error("invalid base64: " + error.message);
   }
@@ -66814,7 +66859,7 @@ function encrypt22(plaintext, conversationKey, nonce = randomBytes4(32)) {
   const padded = pad(plaintext);
   const ciphertext = chacha20(chacha_key, chacha_nonce, padded);
   const mac = hmacAad(hmac_key, ciphertext, nonce);
-  return base64.encode(concatBytes7(new Uint8Array([2]), nonce, ciphertext, mac));
+  return base642.encode(concatBytes7(new Uint8Array([2]), nonce, ciphertext, mac));
 }
 function decrypt22(payload, conversationKey) {
   const { nonce, ciphertext, mac } = decodePayload(payload);
@@ -67553,7 +67598,7 @@ async function getToken(loginUrl, httpMethod, sign2, includeAuthorizationScheme
   }
   const signedEvent = await sign2(event);
   const authorizationScheme = includeAuthorizationScheme ? _authorizationScheme : "";
-  return authorizationScheme + base64.encode(utf8Encoder.encode(JSON.stringify(signedEvent)));
+  return authorizationScheme + base642.encode(utf8Encoder.encode(JSON.stringify(signedEvent)));
 }
 async function validateToken(token, url, method) {
   const event = await unpackEventFromToken(token).catch((error) => {
@@ -67569,7 +67614,7 @@ async function unpackEventFromToken(token) {
     throw new Error("Missing token");
   }
   token = token.replace(_authorizationScheme, "");
-  const eventB64 = utf8Decoder.decode(base64.decode(token));
+  const eventB64 = utf8Decoder.decode(base642.decode(token));
   if (!eventB64 || eventB64.length === 0 || !eventB64.startsWith("{")) {
     throw new Error("Invalid token");
   }
@@ -68521,11 +68566,10 @@ var NostrAdapter = class {
   constructor(config = { keys: {}, components: {}, relays: DEFAULT_NOSTR_RELAYS }) {
     this.config = config;
     this.config.keys = this.config.keys || SchnorrKeyPair.generate().raw;
-    this.config.did = config.did || Identifier.encode({
+    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"
     });
   }
   /**
@@ -68665,22 +68709,22 @@ var NostrAdapter = class {
       this.config.keys.secret = Secp256k1SecretKey.random();
       this.config.keys.public = Secp256k1SecretKey.getPublicKey(this.config.keys.secret).compressed;
       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 || "signet"
         }
       );
       return this.config;
     }
     this.config.keys = keys;
     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 || "signet"
       }
     );
     return this.config;
@@ -69875,12 +69919,12 @@ var CASBeacon = class 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, secretKey, bitcoin3) {
-    throw new CASBeaconError("Method not implemented.", `METHOD_NOT_IMPLEMENTED`, { signedUpdate, secretKey, bitcoin: bitcoin3 });
+  async broadcastSignal(signedUpdate, secretKey, bitcoin2) {
+    throw new CASBeaconError("Method not implemented.", `METHOD_NOT_IMPLEMENTED`, { signedUpdate, secretKey, bitcoin: bitcoin2 });
   }
 };
 
@@ -69889,68 +69933,6 @@ init_shim();
 
 // src/core/beacon/singleton.ts
 init_shim();
-
-// ../kms/dist/esm/index.js
-init_shim();
-
-// ../kms/dist/esm/interface.js
-init_shim();
-
-// ../kms/dist/esm/kms.js
-init_shim();
-
-// ../kms/dist/esm/store.js
-init_shim();
-
-// ../kms/dist/esm/signer.js
-init_shim();
-var Signer = class {
-  /**
-   * The key pair used for signing.
-   * @type {SchnorrKeyPair}
-   */
-  keyPair;
-  /**
-   * The network associated with the signer.
-   * @type {keyof AvailableNetworks}
-   */
-  network;
-  /**
-   * Creates an instance of Signer.
-   * @param {{ keyPair: SchnorrKeyPair; network: keyof AvailableNetworks; }} params The parameters for the signer.
-   * @param {SchnorrKeyPair} params.keyPair The key pair used for signing.
-   * @param {keyof AvailableNetworks} params.network The network associated with the signer.
-   */
-  constructor(params) {
-    this.keyPair = params.keyPair;
-    this.network = params.network;
-  }
-  /**
-   * Gets the public key bytes.
-   * @returns {KeyBytes} The public key bytes.
-   */
-  get publicKey() {
-    return this.keyPair.publicKey.compressed;
-  }
-  /**
-   * Signs the given hash using ECDSA.
-   * @param {Bytes} hash The hash to sign.
-   * @returns {SignatureBytes} The signature of the hash.
-   */
-  sign(hash4) {
-    return this.keyPair.secretKey.sign(hash4, { scheme: "ecdsa" });
-  }
-  /**
-   * Signs the given hash using Schnorr signature.
-   * @param {Bytes} hash The hash to sign.
-   * @returns {SignatureBytes} The Schnorr signature of the hash.
-   */
-  signSchnorr(hash4) {
-    return this.keyPair.secretKey.sign(hash4);
-  }
-};
-
-// src/core/beacon/singleton.ts
 var SingletonBeacon = class extends Beacon {
   /**
    * Creates an instance of SingletonBeacon.
@@ -69977,7 +69959,7 @@ var SingletonBeacon = class extends Beacon {
           signal
         );
       }
-      const encodedUpdate = Canonicalization.process(signedUpdate, { encoding: "base58" });
+      const encodedUpdate = Canonicalization.process(signedUpdate, { encoding: "base58btc" });
       const signalBytes = base58btc.encode(import_buffer.Buffer.from(updateHash, "hex"));
       if (encodedUpdate !== signalBytes) {
         throw new SingletonBeaconError(
@@ -69994,13 +69976,13 @@ var SingletonBeacon = class 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, secretKey, bitcoin3) {
+  async broadcastSignal(signedUpdate, secretKey, bitcoin2) {
     const bitcoinAddress = this.service.serviceEndpoint.replace("bitcoin:", "");
-    const utxos = await bitcoin3.network.rest.address.getUtxos(bitcoinAddress);
+    const utxos = await bitcoin2.rest.address.getUtxos(bitcoinAddress);
     if (!utxos.length) {
       throw new SingletonBeaconError(
         "No UTXOs found, please fund address!",
@@ -70018,17 +70000,20 @@ var SingletonBeacon = class extends Beacon {
         { bitcoinAddress }
       );
     }
-    const prevTx = await bitcoin3.network.rest.transaction.getHex(utxo.txid);
+    const prevTx = await bitcoin2.rest.transaction.getHex(utxo.txid);
     const updateHash = Canonicalization.andHash(signedUpdate);
-    const spendTx = new Psbt2({ network: bitcoin3.network.data }).addInput({
+    const spendTx = new Psbt2({ network: bitcoin2.data }).addInput({
       hash: utxo.txid,
       index: utxo.vout,
       nonWitnessUtxo: import_buffer.Buffer.from(prevTx, "hex")
     }).addOutput({ address: bitcoinAddress, value: BigInt(utxo.value) - BigInt(500) }).addOutput({ script: script_exports.compile([OPS.OP_RETURN, updateHash]), value: 0n });
     const keyPair = SchnorrKeyPair.fromSecret(secretKey);
-    const signer = new Signer({ keyPair, network: bitcoin3.network.name });
+    const signer = {
+      publicKey: keyPair.publicKey.compressed,
+      sign: (hash4) => keyPair.secretKey.sign(hash4, { scheme: "ecdsa" })
+    };
     const signedTx = spendTx.signInput(0, signer).finalizeAllInputs().extractTransaction().toHex();
-    const txid = await bitcoin3.network.rest.transaction.send(signedTx);
+    const txid = await bitcoin2.rest.transaction.send(signedTx);
     console.info(`Singleton Beacon Signal Broadcasted with txid: ${txid}`);
     return signedUpdate;
   }
@@ -70058,12 +70043,12 @@ var SMTBeacon = class 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, secretKey, bitcoin3) {
-    throw new SMTBeaconError("Method not implemented.", `METHOD_NOT_IMPLEMENTED`, { signedUpdate, secretKey, bitcoin: bitcoin3 });
+  async broadcastSignal(signedUpdate, secretKey, bitcoin2) {
+    throw new SMTBeaconError("Method not implemented.", `METHOD_NOT_IMPLEMENTED`, { signedUpdate, secretKey, bitcoin: bitcoin2 });
   }
 };
 
@@ -70103,382 +70088,23 @@ init_shim();
 // ../bitcoin/dist/esm/client/rest/index.js
 init_shim();
 
-// ../bitcoin/dist/esm/constants.js
-init_shim();
-var TXIN_WITNESS_COINBASE = "0000000000000000000000000000000000000000000000000000000000000000";
-var GENESIS_TX_ID = "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b";
-var DEFAULT_BITCOIN_NETWORK_CONFIG = {
-  bitcoin: {
-    rpc: void 0,
-    rest: { host: "https://mempool.space/api" }
-  },
-  testnet3: {
-    rpc: void 0,
-    rest: { host: "https://mempool.space/testnet/api" }
-  },
-  testnet4: {
-    rpc: void 0,
-    rest: { host: "https://mempool.space/testnet4/api" }
-  },
-  signet: {
-    rpc: void 0,
-    rest: { host: "https://mempool.space/signet/api" }
-  },
-  mutinynet: {
-    rpc: void 0,
-    rest: { host: "https://mutinynet.com/api" }
-  },
-  regtest: {
-    rpc: {
-      network: "regtest",
-      host: "http://localhost:18443",
-      port: 18443,
-      username: "polaruser",
-      password: "polarpass",
-      allowDefaultWallet: true,
-      version: "28.1.0"
-    },
-    rest: { host: "http://localhost:3000" }
-  }
-};
-
 // ../bitcoin/dist/esm/client/rest/address.js
 init_shim();
-var BitcoinAddress = class {
-  api;
-  constructor(api) {
-    this.api = api;
-  }
-  /**
-   * Get transaction history for the specified address/scripthash, sorted with newest first.
-   * Returns up to 50 mempool transactions plus the first 25 confirmed transactions.
-   * See {@link https://github.com/blockstream/esplora/blob/master/API.md#get-addressaddresstxs | Esplora GET /address/:address/txs } for details.
-   * @param {string} addressOrScripthash The address or scripthash to check.
-   * @returns {Promise<Array<RawTransactionRest>>} A promise resolving to an array of {@link RawTransactionRest} objects.
-   */
-  async getTxs(addressOrScripthash) {
-    return await this.api({ path: `/address/${addressOrScripthash}/txs` });
-  }
-  /**
-   * Calls getAddressTxs and checks if any funds come back.
-   * Toggle if those funds are confirmed.
-   * @param {string} addressOrScripthash The address or scripthash to check.
-   * @returns {Promise<boolean>} True if the address has any funds, false otherwise.
-   */
-  async isFundedAddress(addressOrScripthash) {
-    const txs = await this.getConfirmedTxs(addressOrScripthash);
-    const confirmed = txs.filter((tx) => tx.status.confirmed);
-    return !!(confirmed && confirmed.length);
-  }
-  /**
-   * Get unconfirmed transaction history for the specified address/scripthash.
-   * Returns up to 50 transactions (no paging).
-   * @param {string} addressOrScripthash The address or scripthash to check.
-   * @returns {Promise<Array<RawTransactionRest>>} A promise resolving to an array of {@link RawTransactionRest} objects.
-   */
-  async getTxsMempool(addressOrScripthash) {
-    return await this.api({ path: `/address/${addressOrScripthash}/txs/mempool` });
-  }
-  /**
-   * Get information about an address/scripthash.
-   * Available fields: address/scripthash, chain_stats and mempool_stats.
-   * {chain,mempool}_stats each contain an object with tx_count, funded_txo_count, funded_txo_sum, spent_txo_count and spent_txo_sum.
-   * Elements-based chains don't have the {funded,spent}_txo_sum fields.
-   * @param {string} addressOrScripthash The address or scripthash to check.
-   * @returns {Promise<AddressInfo>} A promise resolving to an {@link AddressInfo} object.
-   */
-  async getInfo(addressOrScripthash) {
-    return await this.api({ path: `/address/${addressOrScripthash}` });
-  }
-  /**
-   * Get confirmed transaction history for the specified address/scripthash, sorted with newest first.
-   * Returns 25 transactions per page. More can be requested by specifying the last txid seen by the previous query.
-   * @param {string} addressOrScripthash The address or scripthash to check.
-   * @param lastSeenTxId The last transaction id seen by the previous query (optional).
-   * @returns {Promise<Array<RawTransactionRest>>} A promise resolving to an array of {@link RawTransactionRest} objects.
-   */
-  async getConfirmedTxs(addressOrScripthash, lastSeenTxId) {
-    return await this.api({
-      path: lastSeenTxId ? `/address/${addressOrScripthash}/txs/chain/${lastSeenTxId}` : `/address/${addressOrScripthash}/txs/chain`
-    });
-  }
-  /**
-   * Get the list of unspent transaction outputs associated with the address/scripthash.
-   * See {@link https://github.com/Blockstream/esplora/blob/master/API.md#get-addressaddressutxo | Esplora GET /address/:address/utxo } for details.
-   * @param {string} addressOrScripthash The address or scripthash to check.
-   * @returns {Promise<Array<RawTransactionRest>>} A promise resolving to an array of {@link RawTransactionRest} objects.
-   */
-  async getUtxos(addressOrScripthash) {
-    return await this.api({ path: `/address/${addressOrScripthash}/utxo` });
-  }
-};
 
 // ../bitcoin/dist/esm/client/rest/block.js
 init_shim();
 
 // ../bitcoin/dist/esm/errors.js
 init_shim();
-var BitcoinRpcError = class extends Error {
-  type;
-  code;
-  data;
-  constructor(type, code8, message2, data) {
-    super(message2);
-    this.type = type;
-    this.code = code8;
-    this.data = data;
-    this.name = "BitcoinRpcError";
-  }
-};
-var BitcoinRestError = class extends Error {
-  data;
-  constructor(message2, data) {
-    super(message2);
-    this.data = data;
-    this.name = "BitcoinRestError";
-  }
-};
-
-// ../bitcoin/dist/esm/client/rest/block.js
-var BitcoinBlock = class {
-  api;
-  constructor(api) {
-    this.api = api;
-  }
-  /**
-   * Returns the blockheight of the most-work fully-validated chain. The genesis block has height 0.
-   * @returns {Blockheight} The number of the blockheight with the most-work of the fully-validated chain.
-   */
-  async count() {
-    return await this.api({ path: "/blocks/tip/height" });
-  }
-  /**
-   * Returns the block data associated with a `blockhash` of a valid block.
-   * @param {GetBlockParams} params See {@link GetBlockParams} for details.
-   * @param {?string} params.blockhash The blockhash of the block to query.
-   * @param {?number} params.height The block height of the block to query.
-   * @returns {BlockResponse} A promise resolving to a {@link BlockResponse} formatted depending on `verbosity` level.
-   * @throws {BitcoinRpcError} If neither `blockhash` nor `height` is provided.
-   */
-  async get({ blockhash, height }) {
-    if (!blockhash && height === void 0) {
-      throw new BitcoinRestError("INVALID_PARAMS_GET_BLOCK: blockhash or height required", { blockhash, height });
-    }
-    blockhash ??= await this.getHash(height);
-    if (!blockhash || typeof blockhash !== "string") {
-      return void 0;
-    }
-    return await this.api({ path: `/block/${blockhash}` });
-  }
-  /**
-   * Get the block hash for a given block height.
-   * See {@link https://github.com/blockstream/esplora/blob/master/API.md#get-block-heightheight | Esplora GET /block-height/:height } for details.
-   * @param {number} height The block height (required).
-   * @returns {Promise<string>} The hash of the block currently at height..
-   */
-  async getHash(height) {
-    return await this.api({ path: `/block-height/${height}` });
-  }
-};
 
 // ../bitcoin/dist/esm/client/rest/transaction.js
 init_shim();
-var BitcoinTransaction = class {
-  api;
-  constructor(api) {
-    this.api = api;
-  }
-  /**
-   * Returns the transaction in JSON format.
-   * See {@link https://github.com/blockstream/esplora/blob/master/API.md#get-txtxid | Esplora GET /tx/:txid } for details.
-   * @param {string} txid The transaction id (required).
-   * @returns {GetRawTransaction} A promise resolving to data about a transaction in the form specified by verbosity.
-   */
-  async get(txid) {
-    return await this.api({ path: `/tx/${txid}` });
-  }
-  /**
-   * Returns the transaction in JSON format.
-   * See {@link https://github.com/blockstream/esplora/blob/master/API.md#get-txtxid | Esplora GET /tx/:txid } for details.
-   * @param {string} txid The transaction id (required).
-   * @returns {GetRawTransaction} A promise resolving to data about a transaction in the form specified by verbosity.
-   */
-  async isConfirmed(txid) {
-    const tx = await this.get(txid);
-    return tx.status.confirmed;
-  }
-  /**
-   * Returns the raw transaction in hex or as binary data.
-   * See {@link https://github.com/blockstream/esplora/blob/master/API.md#get-txtxidhex | Esplora GET /tx/:txid/hex } and
-   * {@link https://github.com/blockstream/esplora/blob/master/API.md#get-txtxidraw | Esplora GET /tx/:txid/raw } for details.
-   * @param {string} txid The transaction id (required).
-   * @returns {Promise<RawTransactionRest | string>} A promise resolving to the raw transaction in the specified format.
-   */
-  async getHex(txid) {
-    return await this.api({ path: `/tx/${txid}/hex` });
-  }
-  /**
-   * Returns the raw transaction in hex or as binary data.
-   * See {@link https://github.com/blockstream/esplora/blob/master/API.md#get-txtxidhex | Esplora GET /tx/:txid/hex } and
-   * {@link https://github.com/blockstream/esplora/blob/master/API.md#get-txtxidraw | Esplora GET /tx/:txid/raw } for details.
-   * @param {string} txid The transaction id (required).
-   * @returns {Promise<RawTransactionRest | string>} A promise resolving to the raw transaction in the specified format.
-   */
-  async getRaw(txid) {
-    return await this.api({ path: `/tx/${txid}/raw` });
-  }
-  /**
-   * Broadcast a raw transaction to the network. The transaction should be provided as hex in the request body. The txid
-   * will be returned on success.
-   * See {@link https://github.com/blockstream/esplora/blob/master/API.md#post-tx | Esplora POST /tx } for details.
-   * @param {string} tx The raw transaction in hex format (required).
-   * @returns {Promise<string>} The transaction id of the broadcasted transaction.
-   */
-  async send(tx) {
-    return await this.api({ path: "/tx", method: "POST", body: tx, headers: { "Content-Type": "text/plain" } });
-  }
-};
 
-// ../bitcoin/dist/esm/types.js
+// ../bitcoin/dist/esm/client/rest/protocol.js
 init_shim();
-var RestClientConfig = class {
-  host;
-  headers;
-  constructor({ host, headers }) {
-    this.host = host;
-    this.headers = headers;
-  }
-};
-var BitcoinRpcClientConfig = class {
-  network;
-  headers;
-  host;
-  logger;
-  password;
-  timeout;
-  username;
-  version;
-  wallet;
-  allowDefaultWallet;
-  constructor(options2 = {
-    headers: {},
-    host: "http://localhost",
-    logger: console,
-    password: "",
-    timeout: 3e4,
-    username: "",
-    version: "0.21.1",
-    wallet: "",
-    allowDefaultWallet: false
-  }) {
-    this.headers = options2.headers;
-    this.host = options2.host;
-    this.logger = options2.logger;
-    this.password = options2.password;
-    this.timeout = options2.timeout;
-    this.username = options2.username;
-    this.version = options2.version;
-    this.wallet = options2.wallet;
-    this.allowDefaultWallet = options2.allowDefaultWallet;
-  }
-};
-var VerbosityLevel;
-(function(VerbosityLevel2) {
-  VerbosityLevel2[VerbosityLevel2["hex"] = 0] = "hex";
-  VerbosityLevel2[VerbosityLevel2["json"] = 1] = "json";
-  VerbosityLevel2[VerbosityLevel2["jsonext"] = 2] = "jsonext";
-  VerbosityLevel2[VerbosityLevel2["jsonextprev"] = 3] = "jsonextprev";
-})(VerbosityLevel || (VerbosityLevel = {}));
 
-// ../bitcoin/dist/esm/client/rest/index.js
-var BitcoinRestClient = class _BitcoinRestClient {
-  /**
-   * The encapsulated {@link RestClientConfig} object.
-   * @private
-   * @type {RestClientConfig}
-   */
-  _config;
-  /**
-   * The api calls related to bitcoin transactions.
-   * @type {BitcoinTransaction}
-   */
-  transaction;
-  /**
-   * The api calls related to bitcoin blocks.
-   * @type {BitcoinBlock}
-   */
-  block;
-  /**
-   * The api calls related to bitcoin addresses.
-   * @type {BitcoinAddress}
-   */
-  address;
-  /**
-   * The API call method that can be used to make requests to the REST API.
-   * @returns {Promise<any>} A promise resolving to the response data.
-   */
-  api = this.call;
-  constructor(config) {
-    this._config = new RestClientConfig(config);
-    this.api = this.call.bind(this);
-    this.transaction = new BitcoinTransaction(this.api);
-    this.block = new BitcoinBlock(this.api);
-    this.address = new BitcoinAddress(this.api);
-  }
-  /**
-   * Get the configuration object.
-   * @private
-   */
-  get config() {
-    const config = this._config;
-    return config;
-  }
-  /**
-   * Static method connects to a bitcoin node running a esplora REST API.
-   *
-   * @param {RestClientConfig} config The configuration object for the client (optional).
-   * @returns {BitcoinRestClient} A new {@link BitcoinRestClient} instance.
-   * @example
-   * ```
-   * const rest = BitcoinRestClient.connect();
-   * ```
-   */
-  static connect(config) {
-    return new _BitcoinRestClient(config ?? DEFAULT_BITCOIN_NETWORK_CONFIG.regtest.rest);
-  }
-  /**
-   * Make a REST API call to the configured Bitcoin node.
-   * @private
-   * @param {RestApiCallParams} params The parameters for the API call. See {@link RestApiCallParams} for details.
-   * @param {string} [params.path] The path to the API endpoint (required).
-   * @param {string} [params.url] The full URL to the API endpoint (optional).
-   * @param {string} [params.method] The HTTP method to use (default is 'GET').
-   * @param {any} [params.body] The body of the request (optional).
-   * @param {any} [params.headers] Additional headers to include in the request (optional).
-   * @returns {Promise<any>} A promise resolving to the response data.
-   */
-  async call({ path, url, method, body, headers }) {
-    url ??= `${StringUtils.replaceEnd(this.config.host, "/")}${path}`;
-    method ??= "GET";
-    const requestInit = {
-      method,
-      headers: headers ?? {
-        "Content-Type": "application/json",
-        ...this.config.headers
-      }
-    };
-    if (body) {
-      requestInit.body = JSONUtils.isObject(body) ? JSON.stringify(body) : body;
-      requestInit.method = "POST";
-    }
-    const response2 = await fetch(url, requestInit);
-    const data = (response2.headers.get("Content-Type") ?? "json") === "text/plain" ? await response2.text() : await response2.json();
-    if (!response2.ok) {
-      throw new MethodError(`Request to ${url} failed: ${response2.status} - ${response2.statusText}`, "FAILED_HTTP_REQUEST", { data, response: response2 });
-    }
-    return data;
-  }
-};
+// ../bitcoin/dist/esm/client/http.js
+init_shim();
 
 // ../bitcoin/dist/esm/client/rpc/index.js
 init_shim();
@@ -70488,506 +70114,9 @@ init_shim();
 
 // ../bitcoin/dist/esm/client/utils.js
 init_shim();
-function toBase642(s2) {
-  if (typeof import_buffer.Buffer !== "undefined")
-    return import_buffer.Buffer.from(s2, "utf8").toString("base64");
-  if (typeof btoa !== "undefined")
-    return btoa(s2);
-  throw new Error("No base64 encoder available");
-}
-async function safeText(res) {
-  try {
-    return await res.text();
-  } catch {
-    return "";
-  }
-}
 
-// ../bitcoin/dist/esm/client/rpc/json-rpc.js
-var JsonRpcTransport = class {
-  url;
-  authHeader;
-  id = 0;
-  constructor(cfg) {
-    this.url = (cfg.host || "http://127.0.0.1:8332").replace(/\/+$/, "");
-    if (cfg.username && cfg.password) {
-      this.authHeader = `Basic ${toBase642(`${cfg.username}:${cfg.password}`)}`;
-    } else {
-      try {
-        const u = new URL(this.url);
-        if (u.username || u.password) {
-          this.authHeader = `Basic ${toBase642(`${decodeURIComponent(u.username)}:${decodeURIComponent(u.password)}`)}`;
-          u.username = "";
-          u.password = "";
-          this.url = u.toString().replace(/\/+$/, "");
-        }
-      } catch (error) {
-        console.error(`Invalid URL in Bitcoin RPC config: ${this.url}`, error);
-      }
-    }
-  }
-  /**
-   * Make a JSON-RPC call or batch of calls to the Bitcoin node.
-   * @param {BatchOption[] | { method: string; parameters?: any[] }} batch A single RPC call or an array of calls to be made.
-   * @returns {Promise<any[] | any>} The result of the RPC call(s).
-   * @example
-   */
-  async command(batch) {
-    if (Array.isArray(batch)) {
-      const out = [];
-      for (const item of batch) {
-        out.push(await this.call(item.method, item.parameters ?? []));
-      }
-      return out;
-    } else {
-      return this.call(batch.method, batch.parameters ?? []);
-    }
-  }
-  /**
-   * Internal method to perform the actual JSON-RPC call.
-   * @param {string} method The RPC method to call.
-   * @param {any[]} params The parameters for the RPC method.
-   * @returns {Promise<any>} The result of the RPC call.
-   */
-  async call(method, params) {
-    const body = { jsonrpc: "2.0", id: ++this.id, method, params };
-    const res = await fetch(this.url, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        ...this.authHeader ? { Authorization: this.authHeader } : {}
-      },
-      body: JSON.stringify(body)
-    });
-    if (!res.ok) {
-      const text = await safeText(res);
-      const err2 = new Error(text || `${res.status} ${res.statusText}`);
-      err2.code = res.status;
-      err2.rpc = true;
-      throw err2;
-    }
-    const payload = await res.json();
-    if (payload.error) {
-      const err2 = new Error(payload.error.message);
-      err2.code = payload.error.code;
-      err2.rpc = true;
-      throw err2;
-    }
-    return payload.result;
-  }
-};
-
-// ../bitcoin/dist/esm/client/rpc/index.js
-var BitcoinCoreRpcClient = class _BitcoinCoreRpcClient {
-  /**
-   * The singleton instance of the BitcoinCoreRpcClient.
-   * @type {BitcoinCoreRpcClient}
-   * @private
-   */
-  static #instance;
-  /**
-   * The JSON-RPC transport layer.
-   * @type {JsonRpcTransport}
-   * @private
-   */
-  #transport;
-  /**
-   * The configuration for the RPC client.
-   * @type {RpcClientConfig}
-   * @private
-   */
-  #config;
-  /**
-   * Constructs a new {@link BitcoinCoreRpcClient} instance from a new {@link RpcClient | RpcClient}.
-   * @param {RpcClientConfig} config The bitcoin-core client instance.
-   * @example
-   * ```
-   *  import BitcoinRpcClient from '@did-btcr2/method';
-   *  const bob = BitcoinRpcClient.connect(); // To use default polar config, pass no args. Polar must run locally.
-   * ```
-   */
-  constructor(config) {
-    this.#config = new BitcoinRpcClientConfig(config);
-    this.#transport = new JsonRpcTransport(this.#config);
-  }
-  /**
-   * Get the config for the current BitcoinRpcClient object.
-   * @returns {BitcoinRpcClient} The encapsulated {@link BitcoinRpcClient} object.
-   * @example
-   * ```
-   *  import BitcoinRpcClient from '@did-btcr2/method';
-   *  const alice = BitcoinRpcClient.connect();
-   *  const config = alice.config;
-   * ```
-   */
-  get config() {
-    const config = this.#config;
-    return config;
-  }
-  /**
-   * Get the client for the current BitcoinRpcClient object.
-   * @returns {RpcClient} The encapsulated {@link RpcClient} object.
-   * @example
-   * ```
-   * const alice = BitcoinRpcClient.connect();
-   * const config = alice.client;
-   * ```
-   */
-  get client() {
-    const client = this.#transport;
-    return client;
-  }
-  /**
-   * Static method initializes a static instance of BitcoinCoreRpcClient with the given configuration.
-   * The RpcClient returned by this method does not have any named methods.
-   * Use this method to create and pass a new RpcClient instance to a BitcoinCoreRpcClient constructor.
-   *
-   * @param {RpcClientConfig} config The configuration object for the client (optional).
-   * @returns {BitcoinCoreRpcClient} A new RpcClient instance.
-   * @example
-   * ```
-   * const options: RpcClientConfig = {
-   *     host: 'http://localhost:18443',
-   *     username: 'alice',
-   *     password: 'alicepass',
-   *     version: '28.1.0',
-   * }
-   * const alice = BitcoinCoreRpcClient.initialize(options); // Client config required
-   * ```
-   */
-  static initialize(config) {
-    const cfg = new BitcoinRpcClientConfig(config);
-    _BitcoinCoreRpcClient.#instance = new _BitcoinCoreRpcClient(cfg);
-    return _BitcoinCoreRpcClient.#instance;
-  }
-  /**
-   * Static method connects to a bitcoin node running the bitcoin core daemon (bitcoind).
-   * To use default polar config, do not pass a config. See {@link DEFAULT_BITCOIN_NETWORK_CONFIG} for default config.
-   * @required A locally running {@link https://github.com/jamaljsr/polar | Polar Lightning} regtest node.
-   *
-   * @param {?RpcClientConfig} config The configuration object for the client (optional).
-   * @returns A new {@link BitcoinRpcClient} instance.
-   * @example
-   * ```
-   * const alice = BitcoinRpcClient.connect();
-   * ```
-   */
-  static connect(config) {
-    return new _BitcoinCoreRpcClient(config ?? DEFAULT_BITCOIN_NETWORK_CONFIG.regtest.rpc);
-  }
-  /**
-   * Check if the given error is a JSON-RPC error.
-   * @param {unknown} e The error to check.
-   * @returns {boolean} True if the error is a JSON-RPC error, false otherwise.
-   */
-  isJsonRpcError(e2) {
-    return e2 instanceof Error && e2.name === "RpcError" && typeof e2.code === "number";
-  }
-  /**
-   * Executes a JSON-RPC command on the bitcoind node.
-   * @param {MethodNameInLowerCase} method The name of the method to call.
-   * @param {Array<any>} parameters The parameters to pass to the method.
-   * @returns {Promise<T>} A promise resolving to the result of the command.
-   */
-  async executeRpc(method, parameters = []) {
-    try {
-      const raw = await this.client.command([{ method, parameters }]);
-      const normalized = JSONUtils.isUnprototyped(raw) ? JSONUtils.normalize(raw) : raw;
-      const result = Array.isArray(normalized) ? normalized[normalized.length - 1] : normalized;
-      return result;
-    } catch (err2) {
-      this.handleError(err2, method, parameters);
-    }
-  }
-  /**
-   *
-   * Map JSON-RPC error codes to HTTP status codes.
-   * @param {number | undefined} code The JSON-RPC error code.
-   * @returns {number} The corresponding HTTP status code.
-   *
-   * | Error type                     | HTTP code           |
-   * | -------------------------------| --------------------|
-   * | Valid JSON-RPC failure         | **400 / 404 / 422** |
-   * | JSON-RPC authentication issues | **401 / 403**       |
-   * | Upstream bitcoind unreachable  | **502**             |
-   * | Upstream timeout               | **504**             |
-   * | Network transient errors       | **503**             |
-   * | Unknown unexpected errors      | **500**             |
-   */
-  mapRpcCodeToHttp(code8) {
-    switch (code8) {
-      case -32700:
-      case -32600:
-      case -32602:
-        return 400;
-      case -32601:
-        return 404;
-      default:
-        return 422;
-    }
-  }
-  /**
-   * Handle errors that occur while executing commands.
-   * @param methods An array of {@link BatchOption} objects.
-   * @param error The error that was thrown.
-   * @throws Throws a {@link BitcoinRpcError} with the error message.
-   */
-  handleError(err2, method, params) {
-    if (this.isJsonRpcError(err2)) {
-      throw new BitcoinRpcError(err2.name.toUpperCase(), this.mapRpcCodeToHttp(err2.code), `RPC ${method} failed: ${err2.message}`, { method, params });
-    }
-    throw new BitcoinRpcError("UNKNOWN_ERROR", 500, `Unknown failure in ${method}`, { method, params, err: err2 });
-  }
-  /**
-   * Returns the block data associated with a `blockhash` of a valid block.
-   * @param {GetBlockParams} params See {@link GetBlockParams} for details.
-   * @param {?string} params.blockhash The blockhash of the block to query.
-   * @param {?number} params.height The block height of the block to query.
-   * @param {?VerbosityLevel} params.verbosity The verbosity level. See {@link VerbosityLevel}.
-   * @returns {BlockResponse} A promise resolving to a {@link BlockResponse} formatted depending on `verbosity` level.
-   * @throws {BitcoinRpcError} If neither `blockhash` nor `height` is provided.
-   */
-  async getBlock({ blockhash, height, verbosity }) {
-    if (!blockhash && height === void 0) {
-      throw new BitcoinRpcError("INVALID_PARAMS_GET_BLOCK", 400, "blockhash or height required", { blockhash, height });
-    }
-    blockhash ??= await this.getBlockHash(height);
-    if (!blockhash || typeof blockhash !== "string") {
-      return void 0;
-    }
-    const block = await this.executeRpc("getblock", [blockhash, verbosity ?? 3]);
-    switch (verbosity) {
-      case 0:
-        return block;
-      case 1:
-        return block;
-      case 2:
-        return block;
-      case 3:
-        return block;
-      default:
-        return block;
-    }
-  }
-  /**
-   * Returns the blockheight of the most-work fully-validated chain. The genesis block has height 0.
-   * @returns {Blockheight} The number of the blockheight with the most-work of the fully-validated chain.
-   */
-  async getBlockCount() {
-    return await this.executeRpc("getblockcount");
-  }
-  /**
-   * Returns the blockhash of the block at the given height in the active chain.
-   */
-  async getBlockHash(height) {
-    return await this.executeRpc("getblockhash", [height]);
-  }
-  /**
-   * Returns an object containing various blockchain state info.
-   */
-  async getBlockchainInfo() {
-    return this.executeRpc("getblockchaininfo");
-  }
-  /**
-   * Sign inputs for raw transaction (serialized, hex-encoded).
-   * The second optional argument (may be null) is an array of previous transaction outputs that
-   * this transaction depends on but may not yet be in the block chain.
-   * Requires wallet passphrase to be set with walletpassphrase call if wallet is encrypted.
-   * @param {string} hexstring The hex-encoded transaction to send.
-   */
-  async signRawTransaction(hexstring) {
-    return await this.executeRpc("signrawtransactionwithwallet", [hexstring]);
-  }
-  /**
-   * Submit a raw transaction (serialized, hex-encoded) to local node and network.
-   *
-   * The transaction will be sent unconditionally to all peers, so using sendrawtransaction
-   * for manual rebroadcast may degrade privacy by leaking the transaction's origin, as
-   * nodes will normally not rebroadcast non-wallet transactions already in their mempool.
-   *
-   * @param {string} hexstring The hex-encoded transaction to send.
-   * @param {numbner} [maxfeerate] If not passed, default is 0.10.
-   * @returns {Promise<string>} A promise resolving to the transaction hash in hex.
-   */
-  async sendRawTransaction(hexstring, maxfeerate, maxBurnAmount) {
-    return await this.executeRpc("sendrawtransaction", [hexstring, maxfeerate ?? 0.1, maxBurnAmount ?? 0]);
-  }
-  /**
-   * Combines calls to `signRawTransaction` and `sendRawTransaction`.
-   * @param {string} params.hexstring The hex-encoded transaction to send.
-   * @returns {Promise<string>} A promise resolving to the transaction hash in hex.
-   */
-  async signAndSendRawTransaction(hexstring) {
-    const signedRawTx = await this.signRawTransaction(hexstring);
-    return await this.sendRawTransaction(signedRawTx.hex);
-  }
-  /**
-   * Combines calls to `createRawTransaction`, `signRawTransaction` and `sendRawTransaction`.
-   * @param {CreateRawTxInputs[]} inputs The inputs to the transaction (required).
-   * @param {CreateRawTxOutputs[]} outputs The outputs of the transaction (required).
-   * @returns {Promise<string>} A promise resolving to the transaction hash in hex.
-   */
-  async createSignSendRawTransaction(inputs2, outputs2) {
-    const rawTx = await this.createRawTransaction(inputs2, outputs2);
-    const signedRawTx = await this.signRawTransaction(rawTx);
-    const sentRawTx = await this.sendRawTransaction(signedRawTx.hex);
-    return sentRawTx;
-  }
-  /**
-   * Returns up to 'count' most recent transactions skipping the first 'from' transactions for account 'label'.
-   * @param {ListTransactionsParams} params The parameters for the listTransactions command.
-   * @returns {Promise<ListTransactionsResult>} A promise resolving to a {@link ListTransactionsResult} object.
-   */
-  async listTransactions(params) {
-    return await this.executeRpc("listtransactions", [params]);
-  }
-  /**
-   * Create a transaction spending the given inputs and creating new outputs.
-   * Outputs can be addresses or data.
-   * Returns hex-encoded raw transaction.
-   * Note that the transaction's inputs are not signed, and
-   * it is not stored in the wallet or transmitted to the network.
-   * @param {TxInForCreateRaw[]} inputs The inputs to the transaction (required).
-   * @param {CreateRawTxOutputs[]} outputs The outputs of the transaction (required).
-   * @param {number} [locktime] The locktime of the transaction (optional).
-   * @param {boolean} [replacable] Whether the transaction is replaceable (optional).
-   * @returns {string} The hex-encoded raw transaction.
-   */
-  async createRawTransaction(inputs2, outputs2, locktime, replacable) {
-    return await this.executeRpc("createrawtransaction", [inputs2, outputs2, locktime, replacable]);
-  }
-  /**
-   * Derives one or more addresses corresponding to an output descriptor.
-   * Examples of output descriptors are:
-   *   pkh(<pubkey>)                                     P2PKH outputs for the given pubkey
-   *   wpkh(<pubkey>)                                    Native segwit P2PKH outputs for the given pubkey
-   *   sh(multi(<n>,<pubkey>,<pubkey>,...))              P2SH-multisig outputs for the given threshold and pubkeys
-   *   raw(<hex script>)                                 Outputs whose output script equals the specified hex-encoded bytes
-   *   tr(<pubkey>,multi_a(<n>,<pubkey>,<pubkey>,...))   P2TR-multisig outputs for the given threshold and pubkeys
-   *
-   * In the above, <pubkey> either refers to a fixed public key in hexadecimal notation, or to an xpub/xprv optionally followed by one
-   * or more path elements separated by "/", where "h" represents a hardened child key.
-   *
-   * See {@link https://github.com/bitcoin/bitcoin/blob/master/doc/descriptors.md | github.com/bitcoin/bitcoin/descriptors.md}
-   * for more information.
-   * @param {string} descriptor The descriptor.
-   * @param {Array<number>} range If descriptor is ranged, must specify end or [begin,end] to derive.
-   * @returns {Array<DerivedAddresses>} a list of derived addresses
-   * @example First three native segwit receive addresses
-   * ```
-   * const bitcoind = BitcoinRpcClient.connect()
-   * const addresses = bitcoind.deriveAddresses("wpkh([d34db33f/84h/0h/0h]xpub6DJ2dN.../0/*)#cjjspncu", [0,2])
-   * ```
-   */
-  async deriveAddresses(descriptor, range5) {
-    return await this.executeRpc("deriveaddresses", [descriptor, range5]);
-  }
-  /**
-   * Returns the total available balance. The available balance is what the wallet
-   * considers currently spendable, and is thus affected by options which limit
-   * spendability such as -spendzeroconfchange.
-   * @returns {Promise<number>} A promise resolving to the total available balance in BTC.
-   */
-  async getBalance() {
-    return await this.executeRpc("getbalance");
-  }
-  /**
-   * Returns a new Bitcoin address for receiving payments. If 'label' is specified,
-   * it is added to the address book so payments received with the address will be associated with 'label'.
-   * The 'address_type' can be one of "legacy", "p2sh-segwit", "bech32", or "bech32m".
-   * @param {string} addressType The address type to use (required, options=["legacy", "p2sh-segwit", "bech32", "bech32m"], default="bech32").
-   * @param {string} [label] The label to associate with the new address (optional).
-   * @returns {Promise<string>} A promise resolving to the new address.
-   */
-  async getNewAddress(addressType, label) {
-    return await this.executeRpc("getnewaddress", [label ?? "", addressType]);
-  }
-  /**
-   * Returns array of unspent transaction outputs with between minconf and maxconf (inclusive) confirmations.
-   * Optionally filter to only include txouts paid to specified addresses.
-   * @param {Object} params The parameters for the listUnspent command.
-   * @param {number} [params.minconf=0] The minimum number of confirmations an output must have to be included.
-   * @param {number} [params.maxconf=9999999] The maximum number of confirmations an output can have to be included.
-   * @param {string[]} [params.address] Only include outputs paid to these addresses.
-   * @param {boolean} [params.include_unsafe=true] Whether to include outputs that are not safe to spend.
-   * @returns {Promise<UnspentTxInfo[]>} A promise resolving to an array of {@link UnspentTxInfo} objects.
-   */
-  async listUnspent(params) {
-    const args = { minconf: 0, maxconf: 9999999, include_unsafe: true, ...params };
-    return await this.executeRpc("listunspent", [args]);
-  }
-  /**
-   * Send an amount to a given address.
-   * @param {string} address The address to send to.
-   * @param {number} amount The amount to send in BTC.
-   * @returns {Promise<SendToAddressResult>} A promise resolving to the transaction id.
-   */
-  async sendToAddress(address, amount) {
-    const txid = await this.executeRpc("sendtoaddress", [address, amount]);
-    return await this.getRawTransaction(txid);
-  }
-  /**
-   * Sign a message with the private key of an address.
-   * @param {string} address The address to sign the message with.
-   * @param {string} message The message to sign.
-   * @returns {Promise<string>} A promise resolving to the signature in base64.
-   */
-  async signMessage(address, message2) {
-    return await this.executeRpc("signmessage", [address, message2]);
-  }
-  /**
-   * Verify a signed message.
-   * @param {string} address The address to verify the message with.
-   * @param {string} signature The signature to verify in base64.
-   * @param {string} message The message to verify.
-   * @returns {Promise<boolean>} A promise resolving to true if the signature is valid, false otherwise.
-   */
-  async verifyMessage(address, signature2, message2) {
-    return await this.executeRpc("verifymessage", [address, signature2, message2]);
-  }
-  /**
-   * Get detailed information about in-wallet transaction <txid>.
-   * @param txid: The transaction id. (string, required)
-   * @param {boolean} include_watchonly Whether to include watch-only addresses in balance calculation and details.
-   * @returns {WalletTransaction} A promise resolving to a {@link WalletTransaction} object.
-   */
-  async getTransaction(txid, include_watchonly) {
-    return await this.executeRpc("gettransaction", [txid, include_watchonly]);
-  }
-  /**
-   * Get detailed information about a transaction.
-   * By default, this call only returns a transaction if it is in the mempool. If -txindex is enabled
-   * and no blockhash argument is passed, it will return the transaction if it is in the mempool or any block.
-   * If a blockhash argument is passed, it will return the transaction if the specified block is available and
-   * the transaction is in that block.
-   * @param {string} txid The transaction id (required).
-   * @param {?VerbosityLevel} verbosity Response format: 0 (hex), 1 (json) or 2 (jsonext).
-   * @param {?string} blockhash The block in which to look for the transaction (optional).
-   * @returns {GetRawTransaction} A promise resolving to data about a transaction in the form specified by verbosity.
-   */
-  async getRawTransaction(txid, verbosity, blockhash) {
-    const rawTransaction = await this.executeRpc("getrawtransaction", [txid, verbosity ?? 2, blockhash]);
-    switch (verbosity) {
-      case 0:
-        return rawTransaction;
-      case 1:
-        return rawTransaction;
-      case 2:
-        return rawTransaction;
-      default:
-        return rawTransaction;
-    }
-  }
-  /**
-   * Get detailed information about multiple transactions. An extension of {@link getRawTransaction}.
-   * @param {Array<string>} txids An array of transaction ids.
-   * @param {?VerbosityLevel} verbosity Response format: 0 (hex), 1 (json) or 2 (jsonext).
-   * @returns {Promise<Array<RawTransactionResponse>>}
-   */
-  async getRawTransactions(txids, verbosity) {
-    return await Promise.all(txids.map(async (txid) => await this.getRawTransaction(txid, verbosity ?? 2)));
-  }
-};
+// ../bitcoin/dist/esm/client/rpc/protocol.js
+init_shim();
 
 // ../bitcoin/dist/esm/network.js
 init_shim();
@@ -71007,97 +70136,20 @@ function getNetwork(network) {
   }
 }
 
-// ../bitcoin/dist/esm/bitcoin.js
-var BitcoinNetworkConnection = class {
-  network;
-  bitcoin;
-  testnet3;
-  testnet4;
-  signet;
-  mutinynet;
-  regtest;
-  /**
-   * Creates an instance of the Bitcoin class.
-   * @param {BitcoinNetworkConfigMap} configs Optional configuration object for the Bitcoin client. If not provided, it will
-   * be loaded from the BITCOIN_CLIENT_CONFIG environment variables.
-   * @throws {MethodError} If no configs is passed and BITCOIN_NETWORK_CONFIG is missing or invalid.
-   */
-  constructor(configs) {
-    const BITCOIN_NETWORK_CONFIG = import_process.default.env.BITCOIN_NETWORK_CONFIG ?? JSON.stringify(configs ?? DEFAULT_BITCOIN_NETWORK_CONFIG);
-    if (!BITCOIN_NETWORK_CONFIG) {
-      throw new MethodError("No BITCOIN_NETWORK_CONFIG available: must pass `configs` to constructor or set `BITCOIN_NETWORK_CONFIG` in env", "MISSING_BITCOIN_NETWORK_CONFIG", { BITCOIN_NETWORK_CONFIG });
-    }
-    if (!JSONUtils.isParsable(BITCOIN_NETWORK_CONFIG)) {
-      throw new MethodError("Parsing failed: malformed BITCOIN_NETWORK_CONFIG", "MISSING_MALFORMED_BITCOIN_NETWORK_CONFIG", { BITCOIN_NETWORK_CONFIG });
-    }
-    const networkConfigs = JSON.parse(BITCOIN_NETWORK_CONFIG);
-    const networks2 = ["bitcoin", "testnet3", "testnet4", "signet", "mutinynet", "regtest"];
-    for (const network of networks2) {
-      const networkConfig = configs?.[network] ?? networkConfigs[network];
-      if (networkConfig) {
-        this[network] = {
-          name: network,
-          config: networkConfig,
-          rpc: new BitcoinCoreRpcClient(networkConfig.rpc),
-          rest: new BitcoinRestClient(networkConfig.rest),
-          data: getNetwork(network)
-        };
-      }
-    }
-    const ACTIVE_NETWORK = import_process.default.env.ACTIVE_NETWORK?.toLowerCase() ?? "regtest";
-    if (!ACTIVE_NETWORK) {
-      throw new MethodError("Missing ACTIVE_NETWORK environment variable", "MISSING_ACTIVE_NETWORK", { ACTIVE_NETWORK });
-    }
-    if (!this[ACTIVE_NETWORK]) {
-      throw new MethodError(`No configuration found for ACTIVE_NETWORK='${ACTIVE_NETWORK}'`, "MISSING_CONFIG_FOR_NETWORK");
-    }
-    this.network = this[ACTIVE_NETWORK];
-  }
-  /**
-   * Get the Bitcoin network configuration for a specific network.
-   * @param {keyof AvailableNetworks} network - The Bitcoin network (e.g., 'bitcoin', 'testnet3', 'signet', 'regtest').
-   * @returns {Bitcoin} The Bitcoin object.
-   */
-  getNetworkConnection(network) {
-    const availableNetwork = network;
-    if (!this[availableNetwork]) {
-      throw new MethodError(`No configuration found for network='${availableNetwork}'`, "MISSING_CONFIG_FOR_NETWORK");
-    }
-    return this;
-  }
-  /**
-   * Sets the active Bitcoin network.
-   * @param {keyof AvailableNetworks} active - The Bitcoin network to set as active (e.g., 'bitcoin', 'testnet3', 'signet', 'regtest').
-   * @throws {MethodError} If no configuration is found for the specified network.
-   */
-  setActiveNetwork(active) {
-    const availableNetwork = active;
-    if (!this[availableNetwork]) {
-      throw new MethodError(`No configuration found for network='${availableNetwork}'`, "MISSING_CONFIG_FOR_NETWORK");
-    }
-    this.network = this[availableNetwork];
-  }
-  /**
-   * Converts Bitcoin (BTC) to satoshis (SAT).
-   * @param {number} btc - The amount in BTC.
-   * @returns {number} The amount in SAT.
-   */
-  static btcToSats(btc) {
-    return Math.round(btc * 1e8);
-  }
-  /**
-   * Converts satoshis (SAT) to Bitcoin (BTC).
-   * @param {number} sats - The amount in SAT.
-   * @returns {number} The amount in BTC.
-   */
-  static satsToBtc(sats) {
-    return sats / 1e8;
-  }
-};
-var bitcoin2 = new BitcoinNetworkConnection();
+// ../bitcoin/dist/esm/constants.js
+init_shim();
+var TXIN_WITNESS_COINBASE = "0000000000000000000000000000000000000000000000000000000000000000";
+var GENESIS_TX_ID = "4a5e1e4baab89f3a32518a88c31bc87f618f76673e2cc77ab2127b7afdeda33b";
 
-// ../bitcoin/dist/esm/client/rpc/interface.js
+// ../bitcoin/dist/esm/types.js
 init_shim();
+var VerbosityLevel;
+(function(VerbosityLevel2) {
+  VerbosityLevel2[VerbosityLevel2["hex"] = 0] = "hex";
+  VerbosityLevel2[VerbosityLevel2["json"] = 1] = "json";
+  VerbosityLevel2[VerbosityLevel2["jsonext"] = 2] = "jsonext";
+  VerbosityLevel2[VerbosityLevel2["jsonextprev"] = 3] = "jsonextprev";
+})(VerbosityLevel || (VerbosityLevel = {}));
 
 // src/core/beacon/utils.ts
 init_shim();
@@ -71863,40 +70915,6 @@ var base256emoji = from({
   decode: decode25
 });
 
-// ../../node_modules/.pnpm/multiformats@13.4.1/node_modules/multiformats/dist/src/bases/base64.js
-var base64_exports = {};
-__export(base64_exports, {
-  base64: () => base642,
-  base64pad: () => base64pad,
-  base64url: () => base64url2,
-  base64urlpad: () => base64urlpad
-});
-init_shim();
-var base642 = rfc4648({
-  prefix: "m",
-  name: "base64",
-  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
-  bitsPerChar: 6
-});
-var base64pad = rfc4648({
-  prefix: "M",
-  name: "base64pad",
-  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
-  bitsPerChar: 6
-});
-var base64url2 = rfc4648({
-  prefix: "u",
-  name: "base64url",
-  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
-  bitsPerChar: 6
-});
-var base64urlpad = rfc4648({
-  prefix: "U",
-  name: "base64urlpad",
-  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=",
-  bitsPerChar: 6
-});
-
 // ../../node_modules/.pnpm/multiformats@13.4.1/node_modules/multiformats/dist/src/bases/base8.js
 var base8_exports = {};
 __export(base8_exports, {
@@ -73775,7 +72793,7 @@ var __awaiter2 = function(thisArg, _arguments, P3, generator) {
     step((generator = generator.apply(thisArg, _arguments || [])).next());
   });
 };
-var MemoryStore2 = class {
+var MemoryStore = class {
   constructor() {
     this.store = /* @__PURE__ */ new Map();
   }
@@ -79728,7 +78746,7 @@ var LocalKeyManager = class {
   constructor(params) {
     var _a3;
     this._algorithmInstances = /* @__PURE__ */ new Map();
-    this._keyStore = (_a3 = params === null || params === void 0 ? void 0 : params.keyStore) !== null && _a3 !== void 0 ? _a3 : new MemoryStore2();
+    this._keyStore = (_a3 = params === null || params === void 0 ? void 0 : params.keyStore) !== null && _a3 !== void 0 ? _a3 : new MemoryStore();
   }
   /**
    * Generates a hash digest of the provided data.
@@ -87926,7 +86944,7 @@ src_default.formatters.t = (v) => {
   return v == null ? "undefined" : base322.baseEncode(v);
 };
 src_default.formatters.m = (v) => {
-  return v == null ? "undefined" : base642.baseEncode(v);
+  return v == null ? "undefined" : base64.baseEncode(v);
 };
 src_default.formatters.p = (v) => {
   return v == null ? "undefined" : v.toString();
@@ -93804,7 +92822,7 @@ function cidEncoder2(obj) {
   ];
 }
 function bytesEncoder(bytes6) {
-  const bytesString = base642.encode(bytes6).slice(1);
+  const bytesString = base64.encode(bytes6).slice(1);
   return [
     new Token(Type.map, Infinity, 1),
     new Token(Type.string, "/", 1),
@@ -93912,7 +92930,7 @@ var DagJsonTokenizer = class extends Tokenizer {
                   throw new Error("Invalid encoded Bytes form");
                 }
               }
-              const bytes6 = base642.decode(`m${innerValueToken.value}`);
+              const bytes6 = base64.decode(`m${innerValueToken.value}`);
               return new Token(Type.bytes, bytes6, innerValueToken.value.length);
             }
             this.tokenBuffer.push(innerValueToken);
@@ -99490,7 +98508,7 @@ function pbkdf22(password, salt, iterations, keySize, hash4) {
     c: iterations,
     dkLen: keySize
   });
-  return base642.encode(dek).substring(1);
+  return base64.encode(dek).substring(1);
 }
 
 // ../../node_modules/.pnpm/@libp2p+utils@6.7.2/node_modules/@libp2p/utils/dist/src/filters/hashes.js
@@ -99902,7 +98920,7 @@ var AbstractSession = class extends TypedEventEmitter {
     this.initialProviders = init.providers ?? [];
   }
   async retrieve(cid, options2 = {}) {
-    const cidStr = base642.encode(cid.multihash.bytes);
+    const cidStr = base64.encode(cid.multihash.bytes);
     const existingJob = this.requests.get(cidStr);
     if (existingJob != null) {
       this.log("join existing request for %c", cid);
@@ -101764,15 +100782,15 @@ var QueuedBitswapMessage = class {
     this.pendingBytes = 0;
   }
   addWantlistEntry(cid, entry) {
-    const key = base642.encode(cid.multihash.bytes);
+    const key = base64.encode(cid.multihash.bytes);
     this.wantlist.set(key, entry);
   }
   addBlockPresence(cid, blockPresence) {
-    const key = base642.encode(cid.multihash.bytes);
+    const key = base64.encode(cid.multihash.bytes);
     this.blockPresences.set(key, blockPresence);
   }
   addBlock(cid, block) {
-    const key = base642.encode(cid.multihash.bytes);
+    const key = base64.encode(cid.multihash.bytes);
     this.blocks.set(key, block);
   }
 };
@@ -103327,7 +102345,7 @@ var codecs = [{
   code: CODE_CERTHASH,
   name: "certhash",
   size: V,
-  bytesToValue: bytes2mb(base64url2),
+  bytesToValue: bytes2mb(base64url),
   valueToBytes: mb2bytes
 }, {
   code: CODE_HTTP,
@@ -104633,7 +103651,7 @@ var TrustlessGateway = class {
    */
   #uniqueBlockId(cid) {
     const multihashBytes = cid.multihash.bytes;
-    return base642.encode(multihashBytes);
+    return base64.encode(multihashBytes);
   }
   /**
    * Fetch a raw block from `this.url` following the specification defined at
@@ -116401,7 +115419,7 @@ var ITERATIONS = 1e4;
 async function exporter(privateKey, password) {
   const cipher = aes_gcm_browser_exports.create();
   const encryptedKey = await cipher.encrypt(privateKey, password);
-  return base642.encode(encryptedKey);
+  return base64.encode(encryptedKey);
 }
 async function exportPrivateKey(key, password, format4) {
   if (key.type === "RSA") {
@@ -116566,7 +115584,7 @@ async function importPrivateKey(encryptedKey, password) {
   return importFromPem(encryptedKey, password);
 }
 async function importer(privateKey, password) {
-  const encryptedKey = base642.decode(privateKey);
+  const encryptedKey = base64.decode(privateKey);
   const cipher = aes_gcm_browser_exports.create();
   return cipher.decrypt(encryptedKey, password);
 }
@@ -154644,7 +153662,7 @@ function fingerprint2Ma(fingerprint) {
   const output6 = fingerprint.split(":").map((str) => parseInt(str, 16));
   const encoded = Uint8Array.from(output6);
   const digest2 = create(sha2565.code, encoded);
-  return multiaddr(`/certhash/${base64url2.encode(digest2.bytes)}`);
+  return multiaddr(`/certhash/${base64url.encode(digest2.bytes)}`);
 }
 function toSupportedHashFunction(code8) {
   switch (code8) {
@@ -155053,7 +154071,7 @@ var WebRTCDirectTransport = class {
     }, renewTime);
     return {
       pem: cert.toString("pem"),
-      certhash: base64url2.encode((await sha2565.digest(new Uint8Array(cert.rawData))).bytes)
+      certhash: base64url.encode((await sha2565.digest(new Uint8Array(cert.rawData))).bytes)
     };
   }
   async loadCertificate(dsKey, keyPair) {
@@ -156048,15 +155066,15 @@ var BeaconSignalDiscovery = class {
    * 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, bitcoin3) {
+  static async indexer(beaconServices, bitcoin2) {
     const beaconServiceSignals = /* @__PURE__ */ new Map();
-    const currentBlockCount = await bitcoin3.network.rest.block.count();
+    const currentBlockCount = await bitcoin2.rest.block.count();
     for (const beaconService of beaconServices) {
       beaconServiceSignals.set(beaconService, []);
-      const beaconSignals = await bitcoin3.network.rest.address.getTxs(
+      const beaconSignals = await bitcoin2.rest.address.getTxs(
         beaconService.serviceEndpoint
       );
       if (!beaconSignals || !beaconSignals.length) {
@@ -156093,22 +155111,22 @@ var BeaconSignalDiscovery = class {
   /**
    * 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, bitcoin3) {
+  static async fullnode(beaconServices, bitcoin2) {
     const beaconServiceSignals = /* @__PURE__ */ new Map();
     for (const beaconService of beaconServices) {
       beaconServiceSignals.set(beaconService, []);
     }
-    const rpc = bitcoin3.network.rpc;
+    const rpc = bitcoin2.rpc;
     if (!rpc) {
-      throw new ResolveError("RPC connection is not available", "RPC_CONNECTION_ERROR", bitcoin3);
+      throw new ResolveError("RPC connection is not available", "RPC_CONNECTION_ERROR", bitcoin2);
     }
     const targetHeight = await rpc.getBlockCount();
     const beaconServicesMap = BeaconUtils.getBeaconServicesMap(beaconServices);
     let height = 0;
-    let block = await bitcoin3.network.rpc.getBlock({ height });
+    let block = await bitcoin2.rpc.getBlock({ height });
     console.info(`Searching for beacon signals, please wait ...`);
     while (block.height <= targetHeight) {
       for (const tx of block.tx) {
@@ -156573,13 +155591,13 @@ var SchnorrMultikey = class _SchnorrMultikey {
    * Convert the multikey to a JSON object.
    * @returns {MultikeyObject} The multikey as a JSON object.
    */
-  json() {
+  toJSON() {
     return {
       id: this.id,
       controller: this.controller,
       fullId: this.fullId(),
       signer: this.signer,
-      keyPair: this.keyPair.json(),
+      keyPair: this.keyPair.toJSON(),
       verificationMethod: this.toVerificationMethod()
     };
   }
@@ -156739,8 +155757,18 @@ var DidDocument2 = class _DidDocument {
    * Convert the DidDocument to a JSON object.
    * @returns {DidDocument} The JSON representation of the DidDocument.
    */
-  json() {
-    return Object.fromEntries(Object.entries(this));
+  toJSON() {
+    return {
+      id: this.id,
+      "@context": this["@context"],
+      verificationMethod: this.verificationMethod,
+      authentication: this.authentication,
+      assertionMethod: this.assertionMethod,
+      capabilityInvocation: this.capabilityInvocation,
+      capabilityDelegation: this.capabilityDelegation,
+      service: this.service,
+      deactivated: this.deactivated
+    };
   }
   /**
    * Create a minimal DidDocument from "k1" btcr2 identifier.
@@ -157038,7 +156066,7 @@ var Update = class {
       patch: patches,
       targetHash: "",
       targetVersionId: sourceVersionId + 1,
-      sourceHash: Canonicalization.process(sourceDocument, { encoding: "base58" })
+      sourceHash: Canonicalization.process(sourceDocument, { encoding: "base58btc" })
     };
     const targetDocument = JSONPatch.apply(sourceDocument, patches);
     try {
@@ -157050,7 +156078,7 @@ var Update = class {
         targetDocument
       );
     }
-    unsignedUpdate.targetHash = Canonicalization.process(targetDocument, { encoding: "base58" });
+    unsignedUpdate.targetHash = Canonicalization.process(targetDocument, { encoding: "base58btc" });
     return unsignedUpdate;
   }
   /**
@@ -157093,9 +156121,9 @@ var Update = class {
    * @returns {SignedBTCR2Update} The SignedBTCR2Update object containing data to validate the Beacon Signal
    * @throws {UpdateError} if the beaconService type is invalid
    */
-  static async announce(beaconService, update, secretKey, bitcoin3) {
+  static async announce(beaconService, update, secretKey, bitcoin2) {
     const beacon = BeaconFactory.establish(beaconService);
-    const result = await beacon.broadcastSignal(update, secretKey, bitcoin3);
+    const result = await beacon.broadcastSignal(update, secretKey, bitcoin2);
     return result;
   }
 };
@@ -157132,7 +156160,7 @@ var DidBtcr2 = class {
         options2
       );
     }
-    return Identifier.encode({ idType, genesisBytes, version: version3, network });
+    return Identifier.encode(genesisBytes, { idType, version: version3, network });
   }
   /**
    * Entry point for section {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html | 7.2 Resolve}.
@@ -157183,15 +156211,17 @@ var DidBtcr2 = class {
       const currentDocument = await Resolve.currentDocument(didComponents, genesisDocument);
       const beaconServices = currentDocument.service.filter(BeaconUtils.isBeaconService).map(BeaconUtils.parseBeaconServiceEndpoint);
       if (!resolutionOptions?.drivers?.bitcoin) {
-        resolutionOptions.drivers = resolutionOptions.drivers || {};
-        resolutionOptions.drivers.bitcoin = new BitcoinNetworkConnection();
-        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
+        );
       }
-      const bitcoin3 = resolutionOptions.drivers.bitcoin;
+      const bitcoin2 = resolutionOptions.drivers.bitcoin;
       const unsortedUpdates = await Resolve.beaconSignals(
         beaconServices,
         sidecarData,
-        bitcoin3
+        bitcoin2
       );
       if (!unsortedUpdates.length) {
         didResolutionResult.didDocument = currentDocument;
@@ -157209,8 +156239,7 @@ var DidBtcr2 = class {
       didResolutionResult.didDocumentMetadata = result.metadata;
       return didResolutionResult;
     } catch (error) {
-      console.error(error);
-      if (!(error instanceof ResolveError)) throw new Error(error);
+      if (!(error instanceof ResolveError)) throw new Error(error.message ?? error, { cause: error });
       return {
         ...EMPTY_DID_RESOLUTION_RESULT,
         didResolutionMetadata: {
@@ -157235,7 +156264,7 @@ var DidBtcr2 = class {
    * @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`
@@ -157247,7 +156276,7 @@ var DidBtcr2 = class {
     verificationMethodId,
     beaconId,
     signingMaterial,
-    bitcoin: bitcoin3
+    bitcoin: bitcoin2
   }) {
     if (!signingMaterial) {
       throw new UpdateError(
@@ -157296,8 +156325,14 @@ var DidBtcr2 = class {
         { sourceDocument, beaconId }
       );
     }
-    bitcoin3 ??= new BitcoinNetworkConnection();
-    await Update.announce(beaconService, signed, secretKey, bitcoin3);
+    if (!bitcoin2) {
+      throw new UpdateError(
+        "Bitcoin connection required for update. Pass a configured `bitcoin` parameter or use DidBtcr2Api which injects it automatically.",
+        INVALID_DID_UPDATE,
+        { beaconId }
+      );
+    }
+    await Update.announce(beaconService, signed, secretKey, bitcoin2);
     return signed;
   }
   /**
@@ -157337,8 +156372,8 @@ var Resolve = class {
    * @returns {DidDocument} The resolved DID Document object.
    */
   static deterministic(didComponents) {
-    const did = Identifier.encode(didComponents);
     const { genesisBytes } = didComponents;
+    const did = Identifier.encode(genesisBytes, didComponents);
     const { multibase: publicKeyMultibase } = new CompressedSecp256k1PublicKey(genesisBytes);
     const service = BeaconUtils.generateBeaconServices({
       id: did,
@@ -157366,15 +156401,15 @@ var Resolve = class {
    */
   static async external(didComponents, genesisDocument) {
     const hashBytes = Canonicalization.process(genesisDocument, { encoding: "hex" });
-    const genesisBytes = bytesToHex(didComponents.genesisBytes);
-    if (genesisBytes !== hashBytes) {
+    const { genesisBytes } = didComponents;
+    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 }
       );
     }
-    const did = Identifier.encode(didComponents);
+    const did = Identifier.encode(genesisBytes, didComponents);
     const currentDocument = JSON.parse(
       JSON.stringify(genesisDocument).replaceAll(ID_PLACEHOLDER_VALUE, did)
     );
@@ -157440,11 +156475,11 @@ var Resolve = class {
    * 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, sidecarData, bitcoin3) {
-    const beaconServicesSignals = bitcoin3.network.rest ? await BeaconSignalDiscovery.indexer(beaconServices, bitcoin3) : await BeaconSignalDiscovery.fullnode(beaconServices, bitcoin3);
+  static async beaconSignals(beaconServices, sidecarData, bitcoin2) {
+    const beaconServicesSignals = bitcoin2.rest ? await BeaconSignalDiscovery.indexer(beaconServices, bitcoin2) : await BeaconSignalDiscovery.fullnode(beaconServices, bitcoin2);
     const promises = await Promise.all(
       Array.from(beaconServicesSignals.entries()).map(
         async ([service, signals]) => {
@@ -157479,7 +156514,7 @@ var Resolve = class {
       }
     };
     for (const [update, block] of updates) {
-      const currentDocumentHash = Canonicalization.process(response2.didDocument, { encoding: "base58" });
+      const currentDocumentHash = Canonicalization.process(response2.didDocument, { encoding: "base58btc" });
       const blocktime = DateUtils.blocktimeToTimestamp(block.time);
       response2.metadata.updated = DateUtils.toISOStringNonFractional(blocktime);
       response2.metadata.confirmations = block.confirmations;
@@ -157501,7 +156536,7 @@ var Resolve = class {
         }
         response2.didDocument = await this.applyUpdate(response2.didDocument, update);
         const unsignedUpdate = JSONUtils.deleteKeys(update, ["proof"]);
-        updateHashHistory.push(Canonicalization.process(unsignedUpdate, { encoding: "base58" }));
+        updateHashHistory.push(Canonicalization.process(unsignedUpdate, { encoding: "base58btc" }));
       } else if (update.targetVersionId > currentVersionId + 1) {
         throw new ResolveError(
           `Version Id Mismatch: targetVersionId cannot be > currentVersionId + 1`,
@@ -157582,11 +156617,11 @@ var Resolve = class {
     }
     const updatedDocument = JSONPatch.apply(currentDocument, update.patch);
     DidDocument2.validate(updatedDocument);
-    const currentDocumentHash = Canonicalization.process(updatedDocument, { encoding: "base58" });
-    const updateTargetHash = update.targetHash.startsWith("z") ? update.targetHash : `z${update.targetHash}`;
-    if (updateTargetHash !== currentDocumentHash) {
+    const currentDocumentHash = Canonicalization.process(updatedDocument, { encoding: "base58btc" });
+    const updateTargetHash = update.targetHash;
+    if (update.targetHash !== currentDocumentHash) {
       throw new ResolveError(
-        `Invalid update: updateTargetHash !== currentDocumentHash`,
+        `Invalid update: update.targetHash !== currentDocumentHash`,
         INVALID_DID_UPDATE,
         { updateTargetHash, currentDocumentHash }
       );