@did-btcr2/method 0.22.0 → 0.23.0

package/dist/browser.js

@@ -57601,8 +57601,9 @@ var BTCR2 = (() => {
     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";
@@ -57692,6 +57693,40 @@ var BTCR2 = (() => {
     }
   };
 
+  // ../../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 {
     /**
@@ -57715,7 +57750,7 @@ var BTCR2 = (() => {
      */
     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;
@@ -57731,7 +57766,7 @@ var BTCR2 = (() => {
      *
      * @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.
      */
@@ -57774,9 +57809,9 @@ var BTCR2 = (() => {
       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.
      */
@@ -57785,15 +57820,18 @@ var BTCR2 = (() => {
       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.
      */
@@ -57802,9 +57840,12 @@ var BTCR2 = (() => {
       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");
     }
     /**
@@ -57832,13 +57873,29 @@ var BTCR2 = (() => {
       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.
@@ -57862,13 +57919,22 @@ var BTCR2 = (() => {
       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));
     }
   };
 
@@ -57952,9 +58018,6 @@ var BTCR2 = (() => {
     CONTEXT_URL_MAP.w3c.jsonldpatch.v1
   ];
 
-  // ../common/dist/esm/interfaces.js
-  init_shim();
-
   // ../common/dist/esm/json-patch.js
   init_shim();
 
@@ -59623,51 +59686,6 @@ var BTCR2 = (() => {
 
   // ../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 {
@@ -59730,8 +59748,13 @@ var BTCR2 = (() => {
      * 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
+      };
     }
   };
 
@@ -59915,7 +59938,7 @@ var BTCR2 = (() => {
         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);
@@ -59982,8 +60005,20 @@ var BTCR2 = (() => {
      * 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.
@@ -60267,8 +60302,19 @@ var BTCR2 = (() => {
      * 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
+      };
     }
   };
 
@@ -60659,7 +60705,7 @@ var BTCR2 = (() => {
      * 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(),
@@ -60804,9 +60850,13 @@ var BTCR2 = (() => {
 
   // ../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: [],
@@ -60978,7 +61028,7 @@ var BTCR2 = (() => {
      * JSON representation of a CompressedSecp256k1PublicKey object.
      * @returns {PublicKeyObject} The CompressedSecp256k1PublicKey as a JSON object.
      */
-    json() {
+    toJSON() {
       return {
         hex: this.hex,
         multibase: this.multibase,
@@ -61207,10 +61257,10 @@ var BTCR2 = (() => {
      * 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()
       };
     }
     /**
@@ -61303,14 +61353,12 @@ var BTCR2 = (() => {
      *    - 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 });
       }
@@ -61439,14 +61487,16 @@ var BTCR2 = (() => {
      * @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.
@@ -61481,12 +61531,7 @@ var BTCR2 = (() => {
         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 || [];
     }
   };
@@ -61556,22 +61601,22 @@ var BTCR2 = (() => {
         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;
@@ -64212,8 +64257,8 @@ var BTCR2 = (() => {
   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");
@@ -64335,8 +64380,8 @@ var BTCR2 = (() => {
     hex: hex2,
     base16,
     base32,
-    base64,
-    base64url,
+    base64: base642,
+    base64url: base64url2,
     base58: base582,
     base58xmr
   };
@@ -66545,8 +66590,8 @@ var BTCR2 = (() => {
     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) {
@@ -66554,8 +66599,8 @@ var BTCR2 = (() => {
     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);
   }
@@ -66865,7 +66910,7 @@ var BTCR2 = (() => {
       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);
     }
@@ -66886,7 +66931,7 @@ var BTCR2 = (() => {
     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);
@@ -67625,7 +67670,7 @@ var BTCR2 = (() => {
     }
     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) => {
@@ -67641,7 +67686,7 @@ var BTCR2 = (() => {
       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");
     }
@@ -68593,11 +68638,10 @@ var BTCR2 = (() => {
     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"
       });
     }
     /**
@@ -68737,22 +68781,22 @@ var BTCR2 = (() => {
         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;
@@ -69947,12 +69991,12 @@ var BTCR2 = (() => {
      * 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 });
     }
   };
 
@@ -69961,68 +70005,6 @@ var BTCR2 = (() => {
 
   // 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.
@@ -70049,7 +70031,7 @@ var BTCR2 = (() => {
             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(
@@ -70066,13 +70048,13 @@ var BTCR2 = (() => {
      * 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!",
@@ -70090,17 +70072,20 @@ var BTCR2 = (() => {
           { 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;
     }
@@ -70130,12 +70115,12 @@ var BTCR2 = (() => {
      * 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 });
     }
   };
 
@@ -70175,382 +70160,23 @@ var BTCR2 = (() => {
   // ../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();
@@ -70560,506 +70186,9 @@ var BTCR2 = (() => {
 
   // ../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();
@@ -71079,97 +70208,20 @@ var BTCR2 = (() => {
     }
   }
 
-  // ../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();
@@ -71935,40 +70987,6 @@ var BTCR2 = (() => {
     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, {
@@ -73847,7 +72865,7 @@ var BTCR2 = (() => {
       step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
   };
-  var MemoryStore2 = class {
+  var MemoryStore = class {
     constructor() {
       this.store = /* @__PURE__ */ new Map();
     }
@@ -79800,7 +78818,7 @@ var BTCR2 = (() => {
     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.
@@ -87998,7 +87016,7 @@ var BTCR2 = (() => {
     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();
@@ -93876,7 +92894,7 @@ var BTCR2 = (() => {
     ];
   }
   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),
@@ -93984,7 +93002,7 @@ var BTCR2 = (() => {
                     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);
@@ -99562,7 +98580,7 @@ var BTCR2 = (() => {
       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
@@ -99974,7 +98992,7 @@ var BTCR2 = (() => {
       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);
@@ -101836,15 +100854,15 @@ var BTCR2 = (() => {
       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);
     }
   };
@@ -103399,7 +102417,7 @@ var BTCR2 = (() => {
     code: CODE_CERTHASH,
     name: "certhash",
     size: V,
-    bytesToValue: bytes2mb(base64url2),
+    bytesToValue: bytes2mb(base64url),
     valueToBytes: mb2bytes
   }, {
     code: CODE_HTTP,
@@ -104705,7 +103723,7 @@ var BTCR2 = (() => {
      */
     #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
@@ -116473,7 +115491,7 @@ ${values.join("\n")}` : `${blockName} :`;
   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") {
@@ -116638,7 +115656,7 @@ ${values.join("\n")}` : `${blockName} :`;
     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);
   }
@@ -154716,7 +153734,7 @@ ${values.join("\n")}` : `${blockName} :`;
     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) {
@@ -155125,7 +154143,7 @@ a=end-of-candidates
       }, 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) {
@@ -156120,15 +155138,15 @@ a=end-of-candidates
      * 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) {
@@ -156165,22 +155183,22 @@ a=end-of-candidates
     /**
      * 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) {
@@ -156645,13 +155663,13 @@ a=end-of-candidates
      * 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()
       };
     }
@@ -156811,8 +155829,18 @@ a=end-of-candidates
      * 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.
@@ -157110,7 +156138,7 @@ a=end-of-candidates
         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 {
@@ -157122,7 +156150,7 @@ a=end-of-candidates
           targetDocument
         );
       }
-      unsignedUpdate.targetHash = Canonicalization.process(targetDocument, { encoding: "base58" });
+      unsignedUpdate.targetHash = Canonicalization.process(targetDocument, { encoding: "base58btc" });
       return unsignedUpdate;
     }
     /**
@@ -157165,9 +156193,9 @@ a=end-of-candidates
      * @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;
     }
   };
@@ -157204,7 +156232,7 @@ a=end-of-candidates
           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}.
@@ -157255,15 +156283,17 @@ a=end-of-candidates
         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;
@@ -157281,8 +156311,7 @@ a=end-of-candidates
         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: {
@@ -157307,7 +156336,7 @@ a=end-of-candidates
      * @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`
@@ -157319,7 +156348,7 @@ a=end-of-candidates
       verificationMethodId,
       beaconId,
       signingMaterial,
-      bitcoin: bitcoin3
+      bitcoin: bitcoin2
     }) {
       if (!signingMaterial) {
         throw new UpdateError(
@@ -157368,8 +156397,14 @@ a=end-of-candidates
           { 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;
     }
     /**
@@ -157409,8 +156444,8 @@ a=end-of-candidates
      * @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,
@@ -157438,15 +156473,15 @@ a=end-of-candidates
      */
     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)
       );
@@ -157512,11 +156547,11 @@ a=end-of-candidates
      * 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]) => {
@@ -157551,7 +156586,7 @@ a=end-of-candidates
         }
       };
       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;
@@ -157573,7 +156608,7 @@ a=end-of-candidates
           }
           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`,
@@ -157654,11 +156689,11 @@ a=end-of-candidates
       }
       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 }
         );