@did-btcr2/method 0.41.0 → 0.43.0

package/dist/browser.js

@@ -93159,6 +93159,7 @@ a=end-of-candidates
     CASBeaconError: () => CASBeaconError,
     CHANGE_OUTPUT_VBYTES: () => CHANGE_OUTPUT_VBYTES,
     DEFAULT_FEE_ESTIMATOR: () => DEFAULT_FEE_ESTIMATOR,
+    DEFAULT_MAX_DISCOVERY_ROUNDS: () => DEFAULT_MAX_DISCOVERY_ROUNDS,
     DID_REGEX: () => DID_REGEX,
     DUST_LIMIT_SATS: () => DUST_LIMIT_SATS,
     DidBtcr2: () => DidBtcr2,
@@ -93185,6 +93186,7 @@ a=end-of-candidates
     buildAggregationBeaconTx: () => buildAggregationBeaconTx,
     deriveSingletonAddress: () => deriveSingletonAddress,
     detectSingletonScriptKind: () => detectSingletonScriptKind,
+    extractOpReturnSignal: () => extractOpReturnSignal,
     opReturnScript: () => opReturnScript,
     resolveBtcr2SenderPk: () => resolveBtcr2SenderPk,
     resolveChangeAddress: () => resolveChangeAddress
@@ -117693,6 +117695,20 @@ a=end-of-candidates
   };
 
   // src/core/beacon/signal-discovery.ts
+  function extractOpReturnSignal(asm) {
+    if (!asm) {
+      return null;
+    }
+    const tokens = asm.trim().split(/\s+/);
+    if (tokens.length !== 3 || tokens[0] !== "OP_RETURN" || tokens[1] !== "OP_PUSHBYTES_32") {
+      return null;
+    }
+    const signalHash = tokens[2];
+    if (!/^[0-9a-fA-F]{64}$/.test(signalHash)) {
+      return null;
+    }
+    return signalHash.toLowerCase();
+  }
   var BeaconSignalDiscovery = class {
     /**
      * Retrieves the beacon signals for the given array of BeaconService objects
@@ -117714,15 +117730,10 @@ a=end-of-candidates
         }
         for (const beaconSignal of beaconSignals) {
           const signalVout = beaconSignal.vout.slice(-1)[0];
-          if (!signalVout || !signalVout.scriptpubkey_asm.includes("OP_RETURN")) {
-            continue;
-          }
-          const outputMap = new Map(Object.entries(signalVout));
-          const signalVoutScriptPubkey = outputMap.get("scriptpubkey_asm");
-          if (!signalVoutScriptPubkey) {
+          if (!signalVout) {
             continue;
           }
-          const updateHash = signalVoutScriptPubkey.split(" ").slice(-1)[0];
+          const updateHash = extractOpReturnSignal(signalVout.scriptpubkey_asm);
           if (!updateHash) {
             continue;
           }
@@ -117791,14 +117802,11 @@ a=end-of-candidates
               continue;
             }
             const txVoutScriptPubkeyAsm = prevout.vout[vin.vout].scriptPubKey.asm;
-            if (!txVoutScriptPubkeyAsm.includes("OP_RETURN")) {
-              continue;
-            }
-            console.info(`Tx ${tx.txid} contains beacon service address ${scriptPubKey.address} and OP_RETURN!`, tx);
-            const updateHash = txVoutScriptPubkeyAsm.split(" ").slice(-1)[0];
+            const updateHash = extractOpReturnSignal(txVoutScriptPubkeyAsm);
             if (!updateHash) {
               continue;
             }
+            console.info(`Tx ${tx.txid} contains beacon service address ${scriptPubKey.address} and OP_RETURN!`, tx);
             beaconServiceSignals.get(beaconService)?.push({
               tx,
               signalBytes: updateHash,
@@ -119289,7 +119297,8 @@ a=end-of-candidates
       return new Resolver(didComponents, sidecarData, currentDocument, {
         versionId: resolutionOptions.versionId,
         versionTime: resolutionOptions.versionTime,
-        genesisDocument: resolutionOptions.sidecar?.genesisDocument
+        genesisDocument: resolutionOptions.sidecar?.genesisDocument,
+        maxDiscoveryRounds: resolutionOptions.maxDiscoveryRounds
       });
     }
     /**
@@ -119398,6 +119407,21 @@ a=end-of-candidates
 
   // src/core/resolver.ts
   init_utils2();
+  var DEFAULT_MAX_DISCOVERY_ROUNDS = 10;
+  function isRecord(value2) {
+    return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+  }
+  function isCASAnnouncement(value2) {
+    return isRecord(value2) && Object.values(value2).every((v) => typeof v === "string");
+  }
+  function isSignedBTCR2Update(value2) {
+    if (!isRecord(value2)) return false;
+    return Array.isArray(value2.patch) && typeof value2.sourceHash === "string" && typeof value2.targetHash === "string" && typeof value2.targetVersionId === "number" && isRecord(value2.proof);
+  }
+  function isSMTProof(value2) {
+    if (!isRecord(value2)) return false;
+    return typeof value2.id === "string" && typeof value2.collapsed === "string" && Array.isArray(value2.hashes);
+  }
   var Resolver = class _Resolver {
     // --- Immutable inputs ---
     #didComponents;
@@ -119415,6 +119439,10 @@ a=end-of-candidates
     #requestCache = /* @__PURE__ */ new Set();
     #unsortedUpdates = [];
     #resolvedResponse = null;
+    /** Upper bound on multi-round beacon-discovery passes; see {@link DEFAULT_MAX_DISCOVERY_ROUNDS}. */
+    #maxDiscoveryRounds;
+    /** Count of beacon-discovery passes driven by updates adding new beacon services. */
+    #discoveryRounds = 0;
     /**
      * @internal Use {@link DidBtcr2.resolve} to create instances.
      */
@@ -119424,6 +119452,7 @@ a=end-of-candidates
       this.#currentDocument = currentDocument;
       this.#versionId = options2?.versionId;
       this.#versionTime = options2?.versionTime;
+      this.#maxDiscoveryRounds = options2?.maxDiscoveryRounds ?? DEFAULT_MAX_DISCOVERY_ROUNDS;
       if (options2?.genesisDocument) {
         this.#providedGenesisDocument = options2.genesisDocument;
       }
@@ -119738,6 +119767,13 @@ a=end-of-candidates
                 return !this.#requestCache.has(address);
               });
               if (hasNewServices) {
+                if (++this.#discoveryRounds > this.#maxDiscoveryRounds) {
+                  throw new ResolveError(
+                    `Exceeded maximum beacon-discovery rounds (${this.#maxDiscoveryRounds}); the DID document may chain beacon services without terminating.`,
+                    INVALID_DID_DOCUMENT,
+                    { maxDiscoveryRounds: this.#maxDiscoveryRounds }
+                  );
+                }
                 this.#phase = "BeaconDiscovery" /* BeaconDiscovery */;
                 continue;
               }
@@ -119764,38 +119800,84 @@ a=end-of-candidates
     provide(need, data) {
       switch (need.kind) {
         case "NeedGenesisDocument": {
+          if (!isRecord(data)) {
+            throw new ResolveError(
+              "Provided data for NeedGenesisDocument must be a document object.",
+              INVALID_DID_UPDATE,
+              { kind: need.kind }
+            );
+          }
           this.#providedGenesisDocument = data;
           break;
         }
         case "NeedBeaconSignals": {
-          const signals = data;
-          for (const [service, serviceSignals] of signals) {
+          if (!(data instanceof Map)) {
+            throw new ResolveError(
+              "Provided data for NeedBeaconSignals must be a Map of beacon services to signals.",
+              INVALID_DID_UPDATE,
+              { kind: need.kind }
+            );
+          }
+          for (const [service, serviceSignals] of data) {
             this.#beaconServicesSignals.set(service, serviceSignals);
           }
           break;
         }
         case "NeedCASAnnouncement": {
-          const announcement = data;
-          this.#sidecarData.casMap.set(canonicalHash(announcement, { encoding: "hex" }), announcement);
+          if (!isCASAnnouncement(data)) {
+            throw new ResolveError(
+              "Provided data for NeedCASAnnouncement is not a CAS announcement.",
+              INVALID_DID_UPDATE,
+              { kind: need.kind }
+            );
+          }
+          const announcementHash = canonicalHash(data, { encoding: "hex" });
+          if (announcementHash !== need.announcementHash) {
+            throw new ResolveError(
+              `CAS announcement hash mismatch: expected ${need.announcementHash}, got ${announcementHash}.`,
+              INVALID_DID_UPDATE,
+              { expected: need.announcementHash, actual: announcementHash }
+            );
+          }
+          this.#sidecarData.casMap.set(announcementHash, data);
           break;
         }
         case "NeedSignedUpdate": {
-          const update = data;
-          this.#sidecarData.updateMap.set(canonicalHash(update, { encoding: "hex" }), update);
+          if (!isSignedBTCR2Update(data)) {
+            throw new ResolveError(
+              "Provided data for NeedSignedUpdate is not a signed BTCR2 update.",
+              INVALID_DID_UPDATE,
+              { kind: need.kind }
+            );
+          }
+          const updateHash = canonicalHash(data, { encoding: "hex" });
+          if (updateHash !== need.updateHash) {
+            throw new ResolveError(
+              `Signed update hash mismatch: expected ${need.updateHash}, got ${updateHash}.`,
+              INVALID_DID_UPDATE,
+              { expected: need.updateHash, actual: updateHash }
+            );
+          }
+          this.#sidecarData.updateMap.set(updateHash, data);
           break;
         }
         case "NeedSMTProof": {
-          const smtNeed = need;
-          const proof = data;
-          const proofIdHex = encode(decode(proof.id, "base64urlnopad"), "hex");
-          if (proofIdHex !== smtNeed.smtRootHash) {
+          if (!isSMTProof(data)) {
+            throw new ResolveError(
+              "Provided data for NeedSMTProof is not an SMT proof.",
+              INVALID_DID_UPDATE,
+              { kind: need.kind }
+            );
+          }
+          const proofIdHex = encode(decode(data.id, "base64urlnopad"), "hex");
+          if (proofIdHex !== need.smtRootHash) {
             throw new ResolveError(
-              `SMT proof root hash mismatch: expected ${smtNeed.smtRootHash}, got ${proofIdHex}`,
+              `SMT proof root hash mismatch: expected ${need.smtRootHash}, got ${proofIdHex}`,
               INVALID_DID_UPDATE,
-              { expected: smtNeed.smtRootHash, actual: proofIdHex }
+              { expected: need.smtRootHash, actual: proofIdHex }
             );
           }
-          this.#sidecarData.smtMap.set(smtNeed.smtRootHash, proof);
+          this.#sidecarData.smtMap.set(need.smtRootHash, data);
           break;
         }
       }

package/dist/browser.mjs

@@ -117646,6 +117646,20 @@ var BeaconUtils = class {
 };
 
 // src/core/beacon/signal-discovery.ts
+function extractOpReturnSignal(asm) {
+  if (!asm) {
+    return null;
+  }
+  const tokens = asm.trim().split(/\s+/);
+  if (tokens.length !== 3 || tokens[0] !== "OP_RETURN" || tokens[1] !== "OP_PUSHBYTES_32") {
+    return null;
+  }
+  const signalHash = tokens[2];
+  if (!/^[0-9a-fA-F]{64}$/.test(signalHash)) {
+    return null;
+  }
+  return signalHash.toLowerCase();
+}
 var BeaconSignalDiscovery = class {
   /**
    * Retrieves the beacon signals for the given array of BeaconService objects
@@ -117667,15 +117681,10 @@ var BeaconSignalDiscovery = class {
       }
       for (const beaconSignal of beaconSignals) {
         const signalVout = beaconSignal.vout.slice(-1)[0];
-        if (!signalVout || !signalVout.scriptpubkey_asm.includes("OP_RETURN")) {
-          continue;
-        }
-        const outputMap = new Map(Object.entries(signalVout));
-        const signalVoutScriptPubkey = outputMap.get("scriptpubkey_asm");
-        if (!signalVoutScriptPubkey) {
+        if (!signalVout) {
           continue;
         }
-        const updateHash = signalVoutScriptPubkey.split(" ").slice(-1)[0];
+        const updateHash = extractOpReturnSignal(signalVout.scriptpubkey_asm);
         if (!updateHash) {
           continue;
         }
@@ -117744,14 +117753,11 @@ var BeaconSignalDiscovery = class {
             continue;
           }
           const txVoutScriptPubkeyAsm = prevout.vout[vin.vout].scriptPubKey.asm;
-          if (!txVoutScriptPubkeyAsm.includes("OP_RETURN")) {
-            continue;
-          }
-          console.info(`Tx ${tx.txid} contains beacon service address ${scriptPubKey.address} and OP_RETURN!`, tx);
-          const updateHash = txVoutScriptPubkeyAsm.split(" ").slice(-1)[0];
+          const updateHash = extractOpReturnSignal(txVoutScriptPubkeyAsm);
           if (!updateHash) {
             continue;
           }
+          console.info(`Tx ${tx.txid} contains beacon service address ${scriptPubKey.address} and OP_RETURN!`, tx);
           beaconServiceSignals.get(beaconService)?.push({
             tx,
             signalBytes: updateHash,
@@ -119242,7 +119248,8 @@ var DidBtcr2 = class {
     return new Resolver(didComponents, sidecarData, currentDocument, {
       versionId: resolutionOptions.versionId,
       versionTime: resolutionOptions.versionTime,
-      genesisDocument: resolutionOptions.sidecar?.genesisDocument
+      genesisDocument: resolutionOptions.sidecar?.genesisDocument,
+      maxDiscoveryRounds: resolutionOptions.maxDiscoveryRounds
     });
   }
   /**
@@ -119351,6 +119358,21 @@ var DidBtcr2 = class {
 
 // src/core/resolver.ts
 init_utils2();
+var DEFAULT_MAX_DISCOVERY_ROUNDS = 10;
+function isRecord(value2) {
+  return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+}
+function isCASAnnouncement(value2) {
+  return isRecord(value2) && Object.values(value2).every((v) => typeof v === "string");
+}
+function isSignedBTCR2Update(value2) {
+  if (!isRecord(value2)) return false;
+  return Array.isArray(value2.patch) && typeof value2.sourceHash === "string" && typeof value2.targetHash === "string" && typeof value2.targetVersionId === "number" && isRecord(value2.proof);
+}
+function isSMTProof(value2) {
+  if (!isRecord(value2)) return false;
+  return typeof value2.id === "string" && typeof value2.collapsed === "string" && Array.isArray(value2.hashes);
+}
 var Resolver = class _Resolver {
   // --- Immutable inputs ---
   #didComponents;
@@ -119368,6 +119390,10 @@ var Resolver = class _Resolver {
   #requestCache = /* @__PURE__ */ new Set();
   #unsortedUpdates = [];
   #resolvedResponse = null;
+  /** Upper bound on multi-round beacon-discovery passes; see {@link DEFAULT_MAX_DISCOVERY_ROUNDS}. */
+  #maxDiscoveryRounds;
+  /** Count of beacon-discovery passes driven by updates adding new beacon services. */
+  #discoveryRounds = 0;
   /**
    * @internal Use {@link DidBtcr2.resolve} to create instances.
    */
@@ -119377,6 +119403,7 @@ var Resolver = class _Resolver {
     this.#currentDocument = currentDocument;
     this.#versionId = options2?.versionId;
     this.#versionTime = options2?.versionTime;
+    this.#maxDiscoveryRounds = options2?.maxDiscoveryRounds ?? DEFAULT_MAX_DISCOVERY_ROUNDS;
     if (options2?.genesisDocument) {
       this.#providedGenesisDocument = options2.genesisDocument;
     }
@@ -119691,6 +119718,13 @@ var Resolver = class _Resolver {
               return !this.#requestCache.has(address);
             });
             if (hasNewServices) {
+              if (++this.#discoveryRounds > this.#maxDiscoveryRounds) {
+                throw new ResolveError(
+                  `Exceeded maximum beacon-discovery rounds (${this.#maxDiscoveryRounds}); the DID document may chain beacon services without terminating.`,
+                  INVALID_DID_DOCUMENT,
+                  { maxDiscoveryRounds: this.#maxDiscoveryRounds }
+                );
+              }
               this.#phase = "BeaconDiscovery" /* BeaconDiscovery */;
               continue;
             }
@@ -119717,38 +119751,84 @@ var Resolver = class _Resolver {
   provide(need, data) {
     switch (need.kind) {
       case "NeedGenesisDocument": {
+        if (!isRecord(data)) {
+          throw new ResolveError(
+            "Provided data for NeedGenesisDocument must be a document object.",
+            INVALID_DID_UPDATE,
+            { kind: need.kind }
+          );
+        }
         this.#providedGenesisDocument = data;
         break;
       }
       case "NeedBeaconSignals": {
-        const signals = data;
-        for (const [service, serviceSignals] of signals) {
+        if (!(data instanceof Map)) {
+          throw new ResolveError(
+            "Provided data for NeedBeaconSignals must be a Map of beacon services to signals.",
+            INVALID_DID_UPDATE,
+            { kind: need.kind }
+          );
+        }
+        for (const [service, serviceSignals] of data) {
           this.#beaconServicesSignals.set(service, serviceSignals);
         }
         break;
       }
       case "NeedCASAnnouncement": {
-        const announcement = data;
-        this.#sidecarData.casMap.set(canonicalHash(announcement, { encoding: "hex" }), announcement);
+        if (!isCASAnnouncement(data)) {
+          throw new ResolveError(
+            "Provided data for NeedCASAnnouncement is not a CAS announcement.",
+            INVALID_DID_UPDATE,
+            { kind: need.kind }
+          );
+        }
+        const announcementHash = canonicalHash(data, { encoding: "hex" });
+        if (announcementHash !== need.announcementHash) {
+          throw new ResolveError(
+            `CAS announcement hash mismatch: expected ${need.announcementHash}, got ${announcementHash}.`,
+            INVALID_DID_UPDATE,
+            { expected: need.announcementHash, actual: announcementHash }
+          );
+        }
+        this.#sidecarData.casMap.set(announcementHash, data);
         break;
       }
       case "NeedSignedUpdate": {
-        const update = data;
-        this.#sidecarData.updateMap.set(canonicalHash(update, { encoding: "hex" }), update);
+        if (!isSignedBTCR2Update(data)) {
+          throw new ResolveError(
+            "Provided data for NeedSignedUpdate is not a signed BTCR2 update.",
+            INVALID_DID_UPDATE,
+            { kind: need.kind }
+          );
+        }
+        const updateHash = canonicalHash(data, { encoding: "hex" });
+        if (updateHash !== need.updateHash) {
+          throw new ResolveError(
+            `Signed update hash mismatch: expected ${need.updateHash}, got ${updateHash}.`,
+            INVALID_DID_UPDATE,
+            { expected: need.updateHash, actual: updateHash }
+          );
+        }
+        this.#sidecarData.updateMap.set(updateHash, data);
         break;
       }
       case "NeedSMTProof": {
-        const smtNeed = need;
-        const proof = data;
-        const proofIdHex = encode(decode(proof.id, "base64urlnopad"), "hex");
-        if (proofIdHex !== smtNeed.smtRootHash) {
+        if (!isSMTProof(data)) {
+          throw new ResolveError(
+            "Provided data for NeedSMTProof is not an SMT proof.",
+            INVALID_DID_UPDATE,
+            { kind: need.kind }
+          );
+        }
+        const proofIdHex = encode(decode(data.id, "base64urlnopad"), "hex");
+        if (proofIdHex !== need.smtRootHash) {
           throw new ResolveError(
-            `SMT proof root hash mismatch: expected ${smtNeed.smtRootHash}, got ${proofIdHex}`,
+            `SMT proof root hash mismatch: expected ${need.smtRootHash}, got ${proofIdHex}`,
             INVALID_DID_UPDATE,
-            { expected: smtNeed.smtRootHash, actual: proofIdHex }
+            { expected: need.smtRootHash, actual: proofIdHex }
           );
         }
-        this.#sidecarData.smtMap.set(smtNeed.smtRootHash, proof);
+        this.#sidecarData.smtMap.set(need.smtRootHash, data);
         break;
       }
     }
@@ -119825,6 +119905,7 @@ export {
   CASBeaconError,
   CHANGE_OUTPUT_VBYTES,
   DEFAULT_FEE_ESTIMATOR,
+  DEFAULT_MAX_DISCOVERY_ROUNDS,
   DID_REGEX,
   DUST_LIMIT_SATS,
   DidBtcr2,
@@ -119851,6 +119932,7 @@ export {
   buildAggregationBeaconTx,
   deriveSingletonAddress,
   detectSingletonScriptKind,
+  extractOpReturnSignal,
   opReturnScript,
   resolveBtcr2SenderPk,
   resolveChangeAddress