@did-btcr2/method 0.65.1 → 0.66.0

package/dist/cjs/index.js

@@ -589,6 +589,13 @@ var SingletonBeacon = class extends SinglePartyBeacon {
 var import_common4 = require("@did-btcr2/common");
 var import_smt = require("@did-btcr2/smt");
 var import_utils2 = require("@noble/hashes/utils");
+function proofIdHex(proof) {
+  try {
+    return (0, import_smt.hashToHex)((0, import_smt.base64UrlToHash)(proof.id));
+  } catch {
+    return void 0;
+  }
+}
 var SMTBeacon = class extends SinglePartyBeacon {
   /**
    * Creates an instance of SMTBeacon.
@@ -601,15 +608,17 @@ var SMTBeacon = class extends SinglePartyBeacon {
   /**
    * Implements {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#process-smt-beacon | 7.2.e.1 Process SMT Beacon}.
    *
-   * For each signal, the signalBytes contain the hex-encoded SMT root hash.
-   * This method looks up the SMT Proof from the sidecar by root hash,
-   * validates the Merkle inclusion proof, and retrieves the corresponding
-   * signed update using the proof's updateId.
+   * For each signal, the signalBytes contain the hex-encoded SMT root hash
+   * (`smt_root`). This method looks up the SMT Proof from the sidecar by root
+   * hash, checks that the id of the proof is the root, verifies the proof with
+   * the SMT Proof Verification algorithm, and retrieves the signed update by the
+   * proof's updateId. A proof with no updateId announces no update for the DID.
    *
    * @param {Array<BeaconSignal>} signals The array of Beacon Signals to process.
    * @param {SidecarData} sidecar The sidecar data associated with the SMT Beacon.
    * @returns {BeaconProcessResult} Successfully resolved updates and any data needs.
-   * @throws {SMTBeaconError} if proof verification fails or proof is malformed.
+   * @throws {SMTBeaconError} `INVALID_SIGNAL_DATA` if the id of the proof is not the
+   *   signal root, or if the proof does not verify.
    */
   processSignals(signals, sidecar) {
     const updates = new Array();
@@ -625,25 +634,21 @@ var SMTBeacon = class extends SinglePartyBeacon {
         });
         continue;
       }
-      if (!smtProof.nonce) {
+      if (proofIdHex(smtProof) !== signal.signalBytes) {
         throw new SMTBeaconError(
-          "SMT proof missing required nonce field.",
-          "INVALID_SMT_PROOF",
-          { smtProof, did }
+          `SMT proof id does not equal the signal root ${signal.signalBytes}.`,
+          import_common4.INVALID_SIGNAL_DATA,
+          { smtProof, did, smtRootHash: signal.signalBytes }
         );
       }
-      const index = (0, import_smt.didToIndex)(did);
-      const nonceHash = (0, import_smt.base64UrlToHash)(smtProof.nonce);
-      const candidateHash = smtProof.updateId ? (0, import_smt.blockHash)((0, import_smt.blockHash)(nonceHash), (0, import_smt.base64UrlToHash)(smtProof.updateId)) : (0, import_smt.blockHash)((0, import_smt.blockHash)(nonceHash));
-      const valid = (0, import_smt.verifySerializedProof)(smtProof, index, candidateHash);
-      if (!valid) {
+      if (!(0, import_smt.verifyProof)(smtProof, did)) {
         throw new SMTBeaconError(
-          "SMT proof verification failed.",
-          "INVALID_SMT_PROOF",
-          { smtProof, did }
+          `SMT proof verification failed for the signal root ${signal.signalBytes}.`,
+          import_common4.INVALID_SIGNAL_DATA,
+          { smtProof, did, smtRootHash: signal.signalBytes }
         );
       }
-      if (!smtProof.updateId) {
+      if (smtProof.updateId === void 0) {
         continue;
       }
       const updateHashHex = (0, import_smt.hashToHex)((0, import_smt.base64UrlToHash)(smtProof.updateId));
@@ -673,16 +678,15 @@ var SMTBeacon = class extends SinglePartyBeacon {
    * @param {BitcoinConnection} bitcoin The Bitcoin network connection.
    * @param {BroadcastOptions} [options] Optional broadcast configuration (e.g. fee estimator).
    * @return {Promise<BroadcastResult>} The signed update, the signal txid, and the SMT
-   *   inclusion proof (with the leaf nonce embedded). The proof MUST be captured for sidecar
+   *   proof (with the leaf nonce embedded). The proof MUST be captured for sidecar
    *   distribution: the nonce exists only here, so the on-chain signal is unresolvable without it.
    * @throws {BeaconError} if the bitcoin address is invalid, unfunded, or UTXO cannot cover the fee.
    */
   async broadcastSignal(signedUpdate, signer, bitcoin, options) {
     const did = this.did;
-    const canonicalBytes = new TextEncoder().encode((0, import_common4.canonicalize)(signedUpdate));
     const nonce = (0, import_utils2.randomBytes)(32);
     const tree = new import_smt.BTCR2MerkleTree();
-    tree.addEntries([{ did, nonce, signedUpdate: canonicalBytes }]);
+    tree.addEntries([{ did, nonce, updateId: (0, import_common4.canonicalHashBytes)(signedUpdate) }]);
     tree.finalize();
     const proof = tree.proof(did);
     const txid = await this.buildSignAndBroadcast(tree.rootHash, signer, bitcoin, options);
@@ -2058,7 +2062,7 @@ function isSignedBTCR2Update(value) {
 }
 function isSMTProof(value) {
   if (!isRecord(value)) return false;
-  return typeof value.id === "string" && typeof value.collapsed === "string" && Array.isArray(value.hashes);
+  return typeof value.id === "string" && typeof value.collapsed === "string" && Array.isArray(value.hashes) && value.hashes.every((h) => typeof h === "string") && (value.nonce === void 0 || typeof value.nonce === "string") && (value.updateId === void 0 || typeof value.updateId === "string");
 }
 function validateMinConf(value) {
   if (value === void 0) return DEFAULT_MIN_CONF;
@@ -2133,15 +2137,23 @@ var Resolver = class _Resolver {
    * The state of the specification loop, carried across every pass: the version counter
    * (`current_version_id`), the update-hash history that backs duplicate confirmation
    * (`update_hash_history`), the confirmations of the block that contains the most
-   * recently applied unique update (`block_confirmations`), and the header time of that
-   * block as `updated`. A pass that finds a new beacon address returns to discovery, so
-   * the state must not restart: a restart would reject a linear history whose later
-   * updates are announced on beacons that earlier updates added.
+   * recently applied unique update (`block_confirmations`), the height of that block
+   * (`current_block_height`), and the header time of that block as `updated`. A pass
+   * that finds a new beacon address returns to discovery, so the state must not
+   * restart: a restart would reject a linear history whose later updates are
+   * announced on beacons that earlier updates added.
    */
   #currentVersionId = 1;
   #updateHashHistory = [];
   #blockConfirmations = 0;
   #updated;
+  /**
+   * The height of the block that contains the most recently applied update
+   * (`current_block_height`). "Find Beacon Signals" keeps only the signals at or above
+   * it: a beacon address that an update added has no signals for this DID before the
+   * block of that update.
+   */
+  #currentBlockHeight = 0;
   /**
    * Opt-in upper bound on multi-round beacon-discovery passes. `Infinity` (the
    * default) leaves discovery unbounded; termination is already guaranteed by
@@ -2637,6 +2649,7 @@ var Resolver = class _Resolver {
           this.#updateHashHistory.push((0, import_common12.canonicalHashBytes)(unsignedUpdate));
           this.#currentVersionId++;
           this.#blockConfirmations = block.confirmations;
+          this.#currentBlockHeight = block.height;
           this.#updated = import_common12.DateUtils.toISOStringNonFractional(import_common12.DateUtils.blocktimeToTimestamp(block.time));
           if (this.#hasUnscannedBeacons()) {
             if (++this.#discoveryRounds > this.#maxDiscoveryRounds) {
@@ -2692,8 +2705,12 @@ var Resolver = class _Resolver {
    * malformed. It fails fast here with a typed error, in the style of the
    * {@link provide} guards, and not later with an invalid date or a false
    * `versionTime` comparison in the ProcessUpdate phase.
+   *
+   * "Find Beacon Signals" finds only the transactions at or above
+   * `current_block_height`, the height of the block of the most recently applied
+   * update. A signal below it is excluded: it emits no data need and applies no update.
    * @param {Array<BeaconSignal>} signals The signals the caller provided for one service.
-   * @returns {Array<BeaconSignal>} The signals at or above the threshold, in the given order.
+   * @returns {Array<BeaconSignal>} The signals at or above the threshold and the height, in the given order.
    * @throws {ResolveError} `INVALID_DID_UPDATE` for an eligible signal with no valid block metadata.
    */
   #eligibleSignals(signals) {
@@ -2717,6 +2734,7 @@ var Resolver = class _Resolver {
           }
         );
       }
+      if (block.height < this.#currentBlockHeight) continue;
       eligible.push(signal);
     }
     return eligible;
@@ -2759,7 +2777,7 @@ var Resolver = class _Resolver {
         if (announcementHash !== need.announcementHash) {
           throw new import_common12.ResolveError(
             `CAS announcement hash mismatch: expected ${need.announcementHash}, got ${announcementHash}.`,
-            import_common12.INVALID_DID_UPDATE,
+            import_common12.MISSING_UPDATE_DATA,
             { expected: need.announcementHash, actual: announcementHash }
           );
         }
@@ -2778,7 +2796,7 @@ var Resolver = class _Resolver {
         if (updateHash !== need.updateHash) {
           throw new import_common12.ResolveError(
             `Signed update hash mismatch: expected ${need.updateHash}, got ${updateHash}.`,
-            import_common12.INVALID_DID_UPDATE,
+            import_common12.INVALID_SIGNAL_DATA,
             { expected: need.updateHash, actual: updateHash }
           );
         }
@@ -2789,16 +2807,21 @@ var Resolver = class _Resolver {
         if (!isSMTProof(data)) {
           throw new import_common12.ResolveError(
             "Provided data for NeedSMTProof is not an SMT proof.",
-            import_common12.INVALID_DID_UPDATE,
+            import_common12.INVALID_SIGNAL_DATA,
             { kind: need.kind }
           );
         }
-        const proofIdHex = (0, import_common12.encode)((0, import_common12.decode)(data.id, "base64urlnopad"), "hex");
-        if (proofIdHex !== need.smtRootHash) {
+        let proofIdHex2;
+        try {
+          proofIdHex2 = (0, import_common12.encode)((0, import_common12.decode)(data.id, "base64urlnopad"), "hex");
+        } catch {
+          proofIdHex2 = void 0;
+        }
+        if (proofIdHex2 !== need.smtRootHash) {
           throw new import_common12.ResolveError(
-            `SMT proof root hash mismatch: expected ${need.smtRootHash}, got ${proofIdHex}`,
-            import_common12.INVALID_DID_UPDATE,
-            { expected: need.smtRootHash, actual: proofIdHex }
+            `SMT proof root hash mismatch: expected ${need.smtRootHash}, got ${proofIdHex2 ?? "an id that does not decode"}.`,
+            import_common12.INVALID_SIGNAL_DATA,
+            { expected: need.smtRootHash, actual: proofIdHex2 }
           );
         }
         this.#sidecarData.smtMap.set(need.smtRootHash, data);

package/dist/esm/core/beacon/smt-beacon.js

@@ -1,8 +1,17 @@
-import { canonicalize } from '@did-btcr2/common';
-import { base64UrlToHash, blockHash, BTCR2MerkleTree, didToIndex, hashToHex, verifySerializedProof } from '@did-btcr2/smt';
+import { canonicalHashBytes, INVALID_SIGNAL_DATA } from '@did-btcr2/common';
+import { base64UrlToHash, BTCR2MerkleTree, hashToHex, verifyProof } from '@did-btcr2/smt';
 import { randomBytes } from '@noble/hashes/utils';
 import { SinglePartyBeacon } from './beacon.js';
 import { SMTBeaconError } from './error.js';
+/** The hex of the base64url `id` of a proof, or `undefined` if the id does not decode to 32 bytes. */
+function proofIdHex(proof) {
+    try {
+        return hashToHex(base64UrlToHash(proof.id));
+    }
+    catch {
+        return undefined;
+    }
+}
 /**
  * Implements {@link https://dcdpr.github.io/did-btcr2/terminology.html#smt-beacon | SMT Beacon}.
  *
@@ -27,15 +36,17 @@ export class SMTBeacon extends SinglePartyBeacon {
     /**
      * Implements {@link https://dcdpr.github.io/did-btcr2/operations/resolve.html#process-smt-beacon | 7.2.e.1 Process SMT Beacon}.
      *
-     * For each signal, the signalBytes contain the hex-encoded SMT root hash.
-     * This method looks up the SMT Proof from the sidecar by root hash,
-     * validates the Merkle inclusion proof, and retrieves the corresponding
-     * signed update using the proof's updateId.
+     * For each signal, the signalBytes contain the hex-encoded SMT root hash
+     * (`smt_root`). This method looks up the SMT Proof from the sidecar by root
+     * hash, checks that the id of the proof is the root, verifies the proof with
+     * the SMT Proof Verification algorithm, and retrieves the signed update by the
+     * proof's updateId. A proof with no updateId announces no update for the DID.
      *
      * @param {Array<BeaconSignal>} signals The array of Beacon Signals to process.
      * @param {SidecarData} sidecar The sidecar data associated with the SMT Beacon.
      * @returns {BeaconProcessResult} Successfully resolved updates and any data needs.
-     * @throws {SMTBeaconError} if proof verification fails or proof is malformed.
+     * @throws {SMTBeaconError} `INVALID_SIGNAL_DATA` if the id of the proof is not the
+     *   signal root, or if the proof does not verify.
      */
     processSignals(signals, sidecar) {
         const updates = new Array();
@@ -43,7 +54,8 @@ export class SMTBeacon extends SinglePartyBeacon {
         // The DID under resolution keys this beacon's leaf index.
         const did = this.did;
         for (const signal of signals) {
-            // Signal bytes are the hex-encoded SMT root hash; smtMap is keyed by proof.id (also hex)
+            // "Process SMT Beacon": the signal bytes are smt_root, the hex SMT root hash.
+            // The smtMap is keyed by the hex of proof.id. No entry = a need for the proof.
             const smtProof = sidecar.smtMap.get(signal.signalBytes);
             if (!smtProof) {
                 // SMT Proof not available, emit a need
@@ -54,29 +66,23 @@ export class SMTBeacon extends SinglePartyBeacon {
                 });
                 continue;
             }
-            // Nonce is required for proof verification (inclusion and non-inclusion).
-            if (!smtProof.nonce) {
-                throw new SMTBeaconError('SMT proof missing required nonce field.', 'INVALID_SMT_PROOF', { smtProof, did });
+            // The id of the proof must equal smt_root. The resolver keys the map by the
+            // hex of the id, so its entries pass. A caller-built map is checked here too.
+            if (proofIdHex(smtProof) !== signal.signalBytes) {
+                throw new SMTBeaconError(`SMT proof id does not equal the signal root ${signal.signalBytes}.`, INVALID_SIGNAL_DATA, { smtProof, did, smtRootHash: signal.signalBytes });
             }
-            // Verify the SMT proof against the on-chain root. Leaf value per spec:
-            // inclusion = hash(hash(nonce) || updateId); non-inclusion = hash(hash(nonce)).
-            // Hash fields are base64url (no padding) per the SMT Proof spec. A
-            // non-inclusion proof (absent updateId) is verified too, not trusted.
-            const index = didToIndex(did);
-            const nonceHash = base64UrlToHash(smtProof.nonce);
-            const candidateHash = smtProof.updateId
-                ? blockHash(blockHash(nonceHash), base64UrlToHash(smtProof.updateId))
-                : blockHash(blockHash(nonceHash));
-            const valid = verifySerializedProof(smtProof, index, candidateHash);
-            if (!valid) {
-                throw new SMTBeaconError('SMT proof verification failed.', 'INVALID_SMT_PROOF', { smtProof, did });
+            // Verify the proof with the SMT Proof Verification algorithm. The nonce and
+            // updateId fields of the proof select the leaf value (four arms). A proof that
+            // does not decode, or that does not walk to the root, is INVALID_SIGNAL_DATA.
+            if (!verifyProof(smtProof, did)) {
+                throw new SMTBeaconError(`SMT proof verification failed for the signal root ${signal.signalBytes}.`, INVALID_SIGNAL_DATA, { smtProof, did, smtRootHash: signal.signalBytes });
             }
-            // Non-inclusion proof verified: no update for this DID this epoch, skip.
-            if (!smtProof.updateId) {
+            // No updateId: the signal announces no update for this DID. No tuple.
+            if (smtProof.updateId === undefined) {
                 continue;
             }
             // Look up the signed update in sidecar updateMap (keyed by hex canonical
-            // hash). The proof's updateId is base64url, so convert to hex to match.
+            // hash). The proof's updateId is the same hash in base64url.
             const updateHashHex = hashToHex(base64UrlToHash(smtProof.updateId));
             const signedUpdate = sidecar.updateMap.get(updateHashHex);
             if (!signedUpdate) {
@@ -105,20 +111,20 @@ export class SMTBeacon extends SinglePartyBeacon {
      * @param {BitcoinConnection} bitcoin The Bitcoin network connection.
      * @param {BroadcastOptions} [options] Optional broadcast configuration (e.g. fee estimator).
      * @return {Promise<BroadcastResult>} The signed update, the signal txid, and the SMT
-     *   inclusion proof (with the leaf nonce embedded). The proof MUST be captured for sidecar
+     *   proof (with the leaf nonce embedded). The proof MUST be captured for sidecar
      *   distribution: the nonce exists only here, so the on-chain signal is unresolvable without it.
      * @throws {BeaconError} if the bitcoin address is invalid, unfunded, or UTXO cannot cover the fee.
      */
     async broadcastSignal(signedUpdate, signer, bitcoin, options) {
         // The DID keys this beacon's leaf index in the tree.
         const did = this.did;
-        // Build a single-entry SMT from the signed update
-        const canonicalBytes = new TextEncoder().encode(canonicalize(signedUpdate));
+        // Build a single-entry SMT in nonce mode: the leaf value is
+        // hash(hash(nonce) + updateId), with updateId the JSON Document Hash of the update.
         const nonce = randomBytes(32);
         const tree = new BTCR2MerkleTree();
-        tree.addEntries([{ did, nonce, signedUpdate: canonicalBytes }]);
+        tree.addEntries([{ did, nonce, updateId: canonicalHashBytes(signedUpdate) }]);
         tree.finalize();
-        // Serialize the inclusion proof (carrying the nonce and updateId) before
+        // Serialize the proof (carrying the nonce and updateId) before
         // broadcasting: it is the only artifact that can link the on-chain root back
         // to the update, and the nonce it embeds is irrecoverable once dropped.
         const proof = tree.proof(did);

package/dist/esm/core/beacon/smt-beacon.js.map

@@ -1 +1 @@
-{"version":3,"file":"smt-beacon.js","sourceRoot":"","sources":["../../../../src/core/beacon/smt-beacon.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"smt-beacon.js","sourceRoot":"","sources":["../../../../src/core/beacon/smt-beacon.ts"],"names":[],"mappings":"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"}

package/dist/esm/core/resolver.js

@@ -1,5 +1,5 @@
 import { getNetwork } from '@did-btcr2/bitcoin';
-import { canonicalHash, canonicalHashBytes, canonicalize, DateUtils, encode as encodeHash, decode as decodeHash, INTERNAL_ERROR, INVALID_DID, INVALID_DID_UPDATE, INVALID_OPTIONS, JSONPatch, JSONUtils, LATE_PUBLISHING_ERROR, NOT_FOUND, ResolveError } from '@did-btcr2/common';
+import { canonicalHash, canonicalHashBytes, canonicalize, DateUtils, encode as encodeHash, decode as decodeHash, INTERNAL_ERROR, INVALID_DID, INVALID_DID_UPDATE, INVALID_OPTIONS, INVALID_SIGNAL_DATA, JSONPatch, JSONUtils, LATE_PUBLISHING_ERROR, MISSING_UPDATE_DATA, NOT_FOUND, ResolveError } from '@did-btcr2/common';
 import { BTCR2_UPDATE_CONTEXT, isBtcr2UpdateContext } from './btcr2-update.js';
 import { BIP340Cryptosuite, BIP340DataIntegrityProof, SchnorrMultikey } from '@did-btcr2/cryptosuite';
 import { CompressedSecp256k1PublicKey } from '@did-btcr2/keypair';
@@ -44,13 +44,16 @@ function isSignedBTCR2Update(value) {
         && value.targetVersionId >= 2
         && isRecord(value.proof);
 }
-/** True if `value` has the shape of an SMT inclusion / non-inclusion proof. */
+/** True if `value` has the shape of an SMT proof: string fields, `hashes` an array of strings. */
 function isSMTProof(value) {
     if (!isRecord(value))
         return false;
     return typeof value.id === 'string'
         && typeof value.collapsed === 'string'
-        && Array.isArray(value.hashes);
+        && Array.isArray(value.hashes)
+        && value.hashes.every(h => typeof h === 'string')
+        && (value.nonce === undefined || typeof value.nonce === 'string')
+        && (value.updateId === undefined || typeof value.updateId === 'string');
 }
 /**
  * Validate `ResolutionOptions.minConf`. `undefined` selects the specification
@@ -180,15 +183,23 @@ export class Resolver {
      * The state of the specification loop, carried across every pass: the version counter
      * (`current_version_id`), the update-hash history that backs duplicate confirmation
      * (`update_hash_history`), the confirmations of the block that contains the most
-     * recently applied unique update (`block_confirmations`), and the header time of that
-     * block as `updated`. A pass that finds a new beacon address returns to discovery, so
-     * the state must not restart: a restart would reject a linear history whose later
-     * updates are announced on beacons that earlier updates added.
+     * recently applied unique update (`block_confirmations`), the height of that block
+     * (`current_block_height`), and the header time of that block as `updated`. A pass
+     * that finds a new beacon address returns to discovery, so the state must not
+     * restart: a restart would reject a linear history whose later updates are
+     * announced on beacons that earlier updates added.
      */
     #currentVersionId = 1;
     #updateHashHistory = [];
     #blockConfirmations = 0;
     #updated;
+    /**
+     * The height of the block that contains the most recently applied update
+     * (`current_block_height`). "Find Beacon Signals" keeps only the signals at or above
+     * it: a beacon address that an update added has no signals for this DID before the
+     * block of that update.
+     */
+    #currentBlockHeight = 0;
     /**
      * Opt-in upper bound on multi-round beacon-discovery passes. `Infinity` (the
      * default) leaves discovery unbounded; termination is already guaranteed by
@@ -670,7 +681,7 @@ export class Resolver {
                     const removed = !BeaconUtils.getBeaconServices(document).some(service => BeaconUtils.parseBitcoinAddress(service.serviceEndpoint) === address);
                     if (removed)
                         continue;
-                    // Step 7, "Check targetVersionId", first arm: targetVersionId <= currentVersionId
+                    // Step 6, "Check targetVersionId", first arm: targetVersionId <= currentVersionId
                     // re-announces an applied version. Confirm that it is a true duplicate, then
                     // skip it. A duplicate does not advance the version counter, does not append
                     // to the history (the slot already holds the applied update, ADR 067), and
@@ -690,22 +701,24 @@ export class Resolver {
                         this.#phase = ResolverPhase.Complete;
                         continue;
                     }
-                    // Step 7, third arm: a version was skipped, so raise LATE_PUBLISHING.
+                    // Step 6, third arm: a version was skipped, so raise LATE_PUBLISHING.
                     if (update.targetVersionId !== this.#currentVersionId + 1) {
                         throw new ResolveError(`Version Id Mismatch: targetVersionId cannot be > currentVersionId + 1`, LATE_PUBLISHING_ERROR, {
                             targetVersionId: update.targetVersionId,
                             currentVersionId: this.#currentVersionId + 1
                         });
                     }
-                    // Step 7, second arm: targetVersionId == currentVersionId + 1. Apply the update,
+                    // Step 6, second arm: targetVersionId == currentVersionId + 1. Apply the update,
                     // append the unsigned update hash to the history, increment the version.
                     this.#currentDocument = Resolver.applyUpdate(document, update, block);
                     const unsignedUpdate = JSONUtils.deleteKeys(update, ['proof']);
                     this.#updateHashHistory.push(canonicalHashBytes(unsignedUpdate));
                     this.#currentVersionId++;
-                    // Step 6: block_confirmations, and the header time as `updated`. On the apply
-                    // path only: the stop above and the duplicate branch stamp nothing.
+                    // "Apply Update": block_confirmations, current_block_height, and the header time
+                    // as `updated`. On the apply path only: the stop above and the duplicate branch
+                    // stamp nothing.
                     this.#blockConfirmations = block.confirmations;
+                    this.#currentBlockHeight = block.height;
                     this.#updated = DateUtils.toISOStringNonFractional(DateUtils.blocktimeToTimestamp(block.time));
                     // The applied update can add a beacon service. "Find Beacon Signals" runs at
                     // the top of every pass for the addresses that are not scanned yet, so the
@@ -763,8 +776,12 @@ export class Resolver {
      * malformed. It fails fast here with a typed error, in the style of the
      * {@link provide} guards, and not later with an invalid date or a false
      * `versionTime` comparison in the ProcessUpdate phase.
+     *
+     * "Find Beacon Signals" finds only the transactions at or above
+     * `current_block_height`, the height of the block of the most recently applied
+     * update. A signal below it is excluded: it emits no data need and applies no update.
      * @param {Array<BeaconSignal>} signals The signals the caller provided for one service.
-     * @returns {Array<BeaconSignal>} The signals at or above the threshold, in the given order.
+     * @returns {Array<BeaconSignal>} The signals at or above the threshold and the height, in the given order.
      * @throws {ResolveError} `INVALID_DID_UPDATE` for an eligible signal with no valid block metadata.
      */
     #eligibleSignals(signals) {
@@ -785,6 +802,11 @@ export class Resolver {
                     mediantime: block?.mediantime
                 });
             }
+            // "Find Beacon Signals" finds only the transactions at or above current_block_height.
+            // A signal before the block of the update that added the address is not a signal
+            // of this DID.
+            if (block.height < this.#currentBlockHeight)
+                continue;
             eligible.push(signal);
         }
         return eligible;
@@ -812,10 +834,12 @@ export class Resolver {
                     throw new ResolveError('Provided data for NeedCASAnnouncement is not a CAS announcement.', INVALID_DID_UPDATE, { kind: need.kind });
                 }
                 // Fail fast if the provided announcement is not the one the on-chain
-                // signal requested: its canonical hash must equal the need's hash.
+                // signal requested: its canonical hash must equal the need's hash. The
+                // specification ("Process CAS Beacon") treats an announcement whose hash is
+                // not map_update_hash as not available from CAS: MISSING_UPDATE_DATA.
                 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 });
+                    throw new ResolveError(`CAS announcement hash mismatch: expected ${need.announcementHash}, got ${announcementHash}.`, MISSING_UPDATE_DATA, { expected: need.announcementHash, actual: announcementHash });
                 }
                 this.#sidecarData.casMap.set(announcementHash, data);
                 break;
@@ -825,22 +849,33 @@ export class Resolver {
                     throw new ResolveError('Provided data for NeedSignedUpdate is not a signed BTCR2 update.', INVALID_DID_UPDATE, { kind: need.kind });
                 }
                 // Fail fast if the provided update is not the one the on-chain signal
-                // requested: its canonical hash must equal the need's hash.
+                // requested: the specification compares the JSON Document Hash of a
+                // retrieved update to update_hash, and a mismatch is INVALID_SIGNAL_DATA.
                 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 });
+                    throw new ResolveError(`Signed update hash mismatch: expected ${need.updateHash}, got ${updateHash}.`, INVALID_SIGNAL_DATA, { expected: need.updateHash, actual: updateHash });
                 }
                 this.#sidecarData.updateMap.set(updateHash, data);
                 break;
             }
             case 'NeedSMTProof': {
+                // A proof of another shape is data for the signal that does not agree with
+                // its Signal Bytes: INVALID_SIGNAL_DATA, as for the id and the walk below.
                 if (!isSMTProof(data)) {
-                    throw new ResolveError('Provided data for NeedSMTProof is not an SMT proof.', INVALID_DID_UPDATE, { kind: need.kind });
+                    throw new ResolveError('Provided data for NeedSMTProof is not an SMT proof.', INVALID_SIGNAL_DATA, { kind: need.kind });
+                }
+                // proof.id is base64url per spec; smtRootHash is the hex on-chain signal. The
+                // specification ("Process SMT Beacon") compares the id of smt_proof to
+                // smt_root: a mismatch, or an id that does not decode, is INVALID_SIGNAL_DATA.
+                let proofIdHex;
+                try {
+                    proofIdHex = encodeHash(decodeHash(data.id, 'base64urlnopad'), 'hex');
+                }
+                catch {
+                    proofIdHex = undefined;
                 }
-                // proof.id is base64url per spec; smtRootHash is the hex on-chain signal.
-                const proofIdHex = encodeHash(decodeHash(data.id, 'base64urlnopad'), 'hex');
                 if (proofIdHex !== need.smtRootHash) {
-                    throw new ResolveError(`SMT proof root hash mismatch: expected ${need.smtRootHash}, got ${proofIdHex}`, INVALID_DID_UPDATE, { expected: need.smtRootHash, actual: proofIdHex });
+                    throw new ResolveError(`SMT proof root hash mismatch: expected ${need.smtRootHash}, got ${proofIdHex ?? 'an id that does not decode'}.`, INVALID_SIGNAL_DATA, { expected: need.smtRootHash, actual: proofIdHex });
                 }
                 this.#sidecarData.smtMap.set(need.smtRootHash, data);
                 break;