did-beta-bch 3.1.1 → 3.1.2

package/CHANGELOG.md

@@ -2,6 +2,34 @@
 
 All notable changes to `cashlet-did` will be documented here.
 
+## [3.1.2] — 2026-11-07
+
+### Fixed
+- `verifyBchAnchorProof`: corrected the ASERT height calculation and added a
+  configurable `maxCheckpointAgeSeconds` (default 14 days) plus checkpoint
+  timestamp validation.
+- `resolveIdentity` and `queryRelays`: require valid Nostr signatures before
+  trusting or deduplicating events; revocations now require a valid kind `5`
+  event authored by the binding key.
+- BIP47 payment codes now validate the checksum, flags, reserved bytes, and
+  public key.
+- Credential and rating events now include unique NIP-33 `d` tags.
+- Electrum client rejects malformed JSON responses and broadcast txid
+  mismatches.
+- NIP-98 verification rejects duplicate or malformed `u` and `method` tags.
+- `verifyChallengeProof` now requires `issuedAt`; missing, stale, or
+  future-dated challenges are rejected.
+- Fixed a syntax error in `demo/verifier.mjs`.
+
+### Changed
+- Requires Node.js 22+ for the built-in WebSocket transport.
+- Anchor verification defaults to a 14-day maximum checkpoint age; refresh the
+  trusted checkpoint and review it out-of-band.
+
+### Breaking
+- TypeScript callers of `verifyChallengeProof` must pass `issuedAt` as the
+  third argument (or `audience, issuedAt` for audience-bound challenges).
+
 ## [2.0.0] — 2026-11-03
 
 ### Breaking

package/PROTOCOL.md

@@ -141,8 +141,11 @@ of these tags: `u` (verification endpoint), `method` (`POST`), `audience`,
 Both proofs MUST match the same verified binding's BCH address and Nostr
 pubkey, nonce, audience, endpoint, issue time, and expiration.
 
-The server MUST issue an unpredictable, one-time challenge, persist it, and
-atomically consume it only after validating both signatures. Browser-local
+The server MUST issue an unpredictable, one-time challenge, persist its issue
+time, and atomically consume it only after validating both signatures.
+`verifyChallengeProof` requires the server-issued `issuedAt` and rejects a
+challenge older than five minutes or dated more than 60 seconds in the future.
+Browser-local
 challenge state alone is not server-enforced authentication.
 `verifyDualChallengeProof` checks cryptographic and context binding; the
 application is responsible for durable single-use challenge state.
@@ -179,9 +182,15 @@ The exported `BCH_MAINNET_CHECKPOINT` is a fixed mainnet trust root. The result
 is **checkpointed SPV**, not full-node validation: proof sources are untrusted,
 the checkpoint must not be fetched from the same endpoint, and the proof does
 not establish that a supplied branch is the globally highest-work branch.
-There is no chipnet checkpoint or proof-fetch adapter in this package, so
-chipnet anchors remain unverifiable unless an application supplies an
-independently reviewed checkpoint and consensus configuration.
+`fetchAnchorProof` retrieves headers from an Electrum endpoint, but the
+checkpoint itself must be supplied and reviewed out-of-band. Verification
+rejects checkpoints older than `maxCheckpointAgeSeconds` (default 14 days), so
+applications must refresh the trust root regularly.
+
+`BCH_CHIPNET_CHECKPOINT` and `BCH_CHIPNET_ASERT_PARAMETERS` are provided for
+chipnet testing, but chipnet may reset. After a reset, callers must supply a
+new checkpoint derived from the post-reset chain; do not treat the bundled
+chipnet constants as a long-lived trust root.
 
 ## 9. Other helpers
 

package/README.md

@@ -134,7 +134,9 @@ const valid = verifyDualChallengeProof(
 ```
 
 Challenge issuance and one-time consumption belong on a server with durable,
-atomic storage. Do not treat browser-only challenge state as authentication.
+atomic storage. `verifyChallengeProof` requires the server-issued `issuedAt`
+and rejects challenges older than five minutes. Do not treat browser-only
+challenge state as authentication.
 
 ### Key rotation
 
@@ -216,10 +218,15 @@ const result = verifyBchAnchorProof(proof, bindingId, {
   checkpoint: BCH_MAINNET_CHECKPOINT,
   asert: BCH_MAINNET_ASERT_PARAMETERS,
   minConfirmations: 6,
+  maxCheckpointAgeSeconds: 14 * 24 * 60 * 60, // default; update the checkpoint regularly
 })
 ```
 
-`wsTransport` works in both browser and Node.js (Node 22+ has native WebSocket). For Node < 22 or TCP, implement the three-method `ElectrumTransport` interface.
+Checkpoints age out. The default `maxCheckpointAgeSeconds` is 14 days, which
+matches the 2,048-header proof window at 144 BCH blocks/day; applications should
+refresh the trusted checkpoint and review it out-of-band.
+
+`wsTransport` works in both browser and Node.js. Node 22+ is required for the built-in WebSocket client; for other runtimes or TCP, implement the three-method `ElectrumTransport` interface.
 
 Chipnet uses `BCH_CHIPNET_CHECKPOINT` and `BCH_CHIPNET_ASERT_PARAMETERS`. Note chipnet is a test network that may reset; the checkpoint is valid for the current chain instance only.
 

package/dist/anchor-client.js

@@ -3,6 +3,7 @@
  * SPV proofs. Works in Node.js (TCP) and browsers (WebSocket) via a pluggable
  * transport. Default transports are provided for each environment.
  */
+import { hash256, hexToBin, binToHex } from "@bitauth/libauth";
 export const ELECTRUM_MAINNET_TCP = "electroncash.dk:50001";
 export const ELECTRUM_MAINNET_WS = "wss://electroncash.dk:50004";
 export const ELECTRUM_CHIPNET_TCP = "chipnet.imaginary.cash:50001";
@@ -15,7 +16,16 @@ async function electrumCall(transport, requests, timeoutMs = 15000) {
         transport.onLine(line => {
             if (!line.trim())
                 return;
-            const msg = JSON.parse(line);
+            let msg;
+            try {
+                msg = JSON.parse(line);
+            }
+            catch {
+                clearTimeout(timer);
+                transport.close();
+                reject(new Error("Malformed Electrum response"));
+                return;
+            }
             if (msg.error) {
                 clearTimeout(timer);
                 transport.close();
@@ -65,6 +75,14 @@ export async function broadcastAnchorTx(txHex, transport) {
     const txid = results.get(1);
     if (typeof txid !== "string" || !/^[0-9a-f]{64}$/.test(txid))
         throw new Error(`Unexpected broadcast response: ${JSON.stringify(txid)}`);
+    if (!/^(?:[0-9a-f]{2})+$/i.test(txHex))
+        throw new Error("Invalid transaction hex");
+    const raw = hexToBin(txHex);
+    if (typeof raw === "string")
+        throw new Error("Invalid transaction hex");
+    const expectedTxid = binToHex(Uint8Array.from(hash256(raw)).reverse());
+    if (txid !== expectedTxid)
+        throw new Error(`Broadcast txid does not match transaction: expected ${expectedTxid}, got ${txid}`);
     return txid;
 }
 /**

package/dist/anchor-verification.d.ts

@@ -23,6 +23,7 @@ export interface BchAnchorVerificationOptions {
     asert: BchAsertParameters;
     minConfirmations?: number;
     maxHeaders?: number;
+    maxCheckpointAgeSeconds?: number;
     now?: number;
 }
 export interface BchAnchorVerificationResult {

package/dist/anchor-verification.js

@@ -2,6 +2,7 @@ import { decodeTransaction, hash256, hexToBin } from "@bitauth/libauth";
 import { ANCHOR_PREFIX } from "./anchor.js";
 const HEADER_BYTES = 80;
 const MAX_PROOF_HEADERS = 2048;
+const DEFAULT_MAX_CHECKPOINT_AGE_SECS = 14 * 24 * 60 * 60;
 const TARGET_SPACING_SECS = 600n;
 const ASERT_HALF_LIFE_SECS = 172800n;
 const ASERT_RADIX = 1n << 16n;
@@ -62,10 +63,10 @@ function targetToCompact(target) {
     }
     return ((size << 24) | compact) >>> 0;
 }
-function asertTarget(parameters, previousHeight, previousTime) {
+function asertTarget(parameters, candidateHeight, previousTime) {
     const anchorTarget = compactToTarget(parameters.anchorBits);
     const timeDifference = BigInt(previousTime - parameters.anchorPreviousBlockTime);
-    const heightDifference = BigInt(previousHeight - parameters.anchorHeight);
+    const heightDifference = BigInt(candidateHeight - parameters.anchorHeight);
     if (heightDifference < 0n)
         throw new Error("Checkpoint predates the ASERT anchor");
     const exponent = ((timeDifference - TARGET_SPACING_SECS * heightDifference) * ASERT_RADIX) /
@@ -88,7 +89,7 @@ function expectedBits(parameters, previousHeight, previous, candidateTime) {
     if (parameters.allowMinDifficultyBlocks &&
         candidateTime > previous.timestamp + Number(2n * TARGET_SPACING_SECS))
         return parameters.powLimitBits;
-    return targetToCompact(asertTarget(parameters, previousHeight, previous.timestamp));
+    return targetToCompact(asertTarget(parameters, previousHeight + 1, previous.timestamp));
 }
 function assertProofOfWork(header, powLimit) {
     const target = compactToTarget(header.bits);
@@ -146,10 +147,16 @@ export function verifyBchAnchorProof(proof, bindingId, options) {
             return result("invalid", "Invalid binding ID");
         const minConfirmations = options.minConfirmations ?? 6;
         const maxHeaders = options.maxHeaders ?? MAX_PROOF_HEADERS;
+        const maxCheckpointAge = options.maxCheckpointAgeSeconds ?? DEFAULT_MAX_CHECKPOINT_AGE_SECS;
+        const now = options.now ?? Math.floor(Date.now() / 1000);
         if (!Number.isSafeInteger(minConfirmations) || minConfirmations < 1)
             return result("invalid", "Minimum confirmations must be a positive integer");
         if (!Number.isSafeInteger(maxHeaders) || maxHeaders < 1)
             return result("invalid", "Maximum header count must be a positive integer");
+        if (!Number.isSafeInteger(maxCheckpointAge) || maxCheckpointAge < 1)
+            return result("invalid", "Maximum checkpoint age must be a positive integer");
+        if (!Number.isSafeInteger(now))
+            return result("invalid", "Current time must be a safe integer");
         if (!proof || !Array.isArray(proof.headers) || proof.headers.length === 0)
             return result("unverifiable", "Header chain proof is missing");
         if (proof.headers.length > maxHeaders)
@@ -164,8 +171,11 @@ export function verifyBchAnchorProof(proof, bindingId, options) {
             checkpointHeader.hashHex !== checkpoint.hash.toLowerCase() ||
             !Array.isArray(checkpoint.recentTimestamps) ||
             checkpoint.recentTimestamps.length !== 11 ||
+            !checkpoint.recentTimestamps.every(timestamp => Number.isSafeInteger(timestamp)) ||
             checkpoint.recentTimestamps[checkpoint.recentTimestamps.length - 1] !== checkpointHeader.timestamp)
             return result("unverifiable", "Invalid or unsupported trusted checkpoint");
+        if (now - checkpointHeader.timestamp > maxCheckpointAge)
+            return result("unverifiable", "Checkpoint is older than the maximum allowed age");
         if (!Number.isSafeInteger(proof.blockHeight) || proof.blockHeight <= checkpoint.height)
             return result("unverifiable", "Anchor predates the configured trusted checkpoint");
         if (!Number.isSafeInteger(proof.blockHeight) ||
@@ -180,7 +190,6 @@ export function verifyBchAnchorProof(proof, bindingId, options) {
         let timestamps = checkpoint.recentTimestamps.slice(-11);
         let inclusionHeader;
         const powLimit = compactToTarget(options.asert.powLimitBits);
-        const now = options.now ?? Math.floor(Date.now() / 1000);
         for (let offset = 0; offset < proof.headers.length; offset++) {
             const height = checkpoint.height + offset + 1;
             const header = parseHeader(proof.headers[offset]);

package/dist/bip47.js

@@ -2,7 +2,7 @@
  * BIP47 v1 reusable payment code helpers.
  * Notification transactions and scanning are wallet-specific and out of scope.
  */
-import { secp256k1, hash160, encodeCashAddress, deriveHdPublicNodeChild, deriveHdPrivateNodeChild, deriveHdPrivateNodeFromBip39Mnemonic, deriveHdPath, deriveHdPublicNode, } from "@bitauth/libauth";
+import { secp256k1, sha256, hash160, encodeCashAddress, deriveHdPublicNodeChild, deriveHdPrivateNodeChild, deriveHdPrivateNodeFromBip39Mnemonic, deriveHdPath, deriveHdPublicNode, } from "@bitauth/libauth";
 const BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
 // BIP47 payment code: [0x47][0x01][0x00][pubkey 33][chaincode 32][reserved 13][checksum 4] = 85 bytes
 const PC_VERSION = 0x47;
@@ -66,6 +66,9 @@ async function sha256Once(data) {
 async function paymentCodeChecksum(versionAndPayload) {
     return (await sha256Once(await sha256Once(versionAndPayload))).slice(0, 4);
 }
+function paymentCodeChecksumSync(versionAndPayload) {
+    return sha256.hash(sha256.hash(versionAndPayload)).slice(0, 4);
+}
 /**
  * Encode a BIP47 v1 payment code from a public key and chain code.
  */
@@ -96,8 +99,19 @@ export function parsePaymentCode(paymentCode) {
     const payload = decoded.slice(1, 1 + PC_PAYLOAD_BYTES);
     if (payload[0] !== 0x01)
         throw new Error(`Unsupported payment code payload version: ${payload[0]}`);
+    if (payload[1] !== 0x00)
+        throw new Error(`Unsupported payment code features: 0x${payload[1].toString(16)}`);
+    if (!payload.slice(67, PC_PAYLOAD_BYTES).every(byte => byte === 0))
+        throw new Error("Invalid payment code reserved bytes");
+    const checksum = decoded.slice(PC_PAYLOAD_BYTES + 1);
+    const expected = paymentCodeChecksumSync(decoded.slice(0, PC_PAYLOAD_BYTES + 1));
+    if (checksum.length !== 4 || !checksum.every((byte, index) => byte === expected[index]))
+        throw new Error("Invalid payment code checksum");
+    const publicKey = payload.slice(2, 35);
+    if (!secp256k1.validatePublicKey(publicKey))
+        throw new Error("Invalid payment code public key");
     return {
-        publicKey: payload.slice(2, 35),
+        publicKey,
         chainCode: payload.slice(35, 67),
     };
 }

package/dist/credentials.js

@@ -6,6 +6,10 @@
 import { finalizeEvent, nip19, getPublicKey, verifyEvent } from "nostr-tools";
 import { queryRelays, publishToRelays, DEFAULT_RELAYS } from "./relay.js";
 export const CREDENTIAL_KIND = 30085;
+function credentialAddressTag(subjectPubkey, type, issuedAt) {
+    const nonce = Array.from(crypto.getRandomValues(new Uint8Array(16)), byte => byte.toString(16).padStart(2, "0")).join("");
+    return `${type}:${subjectPubkey}:${issuedAt}:${nonce}`;
+}
 /** Issue a credential — issuer signs a Nostr event attesting a claim about subjectNpub */
 export async function issueCredential(subjectNpub, type, issuerPrivkey, claims, relays = DEFAULT_RELAYS) {
     const decoded = nip19.decode(subjectNpub);
@@ -22,6 +26,7 @@ export async function issueCredential(subjectNpub, type, issuerPrivkey, claims,
         kind: CREDENTIAL_KIND,
         created_at: payload.issuedAt,
         tags: [
+            ["d", credentialAddressTag(subjectPubkey, type, payload.issuedAt)],
             ["p", subjectPubkey],
             ["credential-type", type],
             ["t", "cashlet-did-credential"],
@@ -130,6 +135,7 @@ export async function issueRating(subjectNpub, rating, issuerPrivkey, opts = {},
         kind: CREDENTIAL_KIND,
         created_at: payload.issuedAt,
         tags: [
+            ["d", credentialAddressTag(subjectPubkey, "rating", payload.issuedAt)],
             ["p", subjectPubkey],
             ["credential-type", "rating"],
             ["rating", String(rating)],

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { buildDisclosure, verifyDisclosure, type Disclosure, type DisclosureReveal, } from "./disclosure.js";
-export { parsePaymentCode, encodePaymentCode, derivePaymentCode, derivePaymentAddress, derivePaymentPrivkey, hdPublicNodeFromPaymentCode, type PaymentCode, type EncodedPaymentCode, } from "./bip47.js";
+export { parsePaymentCode, encodePaymentCode, derivePaymentCode, derivePaymentAddress, derivePaymentPrivkey, hdPublicNodeFromPaymentCode, deriveHdPath, deriveHdPrivateNodeFromBip39Mnemonic, type PaymentCode, type EncodedPaymentCode, } from "./bip47.js";
 export { buildAnchorTx, ANCHOR_PREFIX, type AnchorUtxo, type AnchorResult, } from "./anchor.js";
 export { verifyBchAnchorProof, BCH_MAINNET_ASERT_PARAMETERS, BCH_MAINNET_CHECKPOINT, BCH_CHIPNET_ASERT_PARAMETERS, BCH_CHIPNET_CHECKPOINT, type BchSpvCheckpoint, type BchAsertParameters, type BchAnchorProof, type BchAnchorVerificationOptions, type BchAnchorVerificationResult, } from "./anchor-verification.js";
 export { broadcastAnchorTx, fetchAnchorProof, wsTransport, ELECTRUM_MAINNET_TCP, ELECTRUM_MAINNET_WS, ELECTRUM_CHIPNET_TCP, ELECTRUM_CHIPNET_WS, type ElectrumTransport, } from "./anchor-client.js";

package/dist/index.js

@@ -1,5 +1,5 @@
 export { buildDisclosure, verifyDisclosure, } from "./disclosure.js";
-export { parsePaymentCode, encodePaymentCode, derivePaymentCode, derivePaymentAddress, derivePaymentPrivkey, hdPublicNodeFromPaymentCode, } from "./bip47.js";
+export { parsePaymentCode, encodePaymentCode, derivePaymentCode, derivePaymentAddress, derivePaymentPrivkey, hdPublicNodeFromPaymentCode, deriveHdPath, deriveHdPrivateNodeFromBip39Mnemonic, } from "./bip47.js";
 export { buildAnchorTx, ANCHOR_PREFIX, } from "./anchor.js";
 export { verifyBchAnchorProof, BCH_MAINNET_ASERT_PARAMETERS, BCH_MAINNET_CHECKPOINT, BCH_CHIPNET_ASERT_PARAMETERS, BCH_CHIPNET_CHECKPOINT, } from "./anchor-verification.js";
 export { broadcastAnchorTx, fetchAnchorProof, wsTransport, ELECTRUM_MAINNET_TCP, ELECTRUM_MAINNET_WS, ELECTRUM_CHIPNET_TCP, ELECTRUM_CHIPNET_WS, } from "./anchor-client.js";

package/dist/nip98.js

@@ -58,11 +58,13 @@ export async function verifyHttpAuth(authHeader, url, method, opts = {}) {
     if (event.created_at - now > HTTP_AUTH_CLOCK_SKEW)
         return { valid: false, error: "Event timestamp is in the future" };
     // 4. URL + method tags
-    const uTag = event.tags.find((t) => t[0] === "u");
-    const mTag = event.tags.find((t) => t[0] === "method");
-    if (uTag?.[1] !== url)
+    if (!Array.isArray(event.tags))
+        return { valid: false, error: "Malformed tags" };
+    const uTags = event.tags.filter((t) => t[0] === "u");
+    const mTags = event.tags.filter((t) => t[0] === "method");
+    if (uTags.length !== 1 || uTags[0].length !== 2 || uTags[0][1] !== url)
         return { valid: false, error: "URL mismatch" };
-    if (mTag?.[1] !== method.toUpperCase())
+    if (mTags.length !== 1 || mTags[0].length !== 2 || mTags[0][1] !== method.toUpperCase())
         return { valid: false, error: "Method mismatch" };
     if (opts.body === undefined)
         return { valid: false, error: "Request body must be provided (use null when absent)" };

package/dist/relay.js

@@ -1,3 +1,4 @@
+import { verifyEvent } from "nostr-tools";
 const CONNECT_TIMEOUT_MS = 5000;
 const RESPONSE_TIMEOUT_MS = 8000;
 const MAX_EVENTS_PER_RELAY = 200;
@@ -67,11 +68,25 @@ export async function queryRelay(url, filter) {
         return [];
     }
 }
+function isValidEvent(event) {
+    if (!event || typeof event.id !== "string")
+        return false;
+    try {
+        return verifyEvent(event);
+    }
+    catch {
+        return false;
+    }
+}
 export async function queryRelays(relays, filter) {
     const results = await Promise.all(relays.map(r => queryRelay(r, filter)));
     const seen = new Set();
-    return results.flat().filter(e => { if (seen.has(e.id))
-        return false; seen.add(e.id); return true; });
+    return results.flat().filter(e => {
+        if (!isValidEvent(e) || seen.has(e.id))
+            return false;
+        seen.add(e.id);
+        return true;
+    });
 }
 export const DEFAULT_RELAYS = [
     "wss://nos.lol",

package/dist/verify.d.ts

@@ -66,13 +66,18 @@ export declare function verifyDualChallengeProof(proof: DualChallengeProof, expe
 }): boolean;
 /** Verify a challenge-response proof.
  * The wallet signs the exact text produced by `bchChallengePayload`.
- * @param issuedAt - unix timestamp when the challenge was issued; if provided, rejects proofs older than 5 minutes.
+ * @param issuedAt - unix timestamp when the challenge was issued; required, rejects proofs older than 5 minutes.
  */
 export declare function verifyChallengeProof(proof: {
     signature: string;
     payload: string;
     address: string;
-}, nonce: string, audience?: string, issuedAt?: number): boolean;
+}, nonce: string, issuedAt: number): boolean;
+export declare function verifyChallengeProof(proof: {
+    signature: string;
+    payload: string;
+    address: string;
+}, nonce: string, audience: string | undefined, issuedAt: number): boolean;
 /**
  * Resolve a BCH address from an npub — the primary pay-by-handle entry point.
  * Verifies both BCH and Nostr signatures before returning the address.

package/dist/verify.js

@@ -105,6 +105,31 @@ function decodeNpub(npub) {
         return null;
     }
 }
+function collectVerifiedRevocationIds(revocations, pubkey) {
+    const revokedIds = new Set();
+    for (const revocation of revocations) {
+        if (!revocation ||
+            revocation.kind !== 5 ||
+            revocation.pubkey !== pubkey ||
+            !Array.isArray(revocation.tags))
+            continue;
+        try {
+            if (!verifyEvent(revocation))
+                continue;
+        }
+        catch {
+            continue;
+        }
+        for (const tag of revocation.tags) {
+            if (Array.isArray(tag) &&
+                tag[0] === "e" &&
+                typeof tag[1] === "string" &&
+                /^[0-9a-f]{64}$/.test(tag[1]))
+                revokedIds.add(tag[1]);
+        }
+    }
+    return revokedIds;
+}
 /** Resolve a BCH address from an npub via Nostr relays */
 export async function resolveIdentity(npub, relays = DEFAULT_RELAYS) {
     const pubkey = decodeNpub(npub);
@@ -116,17 +141,20 @@ export async function resolveIdentity(npub, relays = DEFAULT_RELAYS) {
     ]);
     if (!events.length)
         return null;
-    const revokedIds = new Set(revocations.flatMap(e => Array.isArray(e.tags)
-        ? e.tags.filter(t => Array.isArray(t) && t[0] === "e" && typeof t[1] === "string").map(t => t[1])
-        : []));
-    // Pick latest non-revoked event
-    const resolvedEvents = events
+    const candidates = events
         .filter(e => e && e.pubkey === pubkey && Array.isArray(e.tags) && typeof e.content === "string")
-        .filter(e => !revokedIds.has(e.id))
         .map(event => resolvedIdentityFromEvent(event))
-        .filter((identity) => identity !== null)
+        .filter((identity) => identity !== null);
+    const verified = [];
+    for (const candidate of candidates) {
+        if ((await verifyIdentity(candidate)).status === "verified")
+            verified.push(candidate);
+    }
+    const revokedIds = collectVerifiedRevocationIds(revocations, pubkey);
+    const [latest] = verified
+        .filter(identity => !revokedIds.has(identity.rawEvent.id))
         .sort((a, b) => b.rawEvent.created_at - a.rawEvent.created_at);
-    return resolvedEvents[0] ? { ...resolvedEvents[0], npub } : null;
+    return latest ? { ...latest, npub } : null;
 }
 /** Verify the BCH + Nostr signatures on a resolved identity */
 export async function verifyIdentity(resolved) {
@@ -348,21 +376,19 @@ export function verifyDualChallengeProof(proof, expected) {
         return false;
     }
 }
-/** Verify a challenge-response proof.
- * The wallet signs the exact text produced by `bchChallengePayload`.
- * @param issuedAt - unix timestamp when the challenge was issued; if provided, rejects proofs older than 5 minutes.
- */
-export function verifyChallengeProof(proof, nonce, audience, issuedAt) {
+export function verifyChallengeProof(proof, nonce, audienceOrIssuedAt, issuedAtArg) {
+    const audience = typeof audienceOrIssuedAt === "number" ? undefined : audienceOrIssuedAt;
+    const issuedAt = typeof audienceOrIssuedAt === "number" ? audienceOrIssuedAt : issuedAtArg;
     if (!proof ||
         typeof proof.signature !== "string" ||
         typeof proof.payload !== "string" ||
         typeof proof.address !== "string" ||
         typeof nonce !== "string")
         return false;
-    if (issuedAt !== undefined &&
-        (!Number.isSafeInteger(issuedAt) ||
-            issuedAt > Math.floor(Date.now() / 1000) + 60 ||
-            Math.floor(Date.now() / 1000) - issuedAt > CHALLENGE_TTL_SECS))
+    if (issuedAt === undefined ||
+        !Number.isSafeInteger(issuedAt) ||
+        issuedAt > Math.floor(Date.now() / 1000) + 60 ||
+        Math.floor(Date.now() / 1000) - issuedAt > CHALLENGE_TTL_SECS)
         return false;
     let expectedPayload;
     try {
@@ -555,16 +581,7 @@ async function isBindingRevoked(event, relays) {
         authors: [event.pubkey],
         limit: 100,
     });
-    return revocations.some(revocation => {
-        try {
-            return verifyEvent(revocation) &&
-                revocation.pubkey === event.pubkey &&
-                revocation.tags.some(tag => tag[0] === "e" && tag[1] === event.id);
-        }
-        catch {
-            return false;
-        }
-    });
+    return collectVerifiedRevocationIds(revocations, event.pubkey).has(event.id);
 }
 /**
  * Resolve a BCH address from a NIP-05 handle (e.g. "alice@cashlet.app")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "did-beta-bch",
-  "version": "3.1.1",
+  "version": "3.1.2",
   "description": "Decentralised identity protocol binding BCH addresses to Nostr public keys",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,8 +18,7 @@
     "PROTOCOL.md"
   ],
   "scripts": {
-    "build": "tsc && npm run build:demo",
-    "build:demo": "esbuild demo/client.js --bundle --format=esm --platform=browser --target=es2022 --outfile=demo/bundle.js",
+    "build": "tsc",
     "test": "node --test test/cashlet-did.test.mjs",
     "typecheck": "tsc --noEmit",
     "prepublishOnly": "npm run build"
@@ -37,7 +36,7 @@
   "author": "",
   "license": "MIT",
   "engines": {
-    "node": ">=18"
+    "node": ">=22"
   },
   "dependencies": {
     "@bitauth/libauth": "^3.1.0-next.8",
@@ -46,7 +45,6 @@
     "nostr-tools": "^2.0.0"
   },
   "devDependencies": {
-    "esbuild": "^0.28.2",
     "typescript": "^5.4.0"
   }
 }