did-beta-bch 1.2.0 → 2.0.0

package/dist/verify.js

@@ -1,16 +1,29 @@
 import { verifyEvent, nip05 } from "nostr-tools";
 import { secp256k1, hash256, encodeCashAddress, hash160 } from "@bitauth/libauth";
-import { canonicalize, sha256hex, bchSigningPayload, BINDING_KIND, PROTOCOL_ID, } from "./binding.js";
+import { canonicalize, sha256hex, bchSigningPayload, BINDING_KIND, PROTOCOL_ID, PROTOCOL_VERSION, } from "./binding.js";
 import { queryRelays, DEFAULT_RELAYS } from "./relay.js";
 import { CashletDidError } from "./errors.js";
 import { nip19 } from "nostr-tools";
-/** Encode n as a Bitcoin-style varint (compact size). */
+import { BCH_PROOF_FORMAT, normalizeBchMessageSignature, } from "./signing.js";
+/** Encode n as a Bitcoin CompactSize integer. */
 function varint(n) {
     if (n < 0xfd)
         return new Uint8Array([n]);
+    const value = BigInt(n);
     if (n <= 0xffff)
-        return new Uint8Array([0xfd, n & 0xff, (n >> 8) & 0xff]);
-    return new Uint8Array([0xfe, n & 0xff, (n >> 8) & 0xff, (n >> 16) & 0xff, (n >> 24) & 0xff]);
+        return new Uint8Array([0xfd, Number(value & 0xffn), Number((value >> 8n) & 0xffn)]);
+    if (n <= 0xffffffff)
+        return new Uint8Array([
+            0xfe,
+            Number(value & 0xffn),
+            Number((value >> 8n) & 0xffn),
+            Number((value >> 16n) & 0xffn),
+            Number((value >> 24n) & 0xffn),
+        ]);
+    return new Uint8Array([
+        0xff,
+        ...Array.from({ length: 8 }, (_, i) => Number((value >> BigInt(i * 8)) & 0xffn)),
+    ]);
 }
 /**
  * Compute the double-SHA256 hash used by Bitcoin signed messages.
@@ -23,16 +36,28 @@ function bitcoinMsgHash(message) {
     const prefix = enc.encode("\x18Bitcoin Signed Message:\n");
     return hash256(new Uint8Array([...prefix, ...varint(msgBytes.length), ...msgBytes]));
 }
-function recoverBchAddress(sigHex, msgHash, expectedAddress) {
-    const sig = Uint8Array.from(sigHex.match(/.{2}/g).map(b => parseInt(b, 16)));
-    const addrPrefix = (expectedAddress?.split(":")[0] ?? "bitcoincash");
-    const tryRecover = (compact, id) => {
+function recoverBchAddress(signatureBase64, msgHash, expectedAddress) {
+    try {
+        normalizeBchMessageSignature(signatureBase64);
+    }
+    catch {
+        return null;
+    }
+    const bytes = Uint8Array.from(atob(signatureBase64), c => c.charCodeAt(0));
+    const recoveryId = (bytes[0] - 31);
+    const compact = bytes.slice(1);
+    const prefixes = expectedAddress
+        ? [expectedAddress.split(":")[0]]
+        : ["bitcoincash", "bchtest"];
+    const tryRecover = (prefix) => {
         try {
-            const pub = secp256k1.recoverPublicKeyCompressed(compact, id, msgHash);
+            if (prefix !== "bitcoincash" && prefix !== "bchtest")
+                return null;
+            const pub = secp256k1.recoverPublicKeyCompressed(compact, recoveryId, msgHash);
             if (!(pub instanceof Uint8Array))
                 return null;
             for (const type of ["p2pkh", "p2pkhWithTokens"]) {
-                const r = encodeCashAddress({ prefix: addrPrefix, type, payload: hash160(pub) });
+                const r = encodeCashAddress({ prefix: prefix, type, payload: hash160(pub) });
                 const addr = r?.address ?? (typeof r === "string" ? r : null);
                 if (addr && (!expectedAddress || addr === expectedAddress))
                     return addr;
@@ -41,108 +66,232 @@ function recoverBchAddress(sigHex, msgHash, expectedAddress) {
         catch { /* try next */ }
         return null;
     };
-    // 65-byte: recovery ID is encoded in byte 0 — use it directly, no brute-force
-    if (sig.length === 65) {
-        return tryRecover(sig.slice(1), (sig[0] & 0x03));
-    }
-    // 64-byte raw compact: try all recovery IDs
-    for (const id of [0, 1, 2, 3]) {
-        const addr = tryRecover(sig, id);
+    for (const prefix of prefixes) {
+        const addr = tryRecover(prefix);
         if (addr)
             return addr;
     }
     return null;
 }
+function decodeNpub(npub) {
+    if (typeof npub !== "string")
+        return null;
+    try {
+        const decoded = nip19.decode(npub);
+        if (decoded.type !== "npub" || typeof decoded.data !== "string" || !/^[0-9a-f]{64}$/.test(decoded.data))
+            return null;
+        return decoded.data;
+    }
+    catch {
+        return null;
+    }
+}
 /** Resolve a BCH address from an npub via Nostr relays */
 export async function resolveIdentity(npub, relays = DEFAULT_RELAYS) {
-    const decoded = nip19.decode(npub);
-    if (decoded.type !== "npub")
+    const pubkey = decodeNpub(npub);
+    if (!pubkey)
         return null;
-    const pubkey = decoded.data;
     const [events, revocations] = await Promise.all([
         queryRelays(relays, { kinds: [BINDING_KIND], authors: [pubkey], "#t": [PROTOCOL_ID], limit: 10 }),
         queryRelays(relays, { kinds: [5], authors: [pubkey], limit: 50 }),
     ]);
     if (!events.length)
         return null;
-    const revokedIds = new Set(revocations.flatMap(e => e.tags.filter(t => t[0] === "e").map(t => t[1])));
+    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 event = events
+    const resolvedEvents = events
+        .filter(e => e && e.pubkey === pubkey && Array.isArray(e.tags) && typeof e.content === "string")
         .filter(e => !revokedIds.has(e.id))
-        .sort((a, b) => b.created_at - a.created_at)[0];
-    if (!event)
-        return null;
-    const bchTag = event.tags.find(t => t[0] === "bch");
-    const dTag = event.tags.find(t => t[0] === "d");
-    const bchProofTag = event.tags.find(t => t[0] === "bch-proof");
-    if (!bchTag || !dTag || !bchProofTag)
-        return null;
-    let createdAt = event.created_at;
-    try {
-        createdAt = JSON.parse(event.content).createdAt ?? createdAt;
-    }
-    catch { /* use event ts */ }
-    const anchorTag = event.tags.find(t => t[0] === "bch-anchor");
-    const anchoredAt = anchorTag?.[2] ? Number(anchorTag[2]) : undefined;
-    return {
-        npub,
-        pubkey,
-        bchAddress: bchTag[1],
-        network: bchTag[2] ?? "mainnet",
-        bindingId: dTag[1],
-        createdAt,
-        bchProofTag,
-        rawEvent: event,
-        ...(anchoredAt !== undefined ? { anchoredAt } : {}),
-    };
+        .map(event => resolvedIdentityFromEvent(event))
+        .filter((identity) => identity !== null)
+        .sort((a, b) => b.rawEvent.created_at - a.rawEvent.created_at);
+    return resolvedEvents[0] ? { ...resolvedEvents[0], npub } : null;
 }
 /** Verify the BCH + Nostr signatures on a resolved identity */
 export async function verifyIdentity(resolved) {
+    let signatureBase64;
+    if (!resolved ||
+        !Array.isArray(resolved.bchProofTag) ||
+        resolved.bchProofTag.length !== 4 ||
+        resolved.bchProofTag[0] !== "bch-proof" ||
+        resolved.bchProofTag[1] !== BCH_PROOF_FORMAT ||
+        typeof resolved.bchProofTag[2] !== "string" ||
+        typeof resolved.bchProofTag[3] !== "string" ||
+        !resolved.rawEvent ||
+        !Array.isArray(resolved.rawEvent.tags) ||
+        typeof resolved.rawEvent.content !== "string") {
+        return { status: "malformed", bchValid: false, nostrValid: false, details: "Malformed identity proof" };
+    }
+    try {
+        signatureBase64 = normalizeBchMessageSignature(resolved.bchProofTag[3]);
+    }
+    catch {
+        return { status: "malformed", bchValid: false, nostrValid: false, details: "Malformed BCH compact signature" };
+    }
     const { bchProofTag, rawEvent, bchAddress, bindingId, pubkey } = resolved;
-    const [, message, sigHex] = bchProofTag;
+    const [, , message] = bchProofTag;
     // 1. Nostr event signature
     let nostrValid = false;
+    const tagsAreStrings = rawEvent.tags.every(tag => Array.isArray(tag) && tag.every(value => typeof value === "string"));
     try {
-        nostrValid = verifyEvent(rawEvent);
-        const dTag = rawEvent.tags.find(t => t[0] === "d");
-        const bchTag = rawEvent.tags.find(t => t[0] === "bch");
-        if (dTag?.[1] !== bindingId || bchTag?.[1] !== bchAddress)
-            nostrValid = false;
-        if (rawEvent.pubkey !== pubkey)
-            nostrValid = false;
+        nostrValid = tagsAreStrings && verifyEvent(rawEvent);
     }
     catch {
         nostrValid = false;
     }
-    // 2. BCH signature recovery
+    let bindingMatches = false;
+    try {
+        const parsed = JSON.parse(rawEvent.content);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            throw new Error("Binding content must be an object");
+        const content = parsed;
+        const bch = content.bch;
+        const getTags = (name) => rawEvent.tags.filter(tag => tag[0] === name);
+        const exactlyOne = (name) => {
+            const matches = getTags(name);
+            return matches.length === 1 ? matches[0] : undefined;
+        };
+        const optionalTag = (name) => {
+            const matches = getTags(name);
+            return matches.length <= 1 ? matches[0] : undefined;
+        };
+        const dTag = exactlyOne("d");
+        const bchTag = exactlyOne("bch");
+        const protocolTag = exactlyOne("protocol");
+        const markerTag = exactlyOne("t");
+        const proofTag = exactlyOne("bch-proof");
+        const paymentCodeTag = optionalTag("bch-payment-code");
+        const supersedesTag = optionalTag("supersedes");
+        const anchorTag = optionalTag("bch-anchor");
+        const previousBindingId = content.previousBindingId;
+        const contentKeys = Object.keys(content).sort().join(",");
+        const allowedContentKeys = ["bch", "bindingId", "createdAt", "nonce", "previousBindingId", "protocol", "version"]
+            .filter(key => content[key] !== undefined).sort().join(",");
+        const bchKeys = bch && typeof bch === "object" && !Array.isArray(bch)
+            ? Object.keys(bch).sort().join(",")
+            : "";
+        const expectedBchKeys = bch?.paymentCode === undefined ? "address,network" : "address,network,paymentCode";
+        const expectedPrefix = bch?.network === "mainnet" ? "bitcoincash" : "bchtest";
+        if (rawEvent.kind !== BINDING_KIND ||
+            rawEvent.created_at !== content.createdAt ||
+            contentKeys !== allowedContentKeys ||
+            rawEvent.content !== canonicalize(content) ||
+            content.protocol !== PROTOCOL_ID ||
+            content.version !== PROTOCOL_VERSION ||
+            !/^[0-9a-f]{64}$/.test(content.bindingId) ||
+            typeof bch?.address !== "string" ||
+            !["mainnet", "testnet", "chipnet"].includes(bch?.network) ||
+            !bch.address.startsWith(`${expectedPrefix}:`) ||
+            bchKeys !== expectedBchKeys ||
+            (bch.paymentCode !== undefined && (typeof bch.paymentCode !== "string" || bch.paymentCode.length === 0)) ||
+            !/^[0-9a-f]{64}$/.test(content.nonce) ||
+            !Number.isSafeInteger(content.createdAt) ||
+            (previousBindingId !== undefined && !/^[0-9a-f]{64}$/.test(previousBindingId)) ||
+            !dTag || dTag.length !== 2 ||
+            !bchTag || bchTag.length !== 3 ||
+            !protocolTag || protocolTag.length !== 3 ||
+            !markerTag || markerTag.length !== 2 ||
+            !proofTag || proofTag.length !== 4 ||
+            (bch.paymentCode === undefined ? paymentCodeTag !== undefined : (!paymentCodeTag || paymentCodeTag.length !== 2 || paymentCodeTag[1] !== bch.paymentCode)) ||
+            getTags("bch-payment-code").length > 1 ||
+            (previousBindingId === undefined ? supersedesTag !== undefined : (!supersedesTag || supersedesTag.length !== 2 || supersedesTag[1] !== previousBindingId)) ||
+            getTags("supersedes").length > 1 ||
+            getTags("bch-anchor").length > 1 ||
+            (anchorTag !== undefined && ((anchorTag.length !== 2 && anchorTag.length !== 3) ||
+                !/^[0-9a-f]{64}$/.test(anchorTag[1]) ||
+                (anchorTag.length === 3 && !/^\d+$/.test(anchorTag[2])))) ||
+            dTag?.[1] !== content.bindingId ||
+            bchTag?.[1] !== bch.address ||
+            bchTag?.[2] !== bch.network ||
+            protocolTag?.[1] !== PROTOCOL_ID ||
+            protocolTag?.[2] !== PROTOCOL_VERSION ||
+            markerTag?.[1] !== PROTOCOL_ID ||
+            proofTag?.[0] !== "bch-proof" ||
+            proofTag?.[1] !== BCH_PROOF_FORMAT ||
+            proofTag?.[2] !== message ||
+            proofTag?.[2] !== bchProofTag[2] ||
+            proofTag?.[3] !== signatureBase64 ||
+            content.bindingId !== bindingId ||
+            bch.address !== bchAddress ||
+            bch.network !== resolved.network ||
+            resolved.createdAt !== content.createdAt ||
+            decodeNpub(resolved.npub) !== pubkey ||
+            rawEvent.pubkey !== pubkey) {
+            return { status: "id_mismatch", bchValid: false, nostrValid, details: "Binding record does not match the event and resolved identity" };
+        }
+        const partial = {
+            protocol: PROTOCOL_ID,
+            version: PROTOCOL_VERSION,
+            bch: {
+                address: bch.address,
+                network: bch.network,
+                ...(bch.paymentCode !== undefined ? { paymentCode: bch.paymentCode } : {}),
+            },
+            nostr: { pubkey: rawEvent.pubkey },
+            createdAt: content.createdAt,
+            nonce: content.nonce,
+            purpose: "identity-binding-v2",
+            ...(previousBindingId !== undefined ? { previousBindingId } : {}),
+        };
+        const expectedBindingId = await sha256hex(canonicalize(partial));
+        const expectedMessage = bchSigningPayload({ ...partial, bindingId: content.bindingId });
+        bindingMatches = expectedBindingId === content.bindingId && message === expectedMessage;
+    }
+    catch {
+        return { status: "malformed", bchValid: false, nostrValid, details: "Malformed binding event content" };
+    }
+    if (!bindingMatches)
+        return { status: "id_mismatch", bchValid: false, nostrValid, details: "BCH proof does not commit to this binding" };
+    // 3. BCH signature recovery
     const msgHash = bitcoinMsgHash(message);
-    const recovered = recoverBchAddress(sigHex, msgHash, bchAddress);
+    const recovered = recoverBchAddress(signatureBase64, msgHash, bchAddress);
     const bchValid = recovered === bchAddress;
-    // 3. Payload integrity
-    if (!message.startsWith(`${PROTOCOL_ID}/bch-proof/`)) {
-        return { status: "malformed", bchValid: false, nostrValid, details: "Unexpected proof payload format" };
-    }
     if (bchValid && nostrValid)
-        return { status: "verified", bchValid, nostrValid, details: "Both proofs valid", ...(resolved.anchoredAt !== undefined ? { anchoredAt: resolved.anchoredAt } : {}) };
+        return { status: "verified", bchValid, nostrValid, details: "Both proofs valid" };
     if (!bchValid)
         return { status: "invalid_bch_sig", bchValid, nostrValid, details: "BCH signature invalid" };
     return { status: "invalid_nostr_sig", bchValid, nostrValid, details: "Nostr signature invalid" };
 }
 const CHALLENGE_TTL_SECS = 300; // 5 minutes
+/** Build the exact versioned challenge message that a BCH wallet must sign. */
+export function bchChallengePayload(nonce, audience) {
+    if (typeof nonce !== "string" || nonce.length === 0 || /[\r\n]/.test(nonce))
+        throw new TypeError("Challenge nonce must be a non-empty single-line string");
+    if (audience !== undefined && (typeof audience !== "string" || audience.length === 0 || /[\r\n]/.test(audience)))
+        throw new TypeError("Challenge audience must be a non-empty single-line string");
+    return `${PROTOCOL_ID}/challenge/v${PROTOCOL_VERSION}\n${nonce}${audience === undefined ? "" : `\n${audience}`}`;
+}
 /** Verify a challenge-response proof.
- * Payload must be: `cashlet-did/challenge\n<nonce>\n<audience>`
- * Matches the SIGN_CHALLENGE format used by the Cashlet extension and any conforming client.
+ * 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) {
-    if (issuedAt !== undefined && Math.floor(Date.now() / 1000) - issuedAt > CHALLENGE_TTL_SECS)
+    if (!proof ||
+        typeof proof.signature !== "string" ||
+        typeof proof.payload !== "string" ||
+        typeof proof.address !== "string" ||
+        typeof nonce !== "string")
         return false;
-    if (!proof.payload.startsWith(`${PROTOCOL_ID}/challenge\n`))
+    if (issuedAt !== undefined &&
+        (!Number.isSafeInteger(issuedAt) || Math.floor(Date.now() / 1000) - issuedAt > CHALLENGE_TTL_SECS))
         return false;
-    if (!proof.payload.includes(nonce))
+    let expectedPayload;
+    try {
+        expectedPayload = bchChallengePayload(nonce, audience);
+    }
+    catch {
         return false;
-    if (audience !== undefined && !proof.payload.includes(audience))
+    }
+    if (proof.payload !== expectedPayload)
+        return false;
+    try {
+        normalizeBchMessageSignature(proof.signature);
+    }
+    catch {
         return false;
+    }
     const msgHash = bitcoinMsgHash(proof.payload);
     return recoverBchAddress(proof.signature, msgHash, proof.address) === proof.address;
 }
@@ -162,47 +311,127 @@ export async function resolveAddress(npub, relays = DEFAULT_RELAYS) {
     const result = await verifyIdentity(identity);
     return result.status === "verified" ? identity.bchAddress : null;
 }
-/** Returns full binding history for an npub, newest first, with cryptographic supersedes validation */
+/** Returns verified binding events newest first, following and validating each supersedes reference. */
 export async function resolveIdentityChain(npub, relays = DEFAULT_RELAYS) {
-    const decoded = nip19.decode(npub);
-    if (decoded.type !== "npub")
+    const pubkey = decodeNpub(npub);
+    if (!pubkey)
         return [];
-    const pubkey = decoded.data;
     const events = await queryRelays(relays, {
         kinds: [BINDING_KIND],
         authors: [pubkey],
         "#t": [PROTOCOL_ID],
         limit: 50,
     });
-    const results = [];
-    for (const event of events.sort((a, b) => b.created_at - a.created_at)) {
-        const bchTag = event.tags.find(t => t[0] === "bch");
-        const dTag = event.tags.find(t => t[0] === "d");
-        const bchProofTag = event.tags.find(t => t[0] === "bch-proof");
-        if (!bchTag || !dTag || !bchProofTag)
+    const validCandidates = [];
+    for (const event of events) {
+        const candidate = resolvedIdentityFromEvent(event);
+        if (!candidate)
+            continue;
+        const verified = await verifyIdentity(candidate);
+        if (verified.status !== "verified" || await isBindingRevoked(event, relays))
             continue;
-        let createdAt = event.created_at;
+        validCandidates.push(candidate);
+    }
+    validCandidates.sort((a, b) => b.rawEvent.created_at - a.rawEvent.created_at);
+    if (!validCandidates.length)
+        return [];
+    const chain = [];
+    const visited = new Set();
+    let current = validCandidates[0];
+    while (current) {
+        if (visited.has(current.bindingId))
+            return [];
+        visited.add(current.bindingId);
+        chain.push(current);
+        const supersedes = current.rawEvent.tags.find(t => t[0] === "supersedes")?.[1];
+        if (!supersedes)
+            return chain;
+        const predecessors = await queryRelays(relays, {
+            kinds: [BINDING_KIND],
+            "#t": [PROTOCOL_ID],
+            "#d": [supersedes],
+            limit: 50,
+        });
+        let predecessor;
+        for (const event of predecessors) {
+            const candidate = resolvedIdentityFromEvent(event);
+            if (!candidate || candidate.bindingId !== supersedes)
+                continue;
+            const verified = await verifyIdentity(candidate);
+            if (verified.status !== "verified" || await isBindingRevoked(event, relays))
+                continue;
+            predecessor = candidate;
+            break;
+        }
+        if (!predecessor)
+            return [];
+        current = predecessor;
+    }
+    return chain;
+}
+function resolvedIdentityFromEvent(event) {
+    if (event.kind !== BINDING_KIND ||
+        !/^[0-9a-f]{64}$/.test(event.pubkey) ||
+        !Array.isArray(event.tags))
+        return null;
+    const bchTag = event.tags.find(t => Array.isArray(t) && t[0] === "bch");
+    const dTag = event.tags.find(t => Array.isArray(t) && t[0] === "d");
+    const protocolTags = event.tags.filter(t => Array.isArray(t) && t[0] === "protocol");
+    const proofTags = event.tags.filter(t => Array.isArray(t) && t[0] === "bch-proof");
+    const bchProofTag = proofTags[0];
+    if (!bchTag?.[1] || !dTag?.[1] ||
+        protocolTags.length !== 1 || protocolTags[0].length !== 3 ||
+        protocolTags[0][1] !== PROTOCOL_ID || protocolTags[0][2] !== PROTOCOL_VERSION ||
+        proofTags.length !== 1 || bchProofTag.length !== 4 ||
+        bchProofTag[1] !== BCH_PROOF_FORMAT ||
+        !bchProofTag[2] || !bchProofTag[3])
+        return null;
+    let content;
+    try {
+        const parsed = JSON.parse(event.content);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return null;
+        content = parsed;
+    }
+    catch {
+        return null;
+    }
+    const createdAt = typeof content.createdAt === "number" ? content.createdAt : event.created_at;
+    const anchorTag = event.tags.find(t => Array.isArray(t) && t[0] === "bch-anchor");
+    const claimedBlockHeight = anchorTag?.[2] && /^\d+$/.test(anchorTag[2]) ? Number(anchorTag[2]) : undefined;
+    return {
+        npub: nip19.npubEncode(event.pubkey),
+        pubkey: event.pubkey,
+        bchAddress: bchTag[1],
+        network: bchTag[2],
+        bindingId: dTag[1],
+        createdAt,
+        bchProofTag: bchProofTag,
+        rawEvent: event,
+        ...(anchorTag?.[1] ? {
+            anchorClaim: {
+                txid: anchorTag[1],
+                ...(claimedBlockHeight !== undefined ? { blockHeight: claimedBlockHeight } : {}),
+            },
+        } : {}),
+    };
+}
+async function isBindingRevoked(event, relays) {
+    const revocations = await queryRelays(relays, {
+        kinds: [5],
+        authors: [event.pubkey],
+        limit: 100,
+    });
+    return revocations.some(revocation => {
         try {
-            createdAt = JSON.parse(event.content).createdAt ?? createdAt;
+            return verifyEvent(revocation) &&
+                revocation.pubkey === event.pubkey &&
+                revocation.tags.some(tag => tag[0] === "e" && tag[1] === event.id);
         }
-        catch { /* use event ts */ }
-        // Validate supersedes tag: the referenced event must exist and its d-tag must match claimedId
-        const supersedesTag = event.tags.find(t => t[0] === "supersedes");
-        if (supersedesTag) {
-            const claimedId = supersedesTag[1];
-            const [prev] = await queryRelays(relays, { "#d": [claimedId], kinds: [BINDING_KIND], limit: 1 });
-            if (prev) {
-                const prevDTag = prev.tags.find(t => t[0] === "d");
-                if (prevDTag?.[1] !== claimedId) {
-                    throw new CashletDidError("CHAIN_BROKEN", `supersedes tag ${claimedId} does not match referenced event d-tag`);
-                }
-            }
+        catch {
+            return false;
         }
-        const anchorTag = event.tags.find(t => t[0] === "bch-anchor");
-        const anchoredAt = anchorTag?.[2] ? Number(anchorTag[2]) : undefined;
-        results.push({ npub, pubkey, bchAddress: bchTag[1], network: bchTag[2] ?? "mainnet", bindingId: dTag[1], createdAt, bchProofTag, rawEvent: event, ...(anchoredAt !== undefined ? { anchoredAt } : {}) });
-    }
-    return results;
+    });
 }
 /**
  * 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": "1.2.0",
+  "version": "2.0.0",
   "description": "Decentralised identity protocol binding BCH addresses to Nostr public keys",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,7 +18,8 @@
     "PROTOCOL.md"
   ],
   "scripts": {
-    "build": "tsc",
+    "build": "tsc && npm run build:demo",
+    "build:demo": "esbuild demo/client.js --bundle --format=esm --platform=browser --target=es2022 --outfile=demo/bundle.js",
     "typecheck": "tsc --noEmit",
     "test": "node --test test/cashlet-did.test.mjs",
     "prepublishOnly": "npm run build"
@@ -45,6 +46,7 @@
     "nostr-tools": "^2.0.0"
   },
   "devDependencies": {
+    "esbuild": "^0.28.2",
     "typescript": "^5.4.0"
   }
 }