did-beta-bch 1.2.0 → 2.0.0

package/dist/anchor.js

@@ -1,20 +1,33 @@
 /**
  * BCH on-chain identity commitment via OP_RETURN.
- * Anchors a bindingId to a BCH block, providing a tamper-evident timestamp.
+ * Builds a transaction committing to a bindingId; it does not broadcast or verify confirmation.
  */
 export const ANCHOR_PREFIX = "cashlet-did:";
 const OP_RETURN = 0x6a;
-const DUST_SATS = 1000; // anchor output value (burned)
-const FEE_SATS = 500;
+const MIN_FEE_SATS = 500;
+function pushData(data) {
+    if (data.length <= 0x4b)
+        return new Uint8Array([data.length, ...data]);
+    if (data.length <= 0xff)
+        return new Uint8Array([0x4c, data.length, ...data]);
+    if (data.length <= 0xffff)
+        return new Uint8Array([0x4d, data.length & 0xff, data.length >>> 8, ...data]);
+    throw new Error("Anchor data is too large for a script push");
+}
 /** Build an OP_RETURN tx anchoring a bindingId to the BCH chain */
 export async function buildAnchorTx(bindingId, utxo) {
-    if (utxo.valueSats <= FEE_SATS)
-        throw new Error(`UTXO value ${utxo.valueSats} sats too small to cover fee ${FEE_SATS} sats`);
+    if (!/^[0-9a-f]{64}$/.test(bindingId))
+        throw new Error("bindingId must be 64 lowercase hex characters");
+    const feeSats = utxo.feeSats ?? MIN_FEE_SATS;
+    if (feeSats < MIN_FEE_SATS)
+        throw new Error(`feeSats ${feeSats} below minimum ${MIN_FEE_SATS}`);
+    if (utxo.valueSats <= feeSats)
+        throw new Error(`UTXO value ${utxo.valueSats} sats too small to cover fee ${feeSats} sats`);
     const { encodeTransaction, generateTransaction, hexToBin, binToHex, walletTemplateP2pkhNonHd, importWalletTemplate, walletTemplateToCompilerBch } = await import("@bitauth/libauth");
     const data = ANCHOR_PREFIX + bindingId;
     const dataBytes = new TextEncoder().encode(data);
     // OP_RETURN <push> <data>
-    const opReturnScript = new Uint8Array([OP_RETURN, dataBytes.length, ...dataBytes]);
+    const opReturnScript = new Uint8Array([OP_RETURN, ...pushData(dataBytes)]);
     const template = importWalletTemplate(walletTemplateP2pkhNonHd);
     if (typeof template === "string")
         throw new Error(template);
@@ -38,7 +51,7 @@ export async function buildAnchorTx(bindingId, utxo) {
             // change back to sender minus fee
             {
                 lockingBytecode: utxo.lockingBytecode,
-                valueSatoshis: BigInt(utxo.valueSats - FEE_SATS),
+                valueSatoshis: BigInt(utxo.valueSats - feeSats),
             },
         ],
         version: 2,

package/dist/binding.d.ts

@@ -1,5 +1,6 @@
+import { type BchMessageProof } from "./signing.js";
 export declare const PROTOCOL_ID = "cashlet-did";
-export declare const PROTOCOL_VERSION = "1.0.0";
+export declare const PROTOCOL_VERSION = "2.0.0";
 export declare const BINDING_KIND = 30078;
 export type Network = "mainnet" | "testnet" | "chipnet";
 export interface CanonicalBinding {
@@ -16,7 +17,7 @@ export interface CanonicalBinding {
     };
     createdAt: number;
     nonce: string;
-    purpose: "identity-binding-v1";
+    purpose: "identity-binding-v2";
     previousBindingId?: string;
     anchor?: {
         txid: string;
@@ -25,11 +26,7 @@ export interface CanonicalBinding {
 }
 export interface IdentityBinding {
     binding: CanonicalBinding;
-    bchProof: {
-        message: string;
-        signature: string;
-        pubkeyHex?: string;
-    };
+    bchProof: BchMessageProof;
     nostrProof: {
         event: NostrEvent;
     };
@@ -48,10 +45,7 @@ export declare function canonicalize(v: unknown): string;
 export declare function sha256hex(s: string): Promise<string>;
 export declare function buildBinding(bchAddress: string, network: Network, nostrPubkey: string, paymentCode?: string, previousBindingId?: string): Promise<CanonicalBinding>;
 export declare function bchSigningPayload(binding: CanonicalBinding): string;
-export declare function nostrEventTemplate(binding: CanonicalBinding, bchProof?: {
-    message: string;
-    signature: string;
-}): {
+export declare function nostrEventTemplate(binding: CanonicalBinding, bchProof?: BchMessageProof): {
     kind: number;
     created_at: number;
     tags: string[][];

package/dist/binding.js

@@ -1,5 +1,6 @@
+import { BCH_PROOF_FORMAT, normalizeBchMessageSignature, } from "./signing.js";
 export const PROTOCOL_ID = "cashlet-did";
-export const PROTOCOL_VERSION = "1.0.0";
+export const PROTOCOL_VERSION = "2.0.0";
 export const BINDING_KIND = 30078;
 export function canonicalize(v) {
     if (v === null || typeof v !== "object")
@@ -21,6 +22,15 @@ function randomHex(bytes) {
     return Array.from(arr).map(b => b.toString(16).padStart(2, "0")).join("");
 }
 export async function buildBinding(bchAddress, network, nostrPubkey, paymentCode, previousBindingId) {
+    const expectedPrefix = network === "mainnet" ? "bitcoincash" : "bchtest";
+    if (!["mainnet", "testnet", "chipnet"].includes(network))
+        throw new Error(`Invalid BCH network: ${network}`);
+    if (!bchAddress.startsWith(`${expectedPrefix}:`) || bchAddress.split(":")[1]?.length < 20)
+        throw new Error(`Invalid BCH address: ${bchAddress}`);
+    if (!/^[0-9a-f]{64}$/.test(nostrPubkey))
+        throw new Error(`Invalid Nostr pubkey: ${nostrPubkey}`);
+    if (previousBindingId !== undefined && !/^[0-9a-f]{64}$/.test(previousBindingId))
+        throw new Error(`Invalid previous binding ID: ${previousBindingId}`);
     const partial = {
         protocol: PROTOCOL_ID,
         version: PROTOCOL_VERSION,
@@ -28,7 +38,7 @@ export async function buildBinding(bchAddress, network, nostrPubkey, paymentCode
         nostr: { pubkey: nostrPubkey },
         createdAt: Math.floor(Date.now() / 1000),
         nonce: randomHex(32),
-        purpose: "identity-binding-v1",
+        purpose: "identity-binding-v2",
         ...(previousBindingId ? { previousBindingId } : {}),
     };
     const bindingId = await sha256hex(canonicalize(partial));
@@ -46,9 +56,14 @@ export function bchSigningPayload(binding) {
     });
 }
 export function nostrEventTemplate(binding, bchProof) {
+    if (bchProof) {
+        if (bchProof.message !== bchSigningPayload(binding))
+            throw new Error("BCH proof message does not match the binding");
+        normalizeBchMessageSignature(bchProof.signatureBase64);
+    }
     return {
         kind: BINDING_KIND,
-        created_at: Math.floor(Date.now() / 1000),
+        created_at: binding.createdAt,
         tags: [
             ["d", binding.bindingId],
             ["bch", binding.bch.address, binding.bch.network],
@@ -57,7 +72,7 @@ export function nostrEventTemplate(binding, bchProof) {
             ["t", PROTOCOL_ID],
             ...(binding.previousBindingId ? [["supersedes", binding.previousBindingId]] : []),
             ...(binding.anchor ? [["bch-anchor", binding.anchor.txid, ...(binding.anchor.blockHeight ? [String(binding.anchor.blockHeight)] : [])]] : []),
-            ...(bchProof ? [["bch-proof", bchProof.message, bchProof.signature]] : []),
+            ...(bchProof ? [["bch-proof", BCH_PROOF_FORMAT, bchProof.message, bchProof.signatureBase64]] : []),
         ],
         content: canonicalize({
             protocol: PROTOCOL_ID,

package/dist/credentials.d.ts

@@ -1,6 +1,6 @@
 /**
  * Verifiable Credentials — third-party attestations anchored to a Nostr identity.
- * Issuer signs a Nostr event (kind 30079) attesting a claim about a subject npub.
+ * Issuer signs a Nostr event (kind 30085) attesting a claim about a subject npub.
  * Subject's binding event links to received credentials via ["credential", eventId, issuerPubkey, type] tag.
  */
 import type { RelayResult } from "./relay.js";
@@ -38,7 +38,13 @@ export declare function issueRating(subjectNpub: string, rating: 1 | 2 | 3 | 4 |
 }>;
 /** Revoke a credential by publishing a NIP-09 kind:5 deletion event */
 export declare function revokeCredential(eventId: string, issuerPrivkey: Uint8Array, relays?: string[]): Promise<RelayResult[]>;
-/** Compute a reputation score for an npub based on ratings and credentials */
+/**
+ * Compute a reputation score (0–100) for an npub.
+ * Formula: rating score (0–50) + issuer diversity bonus (0–50).
+ *   rating score  = (averageRating / 5) * 50
+ *   issuer bonus  = min(uniqueIssuers, 10) * 5
+ * Pass a custom `weight` function to override the formula.
+ */
 export declare function scoreReputation(npub: string, relays?: string[]): Promise<{
     credentialCount: number;
     ratingCount: number;

package/dist/credentials.js

@@ -1,11 +1,11 @@
 /**
  * Verifiable Credentials — third-party attestations anchored to a Nostr identity.
- * Issuer signs a Nostr event (kind 30079) attesting a claim about a subject npub.
+ * Issuer signs a Nostr event (kind 30085) attesting a claim about a subject npub.
  * Subject's binding event links to received credentials via ["credential", eventId, issuerPubkey, type] tag.
  */
-import { finalizeEvent, nip19, getPublicKey } from "nostr-tools";
+import { finalizeEvent, nip19, getPublicKey, verifyEvent } from "nostr-tools";
 import { queryRelays, publishToRelays, DEFAULT_RELAYS } from "./relay.js";
-export const CREDENTIAL_KIND = 30085; // kind 30079 is reserved for revocation (DID-PLAN)
+export const CREDENTIAL_KIND = 30085;
 /** 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);
@@ -48,24 +48,64 @@ export async function resolveCredentials(npub, relays = DEFAULT_RELAYS) {
         "#t": ["cashlet-did-credential"],
         limit: 50,
     });
-    // Fetch revocations and filter them out
+    // Fetch revocations; only a valid event from the credential issuer can revoke it.
     const revocations = await queryRelays(relays, {
         kinds: [5],
         authors: events.map(e => e.pubkey),
         limit: 100,
     });
-    const revokedIds = new Set(revocations.flatMap(e => e.tags.filter((t) => t[0] === "e").map((t) => t[1])));
-    return events
-        .filter(e => !revokedIds.has(e.id))
-        .map(e => {
+    const revokedByIssuer = new Map();
+    for (const revocation of revocations) {
         try {
-            const payload = JSON.parse(e.content);
-            return { id: e.id, issuer: e.pubkey, payload, rawEvent: e };
+            if (!verifyEvent(revocation) || revocation.kind !== 5)
+                continue;
         }
         catch {
-            return null;
+            continue;
         }
-    }).filter(Boolean);
+        const revokedIds = revokedByIssuer.get(revocation.pubkey) ?? new Set();
+        for (const tag of revocation.tags)
+            if (tag[0] === "e" && tag[1])
+                revokedIds.add(tag[1]);
+        revokedByIssuer.set(revocation.pubkey, revokedIds);
+    }
+    const now = Math.floor(Date.now() / 1000);
+    const credentials = [];
+    for (const event of events) {
+        if (revokedByIssuer.get(event.pubkey)?.has(event.id))
+            continue;
+        try {
+            if (!verifyEvent(event) || event.kind !== CREDENTIAL_KIND)
+                continue;
+            const parsed = JSON.parse(event.content);
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+                continue;
+            const payload = parsed;
+            const subjectTag = event.tags.find(tag => tag[0] === "p");
+            const typeTag = event.tags.find(tag => tag[0] === "credential-type");
+            const markerTag = event.tags.find(tag => tag[0] === "t");
+            if (payload.subject !== pubkey ||
+                typeof payload.type !== "string" || payload.type.length === 0 ||
+                !Number.isSafeInteger(payload.issuedAt) ||
+                payload.issuedAt !== event.created_at ||
+                subjectTag?.[1] !== pubkey ||
+                typeTag?.[1] !== payload.type ||
+                markerTag?.[1] !== "cashlet-did-credential" ||
+                (payload.expiry !== undefined && (!Number.isSafeInteger(payload.expiry) || payload.expiry <= now)) ||
+                (payload.rating !== undefined && (!Number.isInteger(payload.rating) || payload.rating < 1 || payload.rating > 5)) ||
+                (payload.comment !== undefined && typeof payload.comment !== "string") ||
+                (payload.claims !== undefined && (typeof payload.claims !== "object" ||
+                    payload.claims === null ||
+                    Array.isArray(payload.claims) ||
+                    Object.values(payload.claims).some(value => typeof value !== "string"))))
+                continue;
+            credentials.push({ id: event.id, issuer: event.pubkey, payload, rawEvent: event });
+        }
+        catch {
+            continue;
+        }
+    }
+    return credentials;
 }
 /** Issue a star rating (1–5) to an npub — usable by any wallet or app */
 export async function issueRating(subjectNpub, rating, issuerPrivkey, opts = {}, relays = DEFAULT_RELAYS) {
@@ -115,7 +155,13 @@ export async function revokeCredential(eventId, issuerPrivkey, relays = DEFAULT_
     const signed = finalizeEvent(template, issuerPrivkey);
     return publishToRelays(relays, signed);
 }
-/** Compute a reputation score for an npub based on ratings and credentials */
+/**
+ * Compute a reputation score (0–100) for an npub.
+ * Formula: rating score (0–50) + issuer diversity bonus (0–50).
+ *   rating score  = (averageRating / 5) * 50
+ *   issuer bonus  = min(uniqueIssuers, 10) * 5
+ * Pass a custom `weight` function to override the formula.
+ */
 export async function scoreReputation(npub, relays = DEFAULT_RELAYS) {
     const credentials = await resolveCredentials(npub, relays);
     const ratings = credentials.filter(c => c.payload.type === "rating" && c.payload.rating);

package/dist/disclosure.d.ts

@@ -10,10 +10,14 @@
  *   // verifier calls verifyDisclosure(revealed, commitments)
  */
 export interface Disclosure {
-    /** SHA-256 hashes of each attribute — publish these in the binding event */
+    /** Salted SHA-256 hashes of each attribute — keep each salt private until reveal */
     commitments: Record<string, string>;
-    /** Reveal selected attribute values — share with verifier */
-    reveal: (keys: string[]) => Record<string, string>;
+    /** Reveal selected values with their salts — share these only for requested attributes */
+    reveal: (keys: string[]) => Record<string, DisclosureReveal>;
+}
+export interface DisclosureReveal {
+    value: string;
+    salt: string;
 }
 /** Build a disclosure object from a set of attributes */
 export declare function buildDisclosure(attrs: Record<string, string>): Promise<Disclosure>;
@@ -21,7 +25,7 @@ export declare function buildDisclosure(attrs: Record<string, string>): Promise<
  * Verify that revealed attributes match their published commitments.
  * Returns the set of verified attribute keys.
  */
-export declare function verifyDisclosure(revealed: Record<string, string>, commitments: Record<string, string>): Promise<{
+export declare function verifyDisclosure(revealed: Record<string, DisclosureReveal>, commitments: Record<string, string>): Promise<{
     verified: string[];
     failed: string[];
 }>;

package/dist/disclosure.js

@@ -9,20 +9,27 @@
  *   const revealed = d.reveal(["merchant"])
  *   // verifier calls verifyDisclosure(revealed, commitments)
  */
-async function hashAttr(key, value) {
-    const data = new TextEncoder().encode(`cashlet-did/attr/${key}:${value}`);
+function randomSalt() {
+    const bytes = crypto.getRandomValues(new Uint8Array(32));
+    return Array.from(bytes).map(b => b.toString(16).padStart(2, "0")).join("");
+}
+async function hashAttr(key, value, salt) {
+    const data = new TextEncoder().encode(`cashlet-did/attr/v2\n${JSON.stringify([key, value, salt])}`);
     const buf = await crypto.subtle.digest("SHA-256", data);
     return Array.from(new Uint8Array(buf)).map(b => b.toString(16).padStart(2, "0")).join("");
 }
 /** Build a disclosure object from a set of attributes */
 export async function buildDisclosure(attrs) {
     const commitments = {};
+    const salts = {};
     for (const [k, v] of Object.entries(attrs)) {
-        commitments[k] = await hashAttr(k, v);
+        const salt = randomSalt();
+        salts[k] = salt;
+        commitments[k] = await hashAttr(k, v, salt);
     }
     return {
         commitments,
-        reveal: (keys) => Object.fromEntries(keys.filter(k => k in attrs).map(k => [k, attrs[k]])),
+        reveal: (keys) => Object.fromEntries(keys.filter(k => k in attrs).map(k => [k, { value: attrs[k], salt: salts[k] }])),
     };
 }
 /**
@@ -34,11 +41,16 @@ export async function verifyDisclosure(revealed, commitments) {
     const failed = [];
     for (const [k, v] of Object.entries(revealed)) {
         const expected = commitments[k];
-        if (!expected) {
+        if (!expected ||
+            !v ||
+            typeof v !== "object" ||
+            typeof v.value !== "string" ||
+            typeof v.salt !== "string" ||
+            !/^[0-9a-f]{64}$/.test(v.salt)) {
             failed.push(k);
             continue;
         }
-        const actual = await hashAttr(k, v);
+        const actual = await hashAttr(k, v.value, v.salt);
         (actual === expected ? verified : failed).push(k);
     }
     return { verified, failed };

package/dist/index.d.ts

@@ -1,9 +1,10 @@
-export { buildDisclosure, verifyDisclosure, type Disclosure, } from "./disclosure.js";
+export { buildDisclosure, verifyDisclosure, type Disclosure, type DisclosureReveal, } from "./disclosure.js";
 export { buildAnchorTx, ANCHOR_PREFIX, type AnchorUtxo, type AnchorResult, } from "./anchor.js";
 export { issueCredential, issueRating, revokeCredential, resolveCredentials, scoreReputation, CREDENTIAL_KIND, type CredentialPayload, type IssuedCredential, } from "./credentials.js";
 export { PROTOCOL_ID, PROTOCOL_VERSION, BINDING_KIND, type Network, type CanonicalBinding, type IdentityBinding, type NostrEvent, buildBinding, bchSigningPayload, nostrEventTemplate, canonicalize, sha256hex, } from "./binding.js";
+export { BCH_PROOF_FORMAT, normalizeBchMessageSignature, signBchMessage, type BchMessageProof, type BchMessageSigner, type BchProofTag, } from "./signing.js";
 export { publishToRelay, publishToRelays, queryRelay, queryRelays, DEFAULT_RELAYS, type RelayResult, } from "./relay.js";
-export { resolveIdentity, resolveAddress, resolveByNip05, verifyIdentity, verifyChallengeProof, resolveIdentityChain, type VerifyResult, type VerifyStatus, type ResolvedIdentity, } from "./verify.js";
+export { resolveIdentity, resolveAddress, resolveByNip05, verifyIdentity, bchChallengePayload, verifyChallengeProof, resolveIdentityChain, type VerifyResult, type VerifyStatus, type ResolvedIdentity, type BCHAnchorClaim, } from "./verify.js";
 export { CashletDidError, type CashletDidErrorCode } from "./errors.js";
 export { deriveNostrKeypair, type NostrKeypair, } from "./keygen.js";
 export { buildHttpAuthEventAsync, verifyHttpAuth, type HttpAuthEventTemplate, type HttpAuthResult, } from "./nip98.js";

package/dist/index.js

@@ -6,12 +6,13 @@ export {
 PROTOCOL_ID, PROTOCOL_VERSION, BINDING_KIND, 
 // Binding construction
 buildBinding, bchSigningPayload, nostrEventTemplate, canonicalize, sha256hex, } from "./binding.js";
+export { BCH_PROOF_FORMAT, normalizeBchMessageSignature, signBchMessage, } from "./signing.js";
 export { 
 // Relay communication
 publishToRelay, publishToRelays, queryRelay, queryRelays, DEFAULT_RELAYS, } from "./relay.js";
 export { 
 // Verification
-resolveIdentity, resolveAddress, resolveByNip05, verifyIdentity, verifyChallengeProof, resolveIdentityChain, } from "./verify.js";
+resolveIdentity, resolveAddress, resolveByNip05, verifyIdentity, bchChallengePayload, verifyChallengeProof, resolveIdentityChain, } from "./verify.js";
 export { CashletDidError } from "./errors.js";
 export { deriveNostrKeypair, } from "./keygen.js";
 export { buildHttpAuthEventAsync, verifyHttpAuth, } from "./nip98.js";

package/dist/nip98.d.ts

@@ -24,10 +24,12 @@ export interface HttpAuthResult {
  * @param authHeader - value of the Authorization header (e.g. "Nostr <base64>")
  * @param url        - the full request URL (must match event tag exactly)
  * @param method     - HTTP method (must match event tag exactly)
+ * @param opts.body  - actual request body, or `null` for a request without a body; required
  * @param opts.verifyBch - if true, resolve + verify the signer's BCH binding
  * @param opts.relays    - relay list for BCH binding resolution
  */
 export declare function verifyHttpAuth(authHeader: string, url: string, method: string, opts?: {
+    body?: Uint8Array | null;
     verifyBch?: boolean;
     relays?: string[];
 }): Promise<HttpAuthResult>;

package/dist/nip98.js

@@ -2,6 +2,7 @@ import { verifyEvent } from "nostr-tools";
 import { resolveIdentity, verifyIdentity } from "./verify.js";
 const HTTP_AUTH_KIND = 27235;
 const HTTP_AUTH_TTL = 60; // seconds — NIP-98 spec
+const HTTP_AUTH_CLOCK_SKEW = 60;
 /**
  * Build a NIP-98 HTTP Auth event template.
  * Pass a body Uint8Array to include its SHA-256 hash as a `payload` tag.
@@ -14,12 +15,14 @@ export async function buildHttpAuthEventAsync(url, method, body) {
         ["method", method.toUpperCase()],
     ];
     if (body) {
-        const hashBuf = await crypto.subtle.digest("SHA-256", body);
-        const hash = Array.from(new Uint8Array(hashBuf)).map(b => b.toString(16).padStart(2, "0")).join("");
-        tags.push(["payload", hash]);
+        tags.push(["payload", await sha256Hex(body)]);
     }
     return { kind: HTTP_AUTH_KIND, created_at: Math.floor(Date.now() / 1000), tags, content: "" };
 }
+async function sha256Hex(data) {
+    const hashBuf = await crypto.subtle.digest("SHA-256", data);
+    return Array.from(new Uint8Array(hashBuf)).map(b => b.toString(16).padStart(2, "0")).join("");
+}
 /**
  * Verify a NIP-98 Authorization header on the server side.
  * Optionally resolves the signer's BCH binding — proving both Nostr + BCH ownership.
@@ -27,6 +30,7 @@ export async function buildHttpAuthEventAsync(url, method, body) {
  * @param authHeader - value of the Authorization header (e.g. "Nostr <base64>")
  * @param url        - the full request URL (must match event tag exactly)
  * @param method     - HTTP method (must match event tag exactly)
+ * @param opts.body  - actual request body, or `null` for a request without a body; required
  * @param opts.verifyBch - if true, resolve + verify the signer's BCH binding
  * @param opts.relays    - relay list for BCH binding resolution
  */
@@ -47,9 +51,12 @@ export async function verifyHttpAuth(authHeader, url, method, opts = {}) {
     // 2. Kind
     if (event.kind !== HTTP_AUTH_KIND)
         return { valid: false, error: "Wrong event kind" };
-    // 3. TTL
-    if (Math.floor(Date.now() / 1000) - event.created_at > HTTP_AUTH_TTL)
+    // 3. TTL and clock skew
+    const now = Math.floor(Date.now() / 1000);
+    if (!Number.isSafeInteger(event.created_at) || now - event.created_at > HTTP_AUTH_TTL)
         return { valid: false, error: "Event expired" };
+    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");
@@ -57,6 +64,19 @@ export async function verifyHttpAuth(authHeader, url, method, opts = {}) {
         return { valid: false, error: "URL mismatch" };
     if (mTag?.[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)" };
+    const payloadTags = event.tags.filter((t) => t[0] === "payload");
+    if (opts.body === null) {
+        if (payloadTags.length)
+            return { valid: false, error: "Unexpected payload hash for bodyless request" };
+    }
+    else {
+        if (payloadTags.length !== 1 || typeof payloadTags[0][1] !== "string")
+            return { valid: false, error: "Missing or duplicate payload hash" };
+        if (payloadTags[0][1] !== await sha256Hex(opts.body))
+            return { valid: false, error: "Request body hash mismatch" };
+    }
     const result = { valid: true, pubkey: event.pubkey };
     // 5. Optionally resolve + verify BCH binding
     if (opts.verifyBch) {

package/dist/relay.js

@@ -1,8 +1,10 @@
-const TIMEOUT_MS = 8000;
+const CONNECT_TIMEOUT_MS = 5000;
+const RESPONSE_TIMEOUT_MS = 8000;
+const MAX_EVENTS_PER_RELAY = 200;
 function openRelay(url) {
     return new Promise((resolve, reject) => {
         const ws = new WebSocket(url);
-        const t = setTimeout(() => { ws.close(); reject(new Error("connect timeout")); }, TIMEOUT_MS);
+        const t = setTimeout(() => { ws.close(); reject(new Error("connect timeout")); }, CONNECT_TIMEOUT_MS);
         ws.onopen = () => { clearTimeout(t); resolve(ws); };
         ws.onerror = () => { clearTimeout(t); reject(new Error("connect error")); };
     });
@@ -11,7 +13,7 @@ export async function publishToRelay(url, event) {
     try {
         const ws = await openRelay(url);
         return await new Promise((resolve) => {
-            const t = setTimeout(() => { ws.close(); resolve({ relay: url, ok: false, error: "publish timeout" }); }, TIMEOUT_MS);
+            const t = setTimeout(() => { ws.close(); resolve({ relay: url, ok: false, error: "publish timeout" }); }, RESPONSE_TIMEOUT_MS);
             ws.onmessage = (e) => {
                 clearTimeout(t);
                 ws.close();
@@ -42,12 +44,14 @@ export async function queryRelay(url, filter) {
         return await new Promise((resolve) => {
             const events = [];
             const subId = Math.random().toString(36).slice(2);
-            const t = setTimeout(() => { ws.close(); resolve(events); }, TIMEOUT_MS);
+            const t = setTimeout(() => { ws.close(); resolve(events); }, RESPONSE_TIMEOUT_MS);
             ws.onmessage = (e) => {
                 try {
                     const msg = JSON.parse(e.data);
-                    if (msg[0] === "EVENT" && msg[1] === subId)
-                        events.push(msg[2]);
+                    if (msg[0] === "EVENT" && msg[1] === subId) {
+                        if (events.length < MAX_EVENTS_PER_RELAY)
+                            events.push(msg[2]);
+                    }
                     if (msg[0] === "EOSE" && msg[1] === subId) {
                         clearTimeout(t);
                         ws.close();

package/dist/signing.d.ts

@@ -0,0 +1,16 @@
+export declare const BCH_PROOF_FORMAT = "bitcoin-message/compact-base64";
+export type BchProofTag = ["bch-proof", typeof BCH_PROOF_FORMAT, string, string];
+export interface BchMessageProof {
+    message: string;
+    signatureBase64: string;
+}
+export interface BchMessageSigner {
+    signMessage(message: string): Promise<unknown> | unknown;
+}
+/**
+ * Validate and return a wallet's standard Bitcoin compact-message signature.
+ * The header must encode a compressed public key and recovery ID 0–3.
+ */
+export declare function normalizeBchMessageSignature(signature: unknown): string;
+/** Pass exact UTF-8 message text to a transport adapter and validate its response. */
+export declare function signBchMessage(signer: BchMessageSigner, message: string): Promise<string>;

package/dist/signing.js

@@ -0,0 +1,30 @@
+export const BCH_PROOF_FORMAT = "bitcoin-message/compact-base64";
+/**
+ * Validate and return a wallet's standard Bitcoin compact-message signature.
+ * The header must encode a compressed public key and recovery ID 0–3.
+ */
+export function normalizeBchMessageSignature(signature) {
+    if (typeof signature !== "string" || !/^(?:[A-Za-z0-9+/]{4}){21}[A-Za-z0-9+/]{3}=$/.test(signature))
+        throw new Error("BCH message signature must be a canonical 65-byte Base64 compact signature");
+    let decoded;
+    try {
+        decoded = atob(signature);
+    }
+    catch {
+        throw new Error("BCH message signature is not valid Base64");
+    }
+    if (decoded.length !== 65 || btoa(decoded) !== signature)
+        throw new Error("BCH message signature must be canonical Base64 for exactly 65 bytes");
+    const header = decoded.charCodeAt(0);
+    if (header < 31 || header > 34)
+        throw new Error("BCH message signature must use a compressed-key header (31–34)");
+    return signature;
+}
+/** Pass exact UTF-8 message text to a transport adapter and validate its response. */
+export async function signBchMessage(signer, message) {
+    if (!signer || typeof signer.signMessage !== "function")
+        throw new TypeError("A BCH message signer with signMessage(message) is required");
+    if (typeof message !== "string")
+        throw new TypeError("BCH message must be a string");
+    return normalizeBchMessageSignature(await signer.signMessage(message));
+}

package/dist/verify.d.ts

@@ -1,15 +1,15 @@
 import { canonicalize, sha256hex, bchSigningPayload, type CanonicalBinding, type IdentityBinding, type NostrEvent } from "./binding.js";
+import { type BchProofTag } from "./signing.js";
 export type VerifyStatus = "verified" | "invalid_bch_sig" | "invalid_nostr_sig" | "id_mismatch" | "malformed" | "expired";
 export interface VerifyResult {
     status: VerifyStatus;
     bchValid: boolean;
     nostrValid: boolean;
     details: string;
-    /** BCH block timestamp (unix seconds) from the bch-anchor tag, if present.
-     *  Accurate to ~1 block (~10 min): must exceed median of last 11 blocks so
-     *  it cannot be significantly backdated, and can be at most 2 hours ahead of
-     *  network time. Use this instead of the self-reported `createdAt`. */
-    anchoredAt?: number;
+}
+export interface BCHAnchorClaim {
+    txid: string;
+    blockHeight?: number;
 }
 export interface ResolvedIdentity {
     npub: string;
@@ -18,20 +18,19 @@ export interface ResolvedIdentity {
     network: string;
     bindingId: string;
     createdAt: number;
-    bchProofTag: string[];
+    bchProofTag: BchProofTag;
     rawEvent: NostrEvent;
-    /** BCH block timestamp (unix seconds) from the bch-anchor tag, if present.
-     *  More trustworthy than `createdAt` — accurate to ~1 block (~10 min),
-     *  cannot be significantly backdated (median-time-past rule). */
-    anchoredAt?: number;
+    /** Unverified metadata claimed by the event; this library does not verify chain inclusion. */
+    anchorClaim?: BCHAnchorClaim;
 }
 /** Resolve a BCH address from an npub via Nostr relays */
 export declare function resolveIdentity(npub: string, relays?: string[]): Promise<ResolvedIdentity | null>;
 /** Verify the BCH + Nostr signatures on a resolved identity */
 export declare function verifyIdentity(resolved: ResolvedIdentity): Promise<VerifyResult>;
+/** Build the exact versioned challenge message that a BCH wallet must sign. */
+export declare function bchChallengePayload(nonce: string, audience?: string): string;
 /** 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 declare function verifyChallengeProof(proof: {
@@ -49,7 +48,7 @@ export declare function verifyChallengeProof(proof: {
  * if (address) wallet.sendTo(address, amount)
  */
 export declare function resolveAddress(npub: string, relays?: string[]): Promise<string | 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 declare function resolveIdentityChain(npub: string, relays?: string[]): Promise<ResolvedIdentity[]>;
 /**
  * Resolve a BCH address from a NIP-05 handle (e.g. "alice@cashlet.app")