@orangecheck/sdk 1.14.1 → 1.16.0

package/dist/index.js

@@ -1,8 +1,8 @@
 'use strict';
 
 var base = require('@scure/base');
-var buffer = require('buffer');
 var bip322 = require('@orangecheck/bip322');
+var buffer = require('buffer');
 var hmac_js = require('@noble/hashes/hmac.js');
 var sha2_js = require('@noble/hashes/sha2.js');
 var utils_js = require('@noble/hashes/utils.js');
@@ -214,8 +214,345 @@ function logVerificationError(protocol, identifier, error, context) {
   );
 }
 
+// src/utils/time.ts
+var RFC3339 = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
+function rfc3339Ms(value) {
+  if (!value || !RFC3339.test(value)) return null;
+  const ms = Date.parse(value);
+  return Number.isNaN(ms) ? null : ms;
+}
+
+// src/scoring.ts
+function scoreV0(sats, days) {
+  if (sats <= 0 || days <= 0) return 0;
+  return Math.round(Math.log(1 + sats) * (1 + days / 30) * 100) / 100;
+}
+function scoreTier(sats, days) {
+  if (sats >= 1e7 && days >= 365) return "platinum";
+  if (sats >= 1e6 && days >= 180) return "gold";
+  if (sats >= 1e5 && days >= 90) return "silver";
+  if (sats >= 1e4 && days >= 30) return "bronze";
+  return "none";
+}
+function computeScore(sats, days, config) {
+  switch (config.algorithm) {
+    case "v0":
+      return scoreV0(sats, days);
+    case "tier":
+      return scoreTier(sats, days);
+    case "none":
+      return null;
+  }
+}
+function computeAllScores(sats, days) {
+  return { v0: scoreV0(sats, days), tier: scoreTier(sats, days) };
+}
+function toBase64Maybe(sig) {
+  if (/^[0-9a-fA-F]+$/.test(sig) && sig.length % 2 === 0) {
+    return buffer.Buffer.from(sig, "hex").toString("base64");
+  }
+  return sig;
+}
+function signatureScheme(sigBase64) {
+  if (/^(ful|pof)/.test(sigBase64)) return null;
+  if (sigBase64.startsWith("smp")) return "bip322";
+  return buffer.Buffer.from(sigBase64, "base64").length === 65 ? "legacy" : "bip322";
+}
+
+// src/verify.ts
+var log = createLogger("ocp/verify");
+async function verifySignature({ addr, msg, sig }) {
+  const sigBase64 = toBase64Maybe(sig);
+  const scheme = signatureScheme(sigBase64);
+  if (!scheme) return "sig_unsupported_script";
+  const ok = bip322.verifySignature(addr, msg, sigBase64);
+  log.info({ addr, ok, scheme, msgLength: msg.length }, "Signature verification result");
+  if (!ok) return "sig_invalid";
+  return scheme === "legacy" ? "sig_ok_legacy" : "sig_ok_bip322";
+}
+async function signatureIsValid(input) {
+  try {
+    const code = await verifySignature(input);
+    return code === "sig_ok_bip322" || code === "sig_ok_legacy";
+  } catch {
+    return false;
+  }
+}
+function parseCanonicalMessage(msg) {
+  const lines = msg.split("\n").map((l) => l.trim());
+  const getVal = (prefix) => {
+    const needle = prefix + ":";
+    const hit = lines.find((l) => l.toLowerCase().startsWith(needle));
+    if (!hit) return void 0;
+    const idx = hit.indexOf(":");
+    return hit.slice(idx + 1).trim();
+  };
+  const address = getVal("address") || "";
+  const identitiesStr = getVal("identities") || "";
+  const issued_at = getVal("issued_at") || "";
+  const expires = getVal("expires");
+  let identities = [];
+  try {
+    identities = parseIdentities(identitiesStr);
+  } catch (err) {
+    log.warn({ identitiesStr, error: err }, "Failed to parse identities field");
+  }
+  const coreKeys = /* @__PURE__ */ new Set([
+    "orangecheck",
+    "identities",
+    "address",
+    "purpose",
+    "nonce",
+    "issued_at",
+    "ack"
+  ]);
+  const extensions = {};
+  for (const line of lines) {
+    const idx = line.indexOf(":");
+    if (idx === -1) continue;
+    const key = line.slice(0, idx).trim().toLowerCase();
+    const val = line.slice(idx + 1).trim();
+    if (!coreKeys.has(key) && val) extensions[key] = val;
+  }
+  const network = extensions["network"] || "mainnet";
+  const bondStr = extensions["bond"];
+  const bond = bondStr ? parseInt(bondStr, 10) : void 0;
+  return {
+    core: { address, identities, issued_at },
+    expires,
+    network,
+    extensions,
+    bond: bond !== void 0 && !isNaN(bond) && bond > 0 ? bond : void 0
+  };
+}
+async function getAddressUtxos(address, network, opts) {
+  const endpoints = network === "signet" ? [
+    opts?.esploraSignetBase || "https://mempool.space/signet/api",
+    "https://blockstream.info/signet/api"
+  ] : network === "testnet" ? [
+    opts?.esploraTestnetBase || "https://mempool.space/testnet/api",
+    "https://blockstream.info/testnet/api"
+  ] : [
+    opts?.esploraMainnetBase || "https://mempool.space/api",
+    "https://blockstream.info/api"
+  ];
+  let lastError = null;
+  for (const base of endpoints) {
+    try {
+      const url = `${base}/address/${address}/utxo`;
+      log.debug({ url, network }, "Fetching UTXOs");
+      const resp = await fetch(url, {
+        method: "GET",
+        headers: { Accept: "application/json" },
+        signal: AbortSignal.timeout(5e3)
+      });
+      if (!resp.ok) {
+        throw new Error(`HTTP ${resp.status}`);
+      }
+      const data = await resp.json();
+      if (!Array.isArray(data)) {
+        throw new Error("Invalid response: expected array");
+      }
+      for (const utxo of data) {
+        if (typeof utxo.value !== "number" || typeof utxo.status !== "object" || typeof utxo.status.confirmed !== "boolean" || typeof utxo.txid !== "string" || typeof utxo.vout !== "number") {
+          throw new Error("Invalid UTXO structure");
+        }
+      }
+      log.info({ base, count: data.length, network }, "UTXOs fetched successfully");
+      return data;
+    } catch (err) {
+      lastError = err instanceof Error ? err : new Error(String(err));
+      log.warn(
+        { base, error: lastError.message, network },
+        "Esplora endpoint failed, trying next"
+      );
+    }
+  }
+  log.error({ endpoints, error: lastError?.message, network }, "All Esplora endpoints failed");
+  throw new Error(`esplora_all_failed: ${lastError?.message || "unknown"}`);
+}
+function computeMetrics(utxos, bondAmount, coverSats) {
+  const confirmedUtxos = utxos.filter((u) => u.status.confirmed);
+  if (confirmedUtxos.length === 0) {
+    return { sats_bonded: 0, days_unspent: 0, confirmed_balance: 0 };
+  }
+  const confirmed_balance = confirmedUtxos.reduce((sum, u) => sum + u.value, 0);
+  if (bondAmount !== void 0 && bondAmount > 0) {
+    const sorted = [...confirmedUtxos].sort((a, b) => {
+      const heightA = a.status.block_height ?? Infinity;
+      const heightB = b.status.block_height ?? Infinity;
+      if (heightA !== heightB) return heightA - heightB;
+      if (a.txid !== b.txid) return a.txid.localeCompare(b.txid);
+      return a.vout - b.vout;
+    });
+    let sum = 0;
+    let youngestTime = 0;
+    for (const utxo of sorted) {
+      sum += utxo.value;
+      youngestTime = Math.max(youngestTime, utxo.status.block_time || 0);
+      if (sum >= bondAmount) break;
+    }
+    const days_unspent2 = Math.max(
+      0,
+      Math.floor((Date.now() / 1e3 - youngestTime) / (24 * 60 * 60))
+    );
+    return {
+      sats_bonded: bondAmount,
+      // Use exactly bond amount (ignore surplus)
+      days_unspent: days_unspent2,
+      confirmed_balance
+    };
+  }
+  const sats_bonded = confirmed_balance;
+  if (coverSats !== void 0 && coverSats > 0) {
+    const sorted = [...confirmedUtxos].sort(
+      (a, b) => (a.status.block_height ?? Infinity) - (b.status.block_height ?? Infinity)
+    );
+    let sum = 0;
+    let youngestTime = 0;
+    for (const utxo of sorted) {
+      sum += utxo.value;
+      youngestTime = Math.max(youngestTime, utxo.status.block_time || Date.now() / 1e3);
+      if (sum >= coverSats) break;
+    }
+    const days_unspent2 = Math.max(
+      0,
+      Math.floor((Date.now() / 1e3 - youngestTime) / (24 * 60 * 60))
+    );
+    return { sats_bonded, days_unspent: days_unspent2, confirmed_balance };
+  }
+  const oldestTime = Math.min(
+    ...confirmedUtxos.map((u) => u.status.block_time || Date.now() / 1e3)
+  );
+  const days_unspent = Math.max(0, Math.floor((Date.now() / 1e3 - oldestTime) / (24 * 60 * 60)));
+  return { sats_bonded, days_unspent, confirmed_balance };
+}
+async function verify(input, opts = {}) {
+  const codes = [];
+  let network = "mainnet";
+  try {
+    if (!input.msg || !input.addr || !input.sig) {
+      codes.push("bad_request");
+      return { ok: false, codes, network };
+    }
+    const parsed = parseCanonicalMessage(input.msg);
+    network = parsed.network || "mainnet";
+    const attestation_id = await generateAttestationId(input.msg);
+    if (parsed.core.address !== input.addr) {
+      codes.push("bad_request");
+      return { ok: false, codes, network, attestation_id };
+    }
+    if ((network === "testnet" || network === "signet") && !opts.testMode) {
+      codes.push("network_testmode");
+      return { ok: false, codes, network, attestation_id };
+    }
+    if (opts.expectedAud) {
+      const aud = parsed.extensions["aud"];
+      if (!aud || aud !== opts.expectedAud) {
+        codes.push("aud_mismatch");
+        return { ok: false, codes, network, attestation_id };
+      }
+    }
+    if (parsed.expires !== void 0) {
+      const exp = rfc3339Ms(parsed.expires);
+      if (exp === null || exp < Date.now()) {
+        codes.push("expired");
+        return { ok: false, codes, network, attestation_id };
+      }
+    }
+    const sigCode = await verifySignature({
+      addr: input.addr,
+      msg: input.msg,
+      sig: input.sig,
+      ...input.scheme && { scheme: input.scheme }
+    });
+    codes.push(sigCode);
+    const sigOk = sigCode === "sig_ok_bip322" || sigCode === "sig_ok_legacy";
+    if (!sigOk) {
+      return {
+        ok: false,
+        codes,
+        network,
+        attestation_id,
+        identities: parsed.core.identities
+      };
+    }
+    try {
+      const utxos = await getAddressUtxos(input.addr, network, {
+        esploraMainnetBase: opts.esploraMainnetBase,
+        esploraSignetBase: opts.esploraSignetBase
+      });
+      const { sats_bonded, days_unspent, confirmed_balance } = computeMetrics(
+        utxos,
+        parsed.bond,
+        opts.coverSats
+      );
+      if (parsed.bond !== void 0 && parsed.bond > 0) {
+        if (confirmed_balance < parsed.bond) {
+          codes.push("bond_insufficient");
+          log.warn(
+            {
+              bond: parsed.bond,
+              confirmed_balance,
+              address: input.addr
+            },
+            "Bond extension: insufficient balance"
+          );
+          return {
+            ok: false,
+            codes,
+            network,
+            attestation_id,
+            identities: parsed.core.identities
+          };
+        }
+      }
+      if (sats_bonded <= 0) {
+        codes.push("bond_zero");
+        if (utxos.some((u) => !u.status.confirmed)) {
+          codes.push("bond_pending");
+        }
+        return {
+          ok: false,
+          codes,
+          network,
+          attestation_id,
+          identities: parsed.core.identities
+        };
+      } else {
+        codes.push("bond_confirmed");
+      }
+      const metrics = {
+        sats_bonded,
+        days_unspent,
+        score: computeScore(sats_bonded, days_unspent, { algorithm: "v0" })
+      };
+      return {
+        ok: true,
+        codes,
+        network,
+        attestation_id,
+        identities: parsed.core.identities,
+        metrics
+      };
+    } catch (utxoError) {
+      log.error({ err: utxoError }, "UTXO fetch failed");
+      codes.push("bad_request");
+      return { ok: false, codes, network, attestation_id };
+    }
+  } catch (e) {
+    const msg = e instanceof Error ? e.message : String(e ?? "decode_error");
+    if (msg === "decode_error") {
+      codes.push("decode_error");
+    } else {
+      codes.push("bad_request");
+    }
+    return { ok: false, codes, network };
+  }
+}
+
 // src/nostr.ts
-var log = createLogger("ocp/nostr");
+var log2 = createLogger("ocp/nostr");
 var ATTESTATION_EVENT_KIND = 30078;
 var DEFAULT_RELAYS = [
   "wss://relay.damus.io",
@@ -268,7 +605,7 @@ function createAttestationEvent(envelope, pubkey) {
 async function publishToRelays(event, relays = DEFAULT_RELAYS) {
   const success = [];
   const failed = [];
-  log.info({ eventId: event.id, relayCount: relays.length }, "Publishing event to relays");
+  log2.info({ eventId: event.id, relayCount: relays.length }, "Publishing event to relays");
   const deadlineAt = Date.now() + FANOUT_DEADLINE_MS;
   const publishPromises = relays.map(async (relayUrl) => {
     let ws = null;
@@ -307,7 +644,7 @@ async function publishToRelays(event, relays = DEFAULT_RELAYS) {
                 cleanup();
                 resolve();
               } else {
-                log.warn(
+                log2.warn(
                   { relay: relayUrl, reason: data[3] },
                   "Relay rejected event"
                 );
@@ -317,7 +654,7 @@ async function publishToRelays(event, relays = DEFAULT_RELAYS) {
               }
             }
           } catch (err) {
-            log.error(
+            log2.error(
               { relay: relayUrl, error: err },
               "Failed to parse relay response"
             );
@@ -327,7 +664,7 @@ async function publishToRelays(event, relays = DEFAULT_RELAYS) {
           }
         };
         wsRef.onerror = (err) => {
-          log.error({ relay: relayUrl, error: err }, "WebSocket error");
+          log2.error({ relay: relayUrl, error: err }, "WebSocket error");
           recordFailure();
           cleanup();
           reject(err);
@@ -337,7 +674,7 @@ async function publishToRelays(event, relays = DEFAULT_RELAYS) {
         };
       });
     } catch (err) {
-      log.error({ relay: relayUrl, error: err }, "Failed to publish to relay");
+      log2.error({ relay: relayUrl, error: err }, "Failed to publish to relay");
       recordFailure();
     } finally {
       if (ws && ws.readyState !== WebSocket.CLOSED) {
@@ -346,12 +683,12 @@ async function publishToRelays(event, relays = DEFAULT_RELAYS) {
     }
   });
   await Promise.allSettled(publishPromises);
-  log.info({ successCount: success.length, failedCount: failed.length }, "Publishing complete");
+  log2.info({ successCount: success.length, failedCount: failed.length }, "Publishing complete");
   return { success, failed };
 }
 async function queryByAttestationId(attestationId, relays = DEFAULT_RELAYS) {
   const events = [];
-  log.info({ attestationId, relayCount: relays.length }, "Querying relays for attestation");
+  log2.info({ attestationId, relayCount: relays.length }, "Querying relays for attestation");
   const deadlineAt = Date.now() + FANOUT_DEADLINE_MS;
   const queryPromises = relays.map(async (relayUrl) => {
     let ws = null;
@@ -391,11 +728,11 @@ async function queryByAttestationId(attestationId, relays = DEFAULT_RELAYS) {
               resolve();
             }
           } catch (err) {
-            log.error({ relay: relayUrl, error: err }, "Failed to parse event");
+            log2.error({ relay: relayUrl, error: err }, "Failed to parse event");
           }
         };
         wsRef.onerror = (err) => {
-          log.error({ relay: relayUrl, error: err }, "WebSocket error during query");
+          log2.error({ relay: relayUrl, error: err }, "WebSocket error during query");
           cleanup();
           reject(err);
         };
@@ -404,7 +741,7 @@ async function queryByAttestationId(attestationId, relays = DEFAULT_RELAYS) {
         };
       });
     } catch (err) {
-      log.error({ relay: relayUrl, error: err }, "Failed to query relay");
+      log2.error({ relay: relayUrl, error: err }, "Failed to query relay");
     } finally {
       if (ws && ws.readyState !== WebSocket.CLOSED) {
         ws.close();
@@ -412,12 +749,12 @@ async function queryByAttestationId(attestationId, relays = DEFAULT_RELAYS) {
     }
   });
   await Promise.allSettled(queryPromises);
-  log.info({ eventCount: events.length }, "Query complete");
+  log2.info({ eventCount: events.length }, "Query complete");
   return events;
 }
 async function queryByAddress(address, relays = DEFAULT_RELAYS) {
   const events = [];
-  log.info({ address, relayCount: relays.length }, "Querying relays for address");
+  log2.info({ address, relayCount: relays.length }, "Querying relays for address");
   const deadlineAt = Date.now() + FANOUT_DEADLINE_MS;
   const queryPromises = relays.map(async (relayUrl) => {
     try {
@@ -459,28 +796,28 @@ async function queryByAddress(address, relays = DEFAULT_RELAYS) {
               resolve();
             }
           } catch (err) {
-            log.error({ relay: relayUrl, error: err }, "Failed to parse event");
+            log2.error({ relay: relayUrl, error: err }, "Failed to parse event");
           }
         };
         ws.onerror = (err) => {
           clearTimeout(timeout);
-          log.error({ relay: relayUrl, error: err }, "WebSocket error during query");
+          log2.error({ relay: relayUrl, error: err }, "WebSocket error during query");
           reject(err);
         };
       });
     } catch (err) {
-      log.error({ relay: relayUrl, error: err }, "Failed to query relay");
+      log2.error({ relay: relayUrl, error: err }, "Failed to query relay");
     }
   });
   await Promise.allSettled(queryPromises);
-  log.info({ eventCount: events.length }, "Query complete");
+  log2.info({ eventCount: events.length }, "Query complete");
   return events;
 }
 async function queryByIdentity(protocol, identifier, relays = DEFAULT_RELAYS) {
   const events = [];
   const identityTag = `${protocol}:${identifier}`;
   const identityTags = protocol === "nostr" ? nostrIdentifierForms(identifier).map((f) => `nostr:${f}`) : [identityTag];
-  log.info({ protocol, identifier, relayCount: relays.length }, "Querying relays for identity");
+  log2.info({ protocol, identifier, relayCount: relays.length }, "Querying relays for identity");
   const deadlineAt = Date.now() + FANOUT_DEADLINE_MS;
   const queryPromises = relays.map(async (relayUrl) => {
     try {
@@ -515,26 +852,26 @@ async function queryByIdentity(protocol, identifier, relays = DEFAULT_RELAYS) {
               resolve();
             }
           } catch (err) {
-            log.error({ relay: relayUrl, error: err }, "Failed to parse event");
+            log2.error({ relay: relayUrl, error: err }, "Failed to parse event");
           }
         };
         ws.onerror = (err) => {
           clearTimeout(timeout);
-          log.error({ relay: relayUrl, error: err }, "WebSocket error during query");
+          log2.error({ relay: relayUrl, error: err }, "WebSocket error during query");
           reject(err);
         };
       });
     } catch (err) {
-      log.error({ relay: relayUrl, error: err }, "Failed to query relay");
+      log2.error({ relay: relayUrl, error: err }, "Failed to query relay");
     }
   });
   await Promise.allSettled(queryPromises);
-  log.info({ eventCount: events.length }, "Query complete");
+  log2.info({ eventCount: events.length }, "Query complete");
   return events;
 }
 async function queryRecent(relays = DEFAULT_RELAYS, limit = 200) {
   const events = [];
-  log.info({ relayCount: relays.length, limit }, "Querying relays for recent attestations");
+  log2.info({ relayCount: relays.length, limit }, "Querying relays for recent attestations");
   const deadlineAt = Date.now() + FANOUT_DEADLINE_MS;
   const queryPromises = relays.map(async (relayUrl) => {
     try {
@@ -570,30 +907,22 @@ async function queryRecent(relays = DEFAULT_RELAYS, limit = 200) {
               resolve();
             }
           } catch (err) {
-            log.error({ relay: relayUrl, error: err }, "Failed to parse event");
+            log2.error({ relay: relayUrl, error: err }, "Failed to parse event");
           }
         };
         ws.onerror = (err) => {
           clearTimeout(timeout);
-          log.error({ relay: relayUrl, error: err }, "WebSocket error during query");
+          log2.error({ relay: relayUrl, error: err }, "WebSocket error during query");
           reject(err);
         };
       });
     } catch (err) {
-      log.error({ relay: relayUrl, error: err }, "Failed to query relay");
+      log2.error({ relay: relayUrl, error: err }, "Failed to query relay");
     }
   });
   await Promise.allSettled(queryPromises);
-  const seen = /* @__PURE__ */ new Set();
-  const envelopes = [];
-  for (const ev of events) {
-    const envelope = parseAttestationFromEvent(ev);
-    if (!envelope || seen.has(envelope.attestation_id)) continue;
-    if (!await verifyAttestationEnvelope(envelope)) continue;
-    seen.add(envelope.attestation_id);
-    envelopes.push(envelope);
-  }
-  log.info({ eventCount: events.length, unique: envelopes.length }, "Recent query complete");
+  const envelopes = await collectSignedEnvelopes(events);
+  log2.info({ eventCount: events.length, unique: envelopes.length }, "Recent query complete");
   return envelopes;
 }
 async function verifyAttestationEnvelope(envelope) {
@@ -605,22 +934,74 @@ async function verifyAttestationEnvelope(envelope) {
     const computedId = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
     return computedId === envelope.attestation_id;
   } catch (err) {
-    log.error({ error: err }, "Failed to verify attestation envelope");
+    log2.error({ error: err }, "Failed to verify attestation envelope");
     return false;
   }
 }
+function base64Url(text) {
+  const base64 = btoa(String.fromCharCode(...new TextEncoder().encode(text)));
+  return base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+}
+function signedEnvelope(envelope) {
+  let parsed;
+  try {
+    parsed = parseCanonicalMessage(envelope.message);
+  } catch {
+    return null;
+  }
+  if (!parsed.core.address || rfc3339Ms(parsed.core.issued_at) === null) return null;
+  const { expires_at: _copy, ...rest } = envelope;
+  return {
+    ...rest,
+    address: parsed.core.address,
+    identities: parsed.core.identities,
+    issued_at: parsed.core.issued_at,
+    ...parsed.expires !== void 0 ? { expires_at: parsed.expires } : {},
+    message_b64url: base64Url(envelope.message)
+  };
+}
+async function collectSignedEnvelopes(events, accept = () => true) {
+  const copies = /* @__PURE__ */ new Map();
+  for (const event of events) {
+    const raw = parseAttestationFromEvent(event);
+    if (!raw || !await verifyAttestationEnvelope(raw)) continue;
+    const envelope = signedEnvelope(raw);
+    if (!envelope || !accept(event, envelope)) continue;
+    const same = copies.get(envelope.attestation_id) ?? [];
+    if (!same.some((e) => e.signature === envelope.signature && e.scheme === envelope.scheme)) {
+      same.push(envelope);
+    }
+    copies.set(envelope.attestation_id, same);
+  }
+  const kept = [];
+  for (const same of copies.values()) {
+    if (same.length === 1) {
+      kept.push(same[0]);
+      continue;
+    }
+    let valid;
+    for (const e of same) {
+      if (await signatureIsValid({ addr: e.address, msg: e.message, sig: e.signature, scheme: e.scheme })) {
+        valid = e;
+        break;
+      }
+    }
+    kept.push(valid ?? same[0]);
+  }
+  return kept;
+}
 function parseAttestationFromEvent(event) {
   try {
     const envelope = JSON.parse(event.content);
     return envelope;
   } catch (err) {
-    log.error({ eventId: event.id, error: err }, "Failed to parse attestation from event");
+    log2.error({ eventId: event.id, error: err }, "Failed to parse attestation from event");
     return null;
   }
 }
 
 // src/nostr-crypto.ts
-var log2 = createLogger("ocp/nostr-crypto");
+var log3 = createLogger("ocp/nostr-crypto");
 function isNip07Available() {
   if (typeof window === "undefined") {
     return false;
@@ -629,31 +1010,31 @@ function isNip07Available() {
 }
 async function getNostrPublicKey() {
   if (!isNip07Available()) {
-    log2.warn("NIP-07 extension not available");
+    log3.warn("NIP-07 extension not available");
     return null;
   }
   try {
     const nostr = window.nostr;
     const pubkey = await nostr.getPublicKey();
-    log2.info({ pubkey }, "Got Nostr public key from NIP-07");
+    log3.info({ pubkey }, "Got Nostr public key from NIP-07");
     return pubkey;
   } catch (err) {
-    log2.error({ error: err }, "Failed to get Nostr public key");
+    log3.error({ error: err }, "Failed to get Nostr public key");
     return null;
   }
 }
 async function signNostrEvent(event) {
   if (!isNip07Available()) {
-    log2.warn("NIP-07 extension not available");
+    log3.warn("NIP-07 extension not available");
     return null;
   }
   try {
     const nostr = window.nostr;
     const signedEvent = await nostr.signEvent(event);
-    log2.info({ eventId: signedEvent.id }, "Signed Nostr event with NIP-07");
+    log3.info({ eventId: signedEvent.id }, "Signed Nostr event with NIP-07");
     return signedEvent;
   } catch (err) {
-    log2.error({ error: err }, "Failed to sign Nostr event");
+    log3.error({ error: err }, "Failed to sign Nostr event");
     return null;
   }
 }
@@ -670,7 +1051,7 @@ function getNip07Info() {
 }
 
 // src/attestation.ts
-var log3 = createLogger("ocp/attestation");
+var log4 = createLogger("ocp/attestation");
 var AttestationError = class extends Error {
   constructor(message, code) {
     super(message);
@@ -680,7 +1061,7 @@ var AttestationError = class extends Error {
 };
 async function createAttestation(options) {
   const { message, signature, scheme, address, identities = [], extensions = {} } = options;
-  log3.info({ address, identityCount: identities.length }, "Creating attestation");
+  log4.info({ address, identityCount: identities.length }, "Creating attestation");
   const envelope = await createAttestationEnvelope(
     message,
     signature,
@@ -691,529 +1072,117 @@ async function createAttestation(options) {
   );
   const isValid = await verifyAttestationEnvelope(envelope);
   if (!isValid) {
-    throw new AttestationError(
-      "Attestation envelope integrity check failed",
-      "INTEGRITY_CHECK_FAILED"
-    );
-  }
-  log3.info({ attestationId: envelope.attestation_id }, "Attestation created successfully");
-  return envelope;
-}
-async function publishAttestation(options) {
-  const { envelope, npub, relays = DEFAULT_RELAYS } = options;
-  log3.info(
-    { attestationId: envelope.attestation_id, relayCount: relays.length },
-    "Publishing attestation"
-  );
-  const unsignedEvent = createAttestationEvent(envelope, npub);
-  if (!isNip07Available()) {
-    log3.warn("NIP-07 unavailable \u2014 skipping Nostr publish");
-    throw new Error(
-      "nostr_signer_unavailable: install a NIP-07 extension (e.g. nos2x, Alby) to publish"
-    );
-  }
-  log3.info("Using NIP-07 to sign event");
-  const signedEvent = await signNostrEvent(unsignedEvent);
-  if (!signedEvent) {
-    throw new Error("nostr_signing_failed: NIP-07 extension rejected or errored");
-  }
-  const result = await publishToRelays(signedEvent, relays);
-  log3.info(
-    {
-      attestationId: envelope.attestation_id,
-      successCount: result.success.length,
-      failedCount: result.failed.length
-    },
-    "Publishing complete"
-  );
-  return result;
-}
-function eventIndexesEnvelope(event, envelope) {
-  const d = event.tags.find((t) => t[0] === "d")?.[1];
-  const id = envelope.attestation_id;
-  if (d !== id && d !== `orangecheck:${id}`) return false;
-  return event.tags.some((t) => t[0] === "t" && t[1] === envelope.address);
-}
-async function discoverAttestations(options) {
-  const { attestationId, address, identity, relays = DEFAULT_RELAYS } = options;
-  let events = [];
-  if (attestationId) {
-    log3.info({ attestationId }, "Discovering by attestation ID");
-    events = await queryByAttestationId(attestationId, relays);
-  } else if (address) {
-    log3.info({ address }, "Discovering by Bitcoin address");
-    events = await queryByAddress(address, relays);
-  } else if (identity) {
-    log3.info({ identity }, "Discovering by identity");
-    events = await queryByIdentity(identity.protocol, identity.identifier, relays);
-  } else {
-    throw new Error("Must provide attestationId, address, or identity");
-  }
-  const envelopes = [];
-  const kept = /* @__PURE__ */ new Set();
-  for (const event of events) {
-    const envelope = parseAttestationFromEvent(event);
-    if (envelope && kept.has(envelope.attestation_id)) continue;
-    if (envelope && !eventIndexesEnvelope(event, envelope)) {
-      log3.warn({ eventId: event.id }, "Skipping event whose index tags disagree with its envelope");
-    } else if (envelope) {
-      const isValid = await verifyAttestationEnvelope(envelope);
-      if (isValid) {
-        kept.add(envelope.attestation_id);
-        envelopes.push(envelope);
-      } else {
-        log3.warn(
-          { attestationId: envelope.attestation_id },
-          "Skipping invalid attestation envelope"
-        );
-      }
-    }
-  }
-  log3.info({ eventCount: events.length, validCount: envelopes.length }, "Discovery complete");
-  return envelopes;
-}
-async function verifyAttestationById(attestationId, relays = DEFAULT_RELAYS) {
-  log3.info({ attestationId }, "Verifying attestation by ID");
-  const envelopes = await discoverAttestations({ attestationId, relays });
-  if (envelopes.length === 0) {
-    log3.warn({ attestationId }, "Attestation not found on any relay");
-    return null;
-  }
-  if (envelopes.length > 1) {
-    log3.warn(
-      { attestationId, count: envelopes.length },
-      "Multiple attestations found with same ID - using first"
-    );
-  }
-  return envelopes[0] || null;
-}
-async function getAttestationsForAddress(address, relays = DEFAULT_RELAYS) {
-  log3.info({ address }, "Getting all attestations for address");
-  return discoverAttestations({ address, relays });
-}
-async function getAttestationsForIdentity(protocol, identifier, relays = DEFAULT_RELAYS) {
-  log3.info({ protocol, identifier }, "Getting all attestations for identity");
-  return discoverAttestations({ identity: { protocol, identifier }, relays });
-}
-function formatIdentitiesForDisplay(identities) {
-  return identities.map((id) => `${id.protocol}:${id.identifier}`).join(", ");
-}
-function getVerificationUrl(attestationId, baseUrl = "https://attest.ochk.io") {
-  return `${baseUrl}/attest/${attestationId}`;
-}
-function extractAttestationIdFromUrl(url) {
-  try {
-    const u = new URL(url);
-    const m = u.pathname.match(/^\/attest\/([0-9a-f]{64})\/?$/i);
-    if (m) return m[1].toLowerCase();
-    const q = u.searchParams.get("id");
-    if (q && /^[0-9a-f]{64}$/i.test(q)) return q.toLowerCase();
-    return null;
-  } catch {
-    return null;
-  }
-}
-
-// src/scoring.ts
-function scoreV0(sats, days) {
-  if (sats <= 0 || days <= 0) return 0;
-  return Math.round(Math.log(1 + sats) * (1 + days / 30) * 100) / 100;
-}
-function scoreTier(sats, days) {
-  if (sats >= 1e7 && days >= 365) return "platinum";
-  if (sats >= 1e6 && days >= 180) return "gold";
-  if (sats >= 1e5 && days >= 90) return "silver";
-  if (sats >= 1e4 && days >= 30) return "bronze";
-  return "none";
-}
-function computeScore(sats, days, config) {
-  switch (config.algorithm) {
-    case "v0":
-      return scoreV0(sats, days);
-    case "tier":
-      return scoreTier(sats, days);
-    case "none":
-      return null;
-  }
-}
-function computeAllScores(sats, days) {
-  return { v0: scoreV0(sats, days), tier: scoreTier(sats, days) };
-}
-
-// src/verify.ts
-var log4 = createLogger("ocp/verify");
-function looksLikeHex(s) {
-  return /^[0-9a-fA-F]+$/.test(s) && s.length % 2 === 0;
-}
-function toBase64Maybe(sig) {
-  if (looksLikeHex(sig)) {
-    return buffer.Buffer.from(sig, "hex").toString("base64");
-  }
-  return sig;
-}
-function detectSignatureScheme(addr, sig) {
-  const isSegWit = addr.startsWith("bc1") || addr.startsWith("tb1");
-  if (isSegWit) {
-    return "bip322";
-  }
-  const sigBase64 = toBase64Maybe(sig);
-  const looksLikeLegacy = sigBase64.length === 88 && /^[IHG]/.test(sigBase64);
-  if (looksLikeLegacy) {
-    return "legacy";
-  }
-  return "bip322";
-}
-async function verifySignature({
-  addr,
-  msg,
-  sig,
-  scheme
-}) {
-  const detectedScheme = scheme || detectSignatureScheme(addr, sig);
-  log4.debug(
-    { addr, msgLength: msg.length, sigLength: sig.length, scheme: detectedScheme },
-    "Verifying signature"
-  );
-  if (detectedScheme === "bip322") {
-    const sigBase64 = toBase64Maybe(sig);
-    log4.debug(
-      { sigBase64: sigBase64.substring(0, 50) + "..." },
-      "Signature converted to base64"
-    );
-    log4.debug(
-      {
-        msgFull: msg,
-        msgLines: msg.split("\n").length,
-        msgFirstLine: msg.split("\n")[0],
-        msgLastLine: msg.split("\n")[msg.split("\n").length - 1]
-      },
-      "Message being verified"
-    );
-    const ok = bip322.verifySignature(addr, msg, sigBase64);
-    log4.info({ addr, ok }, "BIP-322 verification result");
-    if (!ok) {
-      const isSegWit = addr.startsWith("bc1") || addr.startsWith("tb1");
-      if (isSegWit && sigBase64.length === 88) {
-        log4.warn(
-          { addr, wallet: "possibly Electrum", sigLength: sigBase64.length },
-          "BIP-322 verification failed - likely Electrum wallet (does not support BIP-322 for SegWit)"
-        );
-      } else {
-        log4.error(
-          {
-            addr,
-            sigLength: sigBase64.length,
-            msgLength: msg.length,
-            msgPreview: msg.substring(0, 200)
-          },
-          "BIP-322 verification failed - signature does not match message"
-        );
-      }
-    }
-    return ok ? "sig_ok_bip322" : "sig_invalid";
-  }
-  if (detectedScheme === "legacy") {
-    const sigBase64 = toBase64Maybe(sig);
-    if (!addr.startsWith("1") && !addr.startsWith("m") && !addr.startsWith("n")) {
-      log4.warn({ addr }, "Legacy signature attempted on non-P2PKH address");
-      return "sig_unsupported_script";
-    }
-    log4.debug(
-      {
-        addr,
-        sigBase64: sigBase64.substring(0, 50) + "...",
-        msgPreview: msg.substring(0, 100) + "...",
-        msgLength: msg.length
-      },
-      "Verifying legacy signature"
-    );
-    const ok = bip322.verifySignature(addr, msg, sigBase64);
-    log4.info({ addr, ok, sigBase64Length: sigBase64.length }, "Legacy verification result");
-    if (!ok) {
-      log4.error(
-        {
-          addr,
-          msgFirstLine: msg.split("\n")[0],
-          sigFormat: sigBase64.substring(0, 10)
-        },
-        "Legacy signature verification failed - check message format and signature"
-      );
-    }
-    return ok ? "sig_ok_legacy" : "sig_invalid";
-  }
-  return "invalid_scheme";
-}
-function parseCanonicalMessage(msg) {
-  const lines = msg.split("\n").map((l) => l.trim());
-  const getVal = (prefix) => {
-    const needle = prefix + ":";
-    const hit = lines.find((l) => l.toLowerCase().startsWith(needle));
-    if (!hit) return void 0;
-    const idx = hit.indexOf(":");
-    return hit.slice(idx + 1).trim();
-  };
-  const address = getVal("address") || "";
-  const identitiesStr = getVal("identities") || "";
-  let identities = [];
-  try {
-    identities = parseIdentities(identitiesStr);
-  } catch (err) {
-    log4.warn({ identitiesStr, error: err }, "Failed to parse identities field");
-  }
-  const coreKeys = /* @__PURE__ */ new Set([
-    "orangecheck",
-    "identities",
-    "address",
-    "purpose",
-    "nonce",
-    "issued_at",
-    "ack"
-  ]);
-  const extensions = {};
-  for (const line of lines) {
-    const idx = line.indexOf(":");
-    if (idx === -1) continue;
-    const key = line.slice(0, idx).trim().toLowerCase();
-    const val = line.slice(idx + 1).trim();
-    if (!coreKeys.has(key) && val) extensions[key] = val;
-  }
-  const network = extensions["network"] || "mainnet";
-  const bondStr = extensions["bond"];
-  const bond = bondStr ? parseInt(bondStr, 10) : void 0;
-  return {
-    core: { address, identities },
-    network,
-    extensions,
-    bond: bond !== void 0 && !isNaN(bond) && bond > 0 ? bond : void 0
-  };
-}
-async function getAddressUtxos(address, network, opts) {
-  const endpoints = network === "signet" ? [
-    opts?.esploraSignetBase || "https://mempool.space/signet/api",
-    "https://blockstream.info/signet/api"
-  ] : network === "testnet" ? [
-    opts?.esploraTestnetBase || "https://mempool.space/testnet/api",
-    "https://blockstream.info/testnet/api"
-  ] : [
-    opts?.esploraMainnetBase || "https://mempool.space/api",
-    "https://blockstream.info/api"
-  ];
-  let lastError = null;
-  for (const base of endpoints) {
-    try {
-      const url = `${base}/address/${address}/utxo`;
-      log4.debug({ url, network }, "Fetching UTXOs");
-      const resp = await fetch(url, {
-        method: "GET",
-        headers: { Accept: "application/json" },
-        signal: AbortSignal.timeout(5e3)
-      });
-      if (!resp.ok) {
-        throw new Error(`HTTP ${resp.status}`);
-      }
-      const data = await resp.json();
-      if (!Array.isArray(data)) {
-        throw new Error("Invalid response: expected array");
-      }
-      for (const utxo of data) {
-        if (typeof utxo.value !== "number" || typeof utxo.status !== "object" || typeof utxo.status.confirmed !== "boolean" || typeof utxo.txid !== "string" || typeof utxo.vout !== "number") {
-          throw new Error("Invalid UTXO structure");
-        }
-      }
-      log4.info({ base, count: data.length, network }, "UTXOs fetched successfully");
-      return data;
-    } catch (err) {
-      lastError = err instanceof Error ? err : new Error(String(err));
-      log4.warn(
-        { base, error: lastError.message, network },
-        "Esplora endpoint failed, trying next"
-      );
-    }
+    throw new AttestationError(
+      "Attestation envelope integrity check failed",
+      "INTEGRITY_CHECK_FAILED"
+    );
   }
-  log4.error({ endpoints, error: lastError?.message, network }, "All Esplora endpoints failed");
-  throw new Error(`esplora_all_failed: ${lastError?.message || "unknown"}`);
+  log4.info({ attestationId: envelope.attestation_id }, "Attestation created successfully");
+  return envelope;
 }
-function computeMetrics(utxos, bondAmount, coverSats) {
-  const confirmedUtxos = utxos.filter((u) => u.status.confirmed);
-  if (confirmedUtxos.length === 0) {
-    return { sats_bonded: 0, days_unspent: 0, confirmed_balance: 0 };
-  }
-  const confirmed_balance = confirmedUtxos.reduce((sum, u) => sum + u.value, 0);
-  if (bondAmount !== void 0 && bondAmount > 0) {
-    const sorted = [...confirmedUtxos].sort((a, b) => {
-      const heightA = a.status.block_height ?? Infinity;
-      const heightB = b.status.block_height ?? Infinity;
-      if (heightA !== heightB) return heightA - heightB;
-      if (a.txid !== b.txid) return a.txid.localeCompare(b.txid);
-      return a.vout - b.vout;
-    });
-    let sum = 0;
-    let youngestTime = 0;
-    for (const utxo of sorted) {
-      sum += utxo.value;
-      youngestTime = Math.max(youngestTime, utxo.status.block_time || 0);
-      if (sum >= bondAmount) break;
-    }
-    const days_unspent2 = Math.max(
-      0,
-      Math.floor((Date.now() / 1e3 - youngestTime) / (24 * 60 * 60))
+async function publishAttestation(options) {
+  const { envelope, npub, relays = DEFAULT_RELAYS } = options;
+  log4.info(
+    { attestationId: envelope.attestation_id, relayCount: relays.length },
+    "Publishing attestation"
+  );
+  const unsignedEvent = createAttestationEvent(envelope, npub);
+  if (!isNip07Available()) {
+    log4.warn("NIP-07 unavailable \u2014 skipping Nostr publish");
+    throw new Error(
+      "nostr_signer_unavailable: install a NIP-07 extension (e.g. nos2x, Alby) to publish"
     );
-    return {
-      sats_bonded: bondAmount,
-      // Use exactly bond amount (ignore surplus)
-      days_unspent: days_unspent2,
-      confirmed_balance
-    };
   }
-  const sats_bonded = confirmed_balance;
-  if (coverSats !== void 0 && coverSats > 0) {
-    const sorted = [...confirmedUtxos].sort(
-      (a, b) => (a.status.block_height ?? Infinity) - (b.status.block_height ?? Infinity)
-    );
-    let sum = 0;
-    let youngestTime = 0;
-    for (const utxo of sorted) {
-      sum += utxo.value;
-      youngestTime = Math.max(youngestTime, utxo.status.block_time || Date.now() / 1e3);
-      if (sum >= coverSats) break;
-    }
-    const days_unspent2 = Math.max(
-      0,
-      Math.floor((Date.now() / 1e3 - youngestTime) / (24 * 60 * 60))
-    );
-    return { sats_bonded, days_unspent: days_unspent2, confirmed_balance };
+  log4.info("Using NIP-07 to sign event");
+  const signedEvent = await signNostrEvent(unsignedEvent);
+  if (!signedEvent) {
+    throw new Error("nostr_signing_failed: NIP-07 extension rejected or errored");
   }
-  const oldestTime = Math.min(
-    ...confirmedUtxos.map((u) => u.status.block_time || Date.now() / 1e3)
+  const result = await publishToRelays(signedEvent, relays);
+  log4.info(
+    {
+      attestationId: envelope.attestation_id,
+      successCount: result.success.length,
+      failedCount: result.failed.length
+    },
+    "Publishing complete"
   );
-  const days_unspent = Math.max(0, Math.floor((Date.now() / 1e3 - oldestTime) / (24 * 60 * 60)));
-  return { sats_bonded, days_unspent, confirmed_balance };
+  return result;
 }
-async function verify(input, opts = {}) {
-  const codes = [];
-  let network = "mainnet";
+function eventIndexesEnvelope(event, envelope) {
+  const d = event.tags.find((t) => t[0] === "d")?.[1];
+  const id = envelope.attestation_id;
+  if (d !== id && d !== `orangecheck:${id}`) return false;
+  return event.tags.some((t) => t[0] === "t" && t[1] === envelope.address);
+}
+async function discoverAttestations(options) {
+  const { attestationId, address, identity, relays = DEFAULT_RELAYS } = options;
+  let events = [];
+  if (attestationId) {
+    log4.info({ attestationId }, "Discovering by attestation ID");
+    events = await queryByAttestationId(attestationId, relays);
+  } else if (address) {
+    log4.info({ address }, "Discovering by Bitcoin address");
+    events = await queryByAddress(address, relays);
+  } else if (identity) {
+    log4.info({ identity }, "Discovering by identity");
+    events = await queryByIdentity(identity.protocol, identity.identifier, relays);
+  } else {
+    throw new Error("Must provide attestationId, address, or identity");
+  }
+  const envelopes = await collectSignedEnvelopes(events, (event, envelope) => {
+    if (eventIndexesEnvelope(event, envelope)) return true;
+    log4.warn({ eventId: event.id }, "Skipping event whose index tags disagree with its envelope");
+    return false;
+  });
+  log4.info({ eventCount: events.length, validCount: envelopes.length }, "Discovery complete");
+  return envelopes;
+}
+async function verifyAttestationById(attestationId, relays = DEFAULT_RELAYS) {
+  log4.info({ attestationId }, "Verifying attestation by ID");
+  const envelopes = await discoverAttestations({ attestationId, relays });
+  if (envelopes.length === 0) {
+    log4.warn({ attestationId }, "Attestation not found on any relay");
+    return null;
+  }
+  if (envelopes.length > 1) {
+    log4.warn(
+      { attestationId, count: envelopes.length },
+      "Multiple attestations found with same ID - using first"
+    );
+  }
+  return envelopes[0] || null;
+}
+async function getAttestationsForAddress(address, relays = DEFAULT_RELAYS) {
+  log4.info({ address }, "Getting all attestations for address");
+  return discoverAttestations({ address, relays });
+}
+async function getAttestationsForIdentity(protocol, identifier, relays = DEFAULT_RELAYS) {
+  log4.info({ protocol, identifier }, "Getting all attestations for identity");
+  return discoverAttestations({ identity: { protocol, identifier }, relays });
+}
+function formatIdentitiesForDisplay(identities) {
+  return identities.map((id) => `${id.protocol}:${id.identifier}`).join(", ");
+}
+function getVerificationUrl(attestationId, baseUrl = "https://attest.ochk.io") {
+  return `${baseUrl}/attest/${attestationId}`;
+}
+function extractAttestationIdFromUrl(url) {
   try {
-    if (!input.msg || !input.addr || !input.sig) {
-      codes.push("bad_request");
-      return { ok: false, codes, network };
-    }
-    const parsed = parseCanonicalMessage(input.msg);
-    network = parsed.network || "mainnet";
-    const attestation_id = await generateAttestationId(input.msg);
-    if (parsed.core.address !== input.addr) {
-      codes.push("bad_request");
-      return { ok: false, codes, network, attestation_id };
-    }
-    if ((network === "testnet" || network === "signet") && !opts.testMode) {
-      codes.push("network_testmode");
-      return { ok: false, codes, network, attestation_id };
-    }
-    if (opts.expectedAud) {
-      const aud = parsed.extensions["aud"];
-      if (!aud || aud !== opts.expectedAud) {
-        codes.push("aud_mismatch");
-        return { ok: false, codes, network, attestation_id };
-      }
-    }
-    if (parsed.extensions["expires"]) {
-      const exp = Date.parse(parsed.extensions["expires"]);
-      if (!Number.isNaN(exp) && exp < Date.now()) {
-        codes.push("expired");
-        return { ok: false, codes, network, attestation_id };
-      }
-    }
-    const sigCode = await verifySignature({
-      addr: input.addr,
-      msg: input.msg,
-      sig: input.sig,
-      ...input.scheme && { scheme: input.scheme }
-    });
-    codes.push(sigCode);
-    const sigOk = sigCode === "sig_ok_bip322" || sigCode === "sig_ok_legacy";
-    if (!sigOk) {
-      return {
-        ok: false,
-        codes,
-        network,
-        attestation_id,
-        identities: parsed.core.identities
-      };
-    }
-    try {
-      const utxos = await getAddressUtxos(input.addr, network, {
-        esploraMainnetBase: opts.esploraMainnetBase,
-        esploraSignetBase: opts.esploraSignetBase
-      });
-      const { sats_bonded, days_unspent, confirmed_balance } = computeMetrics(
-        utxos,
-        parsed.bond,
-        opts.coverSats
-      );
-      if (parsed.bond !== void 0 && parsed.bond > 0) {
-        if (confirmed_balance < parsed.bond) {
-          codes.push("bond_insufficient");
-          log4.warn(
-            {
-              bond: parsed.bond,
-              confirmed_balance,
-              address: input.addr
-            },
-            "Bond extension: insufficient balance"
-          );
-          return {
-            ok: false,
-            codes,
-            network,
-            attestation_id,
-            identities: parsed.core.identities
-          };
-        }
-      }
-      if (sats_bonded <= 0) {
-        codes.push("bond_zero");
-        if (utxos.some((u) => !u.status.confirmed)) {
-          codes.push("bond_pending");
-        }
-        return {
-          ok: false,
-          codes,
-          network,
-          attestation_id,
-          identities: parsed.core.identities
-        };
-      } else {
-        codes.push("bond_confirmed");
-      }
-      const metrics = {
-        sats_bonded,
-        days_unspent,
-        score: computeScore(sats_bonded, days_unspent, { algorithm: "v0" })
-      };
-      return {
-        ok: true,
-        codes,
-        network,
-        attestation_id,
-        identities: parsed.core.identities,
-        metrics
-      };
-    } catch (utxoError) {
-      log4.error({ err: utxoError }, "UTXO fetch failed");
-      codes.push("bad_request");
-      return { ok: false, codes, network, attestation_id };
-    }
-  } catch (e) {
-    const msg = e instanceof Error ? e.message : String(e ?? "decode_error");
-    if (msg === "decode_error") {
-      codes.push("decode_error");
-    } else {
-      codes.push("bad_request");
-    }
-    return { ok: false, codes, network };
+    const u = new URL(url);
+    const m = u.pathname.match(/^\/attest\/([0-9a-f]{64})\/?$/i);
+    if (m) return m[1].toLowerCase();
+    const q = u.searchParams.get("id");
+    if (q && /^[0-9a-f]{64}$/i.test(q)) return q.toLowerCase();
+    return null;
+  } catch {
+    return null;
   }
 }
 
 // src/check.ts
+var ISSUED_AHEAD_MS = 12e4;
+var MAX_CANDIDATES = 20;
 async function check(params) {
   const {
     addr,
@@ -1235,14 +1204,17 @@ async function check(params) {
   } else if (identity) {
     found = await getAttestationsForIdentity(identity.protocol, identity.identifier, relays);
   }
-  const envelopes = found.filter((e) => signedMatch(e, { addr, id, identity }));
+  const latest = Date.now() + ISSUED_AHEAD_MS;
+  const envelopes = found.map(signedEnvelope).filter((e) => e !== null).filter((e) => signedMatch(e, { addr, id, identity })).map((e) => ({ e, at: rfc3339Ms(e.issued_at) })).filter(({ at }) => at <= latest).sort((a, b) => b.at - a.at || (a.e.attestation_id < b.e.attestation_id ? -1 : 1)).map(({ e }) => e);
   if (envelopes.length === 0) {
     return { ok: false, sats: 0, days: 0, score: 0, reasons: ["not_found"] };
   }
-  envelopes.sort((a, b) => new Date(b.issued_at).getTime() - new Date(a.issued_at).getTime());
-  const env = envelopes[0];
-  if (!env) {
-    return { ok: false, sats: 0, days: 0, score: 0, reasons: ["not_found"] };
+  let env = envelopes[0];
+  for (const candidate of envelopes.slice(0, MAX_CANDIDATES)) {
+    if (await signedBy(candidate)) {
+      env = candidate;
+      break;
+    }
   }
   const shared = identity ? await backsOtherIdentity(env, identity, relays) : false;
   const outcome = await verify(
@@ -1270,7 +1242,7 @@ async function check(params) {
     score,
     attestation_id: env.attestation_id,
     address: env.address,
-    identities: env.identities,
+    identities: signedIdentities(env),
     network: outcome.network,
     ...reasons.length ? { reasons } : {}
   };
@@ -1306,16 +1278,19 @@ function signedMatch(env, q) {
   }
   return false;
 }
+function signedBy(e) {
+  return signatureIsValid({ addr: e.address, msg: e.message, sig: e.signature, scheme: e.scheme });
+}
 async function backsOtherIdentity(env, identity, relays) {
   const want = identityKey(identity);
   const protocol = identity.protocol.trim().toLowerCase();
   const siblings = await getAttestationsForAddress(env.address, relays);
   for (const e of [env, ...siblings]) {
     if (!signedMatch(e, { addr: env.address })) continue;
-    for (const b of signedIdentities(e)) {
-      if (b.protocol.trim().toLowerCase() !== protocol) continue;
-      if (identityKey(b) !== want) return true;
-    }
+    const other = signedIdentities(e).some(
+      (b) => b.protocol.trim().toLowerCase() === protocol && identityKey(b) !== want
+    );
+    if (other && (e === env || await signedBy(e))) return true;
   }
   return false;
 }
@@ -1432,24 +1407,17 @@ async function verifyChallenge(opts) {
   if (opts.expectedPurpose && purpose !== opts.expectedPurpose) {
     return { ok: false, reason: "purpose_mismatch" };
   }
-  const scheme = opts.scheme ?? "bip322";
-  let sigValid;
-  if (scheme === "bip322") {
-    const sigBase64 = /^[0-9a-fA-F]+$/.test(opts.signature) && opts.signature.length % 2 === 0 ? buffer.Buffer.from(opts.signature, "hex").toString("base64") : opts.signature;
-    sigValid = bip322.verifySignature(address, opts.message, sigBase64);
-  } else if (scheme === "legacy") {
-    if (!/^[1m][a-km-zA-HJ-NP-Z1-9]{25,34}$/.test(address)) {
-      return { ok: false, reason: "sig_unsupported_scheme" };
-    }
-    sigValid = bip322.verifySignature(address, opts.message, opts.signature);
-  } else {
-    return { ok: false, reason: "sig_unsupported_scheme" };
+  const sigBase64 = toBase64Maybe(opts.signature);
+  const scheme = signatureScheme(sigBase64);
+  if (!scheme) return { ok: false, reason: "sig_unsupported_scheme" };
+  if (!bip322.verifySignature(address, opts.message, sigBase64)) {
+    return { ok: false, reason: "sig_invalid" };
   }
-  if (!sigValid) return { ok: false, reason: "sig_invalid" };
   return {
     ok: true,
     reason: "ok",
     address,
+    scheme,
     expiresAt: expiresAt.getTime(),
     nonce,
     ...audience !== void 0 ? { audience } : {},
@@ -2355,12 +2323,12 @@ var STATUS_META = {
   },
   sig_invalid: {
     label: "Signature verification failed",
-    detail: "The signature does not match the message and address. Common issues: (1) Message not copied exactly from Step 2, (2) Wrong wallet/address used, (3) Wallet does not support BIP-322 (Electrum does NOT support BIP-322 for SegWit addresses - use Sparrow Wallet instead). For testnet, ensure your wallet is in testnet mode.",
+    detail: "The signature does not match the message and address. Common issues: (1) the message was not copied exactly, (2) a different address signed it, (3) the wallet signed on another network.",
     severity: "error"
   },
   sig_unsupported_script: {
-    label: "Wallet does not support BIP-322",
-    detail: 'Your wallet generated a legacy signature, but your SegWit address (bc1/tb1) requires BIP-322 message signing. Please use a wallet that supports BIP-322 (like Sparrow Wallet or Bitcoin Core), or switch to a P2PKH address (starting with "1" for mainnet or "m"/"n" for testnet) if your wallet only supports legacy signing.',
+    label: "Signature form not supported",
+    detail: "Your wallet made a BIP-322 full or proof-of-funds signature. Sign with a BIP-322 simple signature, or with legacy message signing, which every address type here accepts.",
     severity: "error"
   },
   bond_confirmed: {
@@ -2485,6 +2453,8 @@ exports.queryByIdentity = queryByIdentity;
 exports.queryRecent = queryRecent;
 exports.requiresManualVerification = requiresManualVerification;
 exports.signNostrEvent = signNostrEvent;
+exports.signatureIsValid = signatureIsValid;
+exports.signedEnvelope = signedEnvelope;
 exports.supportsAutomaticVerification = supportsAutomaticVerification;
 exports.verify = verify;
 exports.verifyAllIdentities = verifyAllIdentities;