@orangecheck/sdk 1.14.0 → 1.15.0

package/dist/attestation.js

@@ -1,11 +1,52 @@
 'use strict';
 
 var base = require('@scure/base');
+var buffer = require('buffer');
+var bip322 = require('@orangecheck/bip322');
 
 // src/canonical.ts
 function toLowerHex(bytes) {
   return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
 }
+var IDENTITY_PROTOCOL_RE = /^[a-z][a-z0-9_-]*$/;
+var IDENTITY_FORBIDDEN_CHARS = /[\r\n,]/;
+function assertSafeIdentity({ protocol, identifier }) {
+  if (!IDENTITY_PROTOCOL_RE.test(protocol)) {
+    throw new Error(
+      `invalid identity protocol: ${JSON.stringify(protocol)} \u2014 must match /^[a-z][a-z0-9_-]*$/`
+    );
+  }
+  if (!identifier || IDENTITY_FORBIDDEN_CHARS.test(identifier)) {
+    throw new Error(
+      `invalid identity identifier: ${JSON.stringify(identifier)} \u2014 must be non-empty and contain no newlines or commas`
+    );
+  }
+}
+function parseIdentities(identitiesStr) {
+  if (!identitiesStr || identitiesStr.trim() === "") {
+    return [];
+  }
+  if (IDENTITY_FORBIDDEN_CHARS.test(identitiesStr.replace(/,/g, ""))) {
+    throw new Error("identities field contains forbidden characters (newline)");
+  }
+  const bindings = identitiesStr.split(",").map((binding) => {
+    const colonIndex = binding.indexOf(":");
+    if (colonIndex === -1) {
+      throw new Error(`Invalid identity binding format: ${binding}`);
+    }
+    return {
+      protocol: binding.substring(0, colonIndex).trim(),
+      identifier: binding.substring(colonIndex + 1).trim()
+    };
+  });
+  for (const b of bindings) {
+    if (!b.protocol || !b.identifier) {
+      throw new Error(`Invalid identity binding: ${b.protocol}:${b.identifier}`);
+    }
+    assertSafeIdentity(b);
+  }
+  return bindings;
+}
 async function generateAttestationId(message) {
   const encoder = new TextEncoder();
   const data = encoder.encode(message);
@@ -109,8 +150,173 @@ function createLogger(namespace) {
   };
 }
 
+// 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;
+}
+var log = 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);
+  log.debug(
+    { addr, msgLength: msg.length, sigLength: sig.length, scheme: detectedScheme },
+    "Verifying signature"
+  );
+  if (detectedScheme === "bip322") {
+    const sigBase64 = toBase64Maybe(sig);
+    log.debug(
+      { sigBase64: sigBase64.substring(0, 50) + "..." },
+      "Signature converted to base64"
+    );
+    log.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);
+    log.info({ addr, ok }, "BIP-322 verification result");
+    if (!ok) {
+      const isSegWit = addr.startsWith("bc1") || addr.startsWith("tb1");
+      if (isSegWit && sigBase64.length === 88) {
+        log.warn(
+          { addr, wallet: "possibly Electrum", sigLength: sigBase64.length },
+          "BIP-322 verification failed - likely Electrum wallet (does not support BIP-322 for SegWit)"
+        );
+      } else {
+        log.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")) {
+      log.warn({ addr }, "Legacy signature attempted on non-P2PKH address");
+      return "sig_unsupported_script";
+    }
+    log.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);
+    log.info({ addr, ok, sigBase64Length: sigBase64.length }, "Legacy verification result");
+    if (!ok) {
+      log.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";
+}
+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
+  };
+}
+
 // 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",
@@ -163,7 +369,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;
@@ -202,7 +408,7 @@ async function publishToRelays(event, relays = DEFAULT_RELAYS) {
                 cleanup();
                 resolve();
               } else {
-                log.warn(
+                log2.warn(
                   { relay: relayUrl, reason: data[3] },
                   "Relay rejected event"
                 );
@@ -212,7 +418,7 @@ async function publishToRelays(event, relays = DEFAULT_RELAYS) {
               }
             }
           } catch (err) {
-            log.error(
+            log2.error(
               { relay: relayUrl, error: err },
               "Failed to parse relay response"
             );
@@ -222,7 +428,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);
@@ -232,7 +438,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) {
@@ -241,12 +447,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;
@@ -286,11 +492,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);
         };
@@ -299,7 +505,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();
@@ -307,12 +513,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 {
@@ -354,28 +560,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 {
@@ -410,21 +616,21 @@ 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 verifyAttestationEnvelope(envelope) {
@@ -436,22 +642,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;
@@ -460,22 +718,22 @@ function isNip07Available() {
 }
 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;
   }
 }
 
 // src/attestation.ts
-var log3 = createLogger("ocp/attestation");
+var log4 = createLogger("ocp/attestation");
 var AttestationError = class extends Error {
   constructor(message, code) {
     super(message);
@@ -485,7 +743,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,
@@ -501,29 +759,29 @@ async function createAttestation(options) {
       "INTEGRITY_CHECK_FAILED"
     );
   }
-  log3.info({ attestationId: envelope.attestation_id }, "Attestation created successfully");
+  log4.info({ attestationId: envelope.attestation_id }, "Attestation created successfully");
   return envelope;
 }
 async function publishAttestation(options) {
   const { envelope, npub, relays = DEFAULT_RELAYS } = options;
-  log3.info(
+  log4.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");
+    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"
     );
   }
-  log3.info("Using NIP-07 to sign event");
+  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 result = await publishToRelays(signedEvent, relays);
-  log3.info(
+  log4.info(
     {
       attestationId: envelope.attestation_id,
       successCount: result.success.length,
@@ -543,46 +801,34 @@ async function discoverAttestations(options) {
   const { attestationId, address, identity, relays = DEFAULT_RELAYS } = options;
   let events = [];
   if (attestationId) {
-    log3.info({ attestationId }, "Discovering by attestation ID");
+    log4.info({ attestationId }, "Discovering by attestation ID");
     events = await queryByAttestationId(attestationId, relays);
   } else if (address) {
-    log3.info({ address }, "Discovering by Bitcoin address");
+    log4.info({ address }, "Discovering by Bitcoin address");
     events = await queryByAddress(address, relays);
   } else if (identity) {
-    log3.info({ identity }, "Discovering by 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 = [];
-  for (const event of events) {
-    const envelope = parseAttestationFromEvent(event);
-    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) {
-        envelopes.push(envelope);
-      } else {
-        log3.warn(
-          { attestationId: envelope.attestation_id },
-          "Skipping invalid attestation envelope"
-        );
-      }
-    }
-  }
-  log3.info({ eventCount: events.length, validCount: envelopes.length }, "Discovery complete");
+  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) {
-  log3.info({ attestationId }, "Verifying attestation by ID");
+  log4.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");
+    log4.warn({ attestationId }, "Attestation not found on any relay");
     return null;
   }
   if (envelopes.length > 1) {
-    log3.warn(
+    log4.warn(
       { attestationId, count: envelopes.length },
       "Multiple attestations found with same ID - using first"
     );
@@ -590,11 +836,11 @@ async function verifyAttestationById(attestationId, relays = DEFAULT_RELAYS) {
   return envelopes[0] || null;
 }
 async function getAttestationsForAddress(address, relays = DEFAULT_RELAYS) {
-  log3.info({ address }, "Getting all attestations for address");
+  log4.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");
+  log4.info({ protocol, identifier }, "Getting all attestations for identity");
   return discoverAttestations({ identity: { protocol, identifier }, relays });
 }
 function formatIdentitiesForDisplay(identities) {