@orangecheck/sdk 1.14.1 → 1.16.0

package/README.md

@@ -61,7 +61,6 @@ const outcome = await verify({
     addr: 'bc1q...',
     msg: canonicalMessage, // the exact signed text
     sig: signature,
-    scheme: 'bip322',
 });
 
 if (outcome.ok) {
@@ -69,6 +68,8 @@ if (outcome.ok) {
 }
 ```
 
+The signature's bytes decide how it is checked: 65 bytes is a legacy (BIP-137) signature, on any address it can stand for, and anything else is BIP-322 simple, with or without the `smp` prefix. `outcome.codes` names the one that verified, `sig_ok_bip322` or `sig_ok_legacy`. A BIP-322 full or proof-of-funds signature gets `sig_unsupported_script`. The `scheme` input is ignored.
+
 Use this when you already hold the `(addr, msg, sig)` tuple — e.g., a user pasted it into your UI, or you're verifying an offline proof.
 
 ---

package/dist/attestation.js

@@ -1,11 +1,52 @@
 'use strict';
 
 var base = require('@scure/base');
+var bip322 = require('@orangecheck/bip322');
+var buffer = require('buffer');
 
 // 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,94 @@ 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;
+}
+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
+  };
+}
+
 // 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 +290,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 +329,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 +339,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 +349,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 +359,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 +368,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 +413,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 +426,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 +434,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 +481,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 +537,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 +563,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 +639,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 +664,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 +680,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,49 +722,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 = [];
-  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");
+  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"
     );
@@ -593,11 +757,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) {