@orangecheck/sdk 0.1.0

package/dist/attestation.mjs

@@ -0,0 +1,567 @@
+// src/canonical.ts
+function toLowerHex(bytes) {
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function parseIdentities(identitiesStr) {
+  if (!identitiesStr || identitiesStr.trim() === "") {
+    return [];
+  }
+  return 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()
+    };
+  }).filter((binding) => binding.protocol && binding.identifier);
+}
+async function generateAttestationId(message) {
+  const encoder = new TextEncoder();
+  const data = encoder.encode(message);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+  return toLowerHex(new Uint8Array(hashBuffer));
+}
+async function createAttestationEnvelope(message, signature, scheme, address, identities, extensions = {}) {
+  const attestation_id = await generateAttestationId(message);
+  const issuedAtMatch = message.match(/issued_at: ([^\n]+)/);
+  const issued_at = issuedAtMatch?.[1] ?? (/* @__PURE__ */ new Date()).toISOString();
+  const expires_at = extensions.expires;
+  const relay_hints = extensions.relay_hints?.split(",").map((r) => r.trim());
+  const publish_targets = extensions.publish?.split(",").map((t) => t.trim());
+  const encoder = new TextEncoder();
+  const messageBytes = encoder.encode(message);
+  const base64 = btoa(String.fromCharCode(...messageBytes));
+  const message_b64url = base64.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");
+  const verification_url = `https://ochk.io/attest/${attestation_id}`;
+  return {
+    attestation_id,
+    scheme,
+    address,
+    identities,
+    message,
+    message_b64url,
+    signature,
+    issued_at,
+    expires_at,
+    verification_url,
+    publish_targets,
+    relay_hints
+  };
+}
+function createLogger(namespace) {
+  const shouldLog = (level) => {
+    return false;
+  };
+  const formatMessage = (msg) => `[${namespace}] ${msg}`;
+  return {
+    debug: (contextOrMessage, message) => {
+      if (shouldLog()) {
+        if (typeof contextOrMessage === "string") {
+          console.debug(formatMessage(contextOrMessage));
+        } else {
+          console.debug(formatMessage(message ?? "Debug"), contextOrMessage);
+        }
+      }
+    },
+    info: (contextOrMessage, message) => {
+      if (shouldLog()) {
+        if (typeof contextOrMessage === "string") {
+          console.info(formatMessage(contextOrMessage));
+        } else {
+          console.info(formatMessage(message ?? "Info"), contextOrMessage);
+        }
+      }
+    },
+    warn: (contextOrMessage, message) => {
+      if (shouldLog()) {
+        if (typeof contextOrMessage === "string") {
+          console.warn(formatMessage(contextOrMessage));
+        } else {
+          console.warn(formatMessage(message ?? "Warning"), contextOrMessage);
+        }
+      }
+    },
+    error: (contextOrMessage, message) => {
+      if (shouldLog()) {
+        if (typeof contextOrMessage === "string") {
+          console.error(formatMessage(contextOrMessage));
+        } else {
+          console.error(formatMessage(message ?? "Error"), contextOrMessage);
+        }
+      }
+    }
+  };
+}
+
+// src/nostr.ts
+var log = createLogger("ocp/nostr");
+var ATTESTATION_EVENT_KIND = 30078;
+var DEFAULT_RELAYS = [
+  "wss://relay.damus.io",
+  "wss://relay.nostr.band",
+  "wss://nos.lol",
+  "wss://relay.snort.social"
+];
+function createAttestationEvent(envelope, pubkey) {
+  const tags = [
+    ["d", envelope.attestation_id],
+    // Parameterized replaceable event identifier
+    ["address", envelope.address],
+    // Bitcoin address
+    ["scheme", envelope.scheme],
+    // Signature scheme (bip322 or legacy)
+    ["issued_at", envelope.issued_at]
+    // ISO timestamp
+  ];
+  for (const identity of envelope.identities) {
+    tags.push(["i", `${identity.protocol}:${identity.identifier}`]);
+  }
+  if (envelope.expires_at) {
+    tags.push(["expires", envelope.expires_at]);
+  }
+  if (envelope.relay_hints?.length) {
+    for (const relay of envelope.relay_hints) {
+      tags.push(["relay", relay]);
+    }
+  }
+  const content = JSON.stringify(envelope, null, 2);
+  return {
+    kind: ATTESTATION_EVENT_KIND,
+    tags,
+    content,
+    created_at: Math.floor(Date.parse(envelope.issued_at) / 1e3),
+    pubkey
+  };
+}
+async function publishToRelays(event, relays = DEFAULT_RELAYS) {
+  const success = [];
+  const failed = [];
+  log.info({ eventId: event.id, relayCount: relays.length }, "Publishing event to relays");
+  const publishPromises = relays.map(async (relayUrl) => {
+    let ws = null;
+    try {
+      ws = new WebSocket(relayUrl);
+      const wsRef = ws;
+      await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          wsRef.close();
+          reject(new Error("Connection timeout"));
+        }, 5e3);
+        const cleanup = () => {
+          clearTimeout(timeout);
+          wsRef.close();
+        };
+        wsRef.onopen = () => {
+          clearTimeout(timeout);
+          wsRef.send(JSON.stringify(["EVENT", event]));
+        };
+        wsRef.onmessage = (msg) => {
+          try {
+            const data = JSON.parse(msg.data);
+            if (data[0] === "OK" && data[1] === event.id) {
+              if (data[2] === true) {
+                success.push(relayUrl);
+                cleanup();
+                resolve();
+              } else {
+                log.warn(
+                  { relay: relayUrl, reason: data[3] },
+                  "Relay rejected event"
+                );
+                failed.push(relayUrl);
+                cleanup();
+                reject(new Error(data[3] || "Relay rejected event"));
+              }
+            }
+          } catch (err) {
+            log.error(
+              { relay: relayUrl, error: err },
+              "Failed to parse relay response"
+            );
+            failed.push(relayUrl);
+            cleanup();
+            reject(err);
+          }
+        };
+        wsRef.onerror = (err) => {
+          log.error({ relay: relayUrl, error: err }, "WebSocket error");
+          failed.push(relayUrl);
+          cleanup();
+          reject(err);
+        };
+        wsRef.onclose = () => {
+          clearTimeout(timeout);
+        };
+      });
+    } catch (err) {
+      log.error({ relay: relayUrl, error: err }, "Failed to publish to relay");
+      if (!failed.includes(relayUrl)) {
+        failed.push(relayUrl);
+      }
+    } finally {
+      if (ws && ws.readyState !== WebSocket.CLOSED) {
+        ws.close();
+      }
+    }
+  });
+  await Promise.allSettled(publishPromises);
+  log.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");
+  const queryPromises = relays.map(async (relayUrl) => {
+    let ws = null;
+    try {
+      ws = new WebSocket(relayUrl);
+      const wsRef = ws;
+      await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          wsRef.close();
+          reject(new Error("Query timeout"));
+        }, 1e4);
+        const cleanup = () => {
+          clearTimeout(timeout);
+          wsRef.close();
+        };
+        wsRef.onopen = () => {
+          const subscriptionId = `ochk_${Date.now()}`;
+          wsRef.send(
+            JSON.stringify([
+              "REQ",
+              subscriptionId,
+              {
+                kinds: [30078],
+                "#d": [attestationId],
+                limit: 1
+              }
+            ])
+          );
+        };
+        wsRef.onmessage = (msg) => {
+          try {
+            const data = JSON.parse(msg.data);
+            if (data[0] === "EVENT") {
+              events.push(data[2]);
+            } else if (data[0] === "EOSE") {
+              cleanup();
+              resolve();
+            }
+          } catch (err) {
+            log.error({ relay: relayUrl, error: err }, "Failed to parse event");
+          }
+        };
+        wsRef.onerror = (err) => {
+          log.error({ relay: relayUrl, error: err }, "WebSocket error during query");
+          cleanup();
+          reject(err);
+        };
+        wsRef.onclose = () => {
+          clearTimeout(timeout);
+        };
+      });
+    } catch (err) {
+      log.error({ relay: relayUrl, error: err }, "Failed to query relay");
+    } finally {
+      if (ws && ws.readyState !== WebSocket.CLOSED) {
+        ws.close();
+      }
+    }
+  });
+  await Promise.allSettled(queryPromises);
+  log.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");
+  const queryPromises = relays.map(async (relayUrl) => {
+    try {
+      const ws = new WebSocket(relayUrl);
+      await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          ws.close();
+          reject(new Error("Query timeout"));
+        }, 1e4);
+        ws.onopen = () => {
+          const subscriptionId = `ochk_addr_${Date.now()}`;
+          ws.send(
+            JSON.stringify([
+              "REQ",
+              subscriptionId,
+              {
+                kinds: [30078],
+                "#address": [address],
+                limit: 10
+              }
+            ])
+          );
+        };
+        ws.onmessage = (msg) => {
+          try {
+            const data = JSON.parse(msg.data);
+            if (data[0] === "EVENT") {
+              events.push(data[2]);
+            } else if (data[0] === "EOSE") {
+              clearTimeout(timeout);
+              ws.close();
+              resolve();
+            }
+          } catch (err) {
+            log.error({ relay: relayUrl, error: err }, "Failed to parse event");
+          }
+        };
+        ws.onerror = (err) => {
+          clearTimeout(timeout);
+          log.error({ relay: relayUrl, error: err }, "WebSocket error during query");
+          reject(err);
+        };
+      });
+    } catch (err) {
+      log.error({ relay: relayUrl, error: err }, "Failed to query relay");
+    }
+  });
+  await Promise.allSettled(queryPromises);
+  log.info({ eventCount: events.length }, "Query complete");
+  return events;
+}
+async function queryByIdentity(protocol, identifier, relays = DEFAULT_RELAYS) {
+  const events = [];
+  const identityTag = `${protocol}:${identifier}`;
+  log.info({ protocol, identifier, relayCount: relays.length }, "Querying relays for identity");
+  const queryPromises = relays.map(async (relayUrl) => {
+    try {
+      const ws = new WebSocket(relayUrl);
+      await new Promise((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          ws.close();
+          reject(new Error("Query timeout"));
+        }, 1e4);
+        ws.onopen = () => {
+          const subscriptionId = `ochk_identity_${Date.now()}`;
+          ws.send(
+            JSON.stringify([
+              "REQ",
+              subscriptionId,
+              {
+                kinds: [30078],
+                "#i": [identityTag],
+                limit: 10
+              }
+            ])
+          );
+        };
+        ws.onmessage = (msg) => {
+          try {
+            const data = JSON.parse(msg.data);
+            if (data[0] === "EVENT") {
+              events.push(data[2]);
+            } else if (data[0] === "EOSE") {
+              clearTimeout(timeout);
+              ws.close();
+              resolve();
+            }
+          } catch (err) {
+            log.error({ relay: relayUrl, error: err }, "Failed to parse event");
+          }
+        };
+        ws.onerror = (err) => {
+          clearTimeout(timeout);
+          log.error({ relay: relayUrl, error: err }, "WebSocket error during query");
+          reject(err);
+        };
+      });
+    } catch (err) {
+      log.error({ relay: relayUrl, error: err }, "Failed to query relay");
+    }
+  });
+  await Promise.allSettled(queryPromises);
+  log.info({ eventCount: events.length }, "Query complete");
+  return events;
+}
+async function verifyAttestationEnvelope(envelope) {
+  try {
+    const encoder = new TextEncoder();
+    const data = encoder.encode(envelope.message);
+    const hashBuffer = await crypto.subtle.digest("SHA-256", data);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    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");
+    return false;
+  }
+}
+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");
+    return null;
+  }
+}
+
+// src/nostr-crypto.ts
+var log2 = createLogger("ocp/nostr-crypto");
+function isNip07Available() {
+  if (typeof window === "undefined") {
+    return false;
+  }
+  return !!window.nostr;
+}
+async function signNostrEvent(event) {
+  if (!isNip07Available()) {
+    log2.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");
+    return signedEvent;
+  } catch (err) {
+    log2.error({ error: err }, "Failed to sign Nostr event");
+    return null;
+  }
+}
+
+// src/attestation.ts
+var log3 = createLogger("ocp/attestation");
+var AttestationError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "AttestationError";
+  }
+};
+async function createAttestation(options) {
+  const { message, signature, scheme, address, identities = [], extensions = {} } = options;
+  log3.info({ address, identityCount: identities.length }, "Creating attestation");
+  const envelope = await createAttestationEnvelope(
+    message,
+    signature,
+    scheme,
+    address,
+    identities,
+    extensions
+  );
+  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;
+}
+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 = [];
+  for (const event of events) {
+    const envelope = parseAttestationFromEvent(event);
+    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");
+  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 parseIdentitiesFromString(identitiesStr) {
+  return parseIdentities(identitiesStr);
+}
+function formatIdentitiesForDisplay(identities) {
+  return identities.map((id) => `${id.protocol}:${id.identifier}`).join(", ");
+}
+function getVerificationUrl(attestationId, baseUrl = "https://ochk.io") {
+  return `${baseUrl}/verify?id=${attestationId}`;
+}
+function extractAttestationIdFromUrl(url) {
+  try {
+    const urlObj = new URL(url);
+    return urlObj.searchParams.get("id");
+  } catch {
+    return null;
+  }
+}
+
+export { AttestationError, createAttestation, discoverAttestations, extractAttestationIdFromUrl, formatIdentitiesForDisplay, getAttestationsForAddress, getAttestationsForIdentity, getVerificationUrl, parseIdentitiesFromString, publishAttestation, verifyAttestationById };
+//# sourceMappingURL=attestation.mjs.map
+//# sourceMappingURL=attestation.mjs.map