@orangecheck/sdk 1.10.0 → 1.12.0

package/dist/index.js

@@ -2,30 +2,10 @@
 
 var base = require('@scure/base');
 var buffer = require('buffer');
-var bip322Js = require('bip322-js');
-var bitcoinMessage = require('bitcoinjs-message');
-var secp256k1_js = require('@noble/curves/secp256k1.js');
+var bip322 = require('@orangecheck/bip322');
 var sha2_js = require('@noble/hashes/sha2.js');
-
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n.default = e;
-  return Object.freeze(n);
-}
-
-var bitcoinMessage__namespace = /*#__PURE__*/_interopNamespace(bitcoinMessage);
+var utils_js = require('@noble/hashes/utils.js');
+var secp256k1_js = require('@noble/curves/secp256k1.js');
 
 // src/canonical.ts
 function toLowerHex(bytes) {
@@ -883,87 +863,79 @@ async function verifySignature({
   sig,
   scheme
 }) {
-  try {
-    const detectedScheme = scheme || detectSignatureScheme(addr, sig);
+  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(
-      { addr, msgLength: msg.length, sigLength: sig.length, scheme: detectedScheme },
-      "Verifying signature"
+      { sigBase64: sigBase64.substring(0, 50) + "..." },
+      "Signature converted to base64"
     );
-    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 = bip322Js.Verifier.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 = bitcoinMessage__namespace.verify(msg, addr, sigBase64);
-      log4.info({ addr, ok, sigBase64Length: sigBase64.length }, "Legacy verification result");
-      if (!ok) {
+    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,
-            msgFirstLine: msg.split("\n")[0],
-            sigFormat: sigBase64.substring(0, 10)
+            sigLength: sigBase64.length,
+            msgLength: msg.length,
+            msgPreview: msg.substring(0, 200)
           },
-          "Legacy signature verification failed - check message format and signature"
+          "BIP-322 verification failed - signature does not match message"
         );
       }
-      return ok ? "sig_ok_legacy" : "sig_invalid";
     }
-    return "invalid_scheme";
-  } catch (err) {
-    log4.error(
-      { addr, error: err instanceof Error ? err.message : String(err) },
-      "Signature verification error"
+    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"
     );
-    return "sig_invalid";
+    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());
@@ -1055,7 +1027,7 @@ async function getAddressUtxos(address, network, opts) {
   log4.error({ endpoints, error: lastError?.message, network }, "All Esplora endpoints failed");
   throw new Error(`esplora_all_failed: ${lastError?.message || "unknown"}`);
 }
-function computeMetrics(utxos, bondAmount) {
+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 };
@@ -1088,13 +1060,30 @@ function computeMetrics(utxos, bondAmount) {
     };
   }
   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 verify2(input, opts = {}) {
+async function verify(input, opts = {}) {
   const codes = [];
   let network = "mainnet";
   try {
@@ -1151,7 +1140,8 @@ async function verify2(input, opts = {}) {
       });
       const { sats_bonded, days_unspent, confirmed_balance } = computeMetrics(
         utxos,
-        parsed.bond
+        parsed.bond,
+        opts.coverSats
       );
       if (parsed.bond !== void 0 && parsed.bond > 0) {
         if (confirmed_balance < parsed.bond) {
@@ -1249,14 +1239,14 @@ async function check(params) {
     return { ok: false, sats: 0, days: 0, score: 0, reasons: ["not_found"] };
   }
   const shared = identity ? await backsOtherIdentity(env, identity, relays) : false;
-  const outcome = await verify2(
+  const outcome = await verify(
     {
       addr: env.address,
       msg: env.message,
       sig: env.signature,
       scheme: env.scheme
     },
-    verifyOptions
+    { ...verifyOptions, coverSats: minSats > 0 ? minSats : void 0 }
   );
   const sats = outcome.metrics?.sats_bonded ?? 0;
   const days = outcome.metrics?.days_unspent ?? 0;
@@ -1437,21 +1427,17 @@ async function verifyChallenge(opts) {
     return { ok: false, reason: "purpose_mismatch" };
   }
   const scheme = opts.scheme ?? "bip322";
-  let sigValid = false;
-  try {
-    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 = bip322Js.Verifier.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 = bitcoinMessage__namespace.verify(opts.message, address, opts.signature);
-    } else {
+  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" };
     }
-  } catch {
-    sigValid = false;
+    sigValid = bip322.verifySignature(address, opts.message, opts.signature);
+  } else {
+    return { ok: false, reason: "sig_unsupported_scheme" };
   }
   if (!sigValid) return { ok: false, reason: "sig_invalid" };
   return {
@@ -1464,6 +1450,164 @@ async function verifyChallenge(opts) {
     ...purpose !== void 0 ? { purpose } : {}
   };
 }
+var HEADER = "orangecheck-bond";
+var ACK = "I pledge this coin to back this subject. It stays in my wallet.";
+var FIELDS = ["address", "outpoint", "subject", "nonce", "issued_at", "expires_at"];
+var BOND_SATS_FLOORS = [1e3, 1e4, 1e5, 1e6, 1e7];
+var BOND_DAYS_FLOORS = [7, 30, 90, 365];
+var BOND_MIN_CONFIRMATIONS = 6;
+var OUTPOINT_RE = /^[0-9a-f]{64}:(0|[1-9][0-9]{0,9})$/;
+var NONCE_RE = /^[0-9a-f]{32}$/;
+var TIME_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/;
+var SUBJECT_RE = /^[\x21-\x7e]{1,256}$/;
+function iso2(d) {
+  return d.toISOString().replace(/\.\d{3}Z$/, "Z");
+}
+function randomNonce2() {
+  const b = new Uint8Array(16);
+  globalThis.crypto.getRandomValues(b);
+  return utils_js.bytesToHex(b);
+}
+function wellFormed(f) {
+  return bip322.decodeAddress(f.address) !== null && OUTPOINT_RE.test(f.outpoint) && SUBJECT_RE.test(f.subject) && NONCE_RE.test(f.nonce) && TIME_RE.test(f.issued_at) && TIME_RE.test(f.expires_at) && Date.parse(f.expires_at) > Date.parse(f.issued_at);
+}
+function buildBondMessage(fields) {
+  if (!wellFormed(fields)) throw new Error("bond fields are malformed");
+  return [HEADER, ...FIELDS.map((k) => `${k}: ${fields[k]}`), `ack: ${ACK}`].join("\n") + "\n";
+}
+function issueBondMessage(opts) {
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const expires = new Date(now.getTime() + (opts.ttlSeconds ?? 600) * 1e3);
+  const nonce = randomNonce2();
+  const message = buildBondMessage({
+    address: opts.address,
+    outpoint: opts.outpoint,
+    subject: opts.subject,
+    nonce,
+    issued_at: iso2(now),
+    expires_at: iso2(expires)
+  });
+  return { message, nonce, expiresAt: expires.getTime() };
+}
+function parseBondMessage(message) {
+  if (!message.endsWith("\n") || message.includes("\r")) return null;
+  const lines = message.slice(0, -1).split("\n");
+  if (lines.length !== FIELDS.length + 2 || lines[0] !== HEADER) return null;
+  if (lines[lines.length - 1] !== `ack: ${ACK}`) return null;
+  const out = {};
+  for (const [i, key] of FIELDS.entries()) {
+    const line = lines[i + 1];
+    const prefix = `${key}: `;
+    if (!line.startsWith(prefix)) return null;
+    out[key] = line.slice(prefix.length);
+  }
+  const fields = out;
+  return wellFormed(fields) && buildBondMessage(fields) === message ? fields : null;
+}
+function bondId(message) {
+  return utils_js.bytesToHex(sha2_js.sha256(utils_js.utf8ToBytes(message)));
+}
+function bondNullifier(audience, outpoint) {
+  return utils_js.bytesToHex(sha2_js.sha256(utils_js.utf8ToBytes(`orangecheck-bond-nullifier
+${audience}
+${outpoint}`)));
+}
+function bondFloors(sats, ageBlocks) {
+  const days = Math.floor(ageBlocks / 144);
+  const floor = (ladder, v) => ladder.filter((f) => v >= f).reduce((a, b) => Math.max(a, b), 0);
+  return { sats_floor: floor(BOND_SATS_FLOORS, sats), days_floor: floor(BOND_DAYS_FLOORS, days) };
+}
+function verifyBondSignature(opts) {
+  const fields = parseBondMessage(opts.message);
+  if (!fields) return { ok: false, reason: "bond_malformed" };
+  if (opts.subject !== void 0 && fields.subject !== opts.subject) {
+    return { ok: false, reason: "bond_subject_mismatch" };
+  }
+  const now = (opts.now ?? /* @__PURE__ */ new Date()).getTime();
+  const skew = (opts.skewSeconds ?? 60) * 1e3;
+  if (Date.parse(fields.issued_at) - skew > now) return { ok: false, reason: "bond_not_yet_valid" };
+  if (Date.parse(fields.expires_at) + skew < now) return { ok: false, reason: "bond_expired" };
+  if (!bip322.verifySignature(fields.address, opts.message, opts.signature)) {
+    return { ok: false, reason: "sig_invalid" };
+  }
+  return { ok: true, fields, bond_id: bondId(opts.message) };
+}
+async function checkBondCoin(opts) {
+  const decoded = bip322.decodeAddress(opts.address);
+  if (!decoded || !OUTPOINT_RE.test(opts.outpoint)) return { ok: false, reason: "bond_malformed" };
+  let coin;
+  let tip;
+  try {
+    [coin, tip] = await Promise.all([opts.source.coin(opts.outpoint), opts.source.tip()]);
+  } catch {
+    return { ok: false, reason: "chain_unavailable" };
+  }
+  if (!coin) return { ok: false, reason: "coin_not_found" };
+  if (coin.scriptPubKey !== utils_js.bytesToHex(decoded.scriptPubKey)) {
+    return { ok: false, reason: "coin_address_mismatch" };
+  }
+  if (coin.confirmedHeight === null) return { ok: false, reason: "coin_unconfirmed" };
+  if (coin.spent) return { ok: false, reason: "coin_spent" };
+  const confirmations = tip.height - coin.confirmedHeight + 1;
+  if (confirmations < (opts.minConfirmations ?? BOND_MIN_CONFIRMATIONS)) {
+    return { ok: false, reason: "coin_too_recent" };
+  }
+  return { ok: true, sats: coin.sats, confirmed_height: coin.confirmedHeight, tip };
+}
+async function verifyBond(opts) {
+  const sig = verifyBondSignature(opts);
+  if (!sig.ok) return sig;
+  const coin = await checkBondCoin({
+    address: sig.fields.address,
+    outpoint: sig.fields.outpoint,
+    source: opts.source,
+    minConfirmations: opts.minConfirmations
+  });
+  if (!coin.ok) return coin;
+  return {
+    ok: true,
+    bond: {
+      bond_id: sig.bond_id,
+      subject: sig.fields.subject,
+      address: sig.fields.address,
+      outpoint: sig.fields.outpoint,
+      sats: coin.sats,
+      confirmed_height: coin.confirmed_height,
+      tip: coin.tip
+    }
+  };
+}
+function esploraSource(base = "https://mempool.space/api", opts = {}) {
+  const get = async (path) => {
+    const r = await (opts.fetch ?? fetch)(`${base}${path}`, {
+      signal: AbortSignal.timeout(opts.timeoutMs ?? 5e3)
+    });
+    if (!r.ok && r.status !== 404) throw new Error(`esplora ${path}: HTTP ${r.status}`);
+    return r;
+  };
+  return {
+    async tip() {
+      const [h, hash] = await Promise.all([get("/blocks/tip/height"), get("/blocks/tip/hash")]);
+      return { height: Number(await h.text()), hash: (await hash.text()).trim() };
+    },
+    async coin(outpoint) {
+      const [txid, voutStr] = outpoint.split(":");
+      const vout = Number(voutStr);
+      const txr = await get(`/tx/${txid}`);
+      if (txr.status === 404) return null;
+      const tx = await txr.json();
+      const out = tx.vout[vout];
+      if (!out) return null;
+      const spend = await (await get(`/tx/${txid}/outspend/${vout}`)).json();
+      return {
+        sats: out.value,
+        scriptPubKey: out.scriptpubkey.toLowerCase(),
+        confirmedHeight: tx.status.confirmed ? tx.status.block_height ?? null : null,
+        spent: spend.spent
+      };
+    }
+  };
+}
 
 // src/utils/rate-limiter.ts
 var RateLimitError = class extends Error {
@@ -2253,17 +2397,26 @@ var STATUS_META = {
   }
 };
 
+exports.BOND_DAYS_FLOORS = BOND_DAYS_FLOORS;
+exports.BOND_MIN_CONFIRMATIONS = BOND_MIN_CONFIRMATIONS;
+exports.BOND_SATS_FLOORS = BOND_SATS_FLOORS;
 exports.DEFAULT_RELAYS = DEFAULT_RELAYS;
 exports.FANOUT_DEADLINE_MS = FANOUT_DEADLINE_MS;
 exports.STATUS_META = STATUS_META;
+exports.bondFloors = bondFloors;
+exports.bondId = bondId;
+exports.bondNullifier = bondNullifier;
+exports.buildBondMessage = buildBondMessage;
 exports.buildCanonicalMessage = buildCanonicalMessage;
 exports.check = check;
+exports.checkBondCoin = checkBondCoin;
 exports.computeAllScores = computeAllScores;
 exports.computeScore = computeScore;
 exports.createAttestation = createAttestation;
 exports.createAttestationEnvelope = createAttestationEnvelope;
 exports.createAttestationEvent = createAttestationEvent;
 exports.discoverAttestations = discoverAttestations;
+exports.esploraSource = esploraSource;
 exports.extractAttestationIdFromUrl = extractAttestationIdFromUrl;
 exports.formatIdentities = formatIdentities;
 exports.formatIdentitiesForDisplay = formatIdentitiesForDisplay;
@@ -2293,10 +2446,12 @@ exports.isNip07Available = isNip07Available;
 exports.isNostrIdentityVerified = isNostrIdentityVerified;
 exports.isValidDomain = isValidDomain;
 exports.isValidTweetUrl = isValidTweetUrl;
+exports.issueBondMessage = issueBondMessage;
 exports.issueChallenge = issueChallenge;
 exports.nostrIdentifierForms = nostrIdentifierForms;
 exports.nostrPubkeyToHex = nostrPubkeyToHex;
 exports.parseAttestationFromEvent = parseAttestationFromEvent;
+exports.parseBondMessage = parseBondMessage;
 exports.parseIdentities = parseIdentities;
 exports.publishAttestation = publishAttestation;
 exports.publishToRelays = publishToRelays;
@@ -2307,9 +2462,11 @@ exports.queryRecent = queryRecent;
 exports.requiresManualVerification = requiresManualVerification;
 exports.signNostrEvent = signNostrEvent;
 exports.supportsAutomaticVerification = supportsAutomaticVerification;
-exports.verify = verify2;
+exports.verify = verify;
 exports.verifyAllIdentities = verifyAllIdentities;
 exports.verifyAttestationById = verifyAttestationById;
+exports.verifyBond = verifyBond;
+exports.verifyBondSignature = verifyBondSignature;
 exports.verifyChallenge = verifyChallenge;
 exports.verifyDnsIdentity = verifyDnsIdentity;
 exports.verifyGitHubIdentity = verifyGitHubIdentity;