@arkade-os/swap 0.0.1

package/dist/nostr.cjs

@@ -0,0 +1,223 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/nostr.ts
+var nostr_exports = {};
+__export(nostr_exports, {
+  RFQ_AD_KIND: () => RFQ_AD_KIND,
+  RFQ_DIRECTED_KIND: () => RFQ_DIRECTED_KIND,
+  RelayUnavailable: () => RelayUnavailable,
+  nostrRfqTransport: () => nostrRfqTransport
+});
+module.exports = __toCommonJS(nostr_exports);
+
+// src/rfq.ts
+var import_base5 = require("@scure/base");
+var import_legacy2 = require("@noble/hashes/legacy.js");
+var import_sdk3 = require("@arkade-os/sdk");
+
+// src/onchainHtlc.ts
+var import_base = require("@scure/base");
+var import_sha2 = require("@noble/hashes/sha2.js");
+var import_legacy = require("@noble/hashes/legacy.js");
+var btc = __toESM(require("@scure/btc-signer"), 1);
+var ONCHAIN_ORDER_MARGIN_SECONDS = 2 * 60 * 60;
+var ONCHAIN_CLAIM_MARGIN_SECONDS = 90 * 60;
+var ONCHAIN_DUST_SATS = BigInt(330);
+var L1_NETWORKS = {
+  bitcoin: btc.NETWORK,
+  testnet: btc.TEST_NETWORK,
+  regtest: { ...btc.TEST_NETWORK, bech32: "bcrt" }
+};
+
+// src/secrets.ts
+var import_base2 = require("@scure/base");
+var import_sha22 = require("@noble/hashes/sha2.js");
+var import_utils = require("@noble/hashes/utils.js");
+var import_secp256k1 = require("@noble/curves/secp256k1.js");
+var import_sdk = require("@arkade-os/sdk");
+
+// src/claimPacket.ts
+var import_base3 = require("@scure/base");
+var import_secp256k12 = require("@noble/curves/secp256k1.js");
+var import_hkdf = require("@noble/hashes/hkdf.js");
+var import_sha23 = require("@noble/hashes/sha2.js");
+var HKDF_INFO = new TextEncoder().encode("covclaimd/preimage/v1");
+
+// src/lockupContract.ts
+var import_base4 = require("@scure/base");
+var import_sdk2 = require("@arkade-os/sdk");
+
+// src/rfq.ts
+var ARKADE_BTC = "arkade:BTC";
+var LIGHTNING_BTC = "lightning:BTC";
+var ONCHAIN_BTC = "onchain:BTC";
+var rfqPair = (from, to) => `${from}->${to}`;
+var LIGHTNING_SEND_PAIR = rfqPair(ARKADE_BTC, LIGHTNING_BTC);
+var LIGHTNING_RECEIVE_PAIR = rfqPair(LIGHTNING_BTC, ARKADE_BTC);
+var ONCHAIN_SEND_PAIR = rfqPair(ARKADE_BTC, ONCHAIN_BTC);
+var ONCHAIN_RECEIVE_PAIR = rfqPair(ONCHAIN_BTC, ARKADE_BTC);
+var SwapRefusal = class extends Error {
+  reason;
+  rfqId;
+  constructor(reason, rfqId) {
+    super(`solver refused: ${reason}`);
+    this.name = "SwapRefusal";
+    this.reason = reason;
+    this.rfqId = rfqId;
+  }
+};
+var MIN_HEADROOM_SECONDS = 90 * 60;
+var MIN_CLAIM_WINDOW_SECONDS = 30 * 60;
+
+// src/nostr.ts
+var import_nostr_tools = require("nostr-tools");
+var RFQ_DIRECTED_KIND = 24859;
+var RFQ_AD_KIND = 38859;
+var DEFAULT_TIMEOUT_MS = 3e4;
+var RelayUnavailable = class extends Error {
+  reasons;
+  constructor(reasons) {
+    super(`lost every relay connection: ${reasons.join("; ") || "connection closed"}`);
+    this.name = "RelayUnavailable";
+    this.reasons = reasons;
+  }
+};
+var closeReasons = (raw) => raw.map((entry) => {
+  if (typeof entry === "string") return entry;
+  const { url, reason } = entry ?? {};
+  return url ? `${url}: ${reason ?? "closed"}` : reason ?? "closed";
+});
+var asQuote = (payload, rfqId) => {
+  const p = payload;
+  if (p?.type === "rfq_refusal") throw new SwapRefusal(p.reason ?? "unknown", p.rfq_id ?? rfqId);
+  if (p?.type !== "rfq_quote" || p.rfq_id !== rfqId) {
+    throw new Error(`unexpected reply: ${p?.type ?? "no payload"}`);
+  }
+  return payload;
+};
+var nostrRfqTransport = (options) => {
+  const relays = options.relays;
+  const solverPubkey = options.solverPubkey;
+  const secretKey = options.secretKey ?? (0, import_nostr_tools.generateSecretKey)();
+  const pubkey = (0, import_nostr_tools.getPublicKey)(secretKey);
+  const pool = options.pool ?? new import_nostr_tools.SimplePool();
+  const ownsPool = !options.pool;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const conversationKey = import_nostr_tools.nip44.v2.utils.getConversationKey(secretKey, solverPubkey);
+  let closed = false;
+  const waiters = /* @__PURE__ */ new Map();
+  const subscription = pool.subscribeMany(
+    relays,
+    { kinds: [RFQ_DIRECTED_KIND], "#p": [pubkey], authors: [solverPubkey] },
+    {
+      onevent(event) {
+        let payload;
+        try {
+          payload = JSON.parse(import_nostr_tools.nip44.v2.decrypt(event.content, conversationKey));
+        } catch {
+          return;
+        }
+        const rfqId = payload?.rfq_id;
+        if (!rfqId) return;
+        waiters.get(rfqId)?.resolve(payload);
+      },
+      // subscribeMany calls this once every relay has closed. Nothing will
+      // arrive after it, so failing now beats waiting out the timeout — and
+      // it names the real cause instead of implicating the solver.
+      onclose(reasons) {
+        if (closed) return;
+        const error = new RelayUnavailable(closeReasons(reasons));
+        for (const waiter of waiters.values()) waiter.reject(error);
+        waiters.clear();
+      }
+    }
+  );
+  const send = async (payload) => {
+    const event = (0, import_nostr_tools.finalizeEvent)(
+      {
+        kind: RFQ_DIRECTED_KIND,
+        created_at: Math.floor(Date.now() / 1e3),
+        tags: [["p", solverPubkey]],
+        content: import_nostr_tools.nip44.v2.encrypt(JSON.stringify(payload), conversationKey)
+      },
+      secretKey
+    );
+    const results = await Promise.allSettled(pool.publish(relays, event));
+    if (!results.some((r) => r.status === "fulfilled")) {
+      throw new Error("no relay accepted the RFQ message");
+    }
+  };
+  const awaitReply = (rfqId) => new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      waiters.delete(rfqId);
+      reject(new Error(`no solver reply within ${timeoutMs}ms`));
+    }, timeoutMs);
+    waiters.set(rfqId, {
+      resolve: (payload) => {
+        clearTimeout(timer);
+        waiters.delete(rfqId);
+        resolve(payload);
+      },
+      reject: (error) => {
+        clearTimeout(timer);
+        waiters.delete(rfqId);
+        reject(error);
+      }
+    });
+  });
+  return {
+    async requestQuote(payload) {
+      const rfqId = String(payload.rfq_id);
+      const reply = awaitReply(rfqId);
+      await send(payload);
+      return asQuote(await reply, rfqId);
+    },
+    async status(rfqId) {
+      const reply = awaitReply(rfqId);
+      await send({ v: 1, type: "rfq_status_request", rfq_id: rfqId });
+      const payload = await reply;
+      if (payload?.type !== "rfq_status") return null;
+      return payload;
+    },
+    async close() {
+      closed = true;
+      subscription.close();
+      waiters.clear();
+      if (ownsPool) pool.close(relays);
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RFQ_AD_KIND,
+  RFQ_DIRECTED_KIND,
+  RelayUnavailable,
+  nostrRfqTransport
+});

package/dist/nostr.d.cts

@@ -0,0 +1,99 @@
+import { b as RfqTransport } from './rfq-CRgIOQ_y.cjs';
+import { SimplePool } from 'nostr-tools';
+import '@arkade-os/sdk';
+import '@arkade-os/solver-discovery';
+
+/**
+ * The Nostr RFQ transport — the PRODUCTION one (docs/rfq-protocol.md § 3.1 in
+ * arkade-os/lightning-swap-service).
+ *
+ * `rfq.ts` ships two other transports: `httpTransport`, and `relayTransport`
+ * which speaks the dev broker's `{op:"sub"|"event"}` framing. Neither is what a
+ * deployed solver listens on. This is, and it satisfies the same
+ * {@link RfqTransport} interface, so everything above the transport — the user
+ * flow, quote verification, the store — is identical whichever one it is handed.
+ *
+ * ## Why this is a separate entry point
+ *
+ * Imported as `@arkade-os/swap/nostr`, never from the package root, and
+ * `nostr-tools` is an OPTIONAL peer dependency. A consumer doing HTTP-only
+ * swaps should not pay for a Nostr library it never calls, and re-exporting
+ * this from `index.ts` would put `nostr-tools` in every consumer's module graph
+ * whether or not they resolve it. The subpath is what keeps that promise: the
+ * module is only loaded if it is imported.
+ *
+ * The consequence, stated plainly: importing this subpath without `nostr-tools`
+ * installed fails at resolution with a module-not-found. That is the intended
+ * failure — loud, at the import, naming the missing package — rather than a
+ * transport that silently degrades.
+ *
+ * A dynamic `await import()` inside the factory would also defer the cost, but
+ * it would make construction async. This transport opens its subscription
+ * eagerly, on purpose (see below), so an async factory would push a `await`
+ * into every caller for no benefit the subpath does not already give.
+ */
+
+/**
+ * Directed RFQ traffic. Provisional in the spec; kept in one place.
+ *
+ * MUST stay inside NIP-01's ephemeral range (20000–29999) and MUST match the
+ * solver's `NOSTR_KIND_DIRECTED`. The two sides subscribe by `kinds`, so a
+ * mismatch is not an error either can report — they simply never see each
+ * other, and every request times out blaming the solver.
+ *
+ * Ephemeral because a negotiation is worthless once it is over: a request
+ * nobody answered inside the timeout, and a quote past its `valid_until`, help
+ * no one, while a retained copy is a permanent record of who negotiated what
+ * with whom. The cost is no store-and-forward — a request sent while the solver
+ * is disconnected is dropped rather than queued — which the timeout and the
+ * caller's retry cover.
+ */
+declare const RFQ_DIRECTED_KIND = 24859;
+/**
+ * Indicative solver advertisement — never binding; only a quote binds.
+ *
+ * Addressable (30000–39999) rather than ephemeral, deliberately: an ad is
+ * standing state a relay should keep the current version of, not a message in a
+ * negotiation. The two constants want OPPOSITE retention, and neither is a typo
+ * of the other.
+ */
+declare const RFQ_AD_KIND = 38859;
+/**
+ * Every relay dropped the subscription, so no reply can arrive on it.
+ *
+ * Distinct from a timeout on purpose. Both look like "no answer", but they mean
+ * opposite things: a timeout says the solver did not respond, while this says
+ * we were never in a position to hear it. Without the distinction the transport
+ * waits out the full timeout and then blames the solver for a failure on our
+ * own side of the wire.
+ */
+declare class RelayUnavailable extends Error {
+    readonly reasons: string[];
+    constructor(reasons: string[]);
+}
+interface NostrRfqOptions {
+    /** Relay URLs from the solver's card. The rendezvous, not solver endpoints. */
+    relays: string[];
+    /** The card's `discovery_pubkey`, x-only hex — who we address. */
+    solverPubkey: string;
+    /**
+     * Transport key. Defaults to a FRESH key per transport, deliberately: the
+     * negotiation should not be linkable to a long-term identity, and nothing in
+     * the protocol needs a stable client key — the quote binds to the covenant,
+     * not to who asked for it.
+     */
+    secretKey?: Uint8Array;
+    /** Injectable for tests; a caller may also share one pool across swaps. */
+    pool?: SimplePool;
+    timeoutMs?: number;
+}
+/**
+ * Build an `RfqTransport` speaking kind-24859 directed traffic.
+ *
+ * Sends are fire-and-forget publishes; replies arrive on a single long-lived
+ * subscription filtered to this transport key, so a reply that arrives before
+ * the publish promise settles is not missed.
+ */
+declare const nostrRfqTransport: (options: NostrRfqOptions) => RfqTransport;
+
+export { type NostrRfqOptions, RFQ_AD_KIND, RFQ_DIRECTED_KIND, RelayUnavailable, nostrRfqTransport };

package/dist/nostr.d.ts

@@ -0,0 +1,99 @@
+import { b as RfqTransport } from './rfq-CRgIOQ_y.js';
+import { SimplePool } from 'nostr-tools';
+import '@arkade-os/sdk';
+import '@arkade-os/solver-discovery';
+
+/**
+ * The Nostr RFQ transport — the PRODUCTION one (docs/rfq-protocol.md § 3.1 in
+ * arkade-os/lightning-swap-service).
+ *
+ * `rfq.ts` ships two other transports: `httpTransport`, and `relayTransport`
+ * which speaks the dev broker's `{op:"sub"|"event"}` framing. Neither is what a
+ * deployed solver listens on. This is, and it satisfies the same
+ * {@link RfqTransport} interface, so everything above the transport — the user
+ * flow, quote verification, the store — is identical whichever one it is handed.
+ *
+ * ## Why this is a separate entry point
+ *
+ * Imported as `@arkade-os/swap/nostr`, never from the package root, and
+ * `nostr-tools` is an OPTIONAL peer dependency. A consumer doing HTTP-only
+ * swaps should not pay for a Nostr library it never calls, and re-exporting
+ * this from `index.ts` would put `nostr-tools` in every consumer's module graph
+ * whether or not they resolve it. The subpath is what keeps that promise: the
+ * module is only loaded if it is imported.
+ *
+ * The consequence, stated plainly: importing this subpath without `nostr-tools`
+ * installed fails at resolution with a module-not-found. That is the intended
+ * failure — loud, at the import, naming the missing package — rather than a
+ * transport that silently degrades.
+ *
+ * A dynamic `await import()` inside the factory would also defer the cost, but
+ * it would make construction async. This transport opens its subscription
+ * eagerly, on purpose (see below), so an async factory would push a `await`
+ * into every caller for no benefit the subpath does not already give.
+ */
+
+/**
+ * Directed RFQ traffic. Provisional in the spec; kept in one place.
+ *
+ * MUST stay inside NIP-01's ephemeral range (20000–29999) and MUST match the
+ * solver's `NOSTR_KIND_DIRECTED`. The two sides subscribe by `kinds`, so a
+ * mismatch is not an error either can report — they simply never see each
+ * other, and every request times out blaming the solver.
+ *
+ * Ephemeral because a negotiation is worthless once it is over: a request
+ * nobody answered inside the timeout, and a quote past its `valid_until`, help
+ * no one, while a retained copy is a permanent record of who negotiated what
+ * with whom. The cost is no store-and-forward — a request sent while the solver
+ * is disconnected is dropped rather than queued — which the timeout and the
+ * caller's retry cover.
+ */
+declare const RFQ_DIRECTED_KIND = 24859;
+/**
+ * Indicative solver advertisement — never binding; only a quote binds.
+ *
+ * Addressable (30000–39999) rather than ephemeral, deliberately: an ad is
+ * standing state a relay should keep the current version of, not a message in a
+ * negotiation. The two constants want OPPOSITE retention, and neither is a typo
+ * of the other.
+ */
+declare const RFQ_AD_KIND = 38859;
+/**
+ * Every relay dropped the subscription, so no reply can arrive on it.
+ *
+ * Distinct from a timeout on purpose. Both look like "no answer", but they mean
+ * opposite things: a timeout says the solver did not respond, while this says
+ * we were never in a position to hear it. Without the distinction the transport
+ * waits out the full timeout and then blames the solver for a failure on our
+ * own side of the wire.
+ */
+declare class RelayUnavailable extends Error {
+    readonly reasons: string[];
+    constructor(reasons: string[]);
+}
+interface NostrRfqOptions {
+    /** Relay URLs from the solver's card. The rendezvous, not solver endpoints. */
+    relays: string[];
+    /** The card's `discovery_pubkey`, x-only hex — who we address. */
+    solverPubkey: string;
+    /**
+     * Transport key. Defaults to a FRESH key per transport, deliberately: the
+     * negotiation should not be linkable to a long-term identity, and nothing in
+     * the protocol needs a stable client key — the quote binds to the covenant,
+     * not to who asked for it.
+     */
+    secretKey?: Uint8Array;
+    /** Injectable for tests; a caller may also share one pool across swaps. */
+    pool?: SimplePool;
+    timeoutMs?: number;
+}
+/**
+ * Build an `RfqTransport` speaking kind-24859 directed traffic.
+ *
+ * Sends are fire-and-forget publishes; replies arrive on a single long-lived
+ * subscription filtered to this transport key, so a reply that arrives before
+ * the publish promise settles is not missed.
+ */
+declare const nostrRfqTransport: (options: NostrRfqOptions) => RfqTransport;
+
+export { type NostrRfqOptions, RFQ_AD_KIND, RFQ_DIRECTED_KIND, RelayUnavailable, nostrRfqTransport };

package/dist/nostr.js

@@ -0,0 +1,134 @@
+import {
+  SwapRefusal
+} from "./chunk-C5P7R7JT.js";
+
+// src/nostr.ts
+import {
+  finalizeEvent,
+  generateSecretKey,
+  getPublicKey,
+  nip44,
+  SimplePool
+} from "nostr-tools";
+var RFQ_DIRECTED_KIND = 24859;
+var RFQ_AD_KIND = 38859;
+var DEFAULT_TIMEOUT_MS = 3e4;
+var RelayUnavailable = class extends Error {
+  reasons;
+  constructor(reasons) {
+    super(`lost every relay connection: ${reasons.join("; ") || "connection closed"}`);
+    this.name = "RelayUnavailable";
+    this.reasons = reasons;
+  }
+};
+var closeReasons = (raw) => raw.map((entry) => {
+  if (typeof entry === "string") return entry;
+  const { url, reason } = entry ?? {};
+  return url ? `${url}: ${reason ?? "closed"}` : reason ?? "closed";
+});
+var asQuote = (payload, rfqId) => {
+  const p = payload;
+  if (p?.type === "rfq_refusal") throw new SwapRefusal(p.reason ?? "unknown", p.rfq_id ?? rfqId);
+  if (p?.type !== "rfq_quote" || p.rfq_id !== rfqId) {
+    throw new Error(`unexpected reply: ${p?.type ?? "no payload"}`);
+  }
+  return payload;
+};
+var nostrRfqTransport = (options) => {
+  const relays = options.relays;
+  const solverPubkey = options.solverPubkey;
+  const secretKey = options.secretKey ?? generateSecretKey();
+  const pubkey = getPublicKey(secretKey);
+  const pool = options.pool ?? new SimplePool();
+  const ownsPool = !options.pool;
+  const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const conversationKey = nip44.v2.utils.getConversationKey(secretKey, solverPubkey);
+  let closed = false;
+  const waiters = /* @__PURE__ */ new Map();
+  const subscription = pool.subscribeMany(
+    relays,
+    { kinds: [RFQ_DIRECTED_KIND], "#p": [pubkey], authors: [solverPubkey] },
+    {
+      onevent(event) {
+        let payload;
+        try {
+          payload = JSON.parse(nip44.v2.decrypt(event.content, conversationKey));
+        } catch {
+          return;
+        }
+        const rfqId = payload?.rfq_id;
+        if (!rfqId) return;
+        waiters.get(rfqId)?.resolve(payload);
+      },
+      // subscribeMany calls this once every relay has closed. Nothing will
+      // arrive after it, so failing now beats waiting out the timeout — and
+      // it names the real cause instead of implicating the solver.
+      onclose(reasons) {
+        if (closed) return;
+        const error = new RelayUnavailable(closeReasons(reasons));
+        for (const waiter of waiters.values()) waiter.reject(error);
+        waiters.clear();
+      }
+    }
+  );
+  const send = async (payload) => {
+    const event = finalizeEvent(
+      {
+        kind: RFQ_DIRECTED_KIND,
+        created_at: Math.floor(Date.now() / 1e3),
+        tags: [["p", solverPubkey]],
+        content: nip44.v2.encrypt(JSON.stringify(payload), conversationKey)
+      },
+      secretKey
+    );
+    const results = await Promise.allSettled(pool.publish(relays, event));
+    if (!results.some((r) => r.status === "fulfilled")) {
+      throw new Error("no relay accepted the RFQ message");
+    }
+  };
+  const awaitReply = (rfqId) => new Promise((resolve, reject) => {
+    const timer = setTimeout(() => {
+      waiters.delete(rfqId);
+      reject(new Error(`no solver reply within ${timeoutMs}ms`));
+    }, timeoutMs);
+    waiters.set(rfqId, {
+      resolve: (payload) => {
+        clearTimeout(timer);
+        waiters.delete(rfqId);
+        resolve(payload);
+      },
+      reject: (error) => {
+        clearTimeout(timer);
+        waiters.delete(rfqId);
+        reject(error);
+      }
+    });
+  });
+  return {
+    async requestQuote(payload) {
+      const rfqId = String(payload.rfq_id);
+      const reply = awaitReply(rfqId);
+      await send(payload);
+      return asQuote(await reply, rfqId);
+    },
+    async status(rfqId) {
+      const reply = awaitReply(rfqId);
+      await send({ v: 1, type: "rfq_status_request", rfq_id: rfqId });
+      const payload = await reply;
+      if (payload?.type !== "rfq_status") return null;
+      return payload;
+    },
+    async close() {
+      closed = true;
+      subscription.close();
+      waiters.clear();
+      if (ownsPool) pool.close(relays);
+    }
+  };
+};
+export {
+  RFQ_AD_KIND,
+  RFQ_DIRECTED_KIND,
+  RelayUnavailable,
+  nostrRfqTransport
+};