@dvmkit/sdk 0.1.1-rc.7 → 0.1.3-rc.7

package/dist/chunk-EPNDZ5DH.js

@@ -0,0 +1,1010 @@
+import {
+  callerLoggers
+} from "./chunk-66HGCPBU.js";
+
+// src/lib/mints.ts
+var RECOMMENDED_MINTS = [
+  {
+    name: "Testnut",
+    description: "Cashu test mint \u2014 use for testing only, not real funds",
+    url: "https://testnut.cashu.space"
+  },
+  {
+    name: "Voltz Mint",
+    description: "Production Cashu mint by the Voltz Wallet team",
+    url: "https://mint.lnvoltz.com"
+  }
+];
+function isTestMintUrl(url) {
+  let host;
+  try {
+    host = new URL(url).hostname.toLowerCase();
+  } catch {
+    return false;
+  }
+  if (host.startsWith("[") && host.endsWith("]")) host = host.slice(1, -1);
+  if (LOOPBACK_HOSTS.has(host)) return true;
+  if (host.endsWith(".localhost")) return true;
+  return TEST_MINT_HOSTS.has(host);
+}
+var LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "0.0.0.0", "::1"]);
+var TEST_MINT_HOSTS = /* @__PURE__ */ new Set(["testnut.cashu.space"]);
+
+// src/lib/x402/env.ts
+import { isAddress } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+var X402_SELF_RELAY_KEY = "DVMKIT_X402_SELF_RELAY_KEY";
+var X402_RECEIVER_AUTHORIZER_KEY = "DVMKIT_X402_RECEIVER_AUTHORIZER_KEY";
+var X402_BATCH_SETTLEMENT_KEY = "DVMKIT_X402_BATCH_SETTLEMENT";
+var X402_RPC_URL_KEY = "DVMKIT_X402_RPC_URL";
+var PRIVATE_KEY_RE = /^0x[0-9a-fA-F]{64}$/;
+var X402EnvValidationError = class extends Error {
+  constructor(code, variable, message, expectedAddress) {
+    super(message);
+    this.code = code;
+    this.variable = variable;
+    this.expectedAddress = expectedAddress;
+    this.name = "X402EnvValidationError";
+  }
+  code;
+  variable;
+  expectedAddress;
+};
+function validateX402Env(env, opts = {}) {
+  const relayKey = env[X402_SELF_RELAY_KEY];
+  const authorizerKey = env[X402_RECEIVER_AUTHORIZER_KEY];
+  const hasRelayKey = relayKey !== void 0;
+  const hasAuthorizerKey = authorizerKey !== void 0;
+  const relay = hasRelayKey ? derive(X402_SELF_RELAY_KEY, relayKey) : void 0;
+  const authorizer = hasAuthorizerKey ? derive(X402_RECEIVER_AUTHORIZER_KEY, authorizerKey) : void 0;
+  const completeWrite = opts.requireCompleteBundle === true && (hasRelayKey || hasAuthorizerKey);
+  if (hasRelayKey || completeWrite) {
+    if (env[X402_BATCH_SETTLEMENT_KEY] !== "true") {
+      fail(
+        "x402_bundle_incomplete",
+        hasRelayKey ? X402_SELF_RELAY_KEY : X402_RECEIVER_AUTHORIZER_KEY,
+        `Changing either x402 private key requires ${X402_BATCH_SETTLEMENT_KEY}=true in the same write.`
+      );
+    }
+    if (!env[X402_RPC_URL_KEY]?.trim()) {
+      fail(
+        "x402_bundle_incomplete",
+        hasRelayKey ? X402_SELF_RELAY_KEY : X402_RECEIVER_AUTHORIZER_KEY,
+        `Changing either x402 private key requires an explicit ${X402_RPC_URL_KEY} in the same write.`
+      );
+    }
+    if (!hasAuthorizerKey || completeWrite && !hasRelayKey) {
+      if (!completeWrite && !hasAuthorizerKey) {
+        fail(
+          "x402_bundle_incomplete",
+          X402_RECEIVER_AUTHORIZER_KEY,
+          `${X402_SELF_RELAY_KEY} requires ${X402_RECEIVER_AUTHORIZER_KEY}.`
+        );
+      }
+      fail(
+        "x402_bundle_incomplete",
+        hasRelayKey ? X402_RECEIVER_AUTHORIZER_KEY : X402_SELF_RELAY_KEY,
+        `Changing either x402 private key requires both ${X402_SELF_RELAY_KEY} and ${X402_RECEIVER_AUTHORIZER_KEY} in the same write.`
+      );
+    }
+  }
+  if (hasRelayKey && relayKey.toLowerCase() === authorizerKey?.toLowerCase()) {
+    fail(
+      "x402_key_reuse",
+      X402_SELF_RELAY_KEY,
+      `${X402_SELF_RELAY_KEY} and ${X402_RECEIVER_AUTHORIZER_KEY} must use different private keys.`
+    );
+  }
+  assertExpectation(X402_SELF_RELAY_KEY, relay, opts.expectedRelay);
+  assertExpectation(X402_RECEIVER_AUTHORIZER_KEY, authorizer, opts.expectedAuthorizer);
+  return { ...relay ? { relay } : {}, ...authorizer ? { authorizer } : {} };
+}
+function derive(variable, key) {
+  if (!PRIVATE_KEY_RE.test(key)) {
+    fail(
+      "invalid_x402_private_key",
+      variable,
+      `${variable} must be a 0x-prefixed 32-byte hex secp256k1 private key.`
+    );
+  }
+  try {
+    return privateKeyToAccount(key).address;
+  } catch {
+    fail(
+      "invalid_x402_private_key",
+      variable,
+      `${variable} must be a valid secp256k1 private key.`
+    );
+  }
+}
+function assertExpectation(variable, actual, expected) {
+  if (expected === void 0) return;
+  if (!isAddress(expected, { strict: false })) {
+    fail(
+      "invalid_x402_expected_address",
+      variable,
+      `Expected address for ${variable} must be a 0x-prefixed 20-byte EVM address.`
+    );
+  }
+  if (actual?.toLowerCase() !== expected.toLowerCase()) {
+    fail(
+      "x402_address_mismatch",
+      variable,
+      `${variable} derives to a different public address than expected ${expected}.`,
+      expected
+    );
+  }
+}
+function fail(code, variable, message, expectedAddress) {
+  throw new X402EnvValidationError(code, variable, message, expectedAddress);
+}
+
+// src/observability/span-writer.ts
+var noop = () => {
+};
+var SPANS_INSERTED_CHANNEL = "spans_inserted";
+var MAX_BUFFERED_SPANS = 1e4;
+var MAX_ROW_JSONB_BYTES = 64 * 1024;
+var MAX_STRING_VALUE_BYTES = 4 * 1024;
+var FLUSH_THRESHOLD = 1e3;
+var MAX_BACKOFF_EXPONENT = 6;
+var SpanWriter = class {
+  constructor(transport, flushIntervalMs = 1e4) {
+    this.transport = transport;
+    this.flushIntervalMs = flushIntervalMs;
+  }
+  transport;
+  flushIntervalMs;
+  buffer = [];
+  flushTimer = null;
+  flushing = false;
+  dropCount = 0;
+  truncatedSpanCount = 0;
+  consecutiveFailures = 0;
+  backoffTimer = null;
+  /** Enqueue a span row. Non-blocking — truncates oversize JSONB and appends to buffer. */
+  enqueue(row) {
+    const originalBytes = JSON.stringify({
+      attributes: row.attributes,
+      dimensions: row.dimensions
+    }).length;
+    if (originalBytes > MAX_ROW_JSONB_BYTES) {
+      row = this.truncateForSize(row, originalBytes);
+    }
+    if (this.buffer.length >= MAX_BUFFERED_SPANS) {
+      this.dropCount++;
+      if (this.dropCount === 1 || this.dropCount % 1e3 === 0) {
+        console.error(
+          JSON.stringify({
+            event: "span_buffer_drop",
+            reason: "buffer_full",
+            total_dropped: this.dropCount,
+            buffer_size: this.buffer.length
+          })
+        );
+      }
+      return;
+    }
+    this.buffer.push(row);
+    if (this.buffer.length >= FLUSH_THRESHOLD && !this.flushing) {
+      void this.flush().catch(noop);
+    }
+  }
+  /** Start periodic flush to the transport. */
+  startFlush() {
+    this.flushTimer = setInterval(() => {
+      void this.flush().catch(noop);
+    }, this.flushIntervalMs);
+  }
+  /** Stop periodic flush. */
+  stopFlush() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    if (this.backoffTimer) {
+      clearTimeout(this.backoffTimer);
+      this.backoffTimer = null;
+    }
+  }
+  /** Flush buffered spans. Single-flight: concurrent calls exit early. */
+  async flush() {
+    if (this.flushing) return;
+    if (this.buffer.length === 0) return;
+    this.flushing = true;
+    const batch = this.buffer;
+    this.buffer = [];
+    try {
+      await this.transport.send(batch);
+      this.consecutiveFailures = 0;
+    } catch (err) {
+      this.consecutiveFailures++;
+      console.error(
+        JSON.stringify({
+          event: "span_flush_failed",
+          error: err instanceof Error ? err.message : String(err),
+          batch_size: batch.length,
+          consecutive_failures: this.consecutiveFailures
+        })
+      );
+      const room = MAX_BUFFERED_SPANS - this.buffer.length;
+      if (room > 0) {
+        this.buffer.unshift(...batch.slice(0, room));
+      }
+      if (this.consecutiveFailures > 1) {
+        const exponent = Math.min(this.consecutiveFailures - 1, MAX_BACKOFF_EXPONENT);
+        const backoffMs = this.flushIntervalMs * Math.pow(2, exponent);
+        this.stopFlush();
+        this.backoffTimer = setTimeout(() => {
+          this.backoffTimer = null;
+          this.startFlush();
+        }, backoffMs);
+      }
+    } finally {
+      this.flushing = false;
+    }
+  }
+  /** Flush remaining spans on shutdown. */
+  async shutdown() {
+    this.stopFlush();
+    await this.flush();
+  }
+  /** Number of spans dropped due to buffer overflow. */
+  getDropCount() {
+    return this.dropCount;
+  }
+  /** Number of spans truncated due to oversized JSONB payload. */
+  getTruncatedSpanCount() {
+    return this.truncatedSpanCount;
+  }
+  /** Current buffer size. */
+  getBufferSize() {
+    return this.buffer.length;
+  }
+  /** Consecutive flush failures; resets to 0 on the next successful flush. */
+  getConsecutiveFailures() {
+    return this.consecutiveFailures;
+  }
+  /**
+   * Two-pass truncation: cap individual string values, then fall back to
+   * wholesale attribute replacement if the blob is still over the limit.
+   */
+  truncateForSize(row, originalBytes) {
+    const truncatedAttrs = {};
+    for (const [key, value] of Object.entries(row.attributes)) {
+      if (typeof value === "string" && value.length > MAX_STRING_VALUE_BYTES) {
+        const omitted = value.length - MAX_STRING_VALUE_BYTES;
+        truncatedAttrs[key] = `${value.slice(0, MAX_STRING_VALUE_BYTES)}\u2026 [truncated, ${omitted} chars omitted]`;
+      } else {
+        truncatedAttrs[key] = value;
+      }
+    }
+    const afterStringPass = JSON.stringify({
+      attributes: truncatedAttrs,
+      dimensions: row.dimensions
+    }).length;
+    let mode;
+    if (afterStringPass <= MAX_ROW_JSONB_BYTES) {
+      row = { ...row, attributes: truncatedAttrs };
+      mode = "string_pass";
+    } else {
+      const dimSize = JSON.stringify(row.dimensions).length;
+      if (dimSize > MAX_ROW_JSONB_BYTES) {
+        console.error(
+          JSON.stringify({
+            event: "span_dimension_oversized",
+            name: row.name,
+            dataset: row.dataset,
+            dimension_bytes: dimSize
+          })
+        );
+      }
+      row = {
+        ...row,
+        attributes: {
+          _truncated: true,
+          original_bytes: originalBytes,
+          original_keys: Object.keys(row.attributes).sort()
+        }
+      };
+      mode = "wholesale_fallback";
+    }
+    this.truncatedSpanCount++;
+    if (this.truncatedSpanCount === 1 || this.truncatedSpanCount % 100 === 0) {
+      console.error(
+        JSON.stringify({
+          event: "span_truncated",
+          name: row.name,
+          dataset: row.dataset,
+          original_bytes: originalBytes,
+          after_string_pass_bytes: afterStringPass,
+          mode,
+          total_truncated: this.truncatedSpanCount
+        })
+      );
+    }
+    return row;
+  }
+};
+var SPAN_COLUMNS = [
+  "span_id",
+  "trace_id",
+  "parent_span_id",
+  "dataset",
+  "name",
+  "level",
+  "status",
+  "started_at_ms",
+  "ended_at_ms",
+  "service",
+  "service_version",
+  "host",
+  "pid",
+  "dimensions",
+  "attributes",
+  "error_message",
+  "error_stack",
+  "sample_rate"
+];
+async function insertSpanBatch(pool, rows) {
+  if (rows.length === 0) return;
+  const values = [];
+  const placeholders = [];
+  let idx = 1;
+  for (const row of rows) {
+    const rowPlaceholders = [];
+    for (const col of SPAN_COLUMNS) {
+      let val = row[col] ?? null;
+      if (col === "sample_rate" && val == null) {
+        val = 1;
+      }
+      if (col === "dimensions" || col === "attributes") {
+        rowPlaceholders.push(`$${idx}::jsonb`);
+        values.push(typeof val === "string" ? val : JSON.stringify(val ?? {}));
+      } else {
+        rowPlaceholders.push(`$${idx}`);
+        values.push(val);
+      }
+      idx++;
+    }
+    placeholders.push(`(${rowPlaceholders.join(", ")})`);
+  }
+  await pool.query(
+    `INSERT INTO observability.spans (${SPAN_COLUMNS.join(", ")})
+     VALUES ${placeholders.join(",\n")}
+     ON CONFLICT (dataset, span_id) DO NOTHING`,
+    values
+  );
+  try {
+    await pool.query(`SELECT pg_notify('${SPANS_INSERTED_CHANNEL}', '')`);
+  } catch {
+  }
+}
+var DbTransport = class {
+  constructor(pool) {
+    this.pool = pool;
+  }
+  pool;
+  async send(rows) {
+    await insertSpanBatch(this.pool, rows);
+  }
+};
+var HttpTransport = class {
+  constructor(platformUrl, serviceToken) {
+    this.platformUrl = platformUrl;
+    this.serviceToken = serviceToken;
+  }
+  platformUrl;
+  serviceToken;
+  async send(rows) {
+    if (rows.length === 0) return;
+    const resp = await fetch(`${this.platformUrl.replace(/\/$/, "")}/_internal/spans`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.serviceToken}`
+      },
+      body: JSON.stringify({ spans: rows })
+    });
+    if (!resp.ok) {
+      const text = await resp.text().catch(() => "");
+      throw new Error(`Span ingestion failed: ${resp.status} ${text}`);
+    }
+  }
+};
+
+// src/lib/nwc.ts
+import { decrypt, encrypt } from "nostr-tools/nip04";
+import { SimplePool, useWebSocketImplementation } from "nostr-tools/pool";
+import { finalizeEvent, getPublicKey } from "nostr-tools/pure";
+import WebSocket from "ws";
+
+// src/lib/hash.ts
+import { createHash } from "crypto";
+function sha256hex(input) {
+  return createHash("sha256").update(input).digest("hex");
+}
+
+// src/lib/nwc.ts
+var webSocketImplementationConfigured = false;
+function ensureWebSocketImplementation() {
+  if (webSocketImplementationConfigured) return;
+  useWebSocketImplementation(WebSocket);
+  webSocketImplementationConfigured = true;
+}
+var NwcError = class extends Error {
+  constructor(code, message, method) {
+    super(message);
+    this.code = code;
+    this.method = method;
+    this.name = "NwcError";
+  }
+  code;
+  method;
+};
+function nwcTimeoutMs() {
+  return positiveSecondsEnv("DVM_NWC_TIMEOUT_SEC", 30);
+}
+function nwcDedupWindowMs() {
+  return positiveSecondsEnv("DVM_NWC_DEDUP_WINDOW_SEC", 240);
+}
+async function withNwcPool(conn, fn, timeoutMs) {
+  return withPool(void 0, conn, (pool) => fn({ pool, timeoutMs }));
+}
+function parseNwcUri(uri) {
+  if (!uri.startsWith("nostr+walletconnect://")) {
+    throw new NwcError("invalid_uri", "NWC URI must start with nostr+walletconnect://");
+  }
+  const withoutScheme = uri.slice("nostr+walletconnect://".length);
+  const [walletPubkey, queryString] = withoutScheme.split("?", 2);
+  if (!walletPubkey || !queryString) {
+    throw new NwcError("invalid_uri", "NWC URI missing pubkey or query params");
+  }
+  const params = new URLSearchParams(queryString);
+  const relays = params.getAll("relay").filter((r) => r.length > 0);
+  const secretHex = params.get("secret");
+  if (relays.length === 0) throw new NwcError("invalid_uri", "NWC URI missing relay param");
+  if (!secretHex) throw new NwcError("invalid_uri", "NWC URI missing secret param");
+  if (!/^[0-9a-fA-F]{64}$/.test(secretHex)) {
+    throw new NwcError("invalid_uri", "NWC URI secret must be 64 hex characters");
+  }
+  const secret = hexToBytes(secretHex);
+  const clientPubkey = getPublicKey(secret);
+  return { walletPubkey, relays, secret, clientPubkey };
+}
+async function payInvoiceReconciling(conn, bolt11, opts = {}) {
+  return callerLoggers.lightning.span(
+    "lightning.pay_invoice",
+    {
+      relays: conn.relays.join(","),
+      wallet_pubkey: conn.walletPubkey,
+      bolt11_hash: sha256hex(bolt11).slice(0, 16)
+    },
+    async () => {
+      const now = opts.now ?? (() => Date.now());
+      const dedupWindowMs = opts.dedupWindowMs ?? nwcDedupWindowMs();
+      return withPool(opts.pool, conn, async (pool) => {
+        const method = "pay_invoice";
+        const event = buildRequestEvent(conn, method, { invoice: bolt11 });
+        const publishedAtMs = now();
+        const first = await attemptPayment(conn, method, event, pool, opts.timeoutMs);
+        if (first.kind === "settled") {
+          return settledOutcome(first, "paid");
+        }
+        if (first.kind === "rejected") throw first.error;
+        if (first.kind === "not_sent") {
+          throw first.error;
+        }
+        const reconciled = await reconcile(conn, bolt11, pool, opts.timeoutMs);
+        if (reconciled.kind === "settled") {
+          callerLoggers.lightning.info("lightning.pay_invoice.reconciled", { republished: false });
+          return settledOutcome(reconciled, "reconciled");
+        }
+        if (reconciled.kind === "unknown") {
+          throw new NwcError(
+            "payment_unknown",
+            "The wallet never answered and could not confirm whether the payment went through."
+          );
+        }
+        if (now() - publishedAtMs >= dedupWindowMs) {
+          throw new NwcError(
+            "payment_unknown",
+            "The wallet never answered and too much time has passed to safely retry the payment."
+          );
+        }
+        callerLoggers.lightning.info("lightning.pay_invoice.republish", { event_id: event.id });
+        const second = await attemptPayment(conn, method, event, pool, opts.timeoutMs);
+        if (second.kind === "settled") {
+          return settledOutcome(second, "republished");
+        }
+        if (second.kind === "rejected") throw second.error;
+        const final = await reconcile(conn, bolt11, pool, opts.timeoutMs);
+        if (final.kind === "settled") {
+          return settledOutcome(final, "republished");
+        }
+        throw new NwcError(
+          "payment_unknown",
+          "The wallet never answered and could not confirm whether the payment went through."
+        );
+      });
+    }
+  );
+}
+async function getBalance(conn, opts = {}) {
+  return callerLoggers.lightning.span(
+    "lightning.get_balance",
+    { relays: conn.relays.join(","), wallet_pubkey: conn.walletPubkey },
+    async () => {
+      const result = await sendNwcRequest(conn, "get_balance", {}, opts);
+      const balance = result.balance ?? 0;
+      callerLoggers.lightning.info("lightning.get_balance.result", { balance_msats: balance });
+      return balance;
+    }
+  );
+}
+async function getInfo(conn, opts = {}) {
+  return callerLoggers.lightning.span(
+    "lightning.get_info",
+    { relays: conn.relays.join(","), wallet_pubkey: conn.walletPubkey },
+    async () => {
+      const result = await sendNwcRequest(conn, "get_info", {}, opts);
+      const info = { alias: result.alias, methods: result.methods ?? [] };
+      const volunteered = extractWalletReportedBudget(result);
+      if (volunteered) info.walletReportedBudget = volunteered;
+      callerLoggers.lightning.info("lightning.get_info.result", {
+        alias: info.alias,
+        methods: info.methods,
+        wallet_reported_budget: volunteered !== void 0
+      });
+      return info;
+    }
+  );
+}
+async function makeInvoice(conn, params, opts = {}) {
+  return callerLoggers.lightning.span(
+    "lightning.make_invoice",
+    {
+      relays: conn.relays.join(","),
+      wallet_pubkey: conn.walletPubkey,
+      amount_msats: params.amountMsats
+    },
+    async () => {
+      const body = { amount: params.amountMsats };
+      if (params.description !== void 0) body.description = params.description;
+      if (params.expirySeconds !== void 0) body.expiry = params.expirySeconds;
+      const result = await sendNwcRequest(conn, "make_invoice", body, opts);
+      const tx = toTransaction(result);
+      if (!tx.invoice) {
+        throw new NwcError("missing_invoice", "Wallet did not return a BOLT11 invoice");
+      }
+      if (!tx.paymentHash) {
+        throw new NwcError("missing_payment_hash", "Wallet did not return a payment hash");
+      }
+      callerLoggers.lightning.info("lightning.make_invoice.result", {
+        payment_hash_hash: sha256hex(tx.paymentHash).slice(0, 16)
+      });
+      return tx;
+    }
+  );
+}
+async function lookupInvoice(conn, params, opts = {}) {
+  return callerLoggers.lightning.span(
+    "lightning.lookup_invoice",
+    {
+      relays: conn.relays.join(","),
+      wallet_pubkey: conn.walletPubkey,
+      payment_hash_hash: params.paymentHash ? sha256hex(params.paymentHash).slice(0, 16) : void 0
+    },
+    async () => {
+      const body = {};
+      if (params.paymentHash) body.payment_hash = params.paymentHash;
+      if (params.invoice) body.invoice = params.invoice;
+      if (!body.payment_hash && !body.invoice) {
+        throw new NwcError("bad_request", "lookupInvoice requires payment_hash or invoice");
+      }
+      const result = await sendNwcRequest(conn, "lookup_invoice", body, opts);
+      return toTransaction(result);
+    }
+  );
+}
+async function listTransactions(conn, options, opts = {}) {
+  return callerLoggers.lightning.span(
+    "lightning.list_transactions",
+    {
+      relays: conn.relays.join(","),
+      wallet_pubkey: conn.walletPubkey,
+      from: options.from,
+      limit: options.limit
+    },
+    async () => {
+      const body = {};
+      if (options.from !== void 0) body.from = options.from;
+      if (options.limit !== void 0) body.limit = options.limit;
+      const result = await sendNwcRequest(conn, "list_transactions", body, opts);
+      if (!Array.isArray(result.transactions)) {
+        throw new NwcError("invalid_response", "Wallet did not return a transaction list.");
+      }
+      const transactions = result.transactions.map(toTransactionSnapshot);
+      callerLoggers.lightning.info("lightning.list_transactions.result", {
+        transaction_count: transactions.length
+      });
+      return transactions;
+    }
+  );
+}
+var VOLUNTEERED_BUDGET_KEYS = [
+  "budget",
+  "budget_renewal",
+  "budget_msats",
+  "budget_amount",
+  "max_amount",
+  "remaining_budget",
+  "budget_remaining",
+  "renews_at"
+];
+function extractWalletReportedBudget(result) {
+  const out = {};
+  for (const key of VOLUNTEERED_BUDGET_KEYS) {
+    const value = result[key];
+    if (value !== void 0 && value !== null) out[key] = value;
+  }
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+async function attemptPayment(conn, method, event, pool, timeoutMs) {
+  let result;
+  try {
+    result = await publishAndAwait(conn, method, event, pool, timeoutMs);
+  } catch (err) {
+    if (err instanceof NwcError && err.code === "relay_unreachable") {
+      return { kind: "not_sent", error: err };
+    }
+    if (err instanceof NwcError && (err.code === "timeout" || err.code === "publish_rejected")) {
+      return { kind: "unknown" };
+    }
+    if (err instanceof NwcError && err.code === "invalid_response") return { kind: "unknown" };
+    if (err instanceof NwcError) return { kind: "rejected", error: err };
+    throw err;
+  }
+  if (!result.preimage) {
+    return {
+      kind: "rejected",
+      error: new NwcError("missing_preimage", "Wallet did not return a payment preimage.")
+    };
+  }
+  const feesPaidMsats = optionalFeeMsats(result.fees_paid);
+  return {
+    kind: "settled",
+    preimage: result.preimage,
+    ...feesPaidMsats !== void 0 ? { feesPaidMsats } : {}
+  };
+}
+async function reconcile(conn, bolt11, pool, timeoutMs) {
+  try {
+    const tx = await lookupInvoice(conn, { invoice: bolt11 }, { pool, timeoutMs });
+    if (tx.invoice !== bolt11) return { kind: "unknown" };
+    if (tx.settledAt != null && tx.preimage) {
+      return {
+        kind: "settled",
+        preimage: tx.preimage,
+        ...tx.feesPaidMsats !== void 0 ? { feesPaidMsats: tx.feesPaidMsats } : {}
+      };
+    }
+    if (tx.settledAt != null) {
+      return {
+        kind: "settled",
+        preimage: "",
+        ...tx.feesPaidMsats !== void 0 ? { feesPaidMsats: tx.feesPaidMsats } : {}
+      };
+    }
+    return { kind: "unpaid" };
+  } catch (err) {
+    if (err instanceof NwcError && err.code.toUpperCase() === "NOT_FOUND") {
+      return { kind: "unpaid" };
+    }
+    return { kind: "unknown" };
+  }
+}
+async function sendNwcRequest(conn, method, params, opts) {
+  return withPool(
+    opts.pool,
+    conn,
+    (pool) => publishAndAwait(conn, method, buildRequestEvent(conn, method, params), pool, opts.timeoutMs)
+  );
+}
+function buildRequestEvent(conn, method, params) {
+  const content = JSON.stringify({ method, params });
+  const encrypted = encrypt(conn.secret, conn.walletPubkey, content);
+  return finalizeEvent(
+    {
+      kind: 23194,
+      tags: [["p", conn.walletPubkey]],
+      content: encrypted,
+      created_at: Math.floor(Date.now() / 1e3)
+    },
+    conn.secret
+  );
+}
+async function publishAndAwait(conn, method, event, pool, timeoutMs) {
+  const relays = conn.relays;
+  const budgetMs = timeoutMs ?? nwcTimeoutMs();
+  const waiter = awaitResponse(pool, relays, conn.walletPubkey, event.id, budgetMs);
+  try {
+    await publishEvent(pool, relays, event);
+  } catch (err) {
+    waiter.cancel();
+    if (err instanceof NwcError) throw err;
+    throw new NwcError(
+      "publish_rejected",
+      `No relay accepted the request (${relays.join(", ")}): ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  const response = await waiter.promise;
+  if (response === null) {
+    throw new NwcError("timeout", `Wallet did not respond within ${Math.round(budgetMs / 1e3)}s`);
+  }
+  let decrypted;
+  try {
+    decrypted = decrypt(conn.secret, conn.walletPubkey, response);
+  } catch {
+    throw new NwcError("invalid_response", "Wallet response could not be decrypted.");
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(decrypted);
+  } catch {
+    throw new NwcError("invalid_response", "Wallet returned a malformed response.");
+  }
+  if (parsed.error) {
+    throw new NwcError(
+      parsed.error.code ?? "wallet_error",
+      parsed.error.message ?? "Wallet error",
+      method
+    );
+  }
+  return parsed.result ?? {};
+}
+function awaitResponse(pool, relays, walletPubkey, eventId, timeoutMs) {
+  let settle;
+  const promise = new Promise((resolve) => {
+    const done = (value) => {
+      clearTimeout(timer);
+      sub.close();
+      resolve(value);
+    };
+    settle = done;
+    const timer = setTimeout(() => {
+      done(null);
+    }, timeoutMs);
+    const sub = pool.subscribeMany(
+      relays,
+      {
+        kinds: [23195],
+        authors: [walletPubkey],
+        "#e": [eventId]
+      },
+      {
+        onevent(ev) {
+          done(ev.content);
+        },
+        // required by nostr-tools
+        oneose() {
+        }
+        // eslint-disable-line @typescript-eslint/no-empty-function
+      }
+    );
+  });
+  return {
+    promise,
+    cancel: () => {
+      settle?.(null);
+    }
+  };
+}
+async function withPool(external, conn, fn) {
+  ensureWebSocketImplementation();
+  if (external) return fn(external);
+  const pool = new SimplePool();
+  try {
+    return await fn(pool);
+  } finally {
+    pool.close(conn.relays);
+  }
+}
+function toTransaction(raw) {
+  const feesPaidMsats = optionalFeeMsats(raw.fees_paid);
+  return {
+    type: raw.type ?? "incoming",
+    invoice: raw.invoice,
+    description: raw.description,
+    paymentHash: raw.payment_hash ?? "",
+    preimage: raw.preimage,
+    amountMsats: raw.amount ?? 0,
+    ...feesPaidMsats !== void 0 ? { feesPaidMsats } : {},
+    createdAt: raw.created_at ?? Math.floor(Date.now() / 1e3),
+    expiresAt: raw.expires_at,
+    settledAt: raw.settled_at ?? void 0
+  };
+}
+function toTransactionSnapshot(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new NwcError("invalid_response", "Wallet returned a malformed transaction.");
+  }
+  const raw = value;
+  if (raw.type !== "incoming" && raw.type !== "outgoing") {
+    throw new NwcError("invalid_response", "Wallet returned an invalid transaction type.");
+  }
+  const amountMsats = requiredNonNegativeInteger(raw.amount, "amount");
+  const createdAt = requiredNonNegativeInteger(raw.created_at, "creation time");
+  const feesPaidMsats = optionalFeeMsats(raw.fees_paid);
+  if (raw.fees_paid != null && feesPaidMsats === void 0) {
+    throw new NwcError("invalid_response", "Wallet returned an invalid transaction fee.");
+  }
+  const settledAt = optionalNonNegativeInteger(raw.settled_at);
+  if (raw.settled_at != null && settledAt === void 0) {
+    throw new NwcError("invalid_response", "Wallet returned an invalid settlement time.");
+  }
+  const invoice = optionalPrivateString(raw.invoice, "invoice");
+  const paymentHash = optionalPrivateString(raw.payment_hash, "payment hash");
+  const reducedIdentity = {
+    type: raw.type,
+    invoice: invoice ?? null,
+    paymentHash: paymentHash ?? null,
+    amountMsats,
+    feesPaidMsats: feesPaidMsats ?? null,
+    createdAt,
+    settledAt: settledAt ?? null
+  };
+  return {
+    fingerprint: sha256hex(JSON.stringify(reducedIdentity)),
+    ...invoice ? { invoiceHash: sha256hex(invoice) } : {},
+    type: raw.type,
+    amountMsats,
+    ...feesPaidMsats !== void 0 ? { feesPaidMsats } : {},
+    createdAt,
+    ...settledAt !== void 0 ? { settledAt } : {}
+  };
+}
+function settledOutcome(payment, outcome) {
+  return {
+    preimage: payment.preimage,
+    outcome,
+    ...payment.feesPaidMsats !== void 0 ? { feesPaidMsats: payment.feesPaidMsats } : {}
+  };
+}
+function optionalFeeMsats(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+function optionalNonNegativeInteger(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+function requiredNonNegativeInteger(value, field) {
+  const parsed = optionalNonNegativeInteger(value);
+  if (parsed === void 0) {
+    throw new NwcError("invalid_response", `Wallet returned an invalid transaction ${field}.`);
+  }
+  return parsed;
+}
+function optionalPrivateString(value, field) {
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string" || value.length === 0) {
+    throw new NwcError("invalid_response", `Wallet returned an invalid transaction ${field}.`);
+  }
+  return value;
+}
+async function publishEvent(pool, relays, event) {
+  const connections = await Promise.allSettled(relays.map((url) => pool.ensureRelay(url)));
+  const live = connections.flatMap((c) => c.status === "fulfilled" ? [c.value] : []);
+  if (live.length === 0) {
+    throw new NwcError(
+      "relay_unreachable",
+      `Could not connect to any of the wallet's relays (${relays.join(", ")}): ${describeRejections(
+        connections
+      )}`
+    );
+  }
+  try {
+    await Promise.any(live.map((relay) => relay.publish(event)));
+  } catch (err) {
+    throw new NwcError(
+      "publish_rejected",
+      `No relay accepted the request (${relays.join(", ")}): ${describeAggregate(err)}`
+    );
+  }
+}
+function describeRejections(results) {
+  const reasons = results.flatMap((r) => r.status === "rejected" ? [errorText(r.reason)] : []);
+  return reasons.length > 0 ? reasons.join("; ") : "no relays configured";
+}
+function describeAggregate(err) {
+  if (err instanceof AggregateError) {
+    return err.errors.map((e) => errorText(e)).join("; ");
+  }
+  return errorText(err);
+}
+function errorText(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function positiveSecondsEnv(name, fallbackSec) {
+  const raw = process.env[name];
+  if (!raw) return fallbackSec * 1e3;
+  const n = Number(raw);
+  if (!Number.isFinite(n) || n <= 0) return fallbackSec * 1e3;
+  return Math.floor(n) * 1e3;
+}
+function hexToBytes(hex) {
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    bytes[i] = parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+  }
+  return bytes;
+}
+
+// src/lib/nwc-backend.ts
+var NwcBackend = class {
+  constructor(conn, opts = {}) {
+    this.conn = conn;
+    this.opts = opts;
+  }
+  conn;
+  opts;
+  async payInvoice(bolt11, _amountMsats) {
+    return payInvoiceReconciling(this.conn, bolt11, this.opts);
+  }
+  async getBalance() {
+    return getBalance(this.conn, this.opts);
+  }
+  async getInfo() {
+    return getInfo(this.conn, this.opts);
+  }
+  async createInvoice(params) {
+    const tx = await makeInvoice(this.conn, params, this.opts);
+    const expiresAtMs = tx.expiresAt ? tx.expiresAt * 1e3 : Date.now() + (params.expirySeconds ?? 3600) * 1e3;
+    return {
+      bolt11: tx.invoice ?? "",
+      paymentHash: tx.paymentHash,
+      amountMsats: tx.amountMsats || params.amountMsats,
+      expiresAt: expiresAtMs
+    };
+  }
+  async lookupInvoice(paymentHash) {
+    const tx = await lookupInvoice(this.conn, { paymentHash }, this.opts);
+    return {
+      settled: tx.settledAt != null,
+      preimage: tx.preimage,
+      settledAt: tx.settledAt != null ? tx.settledAt * 1e3 : void 0,
+      expiresAt: tx.expiresAt != null ? tx.expiresAt * 1e3 : void 0
+    };
+  }
+  async listTransactions(options) {
+    return listTransactions(this.conn, options, this.opts);
+  }
+};
+
+export {
+  RECOMMENDED_MINTS,
+  isTestMintUrl,
+  X402_SELF_RELAY_KEY,
+  X402_RECEIVER_AUTHORIZER_KEY,
+  X402_BATCH_SETTLEMENT_KEY,
+  X402_RPC_URL_KEY,
+  X402EnvValidationError,
+  validateX402Env,
+  SPANS_INSERTED_CHANNEL,
+  SpanWriter,
+  insertSpanBatch,
+  DbTransport,
+  HttpTransport,
+  sha256hex,
+  NwcError,
+  nwcTimeoutMs,
+  nwcDedupWindowMs,
+  withNwcPool,
+  parseNwcUri,
+  payInvoiceReconciling,
+  getBalance,
+  getInfo,
+  makeInvoice,
+  lookupInvoice,
+  listTransactions,
+  NwcBackend
+};