@dvmkit/sdk 0.0.0 → 0.1.0-rc.1

package/dist/chunk-DCNT4PJS.js

@@ -0,0 +1,733 @@
+import {
+  callerLoggers
+} from "./chunk-KXWROQGK.js";
+
+// src/lib/x402/constants.ts
+var X402_DEFAULT_FACILITATOR = "https://x402.org/facilitator";
+
+// src/lib/errors.ts
+var DvmError = class extends Error {
+  constructor(code, message, hint, data, display, proseSources) {
+    super(message);
+    this.code = code;
+    this.hint = hint;
+    this.data = data;
+    this.display = display;
+    this.proseSources = proseSources;
+    this.name = "DvmError";
+  }
+  code;
+  hint;
+  data;
+  display;
+  proseSources;
+};
+
+// src/lib/x402/networks.ts
+var X402_NETWORKS = [
+  {
+    caip2: "eip155:8453",
+    slug: "base",
+    label: "Base",
+    usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    domainName: "USD Coin",
+    domainVersion: "2",
+    viemChain: "base",
+    nativeGas: "ETH",
+    confusable: "USDbC"
+  },
+  {
+    caip2: "eip155:84532",
+    slug: "base-sepolia",
+    label: "Base Sepolia",
+    usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    domainName: "USDC",
+    domainVersion: "2",
+    viemChain: "baseSepolia",
+    nativeGas: "ETH",
+    confusable: null
+  },
+  {
+    caip2: "eip155:43114",
+    slug: "avalanche",
+    label: "Avalanche",
+    usdc: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+    domainName: "USD Coin",
+    domainVersion: "2",
+    viemChain: "avalanche",
+    nativeGas: "AVAX",
+    confusable: "USDC.e"
+  },
+  {
+    caip2: "eip155:43113",
+    slug: "avalanche-fuji",
+    label: "Avalanche Fuji",
+    usdc: "0x5425890298aed601595a70AB815c96711a31Bc65",
+    domainName: "USD Coin",
+    domainVersion: "2",
+    viemChain: "avalancheFuji",
+    nativeGas: "AVAX",
+    confusable: null
+  },
+  {
+    caip2: "eip155:137",
+    slug: "polygon",
+    label: "Polygon",
+    usdc: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+    domainName: "USD Coin (PoS)",
+    domainVersion: "2",
+    viemChain: "polygon",
+    nativeGas: "POL",
+    confusable: "USDC.e"
+  },
+  {
+    caip2: "eip155:80002",
+    slug: "polygon-amoy",
+    label: "Polygon Amoy",
+    usdc: "0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582",
+    domainName: "USDC",
+    domainVersion: "2",
+    viemChain: "polygonAmoy",
+    nativeGas: "POL",
+    confusable: null
+  }
+];
+function x402NetworkByCaip2(caip2) {
+  return BY_CAIP2.get(caip2);
+}
+function x402NetworkBySlug(slug) {
+  return BY_SLUG.get(slug);
+}
+function x402NetworkLabel(network) {
+  const spec = x402NetworkByCaip2(network);
+  return spec ? `${spec.label} (${network})` : network;
+}
+function x402NetworkListForCopy() {
+  return X402_NETWORKS.map((n) => `${n.caip2} (${n.label})`).join(", ");
+}
+function assertSupportedX402Network(network) {
+  if (x402NetworkByCaip2(network)) return;
+  throw new DvmError(
+    "unsupported_network",
+    `Unsupported x402 network: ${network}.`,
+    `${x402SupportedNetworksHint()} If a wallet is connected, run 'dvm wallet x402-network <caip2>'. For a first connection, pass --network to 'dvm wallet x402-connect'.`
+  );
+}
+function x402SupportedNetworksHint() {
+  return `This rail settles native USDC on: ${x402NetworkListForCopy()}.`;
+}
+var BY_CAIP2 = new Map(X402_NETWORKS.map((n) => [n.caip2, n]));
+var BY_SLUG = new Map(X402_NETWORKS.map((n) => [n.slug, n]));
+
+// src/lib/x402/facilitator.ts
+import { createPrivateKey, randomBytes } from "crypto";
+import { HTTPFacilitatorClient } from "@x402/core/server";
+import { importJWK, importPKCS8, SignJWT } from "jose";
+var AUTH_HEADER_TTL_MS = 6e4;
+var AUTH_TOKEN_TTL_SECONDS = 120;
+var FACILITATOR_PATHS = {
+  verify: "POST",
+  settle: "POST",
+  supported: "GET"
+};
+function createX402FacilitatorAuthHeaders(config) {
+  const auth = config.facilitatorAuth;
+  if (!auth) return void 0;
+  const facilitator = new URL(config.facilitator ?? X402_DEFAULT_FACILITATOR);
+  const basePath = facilitator.pathname.replace(/\/+$/, "");
+  let cached;
+  return async () => {
+    const nowMs = Date.now();
+    if (cached && nowMs < cached.refreshAtMs) return cached.headers;
+    const entries = await Promise.all(
+      Object.entries(FACILITATOR_PATHS).map(async ([path, method]) => {
+        const requestPath = `${basePath}/${path}`;
+        const jwt = await generateCdpJwt(
+          auth.keyId,
+          auth.keySecret,
+          `${method} ${facilitator.host}${requestPath}`
+        );
+        return [path, { Authorization: `Bearer ${jwt}` }];
+      })
+    );
+    const headers = Object.fromEntries(entries);
+    cached = { headers, refreshAtMs: nowMs + AUTH_HEADER_TTL_MS };
+    return headers;
+  };
+}
+function createX402FacilitatorClient(config, opts = {}) {
+  return new HTTPFacilitatorClient({
+    url: config.facilitator ?? X402_DEFAULT_FACILITATOR,
+    ...opts.timeoutMs !== void 0 ? { timeoutMs: opts.timeoutMs } : {},
+    ...config.facilitatorAuth ? { createAuthHeaders: createX402FacilitatorAuthHeaders(config) } : {}
+  });
+}
+async function generateCdpJwt(keyId, keySecret, uri) {
+  const now = Math.floor(Date.now() / 1e3);
+  const nonce = randomBytes(16).toString("hex");
+  const claims = { sub: keyId, iss: "cdp", uris: [uri] };
+  try {
+    const ecKey = await importPKCS8(normalizeEs256KeySecret(keySecret), "ES256");
+    return await new SignJWT(claims).setProtectedHeader({ alg: "ES256", kid: keyId, typ: "JWT", nonce }).setIssuedAt(now).setNotBefore(now).setExpirationTime(now + AUTH_TOKEN_TTL_SECONDS).sign(ecKey);
+  } catch {
+  }
+  const decoded = Buffer.from(keySecret, "base64");
+  if (decoded.length !== 64) {
+    throw new Error("Invalid CDP key secret: expected an ES256 PEM or base64 Ed25519 key");
+  }
+  const jwk = {
+    kty: "OKP",
+    crv: "Ed25519",
+    d: decoded.subarray(0, 32).toString("base64url"),
+    x: decoded.subarray(32).toString("base64url")
+  };
+  const edKey = await importJWK(jwk, "EdDSA");
+  return new SignJWT(claims).setProtectedHeader({ alg: "EdDSA", kid: keyId, typ: "JWT", nonce }).setIssuedAt(now).setNotBefore(now).setExpirationTime(now + AUTH_TOKEN_TTL_SECONDS).sign(edKey);
+}
+function normalizeEs256KeySecret(keySecret) {
+  if (!keySecret.includes("-----BEGIN EC PRIVATE KEY-----")) return keySecret;
+  return createPrivateKey(keySecret).export({ format: "pem", type: "pkcs8" });
+}
+
+// src/lib/x402/spec.ts
+var X402_VERSION = 2;
+var X402_V1_VERSION = 1;
+var X402_DEFAULT_NETWORK = "eip155:8453";
+var X402_EXACT_SCHEME = "exact";
+var X402_BATCH_SETTLEMENT_SCHEME = "batch-settlement";
+function buildPaymentRequirements(opts) {
+  const { x402Config, requiredUsdcMicro, resource, description, mimeType } = opts;
+  const version = opts.version ?? X402_VERSION;
+  const network = version === X402_V1_VERSION ? caip2ToX402Network(x402Config.network) : x402Config.network;
+  const usdcContract = usdcContractByCaip2(x402Config.network);
+  const configuredAsset = x402Config.asset;
+  const asset = version === X402_VERSION && configuredAsset?.toUpperCase() === "USDC" ? usdcContract ?? configuredAsset : configuredAsset ?? usdcContract ?? "USDC";
+  const extra = paymentRequirementExtra(x402Config.network, asset, usdcContract, version);
+  if (version === X402_VERSION) {
+    return {
+      scheme: "exact",
+      network,
+      amount: requiredUsdcMicro.toString(),
+      payTo: x402Config.payTo,
+      asset,
+      maxTimeoutSeconds: 60,
+      extra
+    };
+  }
+  return {
+    scheme: "exact",
+    network,
+    maxAmountRequired: requiredUsdcMicro.toString(),
+    resource,
+    description: description ?? x402Config.description ?? "",
+    mimeType: mimeType ?? "application/json",
+    payTo: x402Config.payTo,
+    asset,
+    maxTimeoutSeconds: 60,
+    ...Object.keys(extra).length > 0 ? { extra } : {}
+  };
+}
+function buildPaymentRequiredV2(opts) {
+  const description = opts.description ?? opts.x402Config.description ?? "";
+  const mimeType = opts.mimeType ?? "application/json";
+  return {
+    x402Version: X402_VERSION,
+    ...opts.error ? { error: opts.error } : {},
+    resource: {
+      url: opts.resource,
+      ...description ? { description } : {},
+      ...mimeType ? { mimeType } : {}
+    },
+    accepts: [buildPaymentRequirements({ ...opts, version: X402_VERSION })],
+    extensions: {}
+  };
+}
+function paymentRequiredV2FromV1(requirements, error) {
+  const first = requirements.at(0);
+  if (!first) throw new Error("Cannot build PAYMENT-REQUIRED without requirements");
+  return {
+    x402Version: X402_VERSION,
+    ...error ? { error } : {},
+    resource: {
+      url: first.resource,
+      ...first.description ? { description: first.description } : {},
+      ...first.mimeType ? { mimeType: first.mimeType } : {}
+    },
+    accepts: requirements.map((requirement) => {
+      const network = x402NetworkBySlug(requirement.network)?.caip2 ?? requirement.network;
+      const usdcContract = usdcContractByCaip2(network);
+      const asset = requirement.asset.toUpperCase() === "USDC" ? usdcContract ?? requirement.asset : requirement.asset;
+      return {
+        scheme: "exact",
+        network,
+        amount: requirement.maxAmountRequired,
+        asset,
+        payTo: requirement.payTo,
+        maxTimeoutSeconds: requirement.maxTimeoutSeconds,
+        extra: {
+          ...requirement.extra,
+          ...paymentRequirementExtra(network, asset, usdcContract, X402_VERSION),
+          assetTransferMethod: "eip3009"
+        }
+      };
+    }),
+    extensions: {}
+  };
+}
+function caip2ToX402Network(network) {
+  return x402NetworkByCaip2(network)?.slug ?? network;
+}
+function x402NetworkToCaip2(network) {
+  return x402NetworkBySlug(network)?.caip2 ?? network;
+}
+function chainIdFromCaip2(network) {
+  const parts = network.split(":");
+  return Number.parseInt(parts[1] ?? "8453", 10);
+}
+function usdcContractFor(networkSlug) {
+  return x402NetworkBySlug(networkSlug)?.usdc;
+}
+function usdcContractByCaip2(caip2) {
+  return x402NetworkByCaip2(caip2)?.usdc;
+}
+function usdcDomainNameFor(networkSlug) {
+  return x402NetworkBySlug(networkSlug)?.domainName;
+}
+function usdcDomainVersionFor(networkSlug) {
+  return x402NetworkBySlug(networkSlug)?.domainVersion;
+}
+function decodePayment(header) {
+  const decoded = Buffer.from(header, "base64").toString("utf-8");
+  const parsed = JSON.parse(decoded);
+  if (!parsed || typeof parsed !== "object") throw new Error("Invalid payment header shape");
+  const version = parsed.x402Version;
+  const scheme = version === X402_V1_VERSION ? parsed.scheme : version === X402_VERSION && isRecord(parsed.accepted) ? parsed.accepted.scheme : void 0;
+  if (typeof scheme !== "string") throw new Error("Invalid payment scheme");
+  const decoder = PAYMENT_SCHEME_DECODERS[scheme];
+  if (!decoder) throw new Error(`Unsupported x402 payment scheme: ${scheme}`);
+  return decoder(parsed);
+}
+function encodePayment(payload) {
+  return Buffer.from(JSON.stringify(payload), "utf-8").toString("base64");
+}
+function encodePaymentRequiredHeader(required) {
+  return Buffer.from(JSON.stringify(required), "utf-8").toString("base64");
+}
+function decodePaymentRequiredHeader(header) {
+  const parsed = JSON.parse(Buffer.from(header, "base64").toString("utf-8"));
+  if (!isRecord(parsed) || parsed.x402Version !== X402_VERSION || !isRecord(parsed.resource)) {
+    throw new Error("Invalid PAYMENT-REQUIRED header shape");
+  }
+  if (typeof parsed.resource.url !== "string" || !Array.isArray(parsed.accepts)) {
+    throw new Error("Invalid PAYMENT-REQUIRED header shape");
+  }
+  for (const requirement of parsed.accepts) validateV2Requirements(requirement);
+  return parsed;
+}
+function exactEvmAuthorization(payload) {
+  return payload.payload.authorization;
+}
+function encodeSettleResponseHeader(response) {
+  return Buffer.from(JSON.stringify(response), "utf-8").toString("base64");
+}
+async function verifyWithFacilitator(payload, requirements, config = {}, createAuthHeaders = createX402FacilitatorAuthHeaders(config)) {
+  const facilitator = config.facilitator ?? X402_DEFAULT_FACILITATOR;
+  const url = facilitator.replace(/\/$/, "") + "/verify";
+  return callerLoggers.x402.span(
+    "x402.verify_with_facilitator",
+    { facilitator_url: url },
+    async () => {
+      const authHeaders = (await createAuthHeaders?.())?.verify ?? {};
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...authHeaders },
+        body: JSON.stringify({
+          x402Version: payload.x402Version,
+          paymentPayload: payload,
+          paymentRequirements: requirements
+        })
+      });
+      if (!res.ok) {
+        const rejection = await readFacilitatorRejection(res);
+        if (rejection?.isValid === false && typeof rejection.invalidReason === "string" && rejection.invalidReason.length > 0) {
+          return rejection;
+        }
+        return { isValid: false, invalidReason: `facilitator_status_${res.status}` };
+      }
+      const data = await res.json();
+      callerLoggers.x402.info("x402.verify_with_facilitator.result", { is_valid: data.isValid });
+      return data;
+    }
+  );
+}
+async function settleWithFacilitator(payload, requirements, config = {}, createAuthHeaders = createX402FacilitatorAuthHeaders(config)) {
+  const facilitator = config.facilitator ?? X402_DEFAULT_FACILITATOR;
+  const url = facilitator.replace(/\/$/, "") + "/settle";
+  return callerLoggers.x402.span(
+    "x402.settle_with_facilitator",
+    { facilitator_url: url },
+    async () => {
+      const authHeaders = (await createAuthHeaders?.())?.settle ?? {};
+      const res = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json", ...authHeaders },
+        body: JSON.stringify({
+          x402Version: payload.x402Version,
+          paymentPayload: payload,
+          paymentRequirements: requirements
+        })
+      });
+      if (!res.ok) {
+        const rejection = await readFacilitatorRejection(res);
+        if (rejection?.success === false && typeof rejection.errorReason === "string" && rejection.errorReason.length > 0) {
+          return rejection;
+        }
+        return { success: false, errorReason: `facilitator_status_${res.status}` };
+      }
+      const data = await res.json();
+      callerLoggers.x402.info("x402.settle_with_facilitator.result", {
+        success: data.success,
+        tx_hash: data.transaction
+      });
+      return data;
+    }
+  );
+}
+async function readFacilitatorRejection(res) {
+  if (res.status !== 400) return null;
+  try {
+    const body = await res.json();
+    return isRecord(body) ? body : null;
+  } catch {
+    return null;
+  }
+}
+var PAYMENT_SCHEME_DECODERS = {
+  exact: decodeExactPayment
+};
+function decodeExactPayment(parsed) {
+  validateExactEvmPayload(parsed.payload);
+  if (parsed.x402Version === X402_V1_VERSION) {
+    if (parsed.scheme !== "exact" || typeof parsed.network !== "string") {
+      throw new Error("Invalid x402 v1 exact payload");
+    }
+    return parsed;
+  }
+  if (parsed.x402Version === X402_VERSION) {
+    validateV2Requirements(parsed.accepted);
+    if (parsed.resource !== void 0 && !isResourceInfo(parsed.resource)) {
+      throw new Error("Invalid x402 v2 resource");
+    }
+    if (parsed.extensions !== void 0 && !isRecord(parsed.extensions)) {
+      throw new Error("Invalid x402 v2 extensions");
+    }
+    return parsed;
+  }
+  throw new Error(`Unsupported x402 version: ${String(parsed.x402Version)}`);
+}
+function validateV2Requirements(value) {
+  if (!isRecord(value) || typeof value.scheme !== "string" || typeof value.network !== "string" || typeof value.amount !== "string" || typeof value.asset !== "string" || typeof value.payTo !== "string" || typeof value.maxTimeoutSeconds !== "number" || !isOptionalRecord(value.extra)) {
+    throw new Error("Invalid x402 v2 payment requirements");
+  }
+}
+function validateExactEvmPayload(value) {
+  if (!isRecord(value) || typeof value.signature !== "string" || !isRecord(value.authorization)) {
+    throw new Error("Invalid exact EVM payload");
+  }
+  const authorization = value.authorization;
+  for (const field of ["from", "to", "value", "validAfter", "validBefore", "nonce"]) {
+    if (typeof authorization[field] !== "string") throw new Error("Invalid exact authorization");
+  }
+}
+function paymentRequirementExtra(caip2, asset, usdcContract, version) {
+  if (asset.toLowerCase() !== usdcContract?.toLowerCase()) return {};
+  const network = x402NetworkByCaip2(caip2);
+  if (!network) return {};
+  return {
+    ...version === X402_VERSION ? { assetTransferMethod: "eip3009" } : {},
+    name: network.domainName,
+    version: network.domainVersion
+  };
+}
+function isResourceInfo(value) {
+  return isRecord(value) && typeof value.url === "string";
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function isOptionalRecord(value) {
+  return value === void 0 || value === null || isRecord(value);
+}
+
+// src/lib/credit-implicit.ts
+var IMPLICIT_CREDIT_TTL_MS = 30 * 24 * 60 * 60 * 1e3;
+
+// src/lib/currency.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { dirname } from "path";
+
+// src/defaults.ts
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = process.env.DVM_CONFIG_DIR ?? join(homedir(), ".dvm");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+var CONFIG_BACKUP_FILE = join(CONFIG_DIR, "config.json.bak");
+var CONFIG_AUDIT_FILE = join(CONFIG_DIR, "config-audit.jsonl");
+var CONFIG_PINNED_FILE = join(CONFIG_DIR, "config.json.pinned");
+var JOBS_FILE = join(CONFIG_DIR, "jobs.json");
+var REQUEST_INTENTS_DIR = join(CONFIG_DIR, "request-intents");
+var FAVORITES_FILE = join(CONFIG_DIR, "favorites.json");
+var MESSAGES_DIR = join(CONFIG_DIR, "messages");
+var RECEIPTS_FILE = join(CONFIG_DIR, "receipts.jsonl");
+var CREDITS_FILE = join(CONFIG_DIR, "credits.json");
+var X402_CHANNELS_FILE = join(CONFIG_DIR, "x402-channels.json");
+var TEMPO_CHANNELS_FILE = join(CONFIG_DIR, "tempo-channels.json");
+var FEEDBACK_NUDGES_FILE = join(CONFIG_DIR, "feedback-nudges.json");
+var RECOVERY_MNEMONIC_FILE = join(CONFIG_DIR, "recovery.mnemonic");
+var WALLET_FILE = join(CONFIG_DIR, "wallet.json");
+var AGENT_MNEMONIC_FILE = join(CONFIG_DIR, "wallet.mnemonic");
+var IDENTITIES_FILE = join(CONFIG_DIR, "identities.json");
+var PAIRINGS_DIR = join(CONFIG_DIR, "pairings");
+var BUDGET_FILE = join(CONFIG_DIR, "budget.json");
+var BTC_RATE_FILE = join(CONFIG_DIR, "btc-rate.json");
+var ADMIN_DIR = join(CONFIG_DIR, "admin");
+var PROXY_STATE_FILE = join(ADMIN_DIR, "proxy.json");
+var BUILDER_CONFIG_DIR = process.env.DVMKIT_CONFIG_DIR ?? join(homedir(), ".dvmkit");
+var BUILDER_FILE = join(BUILDER_CONFIG_DIR, "builder.json");
+var BUILDER_MNEMONIC_FILE = join(BUILDER_CONFIG_DIR, "recovery.mnemonic");
+var BUILDER_KEY_FILE = join(BUILDER_CONFIG_DIR, "builder.key");
+var MELT_PENDING_LOG_FILE = join(BUILDER_CONFIG_DIR, "melt-pending.log");
+var DRAIN_PARK_LOG_FILE = join(BUILDER_CONFIG_DIR, "drain-park.log");
+var DRAIN_HOLD_STATE_FILE = join(BUILDER_CONFIG_DIR, "drain-hold.json");
+var MELT_SUCCESS_FILE = join(BUILDER_CONFIG_DIR, "melt-success.json");
+
+// src/lib/config-dir.ts
+import { chmodSync, mkdirSync, statSync } from "fs";
+var CONFIG_DIR_MODE = 448;
+function ensureConfigDir() {
+  ensureConfigSubdir(CONFIG_DIR);
+}
+function ensureConfigSubdir(path) {
+  mkdirSync(path, { recursive: true, mode: CONFIG_DIR_MODE });
+}
+
+// src/lib/fx-coingecko.ts
+var COINGECKO_BTC_USD_URL = "https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=usd";
+var DEFAULT_TIMEOUT_MS = 5e3;
+var DEFAULT_USER_AGENT = "dvmkit-platform/1.0 (+https://dvmkit.com)";
+async function fetchCoinGeckoBtcUsd(opts) {
+  const body = await fetchCoinGeckoBody(opts, COINGECKO_BTC_USD_URL);
+  const btc = body.bitcoin?.usd;
+  if (!isPositiveNumber(btc)) {
+    throw new Error("coingecko response missing bitcoin.usd");
+  }
+  return { btc_usd: btc, as_of: (/* @__PURE__ */ new Date()).toISOString() };
+}
+async function fetchCoinGeckoBody(opts, defaultUrl) {
+  const url = opts?.url ?? defaultUrl;
+  const fetchImpl = opts?.fetchImpl ?? fetch;
+  const timeoutMs = opts?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  const userAgent = opts?.userAgent ?? DEFAULT_USER_AGENT;
+  const res = await fetchImpl(url, {
+    headers: { "User-Agent": userAgent, Accept: "application/json" },
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  if (!res.ok) {
+    throw new Error(`coingecko returned HTTP ${res.status.toString()}`);
+  }
+  return await res.json();
+}
+function isPositiveNumber(v) {
+  return typeof v === "number" && Number.isFinite(v) && v > 0;
+}
+
+// src/lib/currency.ts
+function msatsToUsd(msats, rate) {
+  return msats / 1e11 * rate;
+}
+function usdToMsats(usd, rate) {
+  return Math.round(usd / rate * 1e11);
+}
+function msatsToUsdc(msats, btcUsdRate) {
+  const usd = msatsToUsd(msats, btcUsdRate);
+  return Math.ceil(usd * 1e6);
+}
+function usdcToMsats(usdc, btcUsdRate) {
+  return usdToMsats(usdc, btcUsdRate);
+}
+var COST_ANCHOR_BANDS = {
+  usd: [0.01, 0.1, 1, 10],
+  eur: [0.01, 0.1, 1, 10],
+  gbp: [0.01, 0.1, 1, 10],
+  jpy: [1, 10, 100, 1500]
+};
+function costAnchor(amount, currency = "usd") {
+  const bands = COST_ANCHOR_BANDS[currency] ?? COST_ANCHOR_BANDS.usd;
+  if (amount < bands[0]) return "fraction of a cent";
+  if (amount <= bands[1]) return "comparable to an API call";
+  if (amount <= bands[2]) return "comparable to a ChatGPT query";
+  if (amount <= bands[3]) return "comparable to a coffee";
+  return "significant purchase \u2014 review carefully";
+}
+function formatUsd(usd) {
+  if (usd === 0) return "0.00";
+  if (usd >= 0.01) return usd.toFixed(2);
+  const digits = Math.max(2, -Math.floor(Math.log10(usd)) + 1);
+  return usd.toFixed(digits);
+}
+async function fetchBtcUsdRate() {
+  if (memRate && Date.now() - memTime < CACHE_TTL) {
+    return memRate;
+  }
+  const disk = readDiskCache();
+  if (disk) {
+    memRate = disk;
+    memTime = Date.now();
+    return disk;
+  }
+  const rate = await fetchFromApi();
+  memRate = rate;
+  memTime = Date.now();
+  writeDiskCache(rate);
+  return rate;
+}
+function getLastKnownBtcRate() {
+  if (memRate && memTime > 0) return { rate: memRate, cachedAt: memTime };
+  return readDiskCacheStale();
+}
+function formatStaleness(cachedAt, now = Date.now()) {
+  const ageMs = Math.max(0, now - cachedAt);
+  const seconds = Math.floor(ageMs / 1e3);
+  if (seconds < 60) return `${seconds}s ago`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes} min ago`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 24) return `${hours} hour${hours === 1 ? "" : "s"} ago`;
+  const days = Math.floor(hours / 24);
+  return `${days} day${days === 1 ? "" : "s"} ago`;
+}
+var CACHE_TTL = 5 * 60 * 1e3;
+var CACHE_FILE = BTC_RATE_FILE;
+var memRate = null;
+var memTime = 0;
+function readDiskCache() {
+  try {
+    if (!existsSync(CACHE_FILE)) return null;
+    const data = JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+    if (Date.now() - data.timestamp >= CACHE_TTL) return null;
+    if (!isPlausibleBtcUsdRate(data.rate)) return null;
+    return data.rate;
+  } catch {
+    return null;
+  }
+}
+function readDiskCacheStale() {
+  try {
+    if (!existsSync(CACHE_FILE)) return null;
+    const data = JSON.parse(readFileSync(CACHE_FILE, "utf-8"));
+    if (!isPlausibleBtcUsdRate(data.rate)) return null;
+    return { rate: data.rate, cachedAt: data.timestamp };
+  } catch {
+    return null;
+  }
+}
+function writeDiskCache(rate) {
+  try {
+    ensureConfigSubdir(dirname(CACHE_FILE));
+    writeFileSync(CACHE_FILE, JSON.stringify({ rate, timestamp: Date.now() }));
+  } catch {
+  }
+}
+var MAX_PLAUSIBLE_BTC_USD = 1e7;
+function isPlausibleBtcUsdRate(rate) {
+  return typeof rate === "number" && Number.isFinite(rate) && rate > 0 && rate < MAX_PLAUSIBLE_BTC_USD;
+}
+async function fetchFromApi() {
+  const spot = await fetchCoinGeckoBtcUsd();
+  const rate = spot.btc_usd;
+  if (!isPlausibleBtcUsdRate(rate)) {
+    throw new Error(`implausible BTC/USD rate from upstream: ${String(rate)}`);
+  }
+  return rate;
+}
+
+// src/lib/payment-rails/rpc.ts
+function resolveRpcOverride(envValue, bundled) {
+  const override = envValue?.trim() ?? "";
+  return override.length > 0 ? { url: override, source: "override" } : { url: bundled, source: "bundled" };
+}
+function resolveRpcHttpTransportOptions(source, envValue) {
+  if (source !== "override" || !envValue?.trim()) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(envValue);
+  } catch {
+    throw new Error("RPC headers must be a JSON object of non-empty string values.");
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+    throw new Error("RPC headers must be a JSON object of non-empty string values.");
+  const headers = {};
+  for (const [name, value] of Object.entries(parsed)) {
+    if (!/^[!#$%&'*+.^_`|~0-9A-Za-z-]+$/.test(name) || typeof value !== "string" || value.length === 0 || /[\r\n]/.test(value))
+      throw new Error("RPC headers must be a JSON object of non-empty string values.");
+    headers[name] = value;
+  }
+  if (Object.keys(headers).length === 0)
+    throw new Error("RPC headers must be a JSON object of non-empty string values.");
+  return { fetchOptions: { headers } };
+}
+
+export {
+  X402_DEFAULT_FACILITATOR,
+  createX402FacilitatorAuthHeaders,
+  createX402FacilitatorClient,
+  DvmError,
+  X402_NETWORKS,
+  x402NetworkByCaip2,
+  x402NetworkLabel,
+  x402NetworkListForCopy,
+  assertSupportedX402Network,
+  x402SupportedNetworksHint,
+  X402_VERSION,
+  X402_V1_VERSION,
+  X402_DEFAULT_NETWORK,
+  X402_EXACT_SCHEME,
+  X402_BATCH_SETTLEMENT_SCHEME,
+  buildPaymentRequirements,
+  buildPaymentRequiredV2,
+  paymentRequiredV2FromV1,
+  caip2ToX402Network,
+  x402NetworkToCaip2,
+  chainIdFromCaip2,
+  usdcContractFor,
+  usdcContractByCaip2,
+  usdcDomainNameFor,
+  usdcDomainVersionFor,
+  decodePayment,
+  encodePayment,
+  encodePaymentRequiredHeader,
+  decodePaymentRequiredHeader,
+  exactEvmAuthorization,
+  encodeSettleResponseHeader,
+  verifyWithFacilitator,
+  settleWithFacilitator,
+  IMPLICIT_CREDIT_TTL_MS,
+  CONFIG_FILE,
+  CONFIG_BACKUP_FILE,
+  CONFIG_AUDIT_FILE,
+  CONFIG_PINNED_FILE,
+  X402_CHANNELS_FILE,
+  WALLET_FILE,
+  AGENT_MNEMONIC_FILE,
+  ensureConfigDir,
+  msatsToUsd,
+  msatsToUsdc,
+  usdcToMsats,
+  costAnchor,
+  formatUsd,
+  fetchBtcUsdRate,
+  getLastKnownBtcRate,
+  formatStaleness,
+  resolveRpcOverride,
+  resolveRpcHttpTransportOptions
+};