@dvmkit/sdk 0.6.0-rc.1 → 0.7.0-rc.10

package/dist/{chunk-IWQHUSMO.js → chunk-62FI3NJF.js}

@@ -1,7 +1,7 @@
 import {
   x402NetworkByCaip2,
   x402NetworkBySlug
-} from "./chunk-RLTSCKRI.js";
+} from "./chunk-BPYMEMQX.js";
 
 // src/lib/x402/constants.ts
 var X402_DEFAULT_FACILITATOR = "https://x402.org/facilitator";
@@ -204,6 +204,73 @@ function isOptionalRecord(value) {
   return value === void 0 || value === null || isRecord(value);
 }
 
+// src/lib/payment-amounts.ts
+function msatsToUsd(msats, rate) {
+  return msats / 1e11 * rate;
+}
+function usdToMsats(usd, rate) {
+  return Math.round(usd / rate * 1e11);
+}
+function msatsToUsdCents(msats, btcPriceUsd) {
+  const usd = msatsToUsd(msats, btcPriceUsd);
+  return Math.round(usd * 100);
+}
+function msatsToUsdc(msats, btcUsdRate) {
+  if (!Number.isSafeInteger(msats) || msats < 0) {
+    throw new RangeError("msats must be a non-negative safe integer");
+  }
+  if (!Number.isFinite(btcUsdRate) || btcUsdRate <= 0) {
+    throw new RangeError("BTC/USD rate must be finite and positive");
+  }
+  const [mantissa, exponent = "0"] = btcUsdRate.toString().split("e");
+  const decimalPlaces = mantissa.split(".")[1]?.length ?? 0;
+  const shift = Number(exponent) - decimalPlaces;
+  let numerator = BigInt(msats) * BigInt(mantissa.replace(".", ""));
+  let denominator = 100000n;
+  if (shift > 0) numerator *= 10n ** BigInt(shift);
+  else if (shift < 0) denominator *= 10n ** BigInt(-shift);
+  const micro = (numerator + denominator - 1n) / denominator;
+  if (micro > BigInt(Number.MAX_SAFE_INTEGER)) {
+    throw new RangeError("USDC micro-unit amount exceeds the safe integer range");
+  }
+  return Number(micro);
+}
+function usdcToMsats(usdc, btcUsdRate) {
+  return usdToMsats(usdc, btcUsdRate);
+}
+function msatsToMicro(msats, btcRate) {
+  return Math.round(msatsToUsd(msats, btcRate) * 1e6);
+}
+function microToSats(micro, btcRate) {
+  return Math.ceil(usdToMsats(micro / 1e6, btcRate) / 1e3);
+}
+
+// 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,
   X402_VERSION,
@@ -226,5 +293,14 @@ export {
   encodePaymentRequiredHeader,
   decodePaymentRequiredHeader,
   exactEvmAuthorization,
-  encodeSettleResponseHeader
+  encodeSettleResponseHeader,
+  msatsToUsd,
+  usdToMsats,
+  msatsToUsdCents,
+  msatsToUsdc,
+  usdcToMsats,
+  msatsToMicro,
+  microToSats,
+  resolveRpcOverride,
+  resolveRpcHttpTransportOptions
 };

package/dist/chunk-6HJEVCVI.js

@@ -0,0 +1,17 @@
+import {
+  validateCurrency
+} from "./chunk-HPCXF3DV.js";
+
+// src/sdk/pricing/upfront.ts
+function buildUpfront(input) {
+  const currency = validateCurrency(input.currency);
+  const amount = input.amount;
+  if (!Number.isFinite(amount) || amount < 0) {
+    throw new Error(`invalid upfront amount: ${String(amount)} (must be a non-negative number)`);
+  }
+  return { amount, currency };
+}
+
+export {
+  buildUpfront
+};

package/dist/chunk-A262WVYX.js

@@ -0,0 +1,6 @@
+// src/lib/wire-schema.ts
+var CAPABILITY_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
+
+export {
+  CAPABILITY_NAME_RE
+};

package/dist/{chunk-RLTSCKRI.js → chunk-BPYMEMQX.js}

@@ -1,6 +1,49 @@
-import {
-  DvmError
-} from "./chunk-LIRAHP7B.js";
+// 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;
+};
+function providerProseSources(...sources) {
+  const provenance = {};
+  for (const source of sources) {
+    if (!source) continue;
+    for (const field of ["message", "hint", "display"]) {
+      if (typeof source[field] === "string") provenance[field] = "provider";
+    }
+  }
+  return Object.keys(provenance).length > 0 ? provenance : void 0;
+}
+function isAbortError(err) {
+  return err instanceof Error && (err.name === "AbortError" || err.name === "TimeoutError");
+}
+function transportErrorCode(err) {
+  let current = err;
+  const seen = /* @__PURE__ */ new Set();
+  for (let depth = 0; depth < 5 && isErrorLike(current) && !seen.has(current); depth++) {
+    seen.add(current);
+    const code = current.code;
+    if (typeof code === "string" && /^(?:E[A-Z0-9_]{1,63}|UND_ERR_[A-Z0-9_]{1,63})$/.test(code)) {
+      return code;
+    }
+    current = current.cause;
+  }
+  return void 0;
+}
+function isErrorLike(value) {
+  return (typeof value === "object" || typeof value === "function") && value !== null;
+}
 
 // src/lib/x402/networks.ts
 var X402_NETWORKS = [
@@ -99,6 +142,10 @@ var BY_CAIP2 = new Map(X402_NETWORKS.map((n) => [n.caip2, n]));
 var BY_SLUG = new Map(X402_NETWORKS.map((n) => [n.slug, n]));
 
 export {
+  DvmError,
+  providerProseSources,
+  isAbortError,
+  transportErrorCode,
   X402_NETWORKS,
   x402NetworkByCaip2,
   x402NetworkBySlug,

package/dist/{chunk-IV6Q7NRW.js → chunk-C5RIQWG4.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-AFV77S4C.js";
 import {
   loggers
-} from "./chunk-QR2EF2NI.js";
+} from "./chunk-KCQDXIJU.js";
 import {
   redactUrl
 } from "./chunk-FUJ36YDV.js";

package/dist/{chunk-GAOAYHZA.js → chunk-FBQVOOYF.js}

@@ -1,12 +1,24 @@
+import {
+  diagnosticConsole
+} from "./chunk-ZCNPIILZ.js";
 import {
   withSdkInitLock
 } from "./chunk-COYKJRMM.js";
-import {
-  diagnosticConsole
-} from "./chunk-ETXDTUJO.js";
 
 // src/sdk/server/payout-reporter.ts
 import { createHash, randomUUID } from "crypto";
+async function x402EarnedCeiling(channel, earnedNative) {
+  let earned;
+  try {
+    earned = await earnedNative(channel.channelId.toLowerCase());
+  } catch (error) {
+    return { kind: "unresolved", error };
+  }
+  if (earned === void 0) return { kind: "unbound" };
+  const charged = BigInt(channel.chargedCumulativeAmount);
+  const wanted = BigInt(earned);
+  return { kind: "ceiling", ceiling: wanted < charged ? wanted : charged };
+}
 var MemoryX402BatchStore = class {
   batches = /* @__PURE__ */ new Map();
   get(scope) {
@@ -719,7 +731,8 @@ var PayoutReporter = class {
   }
   /**
    * x402: the open batch (claimed, not yet transferred) plus every channel's
-   * unclaimed voucher value; wedged when the settle keeps failing, and the
+   * earned value not yet claimed — a channel whose earned figure cannot be
+   * read contributes nothing; wedged when the settle keeps failing, and the
    * refund settlements stuck between chain and ledger beside it.
    */
   async snapshotX402() {
@@ -751,12 +764,29 @@ var PayoutReporter = class {
       }
       const unclaimed = [];
       for (const channel of await ctx.storage.list()) {
-        const owed = BigInt(channel.chargedCumulativeAmount) - BigInt(channel.totalClaimed);
+        const claimed = BigInt(channel.totalClaimed);
+        if (BigInt(channel.chargedCumulativeAmount) <= claimed) continue;
+        let resolved;
+        try {
+          resolved = await x402EarnedCeiling(channel, ctx.earnedNative);
+        } catch (err) {
+          resolved = { kind: "unresolved", error: err };
+        }
+        if (resolved.kind === "unresolved") {
+          warn("payout_pending_snapshot_failed", {
+            rail: "x402",
+            "channel.id": channel.channelId,
+            error: message(resolved.error)
+          });
+          continue;
+        }
+        if (resolved.kind === "unbound") continue;
+        const owed = resolved.ceiling - claimed;
         if (owed > 0n) {
           unclaimed.push({
             id: channel.channelId,
             native: Number(owed),
-            label: "unclaimed vouchers"
+            label: "earned, awaiting claim"
           });
         }
       }
@@ -902,6 +932,7 @@ function warn(level, fields) {
 }
 
 export {
+  x402EarnedCeiling,
   MemoryX402BatchStore,
   PostgresX402BatchStore,
   PAYOUT_SNAPSHOT_INTERVAL_MS,

package/dist/{chunk-Z4ZT5LNT.js → chunk-GEI4MAXE.js}

@@ -1,9 +1,9 @@
+import {
+  diagnosticConsole
+} from "./chunk-ZCNPIILZ.js";
 import {
   withSdkInitLock
 } from "./chunk-COYKJRMM.js";
-import {
-  diagnosticConsole
-} from "./chunk-ETXDTUJO.js";
 
 // src/sdk/server/revenue-reporter.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-FYRR2UEZ.js → chunk-GLIAR7RN.js}

@@ -15,7 +15,7 @@ import {
   lotOwedSats,
   netOwedSats,
   x402SettlementPending
-} from "./chunk-JH3SX3LY.js";
+} from "./chunk-IRXIH775.js";
 
 // src/sdk/server/memory-credit-ledger.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-X7EZ5CLI.js → chunk-HCATFJDD.js}

@@ -2,12 +2,12 @@ import {
   parseStoreValue,
   stringifyStoreValue
 } from "./chunk-YG7G4DPZ.js";
+import {
+  withPostgresTransactionRecovery
+} from "./chunk-NV7Z7377.js";
 import {
   withSdkInitLock
 } from "./chunk-COYKJRMM.js";
-import {
-  withPostgresTransactionRecovery
-} from "./chunk-P6QON7ER.js";
 
 // src/sdk/server/tempo-session-store.ts
 import { AsyncLocalStorage } from "async_hooks";

package/dist/{chunk-BYCEKO65.js → chunk-HPCXF3DV.js}

@@ -1,6 +1,6 @@
 import {
   diagnosticConsole
-} from "./chunk-ETXDTUJO.js";
+} from "./chunk-ZCNPIILZ.js";
 
 // src/sdk/pricing/currency.ts
 var InvalidCurrencyError = class extends Error {
@@ -35,6 +35,98 @@ function validateCurrency(raw) {
   return raw;
 }
 
+// src/sdk/pricing/usd.ts
+var InvalidFxRateError = class extends Error {
+  code = "invalid_fx_rate";
+  ratePerBtc;
+  constructor(ratePerBtc) {
+    super(
+      `invalid fx rate ${String(ratePerBtc)} \u2014 expected a finite positive number of fiat per BTC`
+    );
+    this.ratePerBtc = ratePerBtc;
+  }
+};
+function fiatToSatsCeil(amount, ratePerBtc) {
+  if (!Number.isFinite(ratePerBtc) || ratePerBtc <= 0) {
+    throw new InvalidFxRateError(ratePerBtc);
+  }
+  if (!Number.isFinite(amount) || amount < 0) return 0;
+  return Math.ceil(amount * 1e8 / ratePerBtc);
+}
+function satsToFiat(sats, ratePerBtc) {
+  if (!Number.isFinite(ratePerBtc) || ratePerBtc <= 0) {
+    throw new InvalidFxRateError(ratePerBtc);
+  }
+  return sats / 1e8 * ratePerBtc;
+}
+var InvalidUsdPriceError = class extends Error {
+  constructor(field, value, detail) {
+    super(`${field}: ${detail}`);
+    this.field = field;
+    this.value = value;
+    this.name = "InvalidUsdPriceError";
+  }
+  field;
+  value;
+  code = "invalid_usd_price";
+};
+function parseUsdPrice(value, field) {
+  if (!USD_PRICE_RE.test(value)) {
+    throw new InvalidUsdPriceError(
+      field,
+      value,
+      `${JSON.stringify(value)} is not a USD price literal. Use a "$X.XX" string, e.g. "$0.05".`
+    );
+  }
+  const usd = parseFloat(value.slice(1));
+  if (!Number.isFinite(usd) || usd < MIN_USD_PRICE) {
+    throw new InvalidUsdPriceError(
+      field,
+      value,
+      `${JSON.stringify(value)} is below ${MIN_USD_PRICE_LITERAL}, the smallest price the wire can carry \u2014 every price surface rounds to four decimals, so this would advertise as $0 and then charge anyway. Charge at least ${MIN_USD_PRICE_LITERAL}, or omit the price for a free capability.`
+    );
+  }
+  if (roundUsd(usd) !== usd) {
+    throw new InvalidUsdPriceError(
+      field,
+      value,
+      `${JSON.stringify(value)} carries more than four decimal places. Every price surface rounds to four, so this would advertise ${formatUsd(roundUsd(usd))} and charge something else. Use at most four decimals.`
+    );
+  }
+  if (!Number.isSafeInteger(Math.round(usd * 1e6))) {
+    throw new InvalidUsdPriceError(
+      field,
+      value,
+      `${JSON.stringify(value)} is too large to denominate. Use an amount under $9,007,199,254.`
+    );
+  }
+  return usd;
+}
+function roundUsd(usd) {
+  return Math.round(usd * 1e4) / 1e4;
+}
+function formatUsd(usd) {
+  if (usd === 0) return "$0.00";
+  if (usd >= 0.01) return `$${usd.toFixed(2)}`;
+  return `$${usd.toFixed(4)}`;
+}
+function formatFiat(amount, currency) {
+  const code = currency.toUpperCase();
+  const symbol = FIAT_SYMBOLS[currency] ?? "";
+  const digits = currency === "jpy" ? 0 : amount >= 0.01 || amount === 0 ? 2 : 4;
+  const body = `${amount.toFixed(digits)} ${code}`;
+  return symbol ? `${symbol}${body}` : body;
+}
+var USD_PRICE_RE = /^\$\d+(\.\d+)?$/;
+var MIN_USD_PRICE = 1e-4;
+var MIN_USD_PRICE_LITERAL = '"$0.0001"';
+var FIAT_SYMBOLS = {
+  usd: "$",
+  eur: "\u20AC",
+  gbp: "\xA3",
+  jpy: "\xA5"
+};
+
 // src/sdk/pricing/fx.ts
 var DEFAULT_FX_CURRENCIES = ["usd", "eur", "gbp", "jpy"];
 var DEFAULT_FX_RATE_SOURCE = `https://api.coingecko.com/api/v3/simple/price?ids=bitcoin&vs_currencies=${DEFAULT_FX_CURRENCIES.join(",")}`;
@@ -52,14 +144,53 @@ var FxRateUnavailableError = class extends Error {
    * the last-known rate without it. See {@link FxKnownStale}.
    */
   knownStale;
-  constructor(message, copy, knownStale) {
+  sourceFailure;
+  constructor(message, copy, knownStale, sourceFailure) {
     super(message);
     this.name = "FxRateUnavailableError";
     this.display = copy?.display ?? "Couldn't fetch the BTC reference rate to lock pricing";
     this.hint = copy?.hint ?? "transient \u2014 try the quote again in a few seconds";
     this.knownStale = knownStale;
+    this.sourceFailure = normalizeFxSourceFailure(sourceFailure);
   }
 };
+var FX_SOURCE_FAILURE_CATEGORIES = /* @__PURE__ */ new Set([
+  "network_error",
+  "http_error",
+  "invalid_body",
+  "no_usable_rate",
+  "missing_currency",
+  "unknown"
+]);
+function normalizeFxSourceFailure(input) {
+  if (input === void 0) return void 0;
+  try {
+    if (typeof input !== "object" || input === null) return { category: "unknown" };
+    const categoryDescriptor = Object.getOwnPropertyDescriptor(input, "category");
+    const category = categoryDescriptor && "value" in categoryDescriptor ? categoryDescriptor.value : void 0;
+    if (typeof category !== "string" || !FX_SOURCE_FAILURE_CATEGORIES.has(category)) {
+      return { category: "unknown" };
+    }
+    const statusDescriptor = Object.getOwnPropertyDescriptor(input, "httpStatus");
+    const status = statusDescriptor && "value" in statusDescriptor ? statusDescriptor.value : void 0;
+    return {
+      category,
+      ...category === "http_error" && typeof status === "number" && Number.isInteger(status) && status >= 100 && status <= 599 && { httpStatus: status }
+    };
+  } catch {
+    return { category: "unknown" };
+  }
+}
+function readFxSourceFailure(error) {
+  try {
+    const descriptor = Object.getOwnPropertyDescriptor(error, "sourceFailure");
+    if (!descriptor) return void 0;
+    if (!("value" in descriptor)) return { category: "unknown" };
+    return normalizeFxSourceFailure(descriptor.value);
+  } catch {
+    return { category: "unknown" };
+  }
+}
 function createFxFetcher(opts) {
   const currencies = opts?.currencies ?? DEFAULT_FX_CURRENCIES;
   const source = opts?.source ?? DEFAULT_FX_RATE_SOURCE;
@@ -100,7 +231,10 @@ function createFxFetcher(opts) {
           }
         }
         throw new FxRateUnavailableError(
-          lastErr instanceof Error ? lastErr.message : String(lastErr)
+          lastErr instanceof Error ? lastErr.message : String(lastErr),
+          void 0,
+          void 0,
+          lastErr instanceof FxRateUnavailableError ? readFxSourceFailure(lastErr) : { category: "unknown" }
         );
       })();
       inFlight = promise;
@@ -127,7 +261,9 @@ function fxRateFor(snapshot, currency) {
         {
           display: `The ${currency.toUpperCase()} reference rate is unavailable right now.`,
           hint: `The rate source stopped carrying ${currency.toUpperCase()}. Retry in a minute; if it persists the source needs to be reconfigured.`
-        }
+        },
+        void 0,
+        { category: "missing_currency" }
       );
     }
     throw new UnsupportedCurrencyError(currency, Object.keys(snapshot.rates));
@@ -139,19 +275,32 @@ async function fetchOnce(source, currencies, fetchFn) {
   return fetchPlatformShape(source, currencies, fetchFn);
 }
 async function fetchCoinGeckoShape(source, currencies, fetchFn) {
-  const res = await fetchFn(source);
+  const res = await fetchSource(fetchFn, source);
   if (!res.ok) {
-    throw new Error(`fx source ${source} returned ${res.status.toString()}`);
+    throw new FxRateUnavailableError(
+      `fx source ${source} returned ${res.status.toString()}`,
+      void 0,
+      void 0,
+      { category: "http_error", httpStatus: res.status }
+    );
   }
-  const body = await res.json();
-  const bitcoin = body.bitcoin;
-  if (!bitcoin || typeof bitcoin !== "object") {
-    throw new Error(`fx source ${source} returned an unparsable rate body`);
+  const body = await parseRateBody(res);
+  const bitcoin = body?.bitcoin;
+  if (!bitcoin || typeof bitcoin !== "object" || Array.isArray(bitcoin)) {
+    throw new FxRateUnavailableError(
+      `fx source ${source} returned an unparsable rate body`,
+      void 0,
+      void 0,
+      { category: "invalid_body" }
+    );
   }
-  return { rates: collectRates(source, bitcoin, currencies), as_of: (/* @__PURE__ */ new Date()).toISOString() };
+  return {
+    rates: collectRates(source, bitcoin, currencies),
+    as_of: (/* @__PURE__ */ new Date()).toISOString()
+  };
 }
 async function fetchPlatformShape(source, currencies, fetchFn) {
-  const res = await fetchFn(source.url, {
+  const res = await fetchSource(fetchFn, source.url, {
     headers: { Authorization: `Bearer ${source.token}`, Accept: "application/json" }
   });
   if (!res.ok) {
@@ -160,20 +309,57 @@ async function fetchPlatformShape(source, currencies, fetchFn) {
       throw new FxRateUnavailableError(
         `fx source ${source.url} refused: rate ${knownStale.staleDays.toString()}d stale` + (knownStale.thresholdDays !== void 0 ? ` (threshold ${knownStale.thresholdDays.toString()}d)` : ""),
         void 0,
-        knownStale
+        knownStale,
+        { category: "http_error", httpStatus: res.status }
       );
     }
-    throw new Error(`fx source ${source.url} returned ${res.status.toString()}`);
+    throw new FxRateUnavailableError(
+      `fx source ${source.url} returned ${res.status.toString()}`,
+      void 0,
+      void 0,
+      { category: "http_error", httpStatus: res.status }
+    );
   }
-  const body = await res.json();
-  const raw = body.rates;
-  if (!raw || typeof raw !== "object") {
-    throw new Error(`fx source ${source.url} returned an unparsable rate body`);
+  const body = await parseRateBody(res);
+  const raw = body?.rates;
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new FxRateUnavailableError(
+      `fx source ${source.url} returned an unparsable rate body`,
+      void 0,
+      void 0,
+      { category: "invalid_body" }
+    );
   }
   const rates = collectRates(source.url, raw, currencies);
   const as_of = typeof body.as_of === "string" ? body.as_of : (/* @__PURE__ */ new Date()).toISOString();
   return { rates, as_of };
 }
+async function fetchSource(fetchFn, url, init) {
+  try {
+    return await fetchFn(url, init);
+  } catch (err) {
+    if (err instanceof FxRateUnavailableError) throw err;
+    throw new FxRateUnavailableError(
+      err instanceof Error ? err.message : String(err),
+      void 0,
+      void 0,
+      { category: "network_error" }
+    );
+  }
+}
+async function parseRateBody(res) {
+  try {
+    const body = await res.json();
+    return typeof body === "object" && body !== null && !Array.isArray(body) ? body : null;
+  } catch {
+    throw new FxRateUnavailableError(
+      "fx source returned an unparsable rate body",
+      void 0,
+      void 0,
+      { category: "invalid_body" }
+    );
+  }
+}
 function collectRates(source, raw, currencies) {
   const rates = {};
   for (const currency of currencies) {
@@ -182,8 +368,11 @@ function collectRates(source, raw, currencies) {
     rates[currency] = value;
   }
   if (Object.keys(rates).length === 0) {
-    throw new Error(
-      `fx source ${source} returned no usable rate for any of [${currencies.join(", ")}]`
+    throw new FxRateUnavailableError(
+      `fx source ${source} returned no usable rate for any of [${currencies.join(", ")}]`,
+      void 0,
+      void 0,
+      { category: "no_usable_rate" }
     );
   }
   return rates;
@@ -240,6 +429,7 @@ async function parsePlatformStaleRefusal(res) {
   } catch {
     return null;
   }
+  if (typeof body !== "object" || body === null) return null;
   const error = body.error;
   if (!error || typeof error !== "object") return null;
   const { code, detail } = error;
@@ -268,28 +458,26 @@ function resolveFxSourceFromEnv(env) {
   return raw;
 }
 
-// src/sdk/pricing/upfront.ts
-function buildUpfront(input) {
-  const currency = validateCurrency(input.currency);
-  const amount = input.amount;
-  if (!Number.isFinite(amount) || amount < 0) {
-    throw new Error(`invalid upfront amount: ${String(amount)} (must be a non-negative number)`);
-  }
-  return { amount, currency };
-}
-
 export {
   InvalidCurrencyError,
   UnsupportedCurrencyError,
   validateCurrency,
+  InvalidFxRateError,
+  fiatToSatsCeil,
+  satsToFiat,
+  InvalidUsdPriceError,
+  parseUsdPrice,
+  roundUsd,
+  formatUsd,
+  formatFiat,
   DEFAULT_FX_CURRENCIES,
   DEFAULT_FX_RATE_SOURCE,
   FX_CACHE_TTL_MS,
   FX_RETRY_COUNT,
   FxRateUnavailableError,
+  readFxSourceFailure,
   createFxFetcher,
   warmFxSnapshot,
   fxRateFor,
-  resolveFxSourceFromEnv,
-  buildUpfront
+  resolveFxSourceFromEnv
 };

package/dist/{chunk-JH3SX3LY.js → chunk-IRXIH775.js}

@@ -1,15 +1,15 @@
-import {
-  withSdkInitLock
-} from "./chunk-COYKJRMM.js";
 import {
   applyRetryToPool
-} from "./chunk-P6QON7ER.js";
+} from "./chunk-NV7Z7377.js";
 import {
   x402NetworkByCaip2
-} from "./chunk-RLTSCKRI.js";
+} from "./chunk-BPYMEMQX.js";
 import {
   diagnosticConsole
-} from "./chunk-ETXDTUJO.js";
+} from "./chunk-ZCNPIILZ.js";
+import {
+  withSdkInitLock
+} from "./chunk-COYKJRMM.js";
 
 // src/sdk/server/credit-ledger.ts
 import { randomUUID } from "crypto";