@dvmkit/sdk 0.0.0 → 0.1.0-rc.2

package/dist/chunk-S3XAHZQY.js

@@ -0,0 +1,63 @@
+// src/sdk/server/init-lock.ts
+var SDK_INIT_ADVISORY_LOCK = 17320927;
+async function withSdkInitLock(db, fn) {
+  assertPoolFitsLock(db);
+  let holder = holders.get(db);
+  if (holder) {
+    holder.refs += 1;
+  } else {
+    holder = { refs: 1, acquired: acquire(db) };
+    holders.set(db, holder);
+  }
+  let guardedFailed = false;
+  try {
+    await holder.acquired;
+    return await fn();
+  } catch (err) {
+    guardedFailed = true;
+    throw err;
+  } finally {
+    await releaseHolder(db, holder, guardedFailed);
+  }
+}
+var holders = /* @__PURE__ */ new WeakMap();
+function assertPoolFitsLock(db) {
+  const max = db.options?.max;
+  if (max === void 0 || max >= 2) return;
+  throw new Error(
+    `withSdkInitLock: the SDK boot lock needs a pool that allows at least 2 connections (got max=${max}). The lock is held on one pinned client while the guarded DDL runs on another, so boot would hang forever.`
+  );
+}
+async function acquire(db) {
+  const client = await db.connect();
+  try {
+    await client.query(`SELECT pg_advisory_lock(${SDK_INIT_ADVISORY_LOCK})`);
+  } catch (err) {
+    client.release();
+    throw err;
+  }
+  return client;
+}
+async function releaseHolder(db, holder, guardedFailed) {
+  holder.refs -= 1;
+  if (holder.refs > 0) return;
+  holders.delete(db);
+  let client;
+  try {
+    client = await holder.acquired;
+  } catch {
+    return;
+  }
+  try {
+    await client.query(`SELECT pg_advisory_unlock(${SDK_INIT_ADVISORY_LOCK})`);
+    client.release();
+  } catch (err) {
+    client.release(err instanceof Error ? err : new Error(String(err)));
+    if (!guardedFailed) throw err;
+  }
+}
+
+export {
+  SDK_INIT_ADVISORY_LOCK,
+  withSdkInitLock
+};

package/dist/chunk-YG7G4DPZ.js

@@ -0,0 +1,25 @@
+// src/sdk/server/store-json.ts
+var BIGINT_TAG = "#__bigint";
+var TAGGED_BIGINT = /^-?\d+#__bigint$/;
+function stringifyStoreValue(value, what = "Store value") {
+  const encoded = JSON.stringify(
+    value,
+    (_key, item) => typeof item === "bigint" ? `${item.toString()}${BIGINT_TAG}` : item
+  );
+  if (typeof encoded !== "string") throw new Error(`${what} is not serializable`);
+  return encoded;
+}
+function parseStoreValue(value) {
+  const parsed = JSON.parse(value, (_key, item) => {
+    if (typeof item === "string" && TAGGED_BIGINT.test(item)) {
+      return BigInt(item.slice(0, -BIGINT_TAG.length));
+    }
+    return item;
+  });
+  return parsed;
+}
+
+export {
+  stringifyStoreValue,
+  parseStoreValue
+};

package/dist/credit-ledger-RO4FGSHG.js

@@ -0,0 +1,28 @@
+import {
+  CreditLedger,
+  CreditLedgerError,
+  DRAIN_METHODS,
+  FUNDING_RAILS,
+  allocateDrawValue,
+  assertFundingBasis,
+  clipEarmark,
+  growthRailValue,
+  isDrainMethod,
+  isFundingRail,
+  x402SettlementPending
+} from "./chunk-365P52XQ.js";
+import "./chunk-H25M54MI.js";
+import "./chunk-S3XAHZQY.js";
+export {
+  CreditLedger,
+  CreditLedgerError,
+  DRAIN_METHODS,
+  FUNDING_RAILS,
+  allocateDrawValue,
+  assertFundingBasis,
+  clipEarmark,
+  growthRailValue,
+  isDrainMethod,
+  isFundingRail,
+  x402SettlementPending
+};

package/dist/index.d.ts

@@ -0,0 +1,144 @@
+import { C as Currency, Z as ZodLike, D as DVMConfig, a as DVMDescriptor } from './job-store-6gR4pZRP.js';
+export { A as ApprovalContent, b as ArtifactContent, c as CancelContent, d as CanonicalEnvelope, e as CreateSignedRequestVerifierOpts, f as CreditConfig, g as CreditView, h as DEFAULT_CREDIT_MAX, i as DEFAULT_CREDIT_MIN, j as DEFAULT_CREDIT_TTL_SECONDS, k as DVMRouteContext, I as IncomingMessage, l as InputType, m as InvalidCurrencyError, J as JobRecord, n as JobStatus, o as JobStore, K as KVStore, L as Logger, P as PaymentContent, p as PaymentMethod, q as PriceValue, r as ProgressContent, s as PromptOpts, Q as QuoteConfig, t as QuoteContext, u as QuoteResult, R as ResolvedCreditConfig, v as ResponseContent, S as SDKJobContext, w as SDKPaymentRequestOpts, x as SIGNED_REQUEST_AUTH_ID, y as SIGNED_REQUEST_STATEMENT_VERSION, z as SignedRequestAudience, B as SignedRequestDomain, E as SignedRequestError, F as SignedRequestFailure, G as SignedRequestReplayStore, H as SignedRequestSignOpts, M as SignedRequestStatementHeader, N as SignedRequestVerifier, U as UnsupportedCurrencyError, O as createSignedRequestVerifier, T as isZodSchema, V as signedRequestStatementHeader, W as validateCurrency } from './job-store-6gR4pZRP.js';
+export { C as CreateFxFetcherOpts, D as DEFAULT_FX_CURRENCIES, a as DEFAULT_FX_RATE_SOURCE, F as FxFetcher, b as FxRateSnapshot, c as FxRateUnavailableError, P as PinnedFetch, d as PlatformFxSource, S as SSRFError, e as SSRFGuardOpts, f as SSRFReason, g as SSRFResolver, h as assertSafeUrl, i as createFxFetcher, j as createPinnedFetch, k as fxRateFor, r as resolveFxSourceFromEnv } from './ssrf-DZi-xJyn.js';
+export { z } from 'zod';
+import '@cashu/cashu-ts';
+import 'mppx';
+import 'hono';
+import '@x402/core/server';
+import '@x402/evm/batch-settlement/server';
+import 'pg';
+import '@x402/core/types';
+
+/**
+ * Protocol-enforced upfront fiat commitment. The hard invariant of the new
+ * `QuoteResult` shape — every DVM's quote handler returns one. The SDK
+ * derives sats from `amount × fx` at settlement time; for fixed-price DVMs
+ * this is the total cost, for two-phase DVMs (scribe) more may be requested
+ * mid-job via `ctx.requestPayment`.
+ */
+interface Upfront {
+    amount: number;
+    currency: Currency;
+}
+/**
+ * Build a validated `Upfront` literal. Throws `InvalidCurrencyError` when
+ * `currency` doesn't match `/^[a-z]{3}$/`, and a plain `Error` when `amount`
+ * is non-finite or negative. Operators should call this at the boundary of
+ * their `onQuote` handler so a malformed envelope can't escape to the wire.
+ */
+declare function buildUpfront(input: {
+    amount: number;
+    currency: string;
+}): Upfront;
+
+/**
+ * Thrown by `fiatToSatsCeil` / `satsToFiat` when the supplied `ratePerBtc` is
+ * non-finite or non-positive. Surfaces a misconfigured fx fetcher loudly
+ * instead of silently producing a 0-sats charge or a 0-fiat display string —
+ * a silent 0 lost real money in internal-review slice-04. Callers obtain a valid rate
+ * from the SDK's fx fetcher (which raises `FxRateUnavailableError` on
+ * upstream failure); this error is the defence-in-depth backstop for any
+ * caller that constructs a rate by other means.
+ */
+declare class InvalidFxRateError extends Error {
+    readonly code = "invalid_fx_rate";
+    readonly ratePerBtc: unknown;
+    constructor(ratePerBtc: unknown);
+}
+/**
+ * Convert a fiat amount to integer sats at the supplied fiat-per-BTC rate.
+ * Rounds **up** so the operator never overcharges the caller (caller-friendly
+ * rounding). Negative or non-finite amounts collapse to 0 (a $0 charge is
+ * well-defined). A non-finite or non-positive `ratePerBtc` raises
+ * `InvalidFxRateError` — a silent 0 would mask a misconfigured fetcher into
+ * shipping a free charge. The math is currency-agnostic — `ratePerBtc` is the
+ * number of units of *some* fiat per 1 BTC; the caller looks the right rate
+ * out of an `FxRateSnapshot`.
+ */
+declare function fiatToSatsCeil(amount: number, ratePerBtc: number): number;
+/**
+ * Convert integer sats back to a fiat amount at the supplied fiat-per-BTC
+ * rate. A non-finite or non-positive `ratePerBtc` raises
+ * `InvalidFxRateError` — the silent `0` would land in display strings and
+ * mislead callers about the value at hand.
+ */
+declare function satsToFiat(sats: number, ratePerBtc: number): number;
+/**
+ * Round a USD value to 4 decimal places (matches scribe's stored display
+ * precision). This is the **storage / accounting** precision — preserves
+ * sub-cent amounts so a `$0.0150` per-minute rate doesn't collapse to
+ * `$0.02` before it ever reaches a multiplier. See {@link formatUsd} for the
+ * human-render precision, which deliberately truncates at the cent boundary
+ * for amounts ≥ $0.01.
+ */
+declare function roundUsd(usd: number): number;
+/**
+ * Format a USD amount with adaptive precision so sub-cent amounts don't
+ * render as `$0.00`. The 2dp/4dp boundary at $0.01 is **human-render**
+ * precision and is intentionally coarser than {@link roundUsd}'s storage
+ * precision: a value like `0.015` keeps four decimals through `roundUsd`
+ * (storage / multiplier inputs) but renders as `$0.02` here (human display).
+ * Don't try to unify the two — they serve different surfaces.
+ */
+declare function formatUsd(usd: number): string;
+/**
+ * Format a fiat amount with currency-aware symbol, precision, and ISO code.
+ * Used by the CLI to render payment-request `fiat_amount` envelopes ("$0.05
+ * USD", "€0.05 EUR", "¥5 JPY"). Precision is adaptive: JPY has no sub-yen
+ * denomination so renders as 0 decimals, every other currency uses 2 decimals
+ * at or above 0.01 and 4 below so sub-cent figures don't collapse to 0.00.
+ * Unknown currencies (anything not in {@link FIAT_SYMBOLS}) render with the
+ * uppercased ISO code and no leading symbol.
+ */
+declare function formatFiat(amount: number, currency: Currency): string;
+
+/** Create a typed DVM descriptor from a configuration object. */
+declare function configureDVM<State = Record<string, unknown>, InputSchema extends ZodLike | undefined = undefined>(config: DVMConfig<State, InputSchema>): DVMDescriptor<State, InputSchema>;
+/** Check whether this SDK module instance created a value through `configureDVM`. */
+declare function isConfiguredDVMDescriptor(value: unknown): value is DVMDescriptor<unknown, ZodLike | undefined>;
+
+/**
+ * Strict env-flag parser. Returns true only for the literal strings `"1"` or
+ * `"true"` — any other value (including `"false"`, `"0"`, `""`, or `undefined`)
+ * is false.
+ *
+ * Use this everywhere a boolean is read from `process.env` / `ctx.env`. Plain
+ * truthy checks like `!ctx.env.X` mistreat the string `"false"` as truthy and
+ * led to the upfront SDK gate disagreeing with handler-level `requestPayment`
+ * skips on the same env value.
+ */
+declare function envFlag(value: string | undefined): boolean;
+
+/** Options for `withProgressHeartbeat`. */
+interface ProgressHeartbeatOpts {
+    /**
+     * Progress emitter — typically `ctx.progress.bind(ctx)` in a handler, or a
+     * plumbed-through callback in DVM internals. When omitted, the helper just
+     * runs `fn` with no overhead.
+     */
+    onProgress?: (percentComplete: number, phase: string) => void;
+    /** Phase label emitted with each heartbeat. */
+    phase: string;
+    /** Percent (0-100) emitted with each heartbeat. Stays constant across the run. */
+    percent: number;
+    /**
+     * Heartbeat cadence in milliseconds. Default 30s — twice the AC's
+     * "every minute" floor, so a single missed tick still satisfies the contract.
+     */
+    intervalMs?: number;
+}
+/**
+ * Wrap a long-running async op with a periodic progress heartbeat at fixed
+ * `phase` and `percent`. Emits one heartbeat synchronously on entry, then
+ * repeats every `intervalMs` until `fn` settles. Use to keep agents informed
+ * during slow single-call operations (e.g. Whisper transcribe, diariser
+ * polling) where the percent doesn't naturally advance.
+ *
+ * Phase transitions should still be emitted directly via `ctx.progress(...)`
+ * before/after the wrapped call — this helper only covers the "I'm alive,
+ * still in this phase" case.
+ */
+declare function withProgressHeartbeat<T>(opts: ProgressHeartbeatOpts, fn: () => Promise<T>): Promise<T>;
+
+export { Currency, DVMConfig, DVMDescriptor, InvalidFxRateError, type ProgressHeartbeatOpts, type Upfront, ZodLike, buildUpfront, configureDVM, envFlag, fiatToSatsCeil, formatFiat, formatUsd, isConfiguredDVMDescriptor, roundUsd, satsToFiat, withProgressHeartbeat };

package/dist/index.js

@@ -0,0 +1,303 @@
+import {
+  DEFAULT_CREDIT_MAX,
+  DEFAULT_CREDIT_MIN,
+  DEFAULT_CREDIT_TTL_SECONDS,
+  SIGNED_REQUEST_AUTH_ID,
+  SIGNED_REQUEST_STATEMENT_VERSION,
+  SSRFError,
+  SignedRequestError,
+  assertSafeUrl,
+  createPinnedFetch,
+  createSignedRequestVerifier,
+  envFlag,
+  isZodSchema,
+  signedRequestStatementHeader
+} from "./chunk-KQAJVVZT.js";
+import {
+  DEFAULT_FX_CURRENCIES,
+  DEFAULT_FX_RATE_SOURCE,
+  FxRateUnavailableError,
+  InvalidCurrencyError,
+  UnsupportedCurrencyError,
+  buildUpfront,
+  createFxFetcher,
+  fxRateFor,
+  resolveFxSourceFromEnv,
+  validateCurrency
+} from "./chunk-27V2ILSR.js";
+import {
+  InvalidFxRateError,
+  fiatToSatsCeil,
+  formatFiat,
+  formatUsd,
+  parseUsdPrice,
+  roundUsd,
+  satsToFiat
+} from "./chunk-AT6V3SY7.js";
+
+// src/lib/wire-schema.ts
+var CAPABILITY_NAME_RE = /^[a-z0-9][a-z0-9-]*$/;
+
+// src/sdk/configure.ts
+function configureDVM(config) {
+  const tags = collectTags(config);
+  const currency = resolvePricingCurrency(config.currency);
+  const capabilities = buildCapabilityMap(config, currency);
+  const onlyCapability = singleCapabilityEntry(capabilities);
+  const descriptor = {
+    name: config.name,
+    description: config.description ?? "",
+    tags,
+    currency,
+    price: onlyCapability?.price,
+    inputSchema: onlyCapability?.input,
+    state: onlyCapability?.state ?? {},
+    idleTimeout: config.idleTimeout ?? 3600,
+    processingWatchdog: config.processingWatchdog,
+    config,
+    capabilities,
+    paymentMethods: config.paymentMethods,
+    x402: config.x402,
+    mpp: config.mpp,
+    credit: resolveCreditConfig(config.credit),
+    auth: config.auth
+  };
+  CONFIGURED_DVM_DESCRIPTORS.add(descriptor);
+  return Object.freeze(descriptor);
+}
+function isConfiguredDVMDescriptor(value) {
+  return typeof value === "object" && value !== null && CONFIGURED_DVM_DESCRIPTORS.has(value);
+}
+var CONFIGURED_DVM_DESCRIPTORS = /* @__PURE__ */ new WeakSet();
+function resolvePricingCurrency(raw) {
+  if (raw === void 0) return "usd";
+  try {
+    return validateCurrency(raw);
+  } catch (err) {
+    if (err instanceof InvalidCurrencyError) {
+      throw new Error(
+        `configureDVM: currency ${JSON.stringify(raw)} is not an ISO 4217 lowercase code like "usd" or "eur". Omit the field to price in USD.`,
+        { cause: err }
+      );
+    }
+    throw err;
+  }
+}
+function resolveCreditConfig(credit) {
+  if (!credit) return void 0;
+  const min = credit.min ?? DEFAULT_CREDIT_MIN;
+  const max = credit.max ?? DEFAULT_CREDIT_MAX;
+  const ttlSeconds = credit.ttl ?? DEFAULT_CREDIT_TTL_SECONDS;
+  const minAmount = validatePriceLiteral(min, "credit.min");
+  const maxAmount = validatePriceLiteral(max, "credit.max");
+  if (minAmount > maxAmount) {
+    throw new Error(
+      `credit.min (${JSON.stringify(min)}) exceeds credit.max (${JSON.stringify(max)}) \u2014 no funding amount could satisfy both.`
+    );
+  }
+  if (!Number.isFinite(ttlSeconds) || ttlSeconds <= 0) {
+    throw new Error(`credit.ttl must be a positive number of seconds (got ${ttlSeconds}).`);
+  }
+  const allowOneShotStablecoin = credit.allowOneShotStablecoin === true;
+  return { min, max, ttlSeconds, allowOneShotStablecoin };
+}
+function validatePriceLiteral(value, field, key = field) {
+  if (typeof value === "number") {
+    throw new Error(
+      `${field} is a number (${value}). Prices are USD literals \u2014 write ${key}: "$0.01" for one cent. Callers still pay in sats; the SDK converts at request time. Omit the field for a free capability, or use \`onQuote\` for dynamic pricing.`
+    );
+  }
+  if (typeof value !== "string") {
+    throw new Error(`${field} must be a USD literal like "$0.05" (got ${JSON.stringify(value)}).`);
+  }
+  return parseUsdPrice(value, field);
+}
+function validateCapabilityPrice(price, capabilityName, currency) {
+  if (price === void 0) return;
+  if (currency !== "usd") {
+    throw new Error(
+      `configureDVM: capability "${capabilityName}" declares a static price (${JSON.stringify(price)}) but this DVM prices in ${currency}. Static prices are USD literals, so they cannot express ${currency} \u2014 price this capability with \`onQuote\` returning { amount, currency: ${JSON.stringify(currency)} }, or drop the DVM-level \`currency\` to price in USD.`
+    );
+  }
+  validatePriceLiteral(price, `configureDVM: capability "${capabilityName}" price`, "price");
+}
+function collectTags(config) {
+  const tagSet = /* @__PURE__ */ new Set();
+  if (config.tag) tagSet.add(config.tag);
+  if (config.tags) {
+    for (const t of config.tags) tagSet.add(t);
+  }
+  return [...tagSet];
+}
+function buildCapabilityMap(config, currency) {
+  const hasExplicitBlock = config.capabilities !== void 0;
+  const hasFlatCapabilityName = typeof config.capability === "string";
+  const hasFlatHandler = typeof config.onJob === "function";
+  if (hasExplicitBlock && (hasFlatCapabilityName || hasFlatHandler || flatPerCapFieldsSet(config))) {
+    throw new Error(
+      "configureDVM: pass either the flat single-capability shape (capability + onJob + ...) or the explicit `capabilities` block, not both."
+    );
+  }
+  if (hasExplicitBlock) {
+    return buildExplicitCapabilities(config.capabilities ?? {}, currency);
+  }
+  if (!hasFlatHandler) {
+    throw new Error("configureDVM: onJob handler is required");
+  }
+  const name = typeof config.capability === "string" ? config.capability : slugifyCapabilityName(config.name);
+  validateCapabilityName(name);
+  validateCapabilityPrice(config.price, name, currency);
+  validateExampleAgainstInput(name, config.input, config.example);
+  const entry = {
+    name,
+    description: config.description ?? "",
+    input: config.input,
+    example: config.example,
+    state: config.state ?? {},
+    price: config.price,
+    onQuote: config.onQuote,
+    onJob: config.onJob,
+    onResponse: config.onResponse,
+    onPayment: config.onPayment,
+    onApproval: config.onApproval,
+    onCancel: config.onCancel,
+    onMessage: config.onMessage
+  };
+  return { [name]: entry };
+}
+function buildExplicitCapabilities(capabilities, currency) {
+  const keys = Object.keys(capabilities);
+  if (keys.length === 0) {
+    throw new Error("configureDVM: `capabilities` block must declare at least one capability");
+  }
+  const out = {};
+  for (const name of keys) {
+    validateCapabilityName(name);
+    const cap = capabilities[name];
+    if (typeof cap.onJob !== "function") {
+      throw new Error(`configureDVM: capability "${name}" is missing required onJob handler`);
+    }
+    validateCapabilityPrice(cap.price, name, currency);
+    validateExampleAgainstInput(name, cap.input, cap.example);
+    const entry = {
+      name,
+      description: cap.description ?? "",
+      // Per-capability `input` is the builder's Zod schema; the `any` widening
+      // through `Record<string, CapabilityConfig<any, any>>` is unavoidable
+      // here.
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+      input: cap.input,
+      example: cap.example,
+      state: cap.state !== void 0 ? structuredClone(cap.state) : {},
+      price: cap.price,
+      onQuote: cap.onQuote,
+      onJob: cap.onJob,
+      onResponse: cap.onResponse,
+      onPayment: cap.onPayment,
+      onApproval: cap.onApproval,
+      onCancel: cap.onCancel,
+      onMessage: cap.onMessage
+    };
+    out[name] = entry;
+  }
+  return out;
+}
+function flatPerCapFieldsSet(config) {
+  return config.input !== void 0 || config.example !== void 0 || config.state !== void 0 || config.price !== void 0 || config.onQuote !== void 0 || typeof config.onResponse === "function" || typeof config.onPayment === "function" || typeof config.onApproval === "function" || typeof config.onCancel === "function" || typeof config.onMessage === "function";
+}
+function validateExampleAgainstInput(capName, input, example) {
+  if (example === void 0) return;
+  if (!isZodSchema(input)) return;
+  const result = input.safeParse(example);
+  if (result.success) return;
+  throw new Error(
+    `configureDVM: capability "${capName}" example does not satisfy its input schema. Update the example to match the schema (including any \`.refine()\` checks). Issues: ${formatZodIssues(result.error)}`
+  );
+}
+function formatZodIssues(err) {
+  if (err && typeof err === "object" && "issues" in err && Array.isArray(err.issues)) {
+    const issues = err.issues;
+    if (issues.length === 0) return "(no issues reported)";
+    return issues.map((issue) => {
+      const path = issue.path.length > 0 ? issue.path.join(".") : "(root)";
+      return `${path}: ${issue.message}`;
+    }).join("; ");
+  }
+  if (err && typeof err === "object" && "message" in err && typeof err.message === "string") {
+    return err.message.replace(/\s+/g, " ").trim();
+  }
+  try {
+    return JSON.stringify(err);
+  } catch {
+    return String(err);
+  }
+}
+function validateCapabilityName(name) {
+  if (!CAPABILITY_NAME_RE.test(name)) {
+    throw new Error(
+      `configureDVM: invalid capability name "${name}" \u2014 must be lowercase letters/digits/hyphens, must start with a letter or digit, must not contain slashes.`
+    );
+  }
+}
+function slugifyCapabilityName(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function singleCapabilityEntry(capabilities) {
+  const keys = Object.keys(capabilities);
+  if (keys.length !== 1) return void 0;
+  return capabilities[keys[0]];
+}
+
+// src/sdk/heartbeat.ts
+async function withProgressHeartbeat(opts, fn) {
+  const onProgress = opts.onProgress;
+  if (!onProgress) return fn();
+  const intervalMs = opts.intervalMs ?? 3e4;
+  onProgress(opts.percent, opts.phase);
+  const timer = setInterval(() => {
+    onProgress(opts.percent, opts.phase);
+  }, intervalMs);
+  try {
+    return await fn();
+  } finally {
+    clearInterval(timer);
+  }
+}
+
+// src/sdk/index.ts
+import { z } from "zod";
+export {
+  DEFAULT_CREDIT_MAX,
+  DEFAULT_CREDIT_MIN,
+  DEFAULT_CREDIT_TTL_SECONDS,
+  DEFAULT_FX_CURRENCIES,
+  DEFAULT_FX_RATE_SOURCE,
+  FxRateUnavailableError,
+  InvalidCurrencyError,
+  InvalidFxRateError,
+  SIGNED_REQUEST_AUTH_ID,
+  SIGNED_REQUEST_STATEMENT_VERSION,
+  SSRFError,
+  SignedRequestError,
+  UnsupportedCurrencyError,
+  assertSafeUrl,
+  buildUpfront,
+  configureDVM,
+  createFxFetcher,
+  createPinnedFetch,
+  createSignedRequestVerifier,
+  envFlag,
+  fiatToSatsCeil,
+  formatFiat,
+  formatUsd,
+  fxRateFor,
+  isConfiguredDVMDescriptor,
+  isZodSchema,
+  resolveFxSourceFromEnv,
+  roundUsd,
+  satsToFiat,
+  signedRequestStatementHeader,
+  validateCurrency,
+  withProgressHeartbeat,
+  z
+};