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

package/dist/chunk-RW5LP57K.js

@@ -0,0 +1,44 @@
+// src/sdk/store.ts
+var MemoryKVStore = class {
+  data = /* @__PURE__ */ new Map();
+  /** Retrieve a value by key. Returns undefined if not found or expired. */
+  get(key) {
+    const entry = this.data.get(key);
+    if (!entry) return Promise.resolve(void 0);
+    if (entry.expiry !== void 0 && Date.now() > entry.expiry) {
+      this.data.delete(key);
+      return Promise.resolve(void 0);
+    }
+    return Promise.resolve(entry.value);
+  }
+  /** Store a value. Optionally set a TTL in seconds. */
+  set(key, value, opts) {
+    const expiry = opts?.ttl !== void 0 ? Date.now() + opts.ttl * 1e3 : void 0;
+    this.data.set(key, { value, expiry });
+    return Promise.resolve();
+  }
+  /** Delete a key. */
+  delete(key) {
+    this.data.delete(key);
+    return Promise.resolve();
+  }
+  /** List keys, optionally filtered by prefix. Excludes expired entries. */
+  list(prefix) {
+    const now = Date.now();
+    const keys = [];
+    for (const [key, entry] of this.data) {
+      if (entry.expiry !== void 0 && now > entry.expiry) {
+        this.data.delete(key);
+        continue;
+      }
+      if (prefix === void 0 || key.startsWith(prefix)) {
+        keys.push(key);
+      }
+    }
+    return Promise.resolve(keys);
+  }
+};
+
+export {
+  MemoryKVStore
+};

package/dist/chunk-YDIYXGYL.js

@@ -0,0 +1,384 @@
+import {
+  initCallerLoggers
+} from "./chunk-66HGCPBU.js";
+
+// src/sdk/step-cache.ts
+var StepCache = class _StepCache {
+  cache = /* @__PURE__ */ new Map();
+  /** Check if a step result is cached. */
+  has(id) {
+    return this.cache.has(id);
+  }
+  /** Get a cached step result. Throws if not present. */
+  get(id) {
+    if (!this.cache.has(id)) {
+      throw new Error(`StepCache: no cached result for step "${id}"`);
+    }
+    return this.cache.get(id);
+  }
+  /** Cache a step result. */
+  set(id, value) {
+    this.cache.set(id, value);
+  }
+  /** Export all cached steps for persistence. */
+  serialize() {
+    return [...this.cache.entries()].map(([id, value]) => ({ id, value }));
+  }
+  /** Restore a StepCache from persisted records. */
+  static deserialize(records) {
+    const cache = new _StepCache();
+    for (const { id, value } of records) {
+      cache.set(id, value);
+    }
+    return cache;
+  }
+};
+
+// src/sdk/logger.ts
+function createConsoleLogger(jobId) {
+  const fmt = (message, data) => {
+    const parts = [`[${jobId}] ${message}`];
+    if (data) parts.push(data);
+    return parts;
+  };
+  return {
+    debug(message, data) {
+      console.debug(...fmt(message, data));
+    },
+    info(message, data) {
+      console.info(...fmt(message, data));
+    },
+    warn(message, data) {
+      console.warn(...fmt(message, data));
+    },
+    error(message, data) {
+      console.error(...fmt(message, data));
+    }
+  };
+}
+function createStdoutLogger(context) {
+  const emit = (sink, level) => (message, data) => {
+    sink(JSON.stringify({ level, msg: message, ...context, ...data }));
+  };
+  return {
+    debug: emit(console.debug.bind(console), "debug"),
+    info: emit(console.info.bind(console), "info"),
+    warn: emit(console.warn.bind(console), "warn"),
+    error: emit(console.error.bind(console), "error")
+  };
+}
+function createNoopLogger() {
+  const noop2 = () => {
+  };
+  return { debug: noop2, info: noop2, warn: noop2, error: noop2 };
+}
+
+// src/observability/context.ts
+import { AsyncLocalStorage } from "async_hooks";
+import { randomBytes, randomUUID } from "crypto";
+var storage = new AsyncLocalStorage();
+var defaultService = "unknown";
+function setDefaultService(service) {
+  defaultService = service;
+}
+function randomTraceId() {
+  const buf = randomBytes(16);
+  const now = Date.now();
+  buf.writeUInt16BE(Math.floor(now / 4294967296), 0);
+  buf.writeUInt32BE(now % 4294967296, 2);
+  buf[6] = buf[6] & 15 | 112;
+  buf[8] = buf[8] & 63 | 128;
+  return buf.toString("hex");
+}
+function randomSpanId() {
+  return randomUUID().replace(/-/g, "").slice(0, 16);
+}
+function withTraceContext(ctx, fn) {
+  return storage.run(ctx, fn);
+}
+function currentContext(service) {
+  const ctx = storage.getStore();
+  if (ctx) return ctx;
+  return {
+    traceId: randomTraceId(),
+    spanId: null,
+    dimensions: {},
+    service: service ?? defaultService
+  };
+}
+function pinDimension(key, value) {
+  const ctx = storage.getStore();
+  if (ctx) {
+    ctx.dimensions = { ...ctx.dimensions, [key]: value };
+  }
+}
+function rawContext() {
+  return storage.getStore();
+}
+
+// src/observability/with-span.ts
+import { hostname } from "os";
+
+// src/observability/stdout-sink.ts
+var SENSITIVE_KEY_RE = /secret|token|password|private|bearer|seed|preimage|api[_-]?key|signing[_-]?key|priv[_-]?key/i;
+var isTTY = typeof process.stdout.isTTY === "boolean" && process.stdout.isTTY;
+var RED = isTTY ? "\x1B[31m" : "";
+var YELLOW = isTTY ? "\x1B[33m" : "";
+var RESET = isTTY ? "\x1B[0m" : "";
+function formatSpanLine(span) {
+  const ts = new Date(span.started_at_ms).toISOString();
+  const levelStr = colorLevel(span.level);
+  const parts = [`[${ts}]`, span.dataset, `${levelStr}:`, span.name];
+  if (span.trace_id) {
+    parts.push(`trace=${span.trace_id}`);
+  }
+  for (const [k, v] of Object.entries(span.dimensions)) {
+    parts.push(formatKV(k, v));
+  }
+  for (const [k, v] of Object.entries(span.attributes)) {
+    parts.push(formatKV(k, v));
+  }
+  const durationMs = span.ended_at_ms - span.started_at_ms;
+  if (durationMs > 0) {
+    parts.push(`duration=${durationMs}ms`);
+  }
+  if (span.error_message) {
+    parts.push(`error=${truncate(span.error_message, 120)}`);
+  }
+  return parts.join(" ");
+}
+function writeSpanLine(span) {
+  const line = formatSpanLine(span);
+  process.stdout.write(line + "\n");
+}
+function colorLevel(level) {
+  if (level === "error") return `${RED}error${RESET}`;
+  if (level === "warn") return `${YELLOW}warn${RESET}`;
+  return level;
+}
+function formatKV(key, value) {
+  if (SENSITIVE_KEY_RE.test(key)) return `${key}=[REDACTED]`;
+  return `${key}=${truncate(stringify(value), 80)}`;
+}
+function stringify(value) {
+  if (typeof value === "string") return value;
+  if (value === void 0) return "undefined";
+  if (value === null) return "null";
+  if (typeof value === "function") return "[function]";
+  if (typeof value === "symbol") return value.toString();
+  if (typeof value === "bigint") return value.toString();
+  return JSON.stringify(value);
+}
+function truncate(s, max) {
+  if (s.length <= max) return s;
+  return s.slice(0, max - 3) + "...";
+}
+
+// src/observability/with-span.ts
+var emitter = null;
+function setEmitter(fn) {
+  emitter = fn;
+}
+var cachedHost = hostname();
+var serviceVersion = process.env.GIT_SHA ?? process.env.FLY_IMAGE_REF ?? "dev";
+async function withSpan(opts, fn) {
+  const spanId = randomSpanId();
+  const existingCtx = rawContext();
+  const ctx = existingCtx ?? currentContext();
+  const startMs = opts.startMs ?? Date.now();
+  let status = "ok";
+  let level = opts.level;
+  let errorMessage = null;
+  let errorStack = null;
+  if (opts.err) {
+    status = "error";
+    errorMessage = opts.err.message;
+    errorStack = opts.err.stack ?? null;
+  }
+  const childCtx = {
+    traceId: ctx.traceId,
+    spanId,
+    dimensions: { ...ctx.dimensions, ...opts.dims },
+    service: ctx.service,
+    tracestate: ctx.tracestate
+  };
+  const emitRow = () => {
+    const endMs = opts.endMs ?? Date.now();
+    const row = {
+      span_id: spanId,
+      trace_id: ctx.traceId,
+      parent_span_id: ctx.spanId,
+      dataset: opts.dataset,
+      name: opts.name,
+      level: level ?? (status === "error" ? "error" : "info"),
+      status,
+      started_at_ms: startMs,
+      ended_at_ms: endMs,
+      service: ctx.service,
+      service_version: serviceVersion,
+      host: cachedHost,
+      pid: process.pid,
+      dimensions: childCtx.dimensions,
+      attributes: opts.attrs ?? {},
+      error_message: errorMessage,
+      error_stack: errorStack,
+      sample_rate: 1
+    };
+    writeSpanLine(row);
+    if (emitter) emitter(row);
+  };
+  try {
+    const result = await withTraceContext(childCtx, () => fn());
+    if (opts.inspect) {
+      const overrides = opts.inspect(result);
+      if (overrides) {
+        if (overrides.status) status = overrides.status;
+        if (overrides.level) level = overrides.level;
+        if (overrides.errorMessage !== void 0) errorMessage = overrides.errorMessage;
+        if (overrides.attrs) Object.assign(opts.attrs ??= {}, overrides.attrs);
+      }
+    }
+    emitRow();
+    return result;
+  } catch (err) {
+    status = "error";
+    if (err instanceof Error) {
+      errorMessage = err.message;
+      errorStack = err.stack ?? null;
+    } else {
+      errorMessage = String(err);
+    }
+    if (opts.onError) {
+      const overrides = opts.onError(err);
+      if (overrides) Object.assign(opts.attrs ??= {}, overrides);
+    }
+    emitRow();
+    throw err;
+  }
+}
+
+// src/observability/datasets.ts
+var SPANS_DATASETS = [
+  { name: "platform", retentionDays: 90 },
+  { name: "cashu", retentionDays: 90 },
+  { name: "lightning", retentionDays: 90 },
+  { name: "stripe", retentionDays: 90 },
+  { name: "x402", retentionDays: 90 },
+  { name: "tempo", retentionDays: 90 },
+  { name: "isolate", retentionDays: 90 },
+  { name: "audit", retentionDays: 365 },
+  { name: "cron", retentionDays: 30 }
+];
+var DATASET_NAMES = new Set(SPANS_DATASETS.map((d) => d.name));
+
+// src/observability/loggers.ts
+var noop = () => {
+};
+var loggers = buildNoopLoggers();
+function initLoggers(writer, service) {
+  setEmitter((row) => {
+    writer.enqueue(row);
+  });
+  setDefaultService(service);
+  const result = {};
+  for (const ds of SPANS_DATASETS) {
+    result[ds.name] = createLogger(ds.name, {});
+  }
+  loggers = result;
+  initCallerLoggers(result);
+  return result;
+}
+function createLogger(dataset, bakedDims) {
+  const logger = {
+    info(name, attrs) {
+      void withSpan({ dataset, name, level: "info", attrs, dims: bakedDims }, noop).catch(noop);
+    },
+    warn(name, attrs) {
+      void withSpan({ dataset, name, level: "warn", attrs, dims: bakedDims }, noop).catch(noop);
+    },
+    error(name, attrs) {
+      const err = attrs?.err instanceof Error ? attrs.err : void 0;
+      const cleanAttrs = attrs ? { ...attrs } : void 0;
+      if (cleanAttrs) delete cleanAttrs.err;
+      void withSpan(
+        { dataset, name, level: "error", attrs: cleanAttrs, dims: bakedDims, err },
+        noop
+      ).catch(noop);
+    },
+    async span(name, attrs, fn, opts) {
+      return withSpan({ dataset, name, attrs, dims: bakedDims, onError: opts?.onError }, fn);
+    },
+    timer(name, attrs) {
+      const startMs = Date.now();
+      return {
+        [Symbol.dispose]() {
+          const endMs = Date.now();
+          void withSpan({ dataset, name, attrs, dims: bakedDims, startMs, endMs }, noop).catch(
+            noop
+          );
+        }
+      };
+    },
+    set(dims) {
+      for (const [k, v] of Object.entries(dims)) {
+        pinDimension(k, v);
+      }
+    },
+    extend(dims) {
+      return createLogger(dataset, { ...bakedDims, ...dims });
+    },
+    tracked(name, fn) {
+      return ((...args) => logger.span(name, {}, () => fn(...args)));
+    }
+  };
+  return logger;
+}
+function buildNoopLoggers() {
+  const noopLogger = {
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    info() {
+    },
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    warn() {
+    },
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    error() {
+    },
+    async span(_name, _attrs, fn, _opts) {
+      return fn();
+    },
+    timer() {
+      return { [Symbol.dispose]() {
+      } };
+    },
+    // eslint-disable-next-line @typescript-eslint/no-empty-function
+    set() {
+    },
+    extend() {
+      return noopLogger;
+    },
+    tracked(_name, fn) {
+      return fn;
+    }
+  };
+  const result = {};
+  for (const ds of SPANS_DATASETS) {
+    result[ds.name] = noopLogger;
+  }
+  return result;
+}
+
+export {
+  StepCache,
+  createConsoleLogger,
+  createStdoutLogger,
+  createNoopLogger,
+  randomTraceId,
+  withTraceContext,
+  currentContext,
+  pinDimension,
+  setEmitter,
+  withSpan,
+  loggers,
+  initLoggers
+};

package/dist/{chunk-JGGI65I3.js → chunk-Z4BNLUZF.js}

@@ -1,9 +1,6 @@
 import {
   DvmError
 } from "./chunk-MKI6OVW4.js";
-import {
-  callerLoggers
-} from "./chunk-66HGCPBU.js";
 
 // src/lib/x402/constants.ts
 var X402_DEFAULT_FACILITATOR = "https://x402.org/facilitator";
@@ -104,76 +101,6 @@ function x402SupportedNetworksHint() {
 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;
@@ -315,78 +242,6 @@ function exactEvmAuthorization(payload) {
 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
 };
@@ -446,8 +301,6 @@ function isOptionalRecord(value) {
 
 export {
   X402_DEFAULT_FACILITATOR,
-  createX402FacilitatorAuthHeaders,
-  createX402FacilitatorClient,
   X402_NETWORKS,
   x402NetworkByCaip2,
   x402NetworkBySlug,
@@ -475,7 +328,5 @@ export {
   encodePaymentRequiredHeader,
   decodePaymentRequiredHeader,
   exactEvmAuthorization,
-  encodeSettleResponseHeader,
-  verifyWithFacilitator,
-  settleWithFacilitator
+  encodeSettleResponseHeader
 };

package/dist/{credit-ledger-ED6JXKVD.js → credit-ledger-2DFQHNLB.js}

@@ -10,9 +10,9 @@ import {
   isDrainMethod,
   isFundingRail,
   x402SettlementPending
-} from "./chunk-LWUR4CGG.js";
-import "./chunk-C3MTFLC6.js";
+} from "./chunk-MLRCSJYX.js";
 import "./chunk-S3XAHZQY.js";
+import "./chunk-C3MTFLC6.js";
 export {
   CreditLedger,
   CreditLedgerError,