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

package/dist/chunk-BQ2NMWKE.js

@@ -0,0 +1,160 @@
+import {
+  X402_DEFAULT_FACILITATOR
+} from "./chunk-Z4BNLUZF.js";
+import {
+  callerLoggers
+} from "./chunk-66HGCPBU.js";
+
+// 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/facilitator-request.ts
+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;
+  }
+}
+function isRecord(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+
+export {
+  createX402FacilitatorAuthHeaders,
+  createX402FacilitatorClient,
+  verifyWithFacilitator,
+  settleWithFacilitator
+};

package/dist/{chunk-LDTWX7JW.js → chunk-BTZY7VPH.js}

@@ -2,8 +2,9 @@ import {
   DEFAULT_CREDIT_MAX,
   DEFAULT_CREDIT_MIN,
   DEFAULT_CREDIT_TTL_SECONDS,
+  DEFAULT_JOB_RETENTION_DAYS,
   isZodSchema
-} from "./chunk-P4RUVDU7.js";
+} from "./chunk-KXZUCCEY.js";
 import {
   InvalidCurrencyError,
   validateCurrency
@@ -20,6 +21,7 @@ function configureDVM(config) {
   const tags = collectTags(config);
   const currency = resolvePricingCurrency(config.currency);
   const capabilities = buildCapabilityMap(config, currency);
+  const jobRetentionDays = resolveJobRetentionDays(config.jobRetentionDays);
   const onlyCapability = singleCapabilityEntry(capabilities);
   const descriptor = {
     name: config.name,
@@ -31,6 +33,7 @@ function configureDVM(config) {
     state: onlyCapability?.state ?? {},
     idleTimeout: config.idleTimeout ?? 3600,
     processingWatchdog: config.processingWatchdog,
+    jobRetentionDays,
     config,
     capabilities,
     paymentMethods: config.paymentMethods,
@@ -42,6 +45,15 @@ function configureDVM(config) {
   CONFIGURED_DVM_DESCRIPTORS.add(descriptor);
   return Object.freeze(descriptor);
 }
+function resolveJobRetentionDays(raw) {
+  const days = raw ?? DEFAULT_JOB_RETENTION_DAYS;
+  if (!Number.isSafeInteger(days) || days < 0) {
+    throw new Error(
+      `configureDVM: jobRetentionDays must be a non-negative whole number of days; received ${JSON.stringify(raw)}`
+    );
+  }
+  return days;
+}
 function isConfiguredDVMDescriptor(value) {
   return typeof value === "object" && value !== null && CONFIGURED_DVM_DESCRIPTORS.has(value);
 }

package/dist/{chunk-FJDCFHW5.js → chunk-C6JHBLMW.js}

@@ -18,20 +18,14 @@ import {
   assertSupportedX402Network,
   buildPaymentRequirements,
   chainIdFromCaip2,
-  createX402FacilitatorAuthHeaders,
-  decodePayment,
   encodePayment,
-  encodeSettleResponseHeader,
-  exactEvmAuthorization,
-  settleWithFacilitator,
   usdcContractFor,
   usdcDomainNameFor,
   usdcDomainVersionFor,
-  verifyWithFacilitator,
   x402NetworkByCaip2,
   x402NetworkToCaip2,
   x402SupportedNetworksHint
-} from "./chunk-JGGI65I3.js";
+} from "./chunk-Z4BNLUZF.js";
 import {
   costAnchor,
   fetchBtcUsdRate,
@@ -48,9 +42,6 @@ import {
   resolveRpcHttpTransportOptions,
   resolveRpcOverride
 } from "./chunk-MKI6OVW4.js";
-import {
-  callerLoggers
-} from "./chunk-66HGCPBU.js";
 import {
   redactUrl,
   redactUrlsInText
@@ -77,9 +68,6 @@ function x402WrongAssetHint(asset) {
   return `This rail reads only ${asset.label} (${asset.address}) on ${asset.networkLabel}. ${wrongToken} USDC on a different chain is invisible here too \u2014 this wallet reads ${asset.networkLabel} alone. If you funded the wrong one, swap it to ${asset.label} on ${asset.networkLabel}, or bridge the funds across to ${asset.networkLabel}; either way they land where this rail can spend them.`;
 }
 
-// src/lib/x402/client.ts
-import { randomBytes } from "crypto";
-
 // src/lib/btc-rate.ts
 async function resolveBtcUsdRate(purpose) {
   try {
@@ -783,6 +771,7 @@ async function getX402Balance(wallet) {
 }
 
 // src/lib/x402/client.ts
+import { randomBytes } from "crypto";
 async function tryX402Payment(request, wallet) {
   const selection = selectPaymentRequirement(request);
   let networkSlug;
@@ -990,72 +979,6 @@ async function priceableRate(btcRate) {
   }
 }
 
-// src/lib/x402/verify.ts
-async function verifyX402Payment(paymentHeader, config, requiredUsdcMicro, resource, btcUsdRate, exactVersions = { v1: true, v2: true }) {
-  return callerLoggers.x402.span(
-    "x402.verify_payment",
-    {
-      resource,
-      required_usdc_micro: Number(requiredUsdcMicro),
-      facilitator_url: config.facilitator
-    },
-    async () => {
-      let payload;
-      try {
-        payload = decodePayment(paymentHeader);
-      } catch {
-        return { verified: false, amountMsats: 0, invalidReason: "decode_failed" };
-      }
-      if (payload.x402Version === 1 && !exactVersions.v1 || payload.x402Version === 2 && !exactVersions.v2) {
-        return { verified: false, amountMsats: 0, invalidReason: "unsupported_version" };
-      }
-      const requirementOpts = { x402Config: config, requiredUsdcMicro, resource };
-      const requirements = payload.x402Version === 1 ? buildPaymentRequirements({ ...requirementOpts, version: 1 }) : buildPaymentRequirements({ ...requirementOpts, version: 2 });
-      const createAuthHeaders = createX402FacilitatorAuthHeaders(config);
-      const verifyRes = await verifyWithFacilitator(
-        payload,
-        requirements,
-        config,
-        createAuthHeaders
-      );
-      if (!verifyRes.isValid) {
-        return {
-          verified: false,
-          amountMsats: 0,
-          invalidReason: verifyRes.invalidReason ?? "verify_failed"
-        };
-      }
-      const settleRes = await settleWithFacilitator(
-        payload,
-        requirements,
-        config,
-        createAuthHeaders
-      );
-      if (!settleRes.success) {
-        return {
-          verified: false,
-          amountMsats: 0,
-          invalidReason: settleRes.errorReason ?? "settle_failed"
-        };
-      }
-      const amountUsdcMicro = Number.parseInt(exactEvmAuthorization(payload).value, 10);
-      const amountMsats = usdcToMsats(amountUsdcMicro / 1e6, btcUsdRate);
-      callerLoggers.x402.info("x402.verify_payment.result", {
-        verified: true,
-        tx_hash: settleRes.transaction,
-        amount_msats: amountMsats
-      });
-      return {
-        verified: true,
-        amountMsats,
-        amountUsdcMicro,
-        txHash: settleRes.transaction,
-        settleResponseHeader: encodeSettleResponseHeader(settleRes)
-      };
-    }
-  );
-}
-
 export {
   resolveX402Asset,
   x402WrongAssetHint,
@@ -1099,6 +1022,5 @@ export {
   removeX402Wallet,
   getX402Balance,
   tryX402Payment,
-  isSignableExactRequirement,
-  verifyX402Payment
+  isSignableExactRequirement
 };

package/dist/{chunk-EXHBXA4U.js → chunk-DBCLBYHP.js}

@@ -15,7 +15,7 @@ import {
   lotOwedSats,
   netOwedSats,
   x402SettlementPending
-} from "./chunk-LWUR4CGG.js";
+} from "./chunk-MLRCSJYX.js";
 
 // src/sdk/server/memory-credit-ledger.ts
 import { randomUUID } from "crypto";
@@ -624,6 +624,18 @@ var MemoryCreditLedger = class {
     }
     return Promise.resolve(matches.length === 1 ? matches[0] : void 0);
   }
+  listDrawsByJobId(jobId) {
+    const matches = [];
+    for (const credit of this.credits.values()) {
+      for (const draw of credit.draws.values()) {
+        if (draw.jobId === jobId) matches.push(drawRecord(draw, credit));
+      }
+    }
+    matches.sort(
+      (a, b) => a.createdAt - b.createdAt || a.creditId.localeCompare(b.creditId) || a.ledgerSeq - b.ledgerSeq
+    );
+    return Promise.resolve(matches);
+  }
   listPendingDraws(creditId) {
     const credit = this.credits.get(creditId);
     if (!credit) return Promise.resolve([]);