@dvmkit/sdk 0.1.2-rc.7 → 0.1.4-rc.7

package/README.md

@@ -2,31 +2,144 @@
 
 Build Digital Vending Machines: accountless HTTPS services with typed inputs, jobs, and payment rails.
 
-## Development
+Requires Node.js 22 or later. This is pre-1.0 alpha software: pin the exact package version and read the [release notes](./CHANGELOG.md) before upgrading.
+
+## Quickstart: a free DVM
+
+Create a project and install the SDK:
+
+```sh
+mkdir hello-dvm && cd hello-dvm
+npm init -y
+npm install --save-exact @dvmkit/sdk
+```
+
+Save this as `handler.mjs`:
+
+```js
+import { configureDVM, z } from "@dvmkit/sdk";
+
+export default configureDVM({
+  name: "hello",
+  capability: "echo",
+  input: z.object({ text: z.string().min(1) }),
+  example: { text: "hello" },
+  onJob(ctx) {
+    ctx.artifact({ mime_type: "text/plain", data: ctx.input.text });
+    ctx.complete("Echoed the input");
+  },
+});
+```
+
+Save this as `server.mjs`, then run it with `node server.mjs`:
+
+```js
+import { serve } from "@dvmkit/sdk/server";
+import dvm from "./handler.mjs";
+
+await serve(dvm, { devMode: true });
+```
+
+Submit a local request. `devMode` makes Postgres optional and skips payment verification when no Cashu mint is configured:
+
+```sh
+curl -sS http://localhost:8080/v1/job \
+  -H 'content-type: application/json' \
+  --data '{"capability":"echo","data":{"text":"hello"}}'
+```
+
+Test the handler without opening a port or configuring a payment rail:
+
+```js
+import assert from "node:assert/strict";
+import test from "node:test";
+import { createTestContext } from "@dvmkit/sdk/testing";
+import dvm from "./handler.mjs";
+
+test("echoes its input", async () => {
+  const ctx = createTestContext({ input: { text: "hello" } });
+  await dvm.capabilities.echo.onJob(ctx);
+  assert.equal(ctx.completed, true);
+  assert.equal(ctx.messages[0].content.data, "hello");
+});
+```
+
+Run that file with `node --test handler.test.mjs`. The repository carries the complete version under [`examples/quickstart`](./examples/quickstart), plus runnable [signed-auth/custom-route](./examples/authenticated-route) and [payment/lifecycle](./examples/payments-and-lifecycle) examples.
+
+## Public entry points
+
+| Import | Use it for |
+| --- | --- |
+| `@dvmkit/sdk` | DVM descriptors, handler context, bundled Zod, pricing, signing and safe-fetch helpers |
+| `@dvmkit/sdk/server` | Node hosting, Postgres stores, signed-request auth, compatibility gates and payment infrastructure |
+| `@dvmkit/sdk/testing` | Deterministic handler contexts and in-memory stores |
+
+The generated [API reference](./docs/API.md) lists every declaration under these three entries. Deep imports from `dist/` are unsupported.
+
+## Production next steps
+
+- Use Postgres through `DATABASE_URL`; production boot refuses an in-memory job store unless you deliberately supply another durable implementation.
+- Add `auth: secp256k1Auth()` for caller-owned state. The host automatically uses a Postgres replay store when one is available; a per-process replay window is unsafe across replicas.
+- Configure only the rails you operate: Cashu, x402, and Tempo are job payment methods. Lightning is a receive-only prepaid-credit funding leg. Keep every private key, wallet connection, and platform token in your secret store rather than source.
+- A `credit` block opts into reusable prepaid balances and their reclaim obligations. Reusable channels return undrawn collateral through their channel lifecycle; one-payment stablecoin funding is disabled unless `allowOneShotStablecoin: true` because it creates manual refunds. Run and monitor the documented reclaim/payout worker.
+- Honour `ctx.signal`, use `ctx.fetch` for abortable provider calls, and declare provider cost with `ctx.cost` only after the durable step that incurred it.
+
+The public [SDK guide](https://dvmkit.com/docs/sdk) covers signed requests, custom routes, rail configuration, credit reclaim, persistence, and deployment in depth. The [protocol guide](https://dvmkit.com/docs/protocol) specifies the HTTP contract.
+
+## Repository development
 
 Use the Node.js release in `.nvmrc` (Node 22). Install with `npm ci`, then run the same gate CI runs with `npm run verify`: the toolchain check, lint, build, typecheck (including the release scripts under `checkJs`), unit and database tests, the public API surface and package-shape checks, a consumer install, a public-safety scan, the release contract, and a clean-install smoke.
 
 `DATABASE_URL` is optional locally. Without it the database suite is skipped rather than passed, and `verify` says so in its summary, because a skipped suite verified nothing and must not be reported as green. Point `DATABASE_URL` at a scratch Postgres to run it, and pass `npm run verify -- --require-database` to make a missing one a failure, which is what CI does.
 
-The public surface is exactly `@dvmkit/sdk`, `@dvmkit/sdk/server`, and `@dvmkit/sdk/testing`. There is a fourth entry point, `@dvmkit/sdk/internal`, which is not part of it; see below. Documentation is at [dvmkit.ai](https://dvmkit.ai/docs/sdk).
+The public surface is exactly `@dvmkit/sdk`, `@dvmkit/sdk/server`, and `@dvmkit/sdk/testing`.
 
 ## Compatibility and versioning
 
 This is pre-1.0 alpha software and the promises match that. Breaking changes can land in any release, they are announced in the release notes for the release that carries them, and there is no long-term support release. Security fixes are made on the latest published release rather than backported.
 
-The public surface is exactly three entry points: `@dvmkit/sdk`, `@dvmkit/sdk/server`, and `@dvmkit/sdk/testing`. Nothing reachable only through a deep path into `dist/` is public, nothing under `@dvmkit/sdk/internal` is public, and `npm run check:api` pins every exported declaration name against `api-surface.json`, so a change to that surface is a deliberate, reviewed act rather than a side effect.
+Nothing reachable only through a deep path into `dist/` is public. `npm run check:api` pins every exported declaration name against `api-surface.json` and the generated API reference, so a change to the supported surface is a deliberate, reviewed act rather than a side effect.
+
+Wire compatibility with callers is separate from the package version and is declared per endpoint. A server built on this SDK answers `DVM-Protocol-Version: 1`, and an individual endpoint may require a set of named capability tokens the caller advertises, a minimum caller version, or both. Capability tokens are additive, so an endpoint that declares no requirement stays reachable by a caller that sends no compatibility headers at all. A caller that cannot meet what an endpoint declares gets HTTP 426 naming the required capabilities and, where one is declared, the minimum version. The protocol is specified at [dvmkit.com/docs/protocol](https://dvmkit.com/docs/protocol).
 
-Wire compatibility with callers is separate from the package version and is declared per endpoint. A server built on this SDK answers `DVM-Protocol-Version: 1`, and an individual endpoint may require a set of named capability tokens the caller advertises, a minimum caller version, or both. Capability tokens are additive, so an endpoint that declares no requirement stays reachable by a caller that sends no compatibility headers at all. A caller that cannot meet what an endpoint declares gets HTTP 426 naming the required capabilities and, where one is declared, the minimum version. The protocol is specified at [dvmkit.ai/docs/protocol](https://dvmkit.ai/docs/protocol).
+## Job credentials
+
+An unauthenticated `POST /v1/job` returns a one-time `job_token` alongside the `job_id`. Callers must send it as the `X-Job-Token` header on subsequent status reads, message reads (JSON or SSE), message writes, and cancellation. A request with no credential gets a 401 `job_credential_required`; a wrong credential remains the opaque 404 `Job not found` response.
+
+When a caller has lost its local job record, the standalone `@dvmkit/dvm-cli` can use the provider endpoint and token explicitly. Prefer environment variables so the bearer token does not enter shell history or the process list:
+
+```sh
+DVM_JOB_ENDPOINT=https://provider.example \
+  DVM_JOB_TOKEN=<64-character-hex-token> \
+  dvm status <job-id>
+```
+
+The same values are accepted as `--endpoint <url>` and `--job-token <hex>`. These overrides are request-scoped and are not saved; `dvm pay` still requires the local pending request and spending policy, so an endpoint and token alone cannot authorize a payment.
 
 If an upgrade broke something for you, an [API compatibility report](https://github.com/dvmkit/sdk/issues/new/choose) is the most useful thing you can send us. It tells us which parts of the published surface people actually build on, which no test of ours can.
 
-## Internal entry point
+## Per-job costs
+
+A handler can declare what a job cost **you**, the builder, to serve — a vendor API call, a GPU minute, a per-request licence fee — and the SDK reports it to the platform alongside what the caller paid, so your dashboard can state a margin instead of guessing at one.
+
+```ts
+const transcript = await ctx.step("transcribe", async () => {
+  const result = await whisper(audio);
+  ctx.cost({ amount: result.seconds * 0.0001, currency: "usd" });
+  return result;
+});
+ctx.artifact({ mime_type: "text/plain", data: transcript.text });
+```
+
+`amount` is in whole currency units, like every other money figure you hand the SDK. Call it once per cost you incur; the declarations for one job are summed, and only the total is rounded, to a millionth of a unit. That ordering is what makes fine-grained declarations safe: a per-token charge of $0.0000003 is below the reported resolution on its own, but a thousand of them still add up to $0.0003 rather than to nothing. Every call in a job must name the same currency.
 
-`@dvmkit/sdk/internal` exists for one consumer: the dvmkit platform, which runs on this source instead of keeping a fork of it. Do not build on it.
+Three things worth knowing:
 
-It carries no stability promise of any kind. A name under it can change meaning, change signature, or disappear in any release, including a patch release, and that is not a breaking change: it needs no `!` marker, no `BREAKING CHANGE:` footer, and no note in the release notes. It is not documented, its contents track what the platform happens to need, and it is excluded from everything the three public entry points promise above.
+- **Declaring nothing is not declaring zero.** A job whose handler never calls `ctx.cost` reports no cost at all, and the dashboard says the margin is unknown rather than showing it as 100%. `ctx.cost({ amount: 0, currency: "usd" })` is how you say a job genuinely cost you nothing.
+- **Declare the cost where you incur it, including inside `ctx.step`.** The step cache carries those declarations with the result and applies them once when a replay skips the body.
+- **Every terminal job reports its declared cost.** A paid completion carries the cost on its revenue report. A free completion, failure, or cancellation sends a separate cost-only report and does not create revenue.
 
-The names in it are still pinned in `api-surface.json`, so a change to them is visible in review rather than silent; the pin records what moved, it does not promise that it will not move. If something under `./internal` is genuinely useful to a third party, the way to get it is to ask for it: graduating a name to `.`, `./server` or `./testing` is a deliberate, reviewed `feat`, and only then does it acquire the compatibility promises on this page.
+The cost is yours, never the caller's: it is recorded separately from what the caller paid and is never netted against it. Both report shapes use the same durable outbox. Cost-only reports are keyed on the job id and revisioned, so retries and cross-machine updates converge on the latest cumulative value. With the Postgres job store, boot-time and periodic reconciliation enqueue any terminal cost revision that a process exited before reporting.
 
 ## Contributing
 

package/dist/chunk-BIFLRKMO.js

@@ -0,0 +1,87 @@
+import {
+  createX402FacilitatorAuthHeaders,
+  settleWithFacilitator,
+  verifyWithFacilitator
+} from "./chunk-BQ2NMWKE.js";
+import {
+  buildPaymentRequirements,
+  decodePayment,
+  encodeSettleResponseHeader,
+  exactEvmAuthorization
+} from "./chunk-Z4BNLUZF.js";
+import {
+  usdcToMsats
+} from "./chunk-5URG56JJ.js";
+import {
+  callerLoggers
+} from "./chunk-66HGCPBU.js";
+
+// 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 = btcUsdRate > 0 ? usdcToMsats(amountUsdcMicro / 1e6, btcUsdRate) : 0;
+      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 {
+  verifyX402Payment
+};

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([]);