@dvmkit/sdk 0.3.4-rc.10 → 0.4.0-rc.1

package/dist/chunk-KA6VN5FK.js

@@ -0,0 +1,245 @@
+import {
+  parseStoreValue,
+  stringifyStoreValue
+} from "./chunk-YG7G4DPZ.js";
+import {
+  withSdkInitLock
+} from "./chunk-COYKJRMM.js";
+import {
+  diagnosticConsole
+} from "./chunk-ETXDTUJO.js";
+
+// src/sdk/server/tempo-charge-store.ts
+import { Credential } from "mppx";
+import { createHash } from "crypto";
+import { keccak256 } from "viem";
+var DEFAULT_TABLE_NAME = "mpp_tempo_charge_replays";
+var DEFAULT_RETENTION_MS = 60 * 60 * 1e3;
+var DEFAULT_GC_SAMPLE_RATE = 0.01;
+var VALID_IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function replayKeyFor(credential) {
+  const payload = credential.payload;
+  if (payload.type === "proof") return `mppx:charge:proof:${credential.challenge.id}`;
+  if (payload.type === "hash" && /^0x[0-9a-fA-F]{64}$/.test(payload.hash ?? "")) {
+    return `mppx:charge:${payload.hash.toLowerCase()}`;
+  }
+  if (payload.type === "transaction" && /^0x[0-9a-fA-F]+$/.test(payload.signature ?? "")) {
+    return `mppx:charge:${keccak256(payload.signature).toLowerCase()}`;
+  }
+  throw new Error("Hosted Tempo charge credential has no supported replay key");
+}
+function canonicalCredential(credential) {
+  const serialized = Credential.serialize(credential);
+  const encoded = serialized.slice(serialized.indexOf(" ") + 1);
+  const wire = JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+  const sorted = (value) => {
+    if (Array.isArray(value)) return value.map(sorted);
+    if (value && typeof value === "object") {
+      return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, field]) => [key, sorted(field)]));
+    }
+    return value;
+  };
+  return JSON.stringify(sorted(wire));
+}
+var PostgresTempoChargeStore = class {
+  hostingCleanupFence;
+  useHostingCleanupFence(fence) {
+    this.hostingCleanupFence = fence;
+  }
+  async reserveHostedCharge(serializedCredential, intent) {
+    if (!this.hostingCleanupFence) return;
+    const credential = Credential.deserialize(serializedCredential);
+    if (credential.challenge.intent !== "charge" || credential.challenge.method !== "tempo") {
+      throw new Error("Hosted Tempo charge credential is not a Tempo charge");
+    }
+    const challengeId = credential.challenge.id;
+    const replayKey = replayKeyFor(credential);
+    const artifactHash = createHash("sha256").update(serializedCredential).digest("hex");
+    await this.hostingCleanupFence.withNewIntent({
+      ...intent,
+      challengeId,
+      paymentArtifactHash: artifactHash
+    }, async (tx) => {
+      if (intent.paymentSeq !== void 0 && intent.jobId) {
+        const original = await tx.query(
+          `SELECT data->'content'->'tempo_credential' AS credential FROM job_messages
+           WHERE job_id=$1 AND seq=$2 AND status='pending-verification'`,
+          [intent.jobId, intent.paymentSeq]
+        );
+        const recorded = original.rows[0]?.credential;
+        if (!recorded || canonicalCredential(recorded) !== canonicalCredential(credential)) {
+          throw new Error("Hosted Tempo charge differs from the original inbound payment");
+        }
+      }
+      const prior = await tx.query(
+        `SELECT admission_id,job_id,payment_seq,replay_key,payment_artifact_hash FROM sdk_hosted_tempo_charge_intents
+         WHERE challenge_id=$1 FOR UPDATE`,
+        [challengeId]
+      );
+      if (prior.rows[0]) {
+        const row = prior.rows[0];
+        if (row.admission_id !== (intent.admissionId ?? null) || row.job_id !== (intent.jobId ?? null) || row.payment_seq !== (intent.paymentSeq ?? null) || row.replay_key !== replayKey || row.payment_artifact_hash !== artifactHash) {
+          throw new Error("Hosted Tempo charge identity conflicts with the original payment");
+        }
+        return;
+      }
+      await tx.query(
+        `INSERT INTO sdk_hosted_tempo_charge_intents
+         (challenge_id,admission_id,job_id,payment_seq,replay_key,payment_artifact_hash,status)
+         VALUES ($1,$2,$3,$4,$5,$6,'pending')`,
+        [
+          challengeId,
+          intent.admissionId ?? null,
+          intent.jobId ?? null,
+          intent.paymentSeq ?? null,
+          replayKey,
+          artifactHash
+        ]
+      );
+    });
+  }
+  async completeHostedCharge(challengeId) {
+    if (!this.hostingCleanupFence) return;
+    await this.pool.query(
+      `UPDATE sdk_hosted_tempo_charge_intents SET status='complete'
+       WHERE challenge_id=$1 AND status='pending' AND (
+         EXISTS (SELECT 1 FROM processed_payments p
+           WHERE p.payment_id=$1 AND p.rail='tempo' AND p.dvm_id=$2
+             AND p.job_id IS NOT DISTINCT FROM sdk_hosted_tempo_charge_intents.job_id)
+       )`,
+      [challengeId, this.hostingCleanupFence.dvmId]
+    );
+  }
+  pool;
+  tableName;
+  retentionMs;
+  gcSampleRate;
+  now;
+  constructor(pool, opts) {
+    const tableName = opts?.tableName ?? DEFAULT_TABLE_NAME;
+    if (!VALID_IDENTIFIER.test(tableName)) {
+      throw new Error(
+        `PostgresTempoChargeStore: tableName must match ${VALID_IDENTIFIER.source}, got "${tableName}"`
+      );
+    }
+    this.pool = pool;
+    this.tableName = tableName;
+    this.retentionMs = opts?.retentionMs ?? DEFAULT_RETENTION_MS;
+    this.gcSampleRate = opts?.gcSampleRate ?? DEFAULT_GC_SAMPLE_RATE;
+    this.now = opts?.now ?? (() => Date.now());
+    this.get = this.get.bind(this);
+    this.put = this.put.bind(this);
+    this.delete = this.delete.bind(this);
+    this.update = this.update.bind(this);
+  }
+  /** Run the CREATE TABLE migration. Idempotent — safe to call repeatedly. */
+  async init() {
+    await withSdkInitLock(this.pool, () => this.createTables());
+  }
+  /** Read one stored value, or `null` when absent — mppx's miss sentinel. */
+  async get(key) {
+    const { rows } = await this.pool.query(
+      `SELECT value_json FROM ${this.tableName} WHERE store_key = $1`,
+      [key]
+    );
+    return rows[0] ? parseStoreValue(rows[0].value_json) : null;
+  }
+  async put(key, value) {
+    await this.update(key, () => ({ op: "set", value, result: void 0 }));
+  }
+  /** Delete one stored value — mppx's compensating release on a failed broadcast. */
+  async delete(key) {
+    await this.update(key, () => ({ op: "delete", result: void 0 }));
+  }
+  /**
+   * Advisory locking covers the absent-row first write before the row lock.
+   * Both competing presentations of one credential and the shared sponsor
+   * budget need this serialization. The transaction contains no chain call.
+   */
+  async update(key, fn) {
+    const client = await this.pool.connect();
+    try {
+      await client.query("BEGIN");
+      await client.query(`SELECT pg_advisory_xact_lock(hashtextextended($1, 2036))`, [key]);
+      const { rows } = await client.query(
+        `SELECT value_json FROM ${this.tableName} WHERE store_key = $1 FOR UPDATE`,
+        [key]
+      );
+      const current = rows[0] ? parseStoreValue(rows[0].value_json) : null;
+      const change = fn(current);
+      const now = this.now();
+      if (change.op === "set") {
+        if (this.hostingCleanupFence) {
+          const pending = await client.query(
+            `SELECT EXISTS (
+               SELECT 1 FROM sdk_hosted_tempo_charge_intents i
+               LEFT JOIN sdk_hosting_admissions a ON a.id=i.admission_id
+               LEFT JOIN jobs j ON j.id=i.job_id
+               WHERE i.status='pending' AND i.replay_key=$3 AND
+                 ((a.dvm_id=$1 AND a.scope=$2) OR j.dvm_id=$1)
+             ) AS reserved`,
+            [this.hostingCleanupFence.dvmId, this.hostingCleanupFence.scope, key]
+          );
+          if (!pending.rows[0]?.reserved) {
+            await this.hostingCleanupFence.assertNewIntent(client);
+          }
+        }
+        await client.query(
+          `INSERT INTO ${this.tableName} (store_key, value_json, expires_at)
+           VALUES ($1, $2, $3)
+           ON CONFLICT (store_key) DO UPDATE
+             SET value_json = EXCLUDED.value_json, expires_at = EXCLUDED.expires_at`,
+          [
+            key,
+            stringifyStoreValue(change.value, "Tempo charge store value"),
+            now + this.retentionMs
+          ]
+        );
+      } else if (change.op === "delete") {
+        await client.query(`DELETE FROM ${this.tableName} WHERE store_key = $1`, [key]);
+      }
+      await client.query("COMMIT");
+      if (change.op !== "noop") this.maybeSweep(now);
+      return change.result;
+    } catch (error) {
+      await client.query("ROLLBACK").catch(() => void 0);
+      throw error;
+    } finally {
+      client.release();
+    }
+  }
+  async createTables() {
+    await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS ${this.tableName} (
+        store_key  TEXT PRIMARY KEY,
+        value_json TEXT NOT NULL,
+        expires_at BIGINT NOT NULL
+      );
+      CREATE INDEX IF NOT EXISTS ${this.tableName}_expires_at_idx
+        ON ${this.tableName} (expires_at);
+      CREATE TABLE IF NOT EXISTS sdk_hosted_tempo_charge_intents (
+        challenge_id TEXT PRIMARY KEY,
+        admission_id TEXT,
+        job_id TEXT,
+        payment_seq INTEGER,
+        replay_key TEXT,
+        payment_artifact_hash TEXT,
+        status TEXT NOT NULL CHECK (status IN ('pending','complete')),
+        created_at TIMESTAMPTZ NOT NULL DEFAULT clock_timestamp()
+      );
+      ALTER TABLE sdk_hosted_tempo_charge_intents
+        ADD COLUMN IF NOT EXISTS replay_key TEXT,
+        ADD COLUMN IF NOT EXISTS payment_artifact_hash TEXT;
+    `);
+  }
+  maybeSweep(now) {
+    if (this.gcSampleRate <= 0 || Math.random() >= this.gcSampleRate) return;
+    this.pool.query(`DELETE FROM ${this.tableName} WHERE expires_at < $1`, [now]).catch((err) => {
+      diagnosticConsole.error("PostgresTempoChargeStore GC sweep failed:", err);
+    });
+  }
+};
+
+export {
+  PostgresTempoChargeStore
+};

package/dist/chunk-LIRAHP7B.js

@@ -0,0 +1,53 @@
+// 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;
+}
+
+export {
+  DvmError,
+  providerProseSources,
+  isAbortError,
+  transportErrorCode
+};

package/dist/{chunk-MG67KXU7.js → chunk-MZRJR2CW.js}

@@ -3,9 +3,11 @@ import {
   CONFIG_BACKUP_FILE,
   CONFIG_FILE,
   CONFIG_PINNED_FILE,
-  DvmError,
   ensureConfigDir
-} from "./chunk-MKI6OVW4.js";
+} from "./chunk-CZULM42S.js";
+import {
+  DvmError
+} from "./chunk-LIRAHP7B.js";
 
 // src/lib/evm-private-key.ts
 import { secp256k1 } from "@noble/curves/secp256k1.js";

package/dist/{chunk-JDFLRNAZ.js → chunk-PB4FYZET.js}

@@ -131,6 +131,7 @@ var JOB_MESSAGES_CHANNEL = "job_messages";
 var JOB_DVM_ID = /* @__PURE__ */ Symbol("jobDvmId");
 var PostgresJobStore = class {
   pool;
+  hostingCleanupFence;
   listenChannel = null;
   messageSubscribers = /* @__PURE__ */ new Map();
   notifySubscribers = /* @__PURE__ */ new Map();
@@ -138,6 +139,9 @@ var PostgresJobStore = class {
   constructor(pool) {
     this.pool = pool;
   }
+  useHostingCleanupFence(fence) {
+    this.hostingCleanupFence = fence;
+  }
   /** Run the CREATE TABLE migration. Call once at startup. */
   async init() {
     await withSdkInitLock(this.pool, () => this.createTables());
@@ -298,9 +302,11 @@ var PostgresJobStore = class {
         seq     INTEGER NOT NULL,
         data    JSONB NOT NULL,
         status  TEXT NOT NULL DEFAULT 'verified',
+        created_at_ms BIGINT,
         PRIMARY KEY (job_id, seq)
       );
       ALTER TABLE job_messages ADD COLUMN IF NOT EXISTS status TEXT NOT NULL DEFAULT 'verified';
+      ALTER TABLE job_messages ADD COLUMN IF NOT EXISTS created_at_ms BIGINT;
 
       -- per-DVM monotonic receipt counter. Single row by
       -- construction (the CHECK pins the key), and per-DVM by construction
@@ -356,6 +362,7 @@ var PostgresJobStore = class {
     const client = await this.pool.connect();
     const lockKey = requestIdAdvisoryLockKey(claim.requesterPubkey, claim.requestId);
     let locked = false;
+    let transactional = false;
     try {
       const lock = await client.query(
         "SELECT pg_try_advisory_lock($1::bigint) AS acquired",
@@ -363,6 +370,11 @@ var PostgresJobStore = class {
       );
       if (!lock.rows[0]?.acquired) return void 0;
       locked = true;
+      if (createBinding && this.hostingCleanupFence) {
+        await client.query("BEGIN");
+        transactional = true;
+        await this.hostingCleanupFence.assertNewIntent(client);
+      }
       const now = Date.now();
       const inserted = createBinding ? await client.query(
         `INSERT INTO request_id_claims (
@@ -395,6 +407,10 @@ var PostgresJobStore = class {
           result = { jobId: row.job_id, replayed: true };
         }
       }
+      if (transactional) {
+        await client.query("COMMIT");
+        transactional = false;
+      }
       if (!result) return void 0;
       this.requestIdClaimLocks.set(claim.claimToken, {
         client,
@@ -403,6 +419,9 @@ var PostgresJobStore = class {
         requestId: claim.requestId
       });
       return result;
+    } catch (error) {
+      if (transactional) await client.query("ROLLBACK").catch(() => void 0);
+      throw error;
     } finally {
       if (!this.requestIdClaimLocks.has(claim.claimToken)) {
         let discard = false;
@@ -452,7 +471,7 @@ var PostgresJobStore = class {
   }
   async saveRecord(record, dvmId) {
     const now = Date.now();
-    const { rowCount } = await this.pool.query(
+    const write = (q) => q.query(
       `INSERT INTO jobs (
         id, tags, capability, input, params, requester_id, status, summary,
         messages, seq, paid_msats, payment_mint, payment_rail,
@@ -596,6 +615,33 @@ var PostgresJobStore = class {
         record.timingKnown ?? true
       ]
     );
+    let rowCount;
+    if (this.hostingCleanupFence) {
+      const tx = await this.pool.connect();
+      try {
+        await tx.query("BEGIN");
+        const existing = await tx.query(
+          "SELECT dvm_id FROM jobs WHERE id=$1 FOR UPDATE",
+          [record.id]
+        );
+        if (existing.rows[0]) {
+          if (existing.rows[0].dvm_id !== null && existing.rows[0].dvm_id !== this.hostingCleanupFence.dvmId) {
+            throw new Error("Hosted job belongs to another DVM");
+          }
+        } else {
+          await this.hostingCleanupFence.assertNewIntent(tx, { jobId: record.id });
+        }
+        ({ rowCount } = await write(tx));
+        await tx.query("COMMIT");
+      } catch (error) {
+        await tx.query("ROLLBACK").catch(() => void 0);
+        throw error;
+      } finally {
+        tx.release();
+      }
+    } else {
+      ({ rowCount } = await write(this.pool));
+    }
     if (rowCount === 0) {
       diagnosticConsole.warn(
         {
@@ -607,7 +653,7 @@ var PostgresJobStore = class {
       return;
     }
     if (record.status === "completed" || record.status === "failed" || record.status === "cancelled") {
-      await this.pool.query("DELETE FROM job_messages WHERE job_id = $1", [record.id]).catch(() => void 0);
+      await this.deleteResolvedMessages(record.id).catch(() => void 0);
     }
   }
   /** Advance only after the reporter durably enqueued or deduplicated the event. */
@@ -658,8 +704,11 @@ var PostgresJobStore = class {
     return rowCount === 1;
   }
   async delete(id) {
+    if (this.hostingCleanupFence) {
+      throw new Error("Hosted job deletion cannot discard obligation evidence");
+    }
     await this.pool.query("DELETE FROM jobs WHERE id = $1", [id]);
-    await this.pool.query("DELETE FROM job_messages WHERE job_id = $1", [id]).catch(() => void 0);
+    await this.deleteResolvedMessages(id).catch(() => void 0);
   }
   async listJobsForRetention(args) {
     const after = args.after;
@@ -710,8 +759,12 @@ var PostgresJobStore = class {
        WHERE id = $1
          AND last_activity_at = $2
          AND redacted_at IS NULL
-         AND status IN ('completed', 'failed', 'cancelled')`,
-        [args.jobId, args.expectedLastActivityAt, args.redactedAt]
+         AND status IN ('completed', 'failed', 'cancelled')
+         AND ($4::boolean = false OR NOT EXISTS (
+           SELECT 1 FROM job_messages m WHERE m.job_id=jobs.id
+             AND m.data->>'type'='payment'
+             AND m.status IN ('pending-verification','failed-verify')))`,
+        [args.jobId, args.expectedLastActivityAt, args.redactedAt, !!this.hostingCleanupFence]
       );
       if (rowCount === 1) {
         await client.query("DELETE FROM job_messages WHERE job_id = $1", [args.jobId]);
@@ -870,6 +923,7 @@ var PostgresJobStore = class {
     const client = await this.pool.connect();
     try {
       await client.query("BEGIN");
+      if (message.type === "payment") await this.hostingCleanupFence?.assertNewIntent(client);
       const { rows } = await client.query(
         `UPDATE jobs SET next_seq = next_seq + 1, last_activity_at = $2
            WHERE id = $1 AND redacted_at IS NULL
@@ -883,7 +937,9 @@ var PostgresJobStore = class {
       const seq = rows[0].seq;
       const fullMessage = { ...message, seq };
       await client.query(
-        "INSERT INTO job_messages (job_id, seq, data, status) VALUES ($1, $2, $3, 'pending-verification')",
+        `INSERT INTO job_messages (job_id, seq, data, status, created_at_ms)
+         VALUES ($1, $2, $3, 'pending-verification',
+           FLOOR(EXTRACT(EPOCH FROM clock_timestamp()) * 1000)::bigint)`,
         [jobId, seq, JSON.stringify(fullMessage)]
       );
       await client.query("SELECT pg_notify('job_messages', $1)", [jobId]);
@@ -1272,9 +1328,13 @@ var PostgresJobStore = class {
     } finally {
       client.release();
     }
-    await this.pool.query("DELETE FROM job_messages WHERE job_id = $1", [jobId]).catch(() => void 0);
+    await this.deleteResolvedMessages(jobId).catch(() => void 0);
     return true;
   }
+  async deleteResolvedMessages(jobId) {
+    await this.pool.query(this.hostingCleanupFence ? `DELETE FROM job_messages WHERE job_id=$1 AND NOT (
+           data->>'type'='payment' AND status IN ('pending-verification','failed-verify'))` : "DELETE FROM job_messages WHERE job_id=$1", [jobId]);
+  }
   async fetchCountersTx(client, jobId) {
     const { rows } = await client.query(
       "SELECT status, paid_msats, pending_payment_msats, summary FROM jobs WHERE id = $1",

package/dist/{chunk-BQ2NMWKE.js → chunk-PLG4XER6.js}

@@ -1,6 +1,6 @@
 import {
   X402_DEFAULT_FACILITATOR
-} from "./chunk-Z4BNLUZF.js";
+} from "./chunk-IWQHUSMO.js";
 import {
   callerLoggers
 } from "./chunk-66HGCPBU.js";

package/dist/{chunk-Z3EHBW2G.js → chunk-R4DQZFAL.js}

@@ -2,31 +2,33 @@ import {
   connectedTempoAccount,
   tempoBalanceCheckHint,
   tempoTokenReference
-} from "./chunk-YYQG4R7T.js";
+} from "./chunk-74PUEZJ4.js";
 import {
   fundingReachableAt,
   listCredits,
   maxAdvertisedMicro,
   normalizeCreditEndpoint,
   withinAdvertisedTolerance
-} from "./chunk-C2AGARLM.js";
+} from "./chunk-2VGWYG4P.js";
 import {
   costAnchor,
   formatUsd,
   formatUsdcMicrounits
-} from "./chunk-A4CM2BD3.js";
+} from "./chunk-3MHE725Z.js";
 import {
-  DvmError,
   IDENTITIES_FILE,
   TEMPO_CHANNELS_FILE,
   ensureConfigDir,
   resolveRpcHttpTransportOptions,
   resolveRpcOverride
-} from "./chunk-MKI6OVW4.js";
+} from "./chunk-CZULM42S.js";
 import {
   redactUrl,
   redactUrlsInText
 } from "./chunk-FUJ36YDV.js";
+import {
+  DvmError
+} from "./chunk-LIRAHP7B.js";
 
 // src/lib/cli-identity-store.ts
 import { schnorr } from "@noble/curves/secp256k1.js";

package/dist/chunk-RLTSCKRI.js

@@ -0,0 +1,109 @@
+import {
+  DvmError
+} from "./chunk-LIRAHP7B.js";
+
+// src/lib/x402/networks.ts
+var X402_NETWORKS = [
+  {
+    caip2: "eip155:8453",
+    slug: "base",
+    label: "Base",
+    usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    domainName: "USD Coin",
+    domainVersion: "2",
+    viemChain: "base",
+    nativeGas: "ETH",
+    confusable: "USDbC"
+  },
+  {
+    caip2: "eip155:84532",
+    slug: "base-sepolia",
+    label: "Base Sepolia",
+    usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    domainName: "USDC",
+    domainVersion: "2",
+    viemChain: "baseSepolia",
+    nativeGas: "ETH",
+    confusable: null
+  },
+  {
+    caip2: "eip155:43114",
+    slug: "avalanche",
+    label: "Avalanche",
+    usdc: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+    domainName: "USD Coin",
+    domainVersion: "2",
+    viemChain: "avalanche",
+    nativeGas: "AVAX",
+    confusable: "USDC.e"
+  },
+  {
+    caip2: "eip155:43113",
+    slug: "avalanche-fuji",
+    label: "Avalanche Fuji",
+    usdc: "0x5425890298aed601595a70AB815c96711a31Bc65",
+    domainName: "USD Coin",
+    domainVersion: "2",
+    viemChain: "avalancheFuji",
+    nativeGas: "AVAX",
+    confusable: null
+  },
+  {
+    caip2: "eip155:137",
+    slug: "polygon",
+    label: "Polygon",
+    usdc: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+    domainName: "USD Coin (PoS)",
+    domainVersion: "2",
+    viemChain: "polygon",
+    nativeGas: "POL",
+    confusable: "USDC.e"
+  },
+  {
+    caip2: "eip155:80002",
+    slug: "polygon-amoy",
+    label: "Polygon Amoy",
+    usdc: "0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582",
+    domainName: "USDC",
+    domainVersion: "2",
+    viemChain: "polygonAmoy",
+    nativeGas: "POL",
+    confusable: null
+  }
+];
+function x402NetworkByCaip2(caip2) {
+  return BY_CAIP2.get(caip2);
+}
+function x402NetworkBySlug(slug) {
+  return BY_SLUG.get(slug);
+}
+function x402NetworkLabel(network) {
+  const spec = x402NetworkByCaip2(network);
+  return spec ? `${spec.label} (${network})` : network;
+}
+function x402NetworkListForCopy() {
+  return X402_NETWORKS.map((n) => `${n.caip2} (${n.label})`).join(", ");
+}
+function assertSupportedX402Network(network) {
+  if (x402NetworkByCaip2(network)) return;
+  throw new DvmError(
+    "unsupported_network",
+    `Unsupported x402 network: ${network}.`,
+    `${x402SupportedNetworksHint()} If a wallet is connected, run 'dvm wallet x402-network <caip2>'. For a first connection, pass --network to 'dvm wallet x402-connect'.`
+  );
+}
+function x402SupportedNetworksHint() {
+  return `This rail settles native USDC on: ${x402NetworkListForCopy()}.`;
+}
+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 {
+  X402_NETWORKS,
+  x402NetworkByCaip2,
+  x402NetworkBySlug,
+  x402NetworkLabel,
+  x402NetworkListForCopy,
+  assertSupportedX402Network,
+  x402SupportedNetworksHint
+};

package/dist/{chunk-2KGG5ORW.js → chunk-TXX4GOUB.js}

@@ -2,16 +2,16 @@ import {
   createX402FacilitatorAuthHeaders,
   settleWithFacilitator,
   verifyWithFacilitator
-} from "./chunk-BQ2NMWKE.js";
+} from "./chunk-PLG4XER6.js";
 import {
   buildPaymentRequirements,
   decodePayment,
   encodeSettleResponseHeader,
   exactEvmAuthorization
-} from "./chunk-Z4BNLUZF.js";
+} from "./chunk-IWQHUSMO.js";
 import {
   usdcToMsats
-} from "./chunk-A4CM2BD3.js";
+} from "./chunk-3MHE725Z.js";
 import {
   callerLoggers
 } from "./chunk-66HGCPBU.js";