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

package/dist/{chunk-C2AGARLM.js → chunk-2VGWYG4P.js}

@@ -1,11 +1,13 @@
 import {
   IMPLICIT_CREDIT_TTL_MS
-} from "./chunk-A4CM2BD3.js";
+} from "./chunk-3MHE725Z.js";
 import {
   CREDITS_FILE,
-  DvmError,
   ensureConfigDir
-} from "./chunk-MKI6OVW4.js";
+} from "./chunk-CZULM42S.js";
+import {
+  DvmError
+} from "./chunk-LIRAHP7B.js";
 
 // src/lib/output.ts
 import { writeSync } from "fs";

package/dist/{chunk-A4CM2BD3.js → chunk-3MHE725Z.js}

@@ -1,7 +1,7 @@
 import {
   BTC_RATE_FILE,
   ensureConfigSubdir
-} from "./chunk-MKI6OVW4.js";
+} from "./chunk-CZULM42S.js";
 import {
   formatFiat
 } from "./chunk-AT6V3SY7.js";

package/dist/{chunk-VAMSJRJT.js → chunk-5LR6P7WN.js}

@@ -2,22 +2,24 @@ import {
   costAnchor,
   formatUsd,
   msatsToUsd
-} from "./chunk-A4CM2BD3.js";
+} from "./chunk-3MHE725Z.js";
 import {
   AGENT_MNEMONIC_FILE,
   BUILDER_CONFIG_DIR,
   BUILDER_FILE,
   BUILDER_KEY_FILE,
-  DvmError,
   WALLET_FILE,
   ensureConfigDir
-} from "./chunk-MKI6OVW4.js";
+} from "./chunk-CZULM42S.js";
 import {
   canonicaliseForSigning
 } from "./chunk-KXZUCCEY.js";
 import {
   callerLoggers
 } from "./chunk-66HGCPBU.js";
+import {
+  DvmError
+} from "./chunk-LIRAHP7B.js";
 import {
   diagnosticConsole
 } from "./chunk-ETXDTUJO.js";

package/dist/{chunk-YYQG4R7T.js → chunk-74PUEZJ4.js}

@@ -2,16 +2,18 @@ import {
   isValidEvmPrivateKey,
   loadConfig,
   updateConfig
-} from "./chunk-MG67KXU7.js";
+} from "./chunk-MZRJR2CW.js";
 import {
-  DvmError,
   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/payment-rails/tempo-wallet.ts
 var TEMPO_USDC_MAINNET = "0x20C000000000000000000000b9537d11c60E8b50";
@@ -101,7 +103,7 @@ async function generateTempoKey(opts = {}) {
     );
   }
   if (existing && opts.force) {
-    const { assertTempoWalletIdle } = await import("./tempo-lifecycle-TJ62A7UX.js");
+    const { assertTempoWalletIdle } = await import("./tempo-lifecycle-OTHV757Y.js");
     await assertTempoWalletIdle("replace");
   }
   const { privateKeyToAccount, generatePrivateKey } = await import("viem/accounts");

package/dist/{chunk-MKI6OVW4.js → chunk-CZULM42S.js}

@@ -1,50 +1,3 @@
-// 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;
-}
-
 // src/defaults.ts
 import { homedir } from "os";
 import { join } from "path";
@@ -158,10 +111,6 @@ function resolveRpcHttpTransportOptions(source, envValue) {
 }
 
 export {
-  DvmError,
-  providerProseSources,
-  isAbortError,
-  transportErrorCode,
   CONFIG_DIR,
   CONFIG_FILE,
   CONFIG_BACKUP_FILE,

package/dist/{chunk-M4QDXD2A.js → chunk-FYRR2UEZ.js}

@@ -15,7 +15,7 @@ import {
   lotOwedSats,
   netOwedSats,
   x402SettlementPending
-} from "./chunk-2SD2W2BG.js";
+} from "./chunk-JH3SX3LY.js";
 
 // src/sdk/server/memory-credit-ledger.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-4UZN2GP5.js → chunk-GAOAYHZA.js}

@@ -52,9 +52,13 @@ var PostgresX402BatchStore = class {
           first_failed_at BIGINT,
           last_error      TEXT,
           next_retry_at   BIGINT,
+          obligation_ids  JSONB NOT NULL DEFAULT '[]'::jsonb,
           updated_at      BIGINT NOT NULL
         )
       `);
+      await this.db.query(
+        "ALTER TABLE payout_x402_batches ADD COLUMN IF NOT EXISTS obligation_ids JSONB NOT NULL DEFAULT '[]'::jsonb"
+      );
     });
   }
   async get(scope) {
@@ -71,15 +75,16 @@ var PostgresX402BatchStore = class {
       attempts: row.attempts,
       firstFailedAt: row.first_failed_at === null ? null : Number(row.first_failed_at),
       lastError: row.last_error,
-      nextRetryAt: row.next_retry_at === null ? null : Number(row.next_retry_at)
+      nextRetryAt: row.next_retry_at === null ? null : Number(row.next_retry_at),
+      ...row.obligation_ids.length ? { obligationIds: row.obligation_ids } : {}
     };
   }
   async put(batch) {
     await this.db.query(
       `INSERT INTO payout_x402_batches (
          scope, batch_id, claimed_native, voucher_count, claims, opened_at,
-         attempts, first_failed_at, last_error, next_retry_at, updated_at
-       ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)
+         attempts, first_failed_at, last_error, next_retry_at, obligation_ids, updated_at
+       ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)
        ON CONFLICT (scope) DO UPDATE SET
          batch_id = EXCLUDED.batch_id,
          claimed_native = EXCLUDED.claimed_native,
@@ -90,6 +95,7 @@ var PostgresX402BatchStore = class {
          first_failed_at = EXCLUDED.first_failed_at,
          last_error = EXCLUDED.last_error,
          next_retry_at = EXCLUDED.next_retry_at,
+         obligation_ids = EXCLUDED.obligation_ids,
          updated_at = EXCLUDED.updated_at`,
       [
         batch.scope,
@@ -102,6 +108,7 @@ var PostgresX402BatchStore = class {
         batch.firstFailedAt,
         batch.lastError,
         batch.nextRetryAt,
+        JSON.stringify(batch.obligationIds ?? []),
         Date.now()
       ]
     );
@@ -142,6 +149,7 @@ var PayoutReporter = class {
   ownsBatchStore;
   intervalMs;
   now;
+  hostedObligations;
   lastX402SnapshotAt = 0;
   x402;
   tempo;
@@ -156,6 +164,7 @@ var PayoutReporter = class {
     this.batches = opts.batchStore ?? (opts.db ? new PostgresX402BatchStore(opts.db) : new MemoryX402BatchStore());
     this.intervalMs = opts.snapshotIntervalMs ?? PAYOUT_SNAPSHOT_INTERVAL_MS;
     this.now = opts.now ?? Date.now;
+    this.hostedObligations = opts.hostedObligations;
   }
   async init() {
     if (this.ownsBatchStore && this.batches instanceof PostgresX402BatchStore) {
@@ -171,10 +180,12 @@ var PayoutReporter = class {
     if (this.timer) return;
     this.warmup = setTimeout(() => {
       void this.snapshot();
+      void this.reconcileHosted();
     }, WARMUP_MS);
     this.warmup.unref();
     this.timer = setInterval(() => {
       void this.snapshot();
+      void this.reconcileHosted();
     }, this.intervalMs);
     this.timer.unref();
   }
@@ -184,6 +195,45 @@ var PayoutReporter = class {
     if (this.timer) clearInterval(this.timer);
     this.timer = null;
   }
+  async reconcileHosted() {
+    if (!this.hostedObligations) return;
+    try {
+      for (const failure of await this.hostedObligations.recoverOriginalX402Refunds()) {
+        warn("hosted_refund_recovery_pending", { id: failure.id, error: message(failure.error) });
+      }
+      for (const candidate of await this.hostedObligations.recoveryCandidates()) {
+        if (candidate.blockHash) continue;
+        try {
+          await this.hostedObligations.observeCanonical(candidate.id);
+        } catch (error) {
+          warn("hosted_effect_observation_pending", { id: candidate.id, error: message(error) });
+        }
+      }
+      for (const failure of await this.hostedObligations.reconcileX402Batches()) {
+        warn("hosted_batch_recovery_pending", { id: failure.id, error: message(failure.error) });
+      }
+      for (const candidate of await this.hostedObligations.recoveryCandidates()) {
+        if (!candidate.blockHash || candidate.reportId) continue;
+        try {
+          if (candidate.rail === "tempo" && (candidate.operation === "settle" || candidate.operation === "close") && candidate.deltaNative !== null && BigInt(candidate.deltaNative) > 0n) {
+            await this.tempoSettled({
+              txHash: candidate.txHash,
+              channelId: candidate.channelId,
+              trigger: candidate.operation,
+              amount: BigInt(candidate.deltaNative),
+              delta: BigInt(candidate.deltaNative)
+            });
+          } else if (candidate.rail === "x402" && candidate.operation === "settle" && this.x402) {
+            await this.recordX402Settle(this.x402, candidate.txHash);
+          }
+        } catch (error) {
+          warn("hosted_effect_report_pending", { id: candidate.id, error: message(error) });
+        }
+      }
+    } catch (error) {
+      warn("hosted_effect_recovery_pending", { error: message(error) });
+    }
+  }
   enqueuePayout(payload, tx) {
     return this.transport.enqueuePayout(payload, tx);
   }
@@ -263,8 +313,24 @@ var PayoutReporter = class {
    */
   async tempoSettled(event) {
     try {
+      let hostedIds;
+      if (this.hostedObligations) {
+        hostedIds = await this.hostedObligations.submittedIds(
+          "tempo",
+          event.trigger === "close" ? "close" : "settle",
+          event.txHash
+        );
+        if (hostedIds.length === 1) {
+          const observed = await this.hostedObligations.observeCanonical(hostedIds[0]);
+          if (BigInt(observed.deltaNative) !== event.delta) {
+            throw new Error("Hosted Tempo callback differs from finalized settlement amount");
+          }
+        } else if (await this.hostedObligations.hasCompleteHistory()) {
+          throw new Error("Hosted Tempo payout has no exact original settlement obligation");
+        }
+      }
       if (event.delta <= 0n) return;
-      await this.reportPayout({
+      const payload = {
         dvmId: this.dvmId,
         payoutId: `tempo:${event.txHash}`,
         rail: "tempo",
@@ -279,9 +345,23 @@ var PayoutReporter = class {
           ...this.tempo?.network ? { network: this.tempo.network } : {}
         },
         landedAt: this.now()
-      });
+      };
+      if (this.hostedObligations) {
+        if (hostedIds?.length !== 1 || !this.transport.enqueueHostedPayout) {
+          if (await this.hostedObligations.hasCompleteHistory()) {
+            throw new Error("Hosted Tempo payout has no exact original settlement obligation");
+          }
+          await this.reportPayout(payload);
+        } else {
+          await this.transport.enqueueHostedPayout(payload, hostedIds);
+          void this.flush();
+        }
+      } else {
+        await this.reportPayout(payload);
+      }
     } catch (err) {
       warn("payout_report_failed", { rail: "tempo", kind: event.trigger, error: message(err) });
+      if (this.hostedObligations) throw err;
     }
     void this.snapshotTempo();
   }
@@ -300,29 +380,49 @@ var PayoutReporter = class {
    * this does not report the caller refund.
    */
   async tempoCloseReconciled(event, tx) {
-    const settled = BigInt(event.settledToPayee);
+    let settled = BigInt(event.settledToPayee);
+    let hostedIds;
+    if (this.hostedObligations) {
+      hostedIds = await this.hostedObligations.submittedIds("tempo", "close", event.txHash);
+      if (hostedIds.length === 1) {
+        const alreadySettled = await this.hostedObligations.originalTempoCloseSettled(
+          hostedIds[0],
+          event.channelId,
+          event.txHash
+        );
+        settled -= alreadySettled;
+        if (settled < 0n) throw new Error("Hosted Tempo repair precedes its original settled amount");
+      } else if (await this.hostedObligations.hasCompleteHistory(tx)) {
+        throw new Error("Hosted Tempo repair has no original close obligation");
+      }
+    }
     if (settled <= 0n) return;
-    await this.enqueuePayout(
-      {
-        dvmId: this.dvmId,
-        payoutId: `tempo:${event.txHash}`,
-        rail: "tempo",
-        kind: "close",
-        nativeAmount: Number(settled),
-        nativeAsset: "usdc",
-        recipient: this.tempo?.recipient ?? null,
-        refs: {
-          channelId: event.channelId,
-          txHash: event.txHash,
-          trigger: "close",
-          ...this.tempo?.network ? { network: this.tempo.network } : {}
-        },
-        landedAt: this.now(),
-        repaired: true,
-        repairKind: "tempo_close_reconciled"
+    const payload = {
+      dvmId: this.dvmId,
+      payoutId: `tempo:${event.txHash}`,
+      rail: "tempo",
+      kind: "close",
+      nativeAmount: Number(settled),
+      nativeAsset: "usdc",
+      recipient: this.tempo?.recipient ?? null,
+      refs: {
+        channelId: event.channelId,
+        txHash: event.txHash,
+        trigger: "close",
+        ...this.tempo?.network ? { network: this.tempo.network } : {}
       },
-      tx
-    );
+      landedAt: this.now(),
+      repaired: true,
+      repairKind: "tempo_close_reconciled"
+    };
+    if (hostedIds?.length === 1) {
+      if (!this.transport.enqueueHostedPayout) {
+        throw new Error("Hosted Tempo repair lacks its durable report queue");
+      }
+      await this.transport.enqueueHostedPayout(payload, hostedIds, tx);
+    } else {
+      await this.enqueuePayout(payload, tx);
+    }
     if (!tx) {
       void this.flush();
       void this.snapshotTempo();
@@ -343,6 +443,17 @@ var PayoutReporter = class {
         const ctx = this.x402;
         if (ctx) await this.recordX402SettleFailure(ctx, error);
         void this.snapshotX402();
+      },
+      recordRefundClaim: async (transaction, delta) => {
+        const ctx = this.x402;
+        if (!ctx) throw new Error("Hosted x402 refund has no payout context");
+        await this.recordX402Claim(ctx, {
+          delta,
+          vouchers: 1,
+          transactions: [transaction],
+          operation: "refund"
+        });
+        void this.snapshotX402();
       }
     };
   }
@@ -370,7 +481,8 @@ var PayoutReporter = class {
         }
         await this.recordX402Claim(ctx, {
           delta,
-          vouchers: results.reduce((sum, r) => sum + r.vouchers, 0)
+          vouchers: results.reduce((sum, r) => sum + r.vouchers, 0),
+          transactions: results.map((result) => result.transaction)
         });
         void this.snapshotX402();
       }
@@ -389,10 +501,32 @@ var PayoutReporter = class {
         throw err;
       }
     };
+    const refund = async (channelIds) => {
+      const ctx = this.x402;
+      const before = ctx ? await claimedByChannel(ctx.storage) : /* @__PURE__ */ new Map();
+      const results = await manager.refund(channelIds);
+      if (ctx && this.hostedObligations) {
+        for (const result of results) {
+          const original = before.get(result.channel.toLowerCase());
+          if (!original) throw new Error("Hosted x402 refund lost its original channel snapshot");
+          const delta = original.charged - original.claimed;
+          if (delta > 0n) {
+            await this.recordX402Claim(ctx, {
+              delta,
+              vouchers: 1,
+              transactions: [result.transaction],
+              operation: "refund"
+            });
+          }
+        }
+      }
+      return results;
+    };
     return new Proxy(manager, {
       get(target, prop, receiver) {
         if (prop === "claim") return claim;
         if (prop === "settle") return settle;
+        if (prop === "refund" && target.refund) return refund;
         const value = Reflect.get(target, prop, receiver);
         return typeof value === "function" ? value.bind(target) : value;
       }
@@ -401,7 +535,11 @@ var PayoutReporter = class {
   async recordX402Claim(ctx, claim) {
     try {
       const now = this.now();
-      const open = await this.batches.get(ctx.scope) ?? {
+      const existing = await this.batches.get(ctx.scope);
+      if (this.hostedObligations && !existing) {
+        throw new Error("Hosted x402 claim lost its pre-effect payout batch");
+      }
+      const open = existing ?? {
         scope: ctx.scope,
         batchId: randomUUID(),
         claimedNative: 0n,
@@ -416,9 +554,22 @@ var PayoutReporter = class {
       open.claimedNative += claim.delta;
       open.voucherCount += claim.vouchers;
       open.claims += 1;
+      if (this.hostedObligations) {
+        const ids = (await Promise.all(claim.transactions.map((txHash) => this.hostedObligations.submittedIds(
+          "x402",
+          claim.operation ?? "claim",
+          txHash,
+          open.batchId
+        )))).flat();
+        if (!ids.length || ids.length < claim.vouchers || new Set(ids).size !== ids.length) {
+          throw new Error("Hosted x402 claim has no exact reserved voucher set");
+        }
+        open.obligationIds = [.../* @__PURE__ */ new Set([...open.obligationIds ?? [], ...ids])];
+      }
       await this.batches.put(open);
     } catch (err) {
       warn("payout_batch_track_failed", { scope: ctx.scope, error: message(err) });
+      if (this.hostedObligations) throw err;
     }
   }
   async recordX402Settle(ctx, transaction) {
@@ -433,6 +584,23 @@ var PayoutReporter = class {
         warn("payout_batch_empty", { scope: ctx.scope, transaction, batchId: open.batchId });
         return;
       }
+      if (this.hostedObligations) {
+        if (!open.obligationIds?.length) {
+          throw new Error("Hosted x402 payout has no original claim identities");
+        }
+        const settleId = await this.hostedObligations.settlementId(open.batchId, transaction);
+        const settled = await this.hostedObligations.observeCanonical(settleId);
+        if (BigInt(settled.deltaNative) !== open.claimedNative) {
+          throw new Error("Hosted x402 settled amount differs from its original batch");
+        }
+        let claimed = 0n;
+        for (const id of open.obligationIds) {
+          claimed += BigInt((await this.hostedObligations.observeCanonical(id)).deltaNative);
+        }
+        if (claimed !== open.claimedNative) {
+          throw new Error("Hosted x402 batch amount differs from finalized original claims");
+        }
+      }
       const payload = {
         dvmId: this.dvmId,
         payoutId: `x402:batch:${open.batchId}`,
@@ -450,17 +618,25 @@ var PayoutReporter = class {
         },
         landedAt: this.now()
       };
-      const closed = await this.batches.settle(
-        ctx.scope,
-        open.batchId,
-        (tx) => this.enqueuePayout(payload, tx)
-      );
+      const closed = await this.batches.settle(ctx.scope, open.batchId, async (tx) => {
+        if (!this.hostedObligations) return this.enqueuePayout(payload, tx);
+        if (!this.transport.enqueueHostedPayout || !open.obligationIds?.length) {
+          throw new Error("Hosted x402 payout lacks its original claims or durable queue");
+        }
+        const settleId = await this.hostedObligations.settlementId(open.batchId, transaction);
+        await this.transport.enqueueHostedPayout(
+          payload,
+          [...open.obligationIds, settleId],
+          tx
+        );
+      });
       if (!closed) {
         warn("payout_batch_raced", { scope: ctx.scope, transaction, batchId: open.batchId });
         return;
       }
     } catch (err) {
       warn("payout_report_failed", { rail: "x402", kind: "batch", error: message(err) });
+      if (this.hostedObligations) throw err;
       return;
     }
     void this.flush();

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

@@ -1,106 +1,11 @@
 import {
-  DvmError
-} from "./chunk-MKI6OVW4.js";
+  x402NetworkByCaip2,
+  x402NetworkBySlug
+} from "./chunk-RLTSCKRI.js";
 
 // src/lib/x402/constants.ts
 var X402_DEFAULT_FACILITATOR = "https://x402.org/facilitator";
 
-// 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]));
-
 // src/lib/x402/spec.ts
 var X402_VERSION = 2;
 var X402_V1_VERSION = 1;
@@ -301,13 +206,6 @@ function isOptionalRecord(value) {
 
 export {
   X402_DEFAULT_FACILITATOR,
-  X402_NETWORKS,
-  x402NetworkByCaip2,
-  x402NetworkBySlug,
-  x402NetworkLabel,
-  x402NetworkListForCopy,
-  assertSupportedX402Network,
-  x402SupportedNetworksHint,
   X402_VERSION,
   X402_V1_VERSION,
   X402_DEFAULT_NETWORK,