@dexterai/x402 1.9.4 → 2.0.0

package/dist/client/index.d.ts

@@ -1,32 +1,11 @@
-export { P as PaymentReceipt, a as X402Client, X as X402ClientConfig, c as createX402Client, f as fireImpressionBeacon, g as getPaymentReceipt, d as getSponsoredAccessInfo, b as getSponsoredRecommendations } from '../sponsored-access-D1_mINs4.js';
-import { A as AccessPassClientConfig } from '../types-CjLMR7qs.js';
+export { P as PaymentReceipt, a as X402Client, X as X402ClientConfig, c as createX402Client, f as fireImpressionBeacon, g as getPaymentReceipt, d as getSponsoredAccessInfo, b as getSponsoredRecommendations } from '../sponsored-access-DjLEKhOV.js';
+import { A as AccessPassClientConfig, P as PaymentAccept } from '../types-CjLMR7qs.js';
 export { b as AccessPassInfo, a as AccessPassTier, D as DEXTER_FACILITATOR_URL, U as USDC_MINT, X as X402Error } from '../types-CjLMR7qs.js';
-import { Transaction, VersionedTransaction, Keypair } from '@solana/web3.js';
-import { E as EvmWallet } from '../solana-Cxr5byPa.js';
-export { B as BASE_MAINNET, S as SOLANA_MAINNET, a as createEvmAdapter, c as createSolanaAdapter } from '../solana-Cxr5byPa.js';
-export { C as ChainAdapter, W as WalletSet } from '../types-BIHhO2-I.js';
+import { Keypair } from '@solana/web3.js';
+import { S as SolanaWallet, E as EvmWallet } from '../types-D1TGACsL.js';
+export { B as BASE_MAINNET, C as ChainAdapter, b as SOLANA_MAINNET, W as WalletSet, a as createEvmAdapter, c as createSolanaAdapter } from '../types-D1TGACsL.js';
 export { SponsoredAccessSettlementInfo, SponsoredRecommendation } from '@dexterai/x402-ads-types';
 
-/**
- * Simple Fetch Wrapper for Node.js
- *
- * The easiest way to make x402 payments from Node.js scripts.
- * Just provide a private key and it handles everything automatically.
- *
- * @example
- * ```typescript
- * import { wrapFetch } from '@dexterai/x402/client';
- *
- * const x402Fetch = wrapFetch(fetch, {
- *   walletPrivateKey: process.env.SOLANA_PRIVATE_KEY!,
- * });
- *
- * // Make a paid request - payment happens automatically
- * const response = await x402Fetch('https://api.example.com/protected');
- * const data = await response.json();
- * ```
- */
-
 /**
  * Options for wrapFetch
  */
@@ -81,6 +60,11 @@ interface WrapFetchOptions {
      * ```
      */
     accessPass?: AccessPassClientConfig;
+    /**
+     * Called before signing a payment. Return true to proceed, false to reject.
+     * Used internally by Budget Accounts — can also be set directly.
+     */
+    onPaymentRequired?: (requirements: PaymentAccept) => boolean | Promise<boolean>;
 }
 /**
  * Wrap fetch with automatic x402 payment handling
@@ -138,15 +122,9 @@ declare function wrapFetch(fetchImpl: typeof globalThis.fetch, options: WrapFetc
 /** Symbol key for the underlying Keypair — prevents accidental exposure via console.log or JSON.stringify */
 declare const KEYPAIR_SYMBOL: unique symbol;
 /**
- * Keypair wallet interface (compatible with SDK's SolanaWallet)
+ * Keypair wallet interface — extends SolanaWallet with safe Keypair access.
  */
-interface KeypairWallet {
-    /** Public key with toBase58() method */
-    publicKey: {
-        toBase58(): string;
-    };
-    /** Sign a transaction */
-    signTransaction<T extends Transaction | VersionedTransaction>(tx: T): Promise<T>;
+interface KeypairWallet extends SolanaWallet {
     /**
      * Get the underlying Keypair. Accessed via Symbol to prevent accidental
      * exposure through console.log, JSON.stringify, or Object.keys.
@@ -259,4 +237,190 @@ declare function createEvmKeypairWallet(privateKey: string): Promise<EvmWallet>;
  */
 declare function isEvmKeypairWallet(wallet: unknown): wallet is EvmWallet;
 
-export { AccessPassClientConfig, KEYPAIR_SYMBOL, type KeypairWallet, type WrapFetchOptions, createEvmKeypairWallet, createKeypairWallet, isEvmKeypairWallet, isKeypairWallet, wrapFetch };
+/**
+ * API Discovery — Find x402 Paid APIs
+ *
+ * Search the Dexter marketplace for x402-enabled APIs. Discover endpoints
+ * by category, price range, network, and quality score — then pay for them
+ * with the same SDK.
+ *
+ * @example
+ * ```typescript
+ * import { searchAPIs } from '@dexterai/x402/client';
+ *
+ * const results = await searchAPIs({ query: 'sentiment analysis', maxPrice: 0.10 });
+ * for (const api of results) {
+ *   console.log(`${api.name}: ${api.price} — ${api.description}`);
+ * }
+ *
+ * // Then call one with wrapFetch:
+ * const response = await x402Fetch(results[0].url);
+ * ```
+ */
+/**
+ * Search options for discovering x402 APIs
+ */
+interface SearchAPIsOptions {
+    /** Search query (e.g., 'sentiment analysis', 'token price', 'image generation') */
+    query?: string;
+    /** Filter by category (e.g., 'defi', 'ai', 'data', 'social') */
+    category?: string;
+    /** Filter by payment network (e.g., 'solana', 'base', 'polygon') */
+    network?: string;
+    /** Maximum price per call in USDC */
+    maxPrice?: number;
+    /** Only return verified endpoints (quality score 75+) */
+    verifiedOnly?: boolean;
+    /** Sort order */
+    sort?: 'marketplace' | 'relevance' | 'quality_score' | 'settlements' | 'volume' | 'recent';
+    /** Maximum results to return (default 20, max 50) */
+    limit?: number;
+    /** Marketplace API URL (default: Dexter marketplace) */
+    marketplaceUrl?: string;
+}
+/**
+ * A discovered x402 API endpoint
+ */
+interface DiscoveredAPI {
+    /** API name */
+    name: string;
+    /** Full resource URL — pass directly to wrapFetch or createX402Client.fetch */
+    url: string;
+    /** HTTP method */
+    method: string;
+    /** Price per call (formatted, e.g., '$0.05') */
+    price: string;
+    /** Price per call in USDC (raw number, null if free) */
+    priceUsdc: number | null;
+    /** Payment network */
+    network: string | null;
+    /** Human-readable description */
+    description: string;
+    /** Category (e.g., 'defi', 'ai', 'data') */
+    category: string;
+    /** Quality score (0-100, null if unscored) */
+    qualityScore: number | null;
+    /** Whether the endpoint has been verified */
+    verified: boolean;
+    /** Total number of settlements (calls) */
+    totalCalls: number;
+    /** Total volume in USDC (formatted, e.g., '$1,234.56') */
+    totalVolume: string | null;
+    /** Seller name */
+    seller: string | null;
+    /** Seller reputation score */
+    sellerReputation: number | null;
+    /** Whether authentication is required beyond payment */
+    authRequired: boolean;
+    /** Last time someone called this API */
+    lastActive: string | null;
+}
+/**
+ * Search the Dexter marketplace for x402 paid APIs.
+ *
+ * Returns a list of discovered endpoints that can be called directly
+ * with `wrapFetch` or `createX402Client.fetch`.
+ *
+ * @example Find AI APIs under $0.10
+ * ```typescript
+ * const apis = await searchAPIs({ query: 'ai', maxPrice: 0.10 });
+ * ```
+ *
+ * @example Browse all verified DeFi tools
+ * ```typescript
+ * const apis = await searchAPIs({ category: 'defi', verifiedOnly: true });
+ * ```
+ *
+ * @example Find cheapest APIs on Solana
+ * ```typescript
+ * const apis = await searchAPIs({ network: 'solana', sort: 'quality_score' });
+ * ```
+ */
+declare function searchAPIs(options?: SearchAPIsOptions): Promise<DiscoveredAPI[]>;
+
+/**
+ * Budget Account — Autonomous Agent Spending Controls
+ *
+ * Wraps the x402 client with a spending limit, per-request cap,
+ * per-hour rate limit, and optional domain allowlist. Tracks cumulative
+ * spend and exposes remaining budget. When the budget is exhausted,
+ * requests throw instead of paying.
+ *
+ * @example
+ * ```typescript
+ * import { createBudgetAccount } from '@dexterai/x402/client';
+ *
+ * const agent = createBudgetAccount({
+ *   walletPrivateKey: process.env.SOLANA_PRIVATE_KEY,
+ *   budget: {
+ *     total: '50.00',       // $50 total budget
+ *     perRequest: '1.00',   // max $1 per request
+ *     perHour: '10.00',     // max $10/hour
+ *   },
+ *   allowedDomains: ['api.example.com', 'data.example.com'],
+ * });
+ *
+ * const response = await agent.fetch('https://api.example.com/data');
+ * console.log(agent.spent);       // '$0.05'
+ * console.log(agent.remaining);   // '$49.95'
+ * console.log(agent.payments);    // 1
+ * ```
+ */
+
+/** Budget configuration */
+interface BudgetConfig {
+    /** Total spending limit in USD (e.g., '50.00') */
+    total: string;
+    /** Maximum amount per single request in USD (e.g., '1.00'). Optional. */
+    perRequest?: string;
+    /** Maximum spend per hour in USD (e.g., '10.00'). Optional. */
+    perHour?: string;
+}
+/** Budget Account configuration — extends WrapFetchOptions with spending controls */
+interface BudgetAccountConfig extends WrapFetchOptions {
+    /** Spending limits */
+    budget: BudgetConfig;
+    /** Restrict payments to these domains only. If omitted, all domains allowed. */
+    allowedDomains?: string[];
+}
+/** A payment record in the spend ledger */
+interface PaymentRecord {
+    /** Amount paid in USD */
+    amount: number;
+    /** Domain that was paid */
+    domain: string;
+    /** CAIP-2 network used */
+    network: string;
+    /** Timestamp (ms) */
+    timestamp: number;
+}
+/** Budget Account — fetch with spending controls */
+interface BudgetAccount {
+    /** Payment-aware fetch with budget enforcement */
+    fetch: typeof globalThis.fetch;
+    /** Total amount spent (formatted, e.g., '$12.34') */
+    readonly spent: string;
+    /** Remaining budget (formatted, e.g., '$37.66') */
+    readonly remaining: string;
+    /** Number of payments made */
+    readonly payments: number;
+    /** Total spent as a raw number */
+    readonly spentAmount: number;
+    /** Remaining budget as a raw number */
+    readonly remainingAmount: number;
+    /** Full payment history */
+    readonly ledger: readonly PaymentRecord[];
+    /** Spend in the last hour */
+    readonly hourlySpend: number;
+    /** Reset the budget (clears all spend history) */
+    reset: () => void;
+}
+/**
+ * Create a budget-controlled fetch wrapper for autonomous agents.
+ *
+ * Enforces total spend limit, per-request cap, hourly rate limit,
+ * and domain allowlist. Every payment is tracked in an in-memory ledger.
+ */
+declare function createBudgetAccount(config: BudgetAccountConfig): BudgetAccount;
+
+export { AccessPassClientConfig, type BudgetAccount, type BudgetAccountConfig, type BudgetConfig, type DiscoveredAPI, KEYPAIR_SYMBOL, type KeypairWallet, type PaymentRecord, type SearchAPIsOptions, type WrapFetchOptions, createBudgetAccount, createEvmKeypairWallet, createKeypairWallet, isEvmKeypairWallet, isKeypairWallet, searchAPIs, wrapFetch };

package/dist/client/index.js

@@ -629,10 +629,33 @@ function createX402Client(config) {
     fetch: customFetch = globalThis.fetch,
     verbose = false,
     accessPass: accessPassConfig,
-    onPaymentRequired
+    onPaymentRequired,
+    maxRetries = 0,
+    retryDelayMs = 500
   } = config;
   const log = verbose ? console.log.bind(console, "[x402]") : () => {
   };
+  async function fetchWithRetry(input, init) {
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const response = await customFetch(input, init);
+        if (response.status >= 502 && response.status <= 504 && attempt < maxRetries) {
+          log(`Retry ${attempt + 1}/${maxRetries}: server returned ${response.status}`);
+          await new Promise((r) => setTimeout(r, retryDelayMs * Math.pow(2, attempt)));
+          continue;
+        }
+        return response;
+      } catch (err) {
+        lastError = err;
+        if (attempt < maxRetries) {
+          log(`Retry ${attempt + 1}/${maxRetries}: ${err instanceof Error ? err.message : "network error"}`);
+          await new Promise((r) => setTimeout(r, retryDelayMs * Math.pow(2, attempt)));
+        }
+      }
+    }
+    throw lastError;
+  }
   const passCache = /* @__PURE__ */ new Map();
   function getCachedPass(url) {
     try {
@@ -832,7 +855,7 @@ function createX402Client(config) {
         }
       }
     }
-    const response = await customFetch(input, init);
+    const response = await fetchWithRetry(input, init);
     if (response.status !== 402) {
       return response;
     }
@@ -967,7 +990,7 @@ function createX402Client(config) {
     };
     const paymentSignatureHeader = btoa(JSON.stringify(paymentSignature));
     log("Retrying request with payment...");
-    const retryResponse = await customFetch(input, {
+    const retryResponse = await fetchWithRetry(input, {
       ...init,
       headers: {
         ...init?.headers || {},
@@ -1111,7 +1134,8 @@ function wrapFetch(fetchImpl, options) {
     rpcUrls,
     maxAmountAtomic,
     verbose,
-    accessPass
+    accessPass,
+    onPaymentRequired
   } = options;
   if (!walletPrivateKey && !evmPrivateKey) {
     throw new Error("At least one wallet private key is required (walletPrivateKey or evmPrivateKey)");
@@ -1144,7 +1168,8 @@ function wrapFetch(fetchImpl, options) {
     maxAmountAtomic,
     fetch: fetchImpl,
     verbose,
-    accessPass
+    accessPass,
+    onPaymentRequired
   };
   const client = createX402Client(clientConfig);
   const clientFetch = client.fetch.bind(client);
@@ -1157,6 +1182,164 @@ function wrapFetch(fetchImpl, options) {
   return clientFetch;
 }
 
+// src/client/discovery.ts
+var DEFAULT_MARKETPLACE = "https://x402.dexter.cash/api/facilitator/marketplace/resources";
+async function searchAPIs(options = {}) {
+  const {
+    query,
+    category,
+    network,
+    maxPrice,
+    verifiedOnly,
+    sort = "marketplace",
+    limit = 20,
+    marketplaceUrl = DEFAULT_MARKETPLACE
+  } = options;
+  const params = new URLSearchParams();
+  if (query) params.set("search", query);
+  if (category) params.set("category", category);
+  if (network) params.set("network", network);
+  if (maxPrice !== void 0) params.set("maxPrice", String(maxPrice));
+  if (verifiedOnly) params.set("verified", "true");
+  params.set("sort", sort);
+  params.set("order", "desc");
+  params.set("limit", String(Math.min(limit, 50)));
+  const url = `${marketplaceUrl}?${params.toString()}`;
+  const response = await fetch(url, {
+    headers: { "Accept": "application/json" },
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!response.ok) {
+    throw new Error(`Marketplace search failed: ${response.status}`);
+  }
+  const data = await response.json();
+  if (!data.resources) return [];
+  return data.resources.map((r) => ({
+    name: r.displayName || r.resourceUrl,
+    url: r.resourceUrl,
+    method: r.method || "GET",
+    price: r.priceLabel || (r.priceUsdc ? `$${r.priceUsdc.toFixed(4)}` : "free"),
+    priceUsdc: r.priceUsdc ?? null,
+    network: r.priceNetwork ?? null,
+    description: r.description || "",
+    category: r.category || "uncategorized",
+    qualityScore: r.qualityScore ?? null,
+    verified: r.verificationStatus === "pass",
+    totalCalls: r.totalSettlements || 0,
+    totalVolume: r.totalVolumeUsdc ? `$${r.totalVolumeUsdc.toLocaleString("en-US", { minimumFractionDigits: 2 })}` : null,
+    seller: r.seller?.displayName ?? null,
+    sellerReputation: r.reputationScore ?? null,
+    authRequired: r.authRequired || false,
+    lastActive: r.lastSettlementAt ?? null
+  }));
+}
+
+// src/client/budget-account.ts
+function createBudgetAccount(config) {
+  const { budget, allowedDomains, onPaymentRequired: userOnPayment, ...fetchOptions } = config;
+  const totalBudget = parseFloat(budget.total);
+  const perRequestMax = budget.perRequest ? parseFloat(budget.perRequest) : Infinity;
+  const perHourMax = budget.perHour ? parseFloat(budget.perHour) : Infinity;
+  if (isNaN(totalBudget) || totalBudget <= 0) {
+    throw new Error("budget.total must be a positive number");
+  }
+  let ledger = [];
+  let pendingAmount = 0;
+  function getSpent() {
+    return ledger.reduce((sum, r) => sum + r.amount, 0);
+  }
+  function getHourlySpend() {
+    const cutoff = Date.now() - 36e5;
+    return ledger.filter((r) => r.timestamp >= cutoff).reduce((sum, r) => sum + r.amount, 0);
+  }
+  const innerFetch = wrapFetch(fetch, {
+    ...fetchOptions,
+    onPaymentRequired: async (accept) => {
+      const decimals = accept.extra?.decimals ?? 6;
+      const amountUsd = Number(accept.amount) / Math.pow(10, decimals);
+      if (amountUsd > perRequestMax) {
+        throw new X402Error(
+          "amount_exceeds_max",
+          `$${amountUsd.toFixed(4)} exceeds per-request limit of $${perRequestMax.toFixed(2)}`
+        );
+      }
+      const spent = getSpent();
+      if (spent + amountUsd > totalBudget) {
+        throw new X402Error(
+          "amount_exceeds_max",
+          `Budget exceeded. Spent $${spent.toFixed(2)} of $${totalBudget.toFixed(2)}, payment: $${amountUsd.toFixed(4)}`
+        );
+      }
+      const hourly = getHourlySpend();
+      if (hourly + amountUsd > perHourMax) {
+        throw new X402Error(
+          "amount_exceeds_max",
+          `Hourly limit ($${perHourMax.toFixed(2)}) exceeded. Spent $${hourly.toFixed(2)} this hour`
+        );
+      }
+      pendingAmount = amountUsd;
+      if (userOnPayment) return userOnPayment(accept);
+      return true;
+    }
+  });
+  const budgetFetch = (async (input, init) => {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    let domain = "unknown";
+    try {
+      domain = new URL(url).hostname;
+    } catch {
+    }
+    if (allowedDomains) {
+      if (!allowedDomains.some((d) => domain === d || domain.endsWith(`.${d}`))) {
+        throw new X402Error("payment_rejected", `Domain "${domain}" not in allowed domains`);
+      }
+    }
+    pendingAmount = 0;
+    const response = await innerFetch(input, init);
+    if (pendingAmount > 0) {
+      let network = "unknown";
+      const paymentHeader = response.headers.get("PAYMENT-RESPONSE");
+      if (paymentHeader) {
+        try {
+          const decoded = JSON.parse(atob(paymentHeader));
+          network = decoded.network || network;
+        } catch {
+        }
+      }
+      ledger.push({ amount: pendingAmount, domain, network, timestamp: Date.now() });
+      pendingAmount = 0;
+    }
+    return response;
+  });
+  return {
+    fetch: budgetFetch,
+    get spent() {
+      return `$${getSpent().toFixed(2)}`;
+    },
+    get remaining() {
+      return `$${(totalBudget - getSpent()).toFixed(2)}`;
+    },
+    get payments() {
+      return ledger.length;
+    },
+    get spentAmount() {
+      return getSpent();
+    },
+    get remainingAmount() {
+      return totalBudget - getSpent();
+    },
+    get ledger() {
+      return ledger;
+    },
+    get hourlySpend() {
+      return getHourlySpend();
+    },
+    reset() {
+      ledger = [];
+    }
+  };
+}
+
 // src/client/sponsored-access.ts
 function getSponsoredAccessInfo(response) {
   const receipt = getPaymentReceipt(response);
@@ -1185,6 +1368,7 @@ export {
   SOLANA_MAINNET,
   USDC_MINT,
   X402Error,
+  createBudgetAccount,
   createEvmAdapter,
   createEvmKeypairWallet,
   createKeypairWallet,
@@ -1196,6 +1380,6 @@ export {
   getSponsoredRecommendations,
   isEvmKeypairWallet,
   isKeypairWallet,
+  searchAPIs,
   wrapFetch
 };
-//# sourceMappingURL=index.js.map

package/dist/react/index.cjs

@@ -499,10 +499,33 @@ function createX402Client(config) {
     fetch: customFetch = globalThis.fetch,
     verbose = false,
     accessPass: accessPassConfig,
-    onPaymentRequired
+    onPaymentRequired,
+    maxRetries = 0,
+    retryDelayMs = 500
   } = config;
   const log = verbose ? console.log.bind(console, "[x402]") : () => {
   };
+  async function fetchWithRetry(input, init) {
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const response = await customFetch(input, init);
+        if (response.status >= 502 && response.status <= 504 && attempt < maxRetries) {
+          log(`Retry ${attempt + 1}/${maxRetries}: server returned ${response.status}`);
+          await new Promise((r) => setTimeout(r, retryDelayMs * Math.pow(2, attempt)));
+          continue;
+        }
+        return response;
+      } catch (err) {
+        lastError = err;
+        if (attempt < maxRetries) {
+          log(`Retry ${attempt + 1}/${maxRetries}: ${err instanceof Error ? err.message : "network error"}`);
+          await new Promise((r) => setTimeout(r, retryDelayMs * Math.pow(2, attempt)));
+        }
+      }
+    }
+    throw lastError;
+  }
   const passCache = /* @__PURE__ */ new Map();
   function getCachedPass(url) {
     try {
@@ -702,7 +725,7 @@ function createX402Client(config) {
         }
       }
     }
-    const response = await customFetch(input, init);
+    const response = await fetchWithRetry(input, init);
     if (response.status !== 402) {
       return response;
     }
@@ -837,7 +860,7 @@ function createX402Client(config) {
     };
     const paymentSignatureHeader = btoa(JSON.stringify(paymentSignature));
     log("Retrying request with payment...");
-    const retryResponse = await customFetch(input, {
+    const retryResponse = await fetchWithRetry(input, {
       ...init,
       headers: {
         ...init?.headers || {},
@@ -1347,4 +1370,3 @@ function useAccessPass(config) {
   useAccessPass,
   useX402Payment
 });
-//# sourceMappingURL=index.cjs.map

package/dist/react/index.d.cts

@@ -1,6 +1,6 @@
-import { a as X402Client } from '../sponsored-access-Br6YPA-m.cjs';
-export { f as fireImpressionBeacon, b as getSponsoredRecommendations } from '../sponsored-access-Br6YPA-m.cjs';
-import { W as WalletSet, B as BalanceInfo } from '../types-CfKflCZO.cjs';
+import { a as X402Client } from '../sponsored-access-BgEDLg_H.cjs';
+export { f as fireImpressionBeacon, b as getSponsoredRecommendations } from '../sponsored-access-BgEDLg_H.cjs';
+import { W as WalletSet, d as BalanceInfo } from '../types-DWhpiOBD.cjs';
 import { SponsoredRecommendation } from '@dexterai/x402-ads-types';
 export { SponsoredRecommendation } from '@dexterai/x402-ads-types';
 import { a as AccessPassTier } from '../types-CjLMR7qs.cjs';

package/dist/react/index.d.ts

@@ -1,6 +1,6 @@
-import { a as X402Client } from '../sponsored-access-D1_mINs4.js';
-export { f as fireImpressionBeacon, b as getSponsoredRecommendations } from '../sponsored-access-D1_mINs4.js';
-import { W as WalletSet, B as BalanceInfo } from '../types-BIHhO2-I.js';
+import { a as X402Client } from '../sponsored-access-DjLEKhOV.js';
+export { f as fireImpressionBeacon, b as getSponsoredRecommendations } from '../sponsored-access-DjLEKhOV.js';
+import { W as WalletSet, d as BalanceInfo } from '../types-D1TGACsL.js';
 import { SponsoredRecommendation } from '@dexterai/x402-ads-types';
 export { SponsoredRecommendation } from '@dexterai/x402-ads-types';
 import { a as AccessPassTier } from '../types-CjLMR7qs.js';

package/dist/react/index.js

@@ -472,10 +472,33 @@ function createX402Client(config) {
     fetch: customFetch = globalThis.fetch,
     verbose = false,
     accessPass: accessPassConfig,
-    onPaymentRequired
+    onPaymentRequired,
+    maxRetries = 0,
+    retryDelayMs = 500
   } = config;
   const log = verbose ? console.log.bind(console, "[x402]") : () => {
   };
+  async function fetchWithRetry(input, init) {
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        const response = await customFetch(input, init);
+        if (response.status >= 502 && response.status <= 504 && attempt < maxRetries) {
+          log(`Retry ${attempt + 1}/${maxRetries}: server returned ${response.status}`);
+          await new Promise((r) => setTimeout(r, retryDelayMs * Math.pow(2, attempt)));
+          continue;
+        }
+        return response;
+      } catch (err) {
+        lastError = err;
+        if (attempt < maxRetries) {
+          log(`Retry ${attempt + 1}/${maxRetries}: ${err instanceof Error ? err.message : "network error"}`);
+          await new Promise((r) => setTimeout(r, retryDelayMs * Math.pow(2, attempt)));
+        }
+      }
+    }
+    throw lastError;
+  }
   const passCache = /* @__PURE__ */ new Map();
   function getCachedPass(url) {
     try {
@@ -675,7 +698,7 @@ function createX402Client(config) {
         }
       }
     }
-    const response = await customFetch(input, init);
+    const response = await fetchWithRetry(input, init);
     if (response.status !== 402) {
       return response;
     }
@@ -810,7 +833,7 @@ function createX402Client(config) {
     };
     const paymentSignatureHeader = btoa(JSON.stringify(paymentSignature));
     log("Retrying request with payment...");
-    const retryResponse = await customFetch(input, {
+    const retryResponse = await fetchWithRetry(input, {
       ...init,
       headers: {
         ...init?.headers || {},
@@ -1319,4 +1342,3 @@ export {
   useAccessPass,
   useX402Payment
 };
-//# sourceMappingURL=index.js.map

package/dist/server/index.cjs

@@ -2162,4 +2162,3 @@ var import_x402_ads_types = require("@dexterai/x402-ads-types");
   x402BrowserSupport,
   x402Middleware
 });
-//# sourceMappingURL=index.cjs.map

package/dist/server/index.js

@@ -2092,4 +2092,3 @@ export {
   x402BrowserSupport,
   x402Middleware
 };
-//# sourceMappingURL=index.js.map

package/dist/{sponsored-access-Br6YPA-m.d.cts → sponsored-access-BgEDLg_H.d.cts}

@@ -1,4 +1,4 @@
-import { C as ChainAdapter, W as WalletSet } from './types-CfKflCZO.cjs';
+import { C as ChainAdapter, W as WalletSet } from './types-DWhpiOBD.cjs';
 import { A as AccessPassClientConfig, P as PaymentAccept } from './types-CjLMR7qs.cjs';
 import { SponsoredRecommendation, SponsoredAccessSettlementInfo } from '@dexterai/x402-ads-types';
 
@@ -112,6 +112,17 @@ interface X402ClientConfig {
      * ```
      */
     onPaymentRequired?: (requirements: PaymentAccept) => boolean | Promise<boolean>;
+    /**
+     * Maximum retry attempts for transient failures (network errors, 502/503).
+     * Does not cause double payments — EIP-3009 nonces prevent replay.
+     * @default 0 (no retry)
+     */
+    maxRetries?: number;
+    /**
+     * Base delay between retries in milliseconds (doubles each attempt).
+     * @default 500
+     */
+    retryDelayMs?: number;
 }
 /**
  * x402 Client interface