@x402/fetch 0.0.1 → 2.1.0

package/README.md

@@ -1 +1,196 @@
-# @x402/fetch
+# x402-fetch
+
+A utility package that extends the native `fetch` API to automatically handle 402 Payment Required responses using the x402 payment protocol v2. This package enables seamless integration of payment functionality into your applications when making HTTP requests.
+
+## Installation
+
+```bash
+pnpm install @x402/fetch
+```
+
+## Quick Start
+
+```typescript
+import { wrapFetchWithPaymentFromConfig } from "@x402/fetch";
+import { ExactEvmScheme } from "@x402/evm";
+import { privateKeyToAccount } from "viem/accounts";
+
+// Create an account
+const account = privateKeyToAccount("0xYourPrivateKey");
+
+// Wrap the fetch function with payment handling
+const fetchWithPayment = wrapFetchWithPaymentFromConfig(fetch, {
+  schemes: [
+    {
+      network: "eip155:8453", // Base Sepolia
+      client: new ExactEvmScheme(account),
+    },
+  ],
+});
+
+// Make a request that may require payment
+const response = await fetchWithPayment("https://api.example.com/paid-endpoint", {
+  method: "GET",
+});
+
+const data = await response.json();
+```
+
+## API
+
+### `wrapFetchWithPayment(fetch, client)`
+
+Wraps the native fetch API to handle 402 Payment Required responses automatically.
+
+#### Parameters
+
+- `fetch`: The fetch function to wrap (typically `globalThis.fetch`)
+- `client`: An x402Client instance with registered payment schemes
+
+### `wrapFetchWithPaymentFromConfig(fetch, config)`
+
+Convenience wrapper that creates an x402Client from a configuration object.
+
+#### Parameters
+
+- `fetch`: The fetch function to wrap (typically `globalThis.fetch`)
+- `config`: Configuration object with the following properties:
+  - `schemes`: Array of scheme registrations, each containing:
+    - `network`: Network identifier (e.g., 'eip155:8453', 'solana:mainnet', 'eip155:*' for wildcards)
+    - `client`: The scheme client implementation (e.g., `ExactEvmScheme`, `ExactSvmScheme`)
+    - `x402Version`: Optional protocol version (defaults to 2, set to 1 for legacy support)
+  - `paymentRequirementsSelector`: Optional function to select payment requirements from multiple options
+
+#### Returns
+
+A wrapped fetch function that automatically handles 402 responses by:
+1. Making the initial request
+2. If a 402 response is received, parsing the payment requirements
+3. Creating a payment header using the configured scheme client
+4. Retrying the request with the payment header
+
+## Examples
+
+### Basic Usage with EVM
+
+```typescript
+import { config } from "dotenv";
+import { wrapFetchWithPaymentFromConfig, decodePaymentResponseHeader } from "@x402/fetch";
+import { privateKeyToAccount } from "viem/accounts";
+import { ExactEvmScheme } from "@x402/evm";
+
+config();
+
+const { EVM_PRIVATE_KEY, API_URL } = process.env;
+
+const account = privateKeyToAccount(EVM_PRIVATE_KEY as `0x${string}`);
+
+const fetchWithPayment = wrapFetchWithPaymentFromConfig(fetch, {
+  schemes: [
+    {
+      network: "eip155:*", // Support all EVM chains
+      client: new ExactEvmScheme(account),
+    },
+  ],
+});
+
+// Make a request to a paid API endpoint
+fetchWithPayment(API_URL, {
+  method: "GET",
+})
+  .then(async response => {
+    const data = await response.json();
+    
+    // Optionally decode the payment response header
+    const paymentResponse = response.headers.get("PAYMENT-RESPONSE");
+    if (paymentResponse) {
+      const decoded = decodePaymentResponseHeader(paymentResponse);
+      console.log("Payment details:", decoded);
+    }
+    
+    console.log("Response data:", data);
+  })
+  .catch(error => {
+    console.error(error);
+  });
+```
+
+### Using Builder Pattern
+
+For more control, you can use the builder pattern to register multiple schemes:
+
+```typescript
+import { wrapFetchWithPayment, x402Client } from "@x402/fetch";
+import { ExactEvmScheme } from "@x402/evm/exact/client";
+import { ExactSvmScheme } from "@x402/svm/exact/client";
+import { privateKeyToAccount } from "viem/accounts";
+import { createKeyPairSignerFromBytes } from "@solana/kit";
+import { base58 } from "@scure/base";
+
+// Create signers
+const evmSigner = privateKeyToAccount("0xYourPrivateKey");
+const svmSigner = await createKeyPairSignerFromBytes(base58.decode("YourSvmPrivateKey"));
+
+// Build client with multiple schemes
+const client = new x402Client()
+  .register("eip155:*", new ExactEvmScheme(evmSigner))
+  .register("solana:*", new ExactSvmScheme(svmSigner));
+
+// Wrap fetch with the client
+const fetchWithPayment = wrapFetchWithPayment(fetch, client);
+```
+
+### Multi-Chain Support
+
+```typescript
+import { wrapFetchWithPaymentFromConfig } from "@x402/fetch";
+import { ExactEvmScheme } from "@x402/evm";
+import { ExactSvmScheme } from "@x402/svm";
+
+const fetchWithPayment = wrapFetchWithPaymentFromConfig(fetch, {
+  schemes: [
+    // EVM chains
+    {
+      network: "eip155:8453", // Base Sepolia
+      client: new ExactEvmScheme(evmAccount),
+    },
+    // SVM chains
+    {
+      network: "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1", // Solana devnet
+      client: new ExactSvmScheme(svmSigner),
+    },
+  ],
+});
+```
+
+### Custom Payment Requirements Selector
+
+```typescript
+import { wrapFetchWithPaymentFromConfig, type SelectPaymentRequirements } from "@x402/fetch";
+import { ExactEvmScheme } from "@x402/evm";
+
+// Custom selector that prefers the cheapest option
+const selectCheapestOption: SelectPaymentRequirements = (version, accepts) => {
+  if (!accepts || accepts.length === 0) {
+    throw new Error("No payment options available");
+  }
+  
+  // Sort by value and return the cheapest
+  const sorted = [...accepts].sort((a, b) => 
+    BigInt(a.value) - BigInt(b.value)
+  );
+  
+  return sorted[0];
+};
+
+const fetchWithPayment = wrapFetchWithPaymentFromConfig(fetch, {
+  schemes: [
+    {
+      network: "eip155:8453",
+      client: new ExactEvmScheme(account),
+    },
+  ],
+  paymentRequirementsSelector: selectCheapestOption,
+});
+```
+

package/dist/cjs/index.d.ts

@@ -0,0 +1,52 @@
+import { x402Client, x402HTTPClient, x402ClientConfig } from '@x402/core/client';
+export { PaymentPolicy, SchemeRegistration, SelectPaymentRequirements, x402Client, x402ClientConfig, x402HTTPClient } from '@x402/core/client';
+export { decodePaymentResponseHeader } from '@x402/core/http';
+export { Network, PaymentPayload, PaymentRequired, PaymentRequirements, SchemeNetworkClient } from '@x402/core/types';
+
+/**
+ * Enables the payment of APIs using the x402 payment protocol v2.
+ *
+ * This function wraps the native fetch API to automatically handle 402 Payment Required responses
+ * by creating and sending payment headers. It will:
+ * 1. Make the initial request
+ * 2. If a 402 response is received, parse the payment requirements
+ * 3. Create a payment header using the configured x402HTTPClient
+ * 4. Retry the request with the payment header
+ *
+ * @param fetch - The fetch function to wrap (typically globalThis.fetch)
+ * @param client - Configured x402Client or x402HTTPClient instance for handling payments
+ * @returns A wrapped fetch function that handles 402 responses automatically
+ *
+ * @example
+ * ```typescript
+ * import { wrapFetchWithPayment, x402Client } from '@x402/fetch';
+ * import { ExactEvmScheme } from '@x402/evm';
+ * import { ExactSvmScheme } from '@x402/svm';
+ *
+ * const client = new x402Client()
+ *   .register('eip155:8453', new ExactEvmScheme(evmSigner))
+ *   .register('solana:mainnet', new ExactSvmScheme(svmSigner))
+ *   .register('eip155:1', new ExactEvmScheme(evmSigner), 1); // v1 protocol
+ *
+ * const fetchWithPay = wrapFetchWithPayment(fetch, client);
+ *
+ * // Make a request that may require payment
+ * const response = await fetchWithPay('https://api.example.com/paid-endpoint');
+ * ```
+ *
+ * @throws {Error} If no schemes are provided
+ * @throws {Error} If the request configuration is missing
+ * @throws {Error} If a payment has already been attempted for this request
+ * @throws {Error} If there's an error creating the payment header
+ */
+declare function wrapFetchWithPayment(fetch: typeof globalThis.fetch, client: x402Client | x402HTTPClient): (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+/**
+ * Creates a payment-enabled fetch function from a configuration object.
+ *
+ * @param fetch - The fetch function to wrap (typically globalThis.fetch)
+ * @param config - Configuration options including scheme registrations and selectors
+ * @returns A wrapped fetch function that handles 402 responses automatically
+ */
+declare function wrapFetchWithPaymentFromConfig(fetch: typeof globalThis.fetch, config: x402ClientConfig): (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+
+export { wrapFetchWithPayment, wrapFetchWithPaymentFromConfig };

package/dist/cjs/index.js

@@ -0,0 +1,97 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  decodePaymentResponseHeader: () => import_http.decodePaymentResponseHeader,
+  wrapFetchWithPayment: () => wrapFetchWithPayment,
+  wrapFetchWithPaymentFromConfig: () => wrapFetchWithPaymentFromConfig,
+  x402Client: () => import_client2.x402Client,
+  x402HTTPClient: () => import_client2.x402HTTPClient
+});
+module.exports = __toCommonJS(src_exports);
+var import_client = require("@x402/core/client");
+var import_client2 = require("@x402/core/client");
+var import_http = require("@x402/core/http");
+function wrapFetchWithPayment(fetch, client) {
+  const httpClient = client instanceof import_client.x402HTTPClient ? client : new import_client.x402HTTPClient(client);
+  return async (input, init) => {
+    const response = await fetch(input, init);
+    if (response.status !== 402) {
+      return response;
+    }
+    let paymentRequired;
+    try {
+      const getHeader = (name) => response.headers.get(name);
+      let body;
+      try {
+        const responseText = await response.text();
+        if (responseText) {
+          body = JSON.parse(responseText);
+        }
+      } catch {
+      }
+      paymentRequired = httpClient.getPaymentRequiredResponse(getHeader, body);
+    } catch (error) {
+      throw new Error(
+        `Failed to parse payment requirements: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+    let paymentPayload;
+    try {
+      paymentPayload = await client.createPaymentPayload(paymentRequired);
+    } catch (error) {
+      throw new Error(
+        `Failed to create payment payload: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+    const paymentHeaders = httpClient.encodePaymentSignatureHeader(paymentPayload);
+    if (!init) {
+      throw new Error("Missing fetch request configuration");
+    }
+    if (init.__is402Retry) {
+      throw new Error("Payment already attempted");
+    }
+    const newInit = {
+      ...init,
+      headers: {
+        ...init.headers || {},
+        ...paymentHeaders,
+        "Access-Control-Expose-Headers": "PAYMENT-RESPONSE,X-PAYMENT-RESPONSE"
+      },
+      __is402Retry: true
+    };
+    const secondResponse = await fetch(input, newInit);
+    return secondResponse;
+  };
+}
+function wrapFetchWithPaymentFromConfig(fetch, config) {
+  const client = import_client.x402Client.fromConfig(config);
+  return wrapFetchWithPayment(fetch, client);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  decodePaymentResponseHeader,
+  wrapFetchWithPayment,
+  wrapFetchWithPaymentFromConfig,
+  x402Client,
+  x402HTTPClient
+});
+//# sourceMappingURL=index.js.map

package/dist/cjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["import { x402Client, x402ClientConfig, x402HTTPClient } from \"@x402/core/client\";\nimport { type PaymentRequired } from \"@x402/core/types\";\n\n/**\n * Enables the payment of APIs using the x402 payment protocol v2.\n *\n * This function wraps the native fetch API to automatically handle 402 Payment Required responses\n * by creating and sending payment headers. It will:\n * 1. Make the initial request\n * 2. If a 402 response is received, parse the payment requirements\n * 3. Create a payment header using the configured x402HTTPClient\n * 4. Retry the request with the payment header\n *\n * @param fetch - The fetch function to wrap (typically globalThis.fetch)\n * @param client - Configured x402Client or x402HTTPClient instance for handling payments\n * @returns A wrapped fetch function that handles 402 responses automatically\n *\n * @example\n * ```typescript\n * import { wrapFetchWithPayment, x402Client } from '@x402/fetch';\n * import { ExactEvmScheme } from '@x402/evm';\n * import { ExactSvmScheme } from '@x402/svm';\n *\n * const client = new x402Client()\n *   .register('eip155:8453', new ExactEvmScheme(evmSigner))\n *   .register('solana:mainnet', new ExactSvmScheme(svmSigner))\n *   .register('eip155:1', new ExactEvmScheme(evmSigner), 1); // v1 protocol\n *\n * const fetchWithPay = wrapFetchWithPayment(fetch, client);\n *\n * // Make a request that may require payment\n * const response = await fetchWithPay('https://api.example.com/paid-endpoint');\n * ```\n *\n * @throws {Error} If no schemes are provided\n * @throws {Error} If the request configuration is missing\n * @throws {Error} If a payment has already been attempted for this request\n * @throws {Error} If there's an error creating the payment header\n */\nexport function wrapFetchWithPayment(\n  fetch: typeof globalThis.fetch,\n  client: x402Client | x402HTTPClient,\n) {\n  const httpClient = client instanceof x402HTTPClient ? client : new x402HTTPClient(client);\n\n  return async (input: RequestInfo, init?: RequestInit) => {\n    const response = await fetch(input, init);\n\n    if (response.status !== 402) {\n      return response;\n    }\n\n    // Parse payment requirements from response\n    let paymentRequired: PaymentRequired;\n    try {\n      // Create getHeader function for case-insensitive header lookup\n      const getHeader = (name: string) => response.headers.get(name);\n\n      // Try to get from headers first (v2), then from body (v1)\n      let body: PaymentRequired | undefined;\n      try {\n        const responseText = await response.text();\n        if (responseText) {\n          body = JSON.parse(responseText) as PaymentRequired;\n        }\n      } catch {\n        // Ignore JSON parse errors - might be header-only response\n      }\n\n      paymentRequired = httpClient.getPaymentRequiredResponse(getHeader, body);\n    } catch (error) {\n      throw new Error(\n        `Failed to parse payment requirements: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      );\n    }\n\n    // Create payment payload (copy extensions from PaymentRequired)\n    let paymentPayload;\n    try {\n      paymentPayload = await client.createPaymentPayload(paymentRequired);\n    } catch (error) {\n      throw new Error(\n        `Failed to create payment payload: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      );\n    }\n\n    // Encode payment header\n    const paymentHeaders = httpClient.encodePaymentSignatureHeader(paymentPayload);\n\n    // Ensure we have request init\n    if (!init) {\n      throw new Error(\"Missing fetch request configuration\");\n    }\n\n    // Check if this is already a retry to prevent infinite loops\n    if ((init as { __is402Retry?: boolean }).__is402Retry) {\n      throw new Error(\"Payment already attempted\");\n    }\n\n    // Create new request with payment header\n    const newInit = {\n      ...init,\n      headers: {\n        ...(init.headers || {}),\n        ...paymentHeaders,\n        \"Access-Control-Expose-Headers\": \"PAYMENT-RESPONSE,X-PAYMENT-RESPONSE\",\n      },\n      __is402Retry: true,\n    };\n\n    // Retry the request with payment\n    const secondResponse = await fetch(input, newInit);\n    return secondResponse;\n  };\n}\n\n/**\n * Creates a payment-enabled fetch function from a configuration object.\n *\n * @param fetch - The fetch function to wrap (typically globalThis.fetch)\n * @param config - Configuration options including scheme registrations and selectors\n * @returns A wrapped fetch function that handles 402 responses automatically\n */\nexport function wrapFetchWithPaymentFromConfig(\n  fetch: typeof globalThis.fetch,\n  config: x402ClientConfig,\n) {\n  const client = x402Client.fromConfig(config);\n  return wrapFetchWithPayment(fetch, client);\n}\n\n// Re-export types and utilities for convenience\nexport { x402Client, x402HTTPClient } from \"@x402/core/client\";\nexport type {\n  PaymentPolicy,\n  SchemeRegistration,\n  SelectPaymentRequirements,\n  x402ClientConfig,\n} from \"@x402/core/client\";\nexport { decodePaymentResponseHeader } from \"@x402/core/http\";\nexport type {\n  Network,\n  PaymentPayload,\n  PaymentRequired,\n  PaymentRequirements,\n  SchemeNetworkClient,\n} from \"@x402/core/types\";\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,oBAA6D;AAoI7D,IAAAA,iBAA2C;AAO3C,kBAA4C;AApGrC,SAAS,qBACd,OACA,QACA;AACA,QAAM,aAAa,kBAAkB,+BAAiB,SAAS,IAAI,6BAAe,MAAM;AAExF,SAAO,OAAO,OAAoB,SAAuB;AACvD,UAAM,WAAW,MAAM,MAAM,OAAO,IAAI;AAExC,QAAI,SAAS,WAAW,KAAK;AAC3B,aAAO;AAAA,IACT;AAGA,QAAI;AACJ,QAAI;AAEF,YAAM,YAAY,CAAC,SAAiB,SAAS,QAAQ,IAAI,IAAI;AAG7D,UAAI;AACJ,UAAI;AACF,cAAM,eAAe,MAAM,SAAS,KAAK;AACzC,YAAI,cAAc;AAChB,iBAAO,KAAK,MAAM,YAAY;AAAA,QAChC;AAAA,MACF,QAAQ;AAAA,MAER;AAEA,wBAAkB,WAAW,2BAA2B,WAAW,IAAI;AAAA,IACzE,SAAS,OAAO;AACd,YAAM,IAAI;AAAA,QACR,yCAAyC,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,MACnG;AAAA,IACF;AAGA,QAAI;AACJ,QAAI;AACF,uBAAiB,MAAM,OAAO,qBAAqB,eAAe;AAAA,IACpE,SAAS,OAAO;AACd,YAAM,IAAI;AAAA,QACR,qCAAqC,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,MAC/F;AAAA,IACF;AAGA,UAAM,iBAAiB,WAAW,6BAA6B,cAAc;AAG7E,QAAI,CAAC,MAAM;AACT,YAAM,IAAI,MAAM,qCAAqC;AAAA,IACvD;AAGA,QAAK,KAAoC,cAAc;AACrD,YAAM,IAAI,MAAM,2BAA2B;AAAA,IAC7C;AAGA,UAAM,UAAU;AAAA,MACd,GAAG;AAAA,MACH,SAAS;AAAA,QACP,GAAI,KAAK,WAAW,CAAC;AAAA,QACrB,GAAG;AAAA,QACH,iCAAiC;AAAA,MACnC;AAAA,MACA,cAAc;AAAA,IAChB;AAGA,UAAM,iBAAiB,MAAM,MAAM,OAAO,OAAO;AACjD,WAAO;AAAA,EACT;AACF;AASO,SAAS,+BACd,OACA,QACA;AACA,QAAM,SAAS,yBAAW,WAAW,MAAM;AAC3C,SAAO,qBAAqB,OAAO,MAAM;AAC3C;","names":["import_client"]}

package/dist/esm/index.d.mts

@@ -0,0 +1,52 @@
+import { x402Client, x402HTTPClient, x402ClientConfig } from '@x402/core/client';
+export { PaymentPolicy, SchemeRegistration, SelectPaymentRequirements, x402Client, x402ClientConfig, x402HTTPClient } from '@x402/core/client';
+export { decodePaymentResponseHeader } from '@x402/core/http';
+export { Network, PaymentPayload, PaymentRequired, PaymentRequirements, SchemeNetworkClient } from '@x402/core/types';
+
+/**
+ * Enables the payment of APIs using the x402 payment protocol v2.
+ *
+ * This function wraps the native fetch API to automatically handle 402 Payment Required responses
+ * by creating and sending payment headers. It will:
+ * 1. Make the initial request
+ * 2. If a 402 response is received, parse the payment requirements
+ * 3. Create a payment header using the configured x402HTTPClient
+ * 4. Retry the request with the payment header
+ *
+ * @param fetch - The fetch function to wrap (typically globalThis.fetch)
+ * @param client - Configured x402Client or x402HTTPClient instance for handling payments
+ * @returns A wrapped fetch function that handles 402 responses automatically
+ *
+ * @example
+ * ```typescript
+ * import { wrapFetchWithPayment, x402Client } from '@x402/fetch';
+ * import { ExactEvmScheme } from '@x402/evm';
+ * import { ExactSvmScheme } from '@x402/svm';
+ *
+ * const client = new x402Client()
+ *   .register('eip155:8453', new ExactEvmScheme(evmSigner))
+ *   .register('solana:mainnet', new ExactSvmScheme(svmSigner))
+ *   .register('eip155:1', new ExactEvmScheme(evmSigner), 1); // v1 protocol
+ *
+ * const fetchWithPay = wrapFetchWithPayment(fetch, client);
+ *
+ * // Make a request that may require payment
+ * const response = await fetchWithPay('https://api.example.com/paid-endpoint');
+ * ```
+ *
+ * @throws {Error} If no schemes are provided
+ * @throws {Error} If the request configuration is missing
+ * @throws {Error} If a payment has already been attempted for this request
+ * @throws {Error} If there's an error creating the payment header
+ */
+declare function wrapFetchWithPayment(fetch: typeof globalThis.fetch, client: x402Client | x402HTTPClient): (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+/**
+ * Creates a payment-enabled fetch function from a configuration object.
+ *
+ * @param fetch - The fetch function to wrap (typically globalThis.fetch)
+ * @param config - Configuration options including scheme registrations and selectors
+ * @returns A wrapped fetch function that handles 402 responses automatically
+ */
+declare function wrapFetchWithPaymentFromConfig(fetch: typeof globalThis.fetch, config: x402ClientConfig): (input: RequestInfo, init?: RequestInit) => Promise<Response>;
+
+export { wrapFetchWithPayment, wrapFetchWithPaymentFromConfig };

package/dist/esm/index.mjs

@@ -0,0 +1,68 @@
+// src/index.ts
+import { x402Client, x402HTTPClient } from "@x402/core/client";
+import { x402Client as x402Client2, x402HTTPClient as x402HTTPClient2 } from "@x402/core/client";
+import { decodePaymentResponseHeader } from "@x402/core/http";
+function wrapFetchWithPayment(fetch, client) {
+  const httpClient = client instanceof x402HTTPClient ? client : new x402HTTPClient(client);
+  return async (input, init) => {
+    const response = await fetch(input, init);
+    if (response.status !== 402) {
+      return response;
+    }
+    let paymentRequired;
+    try {
+      const getHeader = (name) => response.headers.get(name);
+      let body;
+      try {
+        const responseText = await response.text();
+        if (responseText) {
+          body = JSON.parse(responseText);
+        }
+      } catch {
+      }
+      paymentRequired = httpClient.getPaymentRequiredResponse(getHeader, body);
+    } catch (error) {
+      throw new Error(
+        `Failed to parse payment requirements: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+    let paymentPayload;
+    try {
+      paymentPayload = await client.createPaymentPayload(paymentRequired);
+    } catch (error) {
+      throw new Error(
+        `Failed to create payment payload: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+    const paymentHeaders = httpClient.encodePaymentSignatureHeader(paymentPayload);
+    if (!init) {
+      throw new Error("Missing fetch request configuration");
+    }
+    if (init.__is402Retry) {
+      throw new Error("Payment already attempted");
+    }
+    const newInit = {
+      ...init,
+      headers: {
+        ...init.headers || {},
+        ...paymentHeaders,
+        "Access-Control-Expose-Headers": "PAYMENT-RESPONSE,X-PAYMENT-RESPONSE"
+      },
+      __is402Retry: true
+    };
+    const secondResponse = await fetch(input, newInit);
+    return secondResponse;
+  };
+}
+function wrapFetchWithPaymentFromConfig(fetch, config) {
+  const client = x402Client.fromConfig(config);
+  return wrapFetchWithPayment(fetch, client);
+}
+export {
+  decodePaymentResponseHeader,
+  wrapFetchWithPayment,
+  wrapFetchWithPaymentFromConfig,
+  x402Client2 as x402Client,
+  x402HTTPClient2 as x402HTTPClient
+};
+//# sourceMappingURL=index.mjs.map

package/dist/esm/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/index.ts"],"sourcesContent":["import { x402Client, x402ClientConfig, x402HTTPClient } from \"@x402/core/client\";\nimport { type PaymentRequired } from \"@x402/core/types\";\n\n/**\n * Enables the payment of APIs using the x402 payment protocol v2.\n *\n * This function wraps the native fetch API to automatically handle 402 Payment Required responses\n * by creating and sending payment headers. It will:\n * 1. Make the initial request\n * 2. If a 402 response is received, parse the payment requirements\n * 3. Create a payment header using the configured x402HTTPClient\n * 4. Retry the request with the payment header\n *\n * @param fetch - The fetch function to wrap (typically globalThis.fetch)\n * @param client - Configured x402Client or x402HTTPClient instance for handling payments\n * @returns A wrapped fetch function that handles 402 responses automatically\n *\n * @example\n * ```typescript\n * import { wrapFetchWithPayment, x402Client } from '@x402/fetch';\n * import { ExactEvmScheme } from '@x402/evm';\n * import { ExactSvmScheme } from '@x402/svm';\n *\n * const client = new x402Client()\n *   .register('eip155:8453', new ExactEvmScheme(evmSigner))\n *   .register('solana:mainnet', new ExactSvmScheme(svmSigner))\n *   .register('eip155:1', new ExactEvmScheme(evmSigner), 1); // v1 protocol\n *\n * const fetchWithPay = wrapFetchWithPayment(fetch, client);\n *\n * // Make a request that may require payment\n * const response = await fetchWithPay('https://api.example.com/paid-endpoint');\n * ```\n *\n * @throws {Error} If no schemes are provided\n * @throws {Error} If the request configuration is missing\n * @throws {Error} If a payment has already been attempted for this request\n * @throws {Error} If there's an error creating the payment header\n */\nexport function wrapFetchWithPayment(\n  fetch: typeof globalThis.fetch,\n  client: x402Client | x402HTTPClient,\n) {\n  const httpClient = client instanceof x402HTTPClient ? client : new x402HTTPClient(client);\n\n  return async (input: RequestInfo, init?: RequestInit) => {\n    const response = await fetch(input, init);\n\n    if (response.status !== 402) {\n      return response;\n    }\n\n    // Parse payment requirements from response\n    let paymentRequired: PaymentRequired;\n    try {\n      // Create getHeader function for case-insensitive header lookup\n      const getHeader = (name: string) => response.headers.get(name);\n\n      // Try to get from headers first (v2), then from body (v1)\n      let body: PaymentRequired | undefined;\n      try {\n        const responseText = await response.text();\n        if (responseText) {\n          body = JSON.parse(responseText) as PaymentRequired;\n        }\n      } catch {\n        // Ignore JSON parse errors - might be header-only response\n      }\n\n      paymentRequired = httpClient.getPaymentRequiredResponse(getHeader, body);\n    } catch (error) {\n      throw new Error(\n        `Failed to parse payment requirements: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      );\n    }\n\n    // Create payment payload (copy extensions from PaymentRequired)\n    let paymentPayload;\n    try {\n      paymentPayload = await client.createPaymentPayload(paymentRequired);\n    } catch (error) {\n      throw new Error(\n        `Failed to create payment payload: ${error instanceof Error ? error.message : \"Unknown error\"}`,\n      );\n    }\n\n    // Encode payment header\n    const paymentHeaders = httpClient.encodePaymentSignatureHeader(paymentPayload);\n\n    // Ensure we have request init\n    if (!init) {\n      throw new Error(\"Missing fetch request configuration\");\n    }\n\n    // Check if this is already a retry to prevent infinite loops\n    if ((init as { __is402Retry?: boolean }).__is402Retry) {\n      throw new Error(\"Payment already attempted\");\n    }\n\n    // Create new request with payment header\n    const newInit = {\n      ...init,\n      headers: {\n        ...(init.headers || {}),\n        ...paymentHeaders,\n        \"Access-Control-Expose-Headers\": \"PAYMENT-RESPONSE,X-PAYMENT-RESPONSE\",\n      },\n      __is402Retry: true,\n    };\n\n    // Retry the request with payment\n    const secondResponse = await fetch(input, newInit);\n    return secondResponse;\n  };\n}\n\n/**\n * Creates a payment-enabled fetch function from a configuration object.\n *\n * @param fetch - The fetch function to wrap (typically globalThis.fetch)\n * @param config - Configuration options including scheme registrations and selectors\n * @returns A wrapped fetch function that handles 402 responses automatically\n */\nexport function wrapFetchWithPaymentFromConfig(\n  fetch: typeof globalThis.fetch,\n  config: x402ClientConfig,\n) {\n  const client = x402Client.fromConfig(config);\n  return wrapFetchWithPayment(fetch, client);\n}\n\n// Re-export types and utilities for convenience\nexport { x402Client, x402HTTPClient } from \"@x402/core/client\";\nexport type {\n  PaymentPolicy,\n  SchemeRegistration,\n  SelectPaymentRequirements,\n  x402ClientConfig,\n} from \"@x402/core/client\";\nexport { decodePaymentResponseHeader } from \"@x402/core/http\";\nexport type {\n  Network,\n  PaymentPayload,\n  PaymentRequired,\n  PaymentRequirements,\n  SchemeNetworkClient,\n} from \"@x402/core/types\";\n"],"mappings":";AAAA,SAAS,YAA8B,sBAAsB;AAoI7D,SAAS,cAAAA,aAAY,kBAAAC,uBAAsB;AAO3C,SAAS,mCAAmC;AApGrC,SAAS,qBACd,OACA,QACA;AACA,QAAM,aAAa,kBAAkB,iBAAiB,SAAS,IAAI,eAAe,MAAM;AAExF,SAAO,OAAO,OAAoB,SAAuB;AACvD,UAAM,WAAW,MAAM,MAAM,OAAO,IAAI;AAExC,QAAI,SAAS,WAAW,KAAK;AAC3B,aAAO;AAAA,IACT;AAGA,QAAI;AACJ,QAAI;AAEF,YAAM,YAAY,CAAC,SAAiB,SAAS,QAAQ,IAAI,IAAI;AAG7D,UAAI;AACJ,UAAI;AACF,cAAM,eAAe,MAAM,SAAS,KAAK;AACzC,YAAI,cAAc;AAChB,iBAAO,KAAK,MAAM,YAAY;AAAA,QAChC;AAAA,MACF,QAAQ;AAAA,MAER;AAEA,wBAAkB,WAAW,2BAA2B,WAAW,IAAI;AAAA,IACzE,SAAS,OAAO;AACd,YAAM,IAAI;AAAA,QACR,yCAAyC,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,MACnG;AAAA,IACF;AAGA,QAAI;AACJ,QAAI;AACF,uBAAiB,MAAM,OAAO,qBAAqB,eAAe;AAAA,IACpE,SAAS,OAAO;AACd,YAAM,IAAI;AAAA,QACR,qCAAqC,iBAAiB,QAAQ,MAAM,UAAU,eAAe;AAAA,MAC/F;AAAA,IACF;AAGA,UAAM,iBAAiB,WAAW,6BAA6B,cAAc;AAG7E,QAAI,CAAC,MAAM;AACT,YAAM,IAAI,MAAM,qCAAqC;AAAA,IACvD;AAGA,QAAK,KAAoC,cAAc;AACrD,YAAM,IAAI,MAAM,2BAA2B;AAAA,IAC7C;AAGA,UAAM,UAAU;AAAA,MACd,GAAG;AAAA,MACH,SAAS;AAAA,QACP,GAAI,KAAK,WAAW,CAAC;AAAA,QACrB,GAAG;AAAA,QACH,iCAAiC;AAAA,MACnC;AAAA,MACA,cAAc;AAAA,IAChB;AAGA,UAAM,iBAAiB,MAAM,MAAM,OAAO,OAAO;AACjD,WAAO;AAAA,EACT;AACF;AASO,SAAS,+BACd,OACA,QACA;AACA,QAAM,SAAS,WAAW,WAAW,MAAM;AAC3C,SAAO,qBAAqB,OAAO,MAAM;AAC3C;","names":["x402Client","x402HTTPClient"]}

package/package.json

@@ -1,12 +1,60 @@
 {
   "name": "@x402/fetch",
-  "version": "0.0.1",
-  "description": "The Fetch wrapper package for the x402 payment protocol",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "author": "Coinbase Inc.",
+  "version": "2.1.0",
+  "main": "./dist/cjs/index.js",
+  "module": "./dist/esm/index.js",
+  "types": "./dist/index.d.ts",
+  "keywords": [],
   "license": "Apache-2.0",
-  "repository": "https://github.com/coinbase/x402"
+  "author": "Coinbase Inc.",
+  "repository": "https://github.com/coinbase/x402",
+  "description": "x402 Payment Protocol Fetch Extension",
+  "devDependencies": {
+    "@eslint/js": "^9.24.0",
+    "@types/node": "^22.13.4",
+    "@typescript-eslint/eslint-plugin": "^8.29.1",
+    "@typescript-eslint/parser": "^8.29.1",
+    "eslint": "^9.24.0",
+    "eslint-plugin-import": "^2.31.0",
+    "eslint-plugin-jsdoc": "^50.6.9",
+    "eslint-plugin-prettier": "^5.2.6",
+    "prettier": "3.5.2",
+    "tsup": "^8.4.0",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3",
+    "vite": "^6.2.6",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.0.5"
+  },
+  "dependencies": {
+    "viem": "^2.39.3",
+    "zod": "^3.24.2",
+    "@x402/core": "^2.1.0"
+  },
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/esm/index.d.mts",
+        "default": "./dist/esm/index.mjs"
+      },
+      "require": {
+        "types": "./dist/cjs/index.d.ts",
+        "default": "./dist/cjs/index.js"
+      }
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "start": "tsx --env-file=.env index.ts",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "build": "tsup",
+    "watch": "tsc --watch",
+    "format": "prettier -c .prettierrc --write \"**/*.{ts,js,cjs,json,md}\"",
+    "format:check": "prettier -c .prettierrc --check \"**/*.{ts,js,cjs,json,md}\"",
+    "lint": "eslint . --ext .ts --fix",
+    "lint:check": "eslint . --ext .ts"
+  }
 }

package/index.js

@@ -1,3 +0,0 @@
-// Placeholder for @x402/fetch
-module.exports = {};
-