diff --git a/README.md b/README.md
index b31c4d9..18e45e8 100644
--- a/README.md
+++ b/README.md
@@ -28,7 +28,7 @@ or for use without any build tools:
 
 ```html
 <script type="module">
-  import { LightningAddress } from "https://esm.sh/@getalby/lightning-tools@5.0.0"; // jsdelivr.net, skypack.dev also work
+  import { LightningAddress } from "https://esm.sh/@getalby/lightning-tools@7"; // jsdelivr.net, skypack.dev also work
 
   // use LightningAddress normally...
   (async () => {
@@ -168,6 +168,8 @@ Native zaps without a browser extension are possible by using a Nostr Wallet Con
 
 See [examples/zaps-nwc](examples/zaps-nwc.js)
 
+> All examples in the [examples/](examples/) directory are runnable. See [examples/README.md](examples/README.md) for setup instructions.
+
 ### L402
 
 L402 is a protocol standard based on the HTTP 402 Payment Required error code
@@ -181,19 +183,18 @@ This library includes a `fetchWithL402` function to consume L402 protected resou
 - url: the L402 protected URL
 - fetchArgs: arguments are passed to the underlying `fetch()` function used to do the HTTP request
 - options:
-  - wallet: any object that implements `sendPayment(paymentRequest)` and returns `{ preimage }`. Used to pay the L402 invoice.
+  - wallet: any object (e.g. a NWC client) that implements `payInvoice({ invoice })` and returns `{ preimage }`. Used to pay the L402 invoice.
   - store: a key/value store object to persiste the l402 for each URL. The store must implement a `getItem()`/`setItem()` function as the browser's localStorage. By default a memory storage is used.
-  - headerKey: defaults to L402 but if you need to consume an old LSAT API set this to LSAT
 
 ##### Examples
 
 ```js
 import { fetchWithL402 } from "@getalby/lightning-tools/l402";
 
-// pass a wallet that implements sendPayment()
+// pass a wallet that implements payInvoice()
 // the tokens/preimage data will be stored in the browser's localStorage and used for any following request
 await fetchWithL402(
-  "https://lsat-weather-api.getalby.repl.co/kigali",
+  "https://l402.example.com/protected-resource",
   {},
   { wallet: myWallet, store: window.localStorage },
 )
@@ -203,32 +204,94 @@ await fetchWithL402(
 
 ```js
 import { fetchWithL402 } from "@getalby/lightning-tools/l402";
-import { NostrWebLNProvider } from "@getalby/sdk";
+import { NWCClient } from "@getalby/sdk";
 
-// use a NWC provider as the wallet to do the payments
-const nwc = new NostrWebLNProvider({
-  nostrWalletConnectUrl: loadNWCUrl(),
+// use a NWC client as the wallet to do the payments
+const nwc = new NWCClient({
+  nostrWalletConnectUrl: "nostr+walletconnect://...",
 });
 
 // this will fetch the resource and pay the invoice using the NWC wallet
 await fetchWithL402(
-  "https://lsat-weather-api.getalby.repl.co/kigali",
+  "https://l402.example.com/protected-resource",
   {},
   { wallet: nwc },
 )
   .then((res) => res.json())
-  .then(console.log);
+  .then(console.log)
+  .finally(() => nwc.close());
 ```
 
+### X402
+
+Similar to L402 X402 is an open protocol for machine-to-machine payments built on the HTTP 402 Payment Required status code.
+It enables APIs and resources to request payments inline, without prior registration or authentication. 
+
+This library includes a `fetchWithX402` function to consume X402-protected resources that support the lightning network. 
+(Note: X402 works also with other coins and network. This library supports X402 resources that accept Bitcoin on the lightning network)
+
+#### fetchWithX402(url: string, fetchArgs, options)
+
+- url: the X402 protected URL
+- fetchArgs: arguments are passed to the underlying `fetch()` function used to do the HTTP request
+- options:
+  - wallet: any object (e.g. a NWC client) that implements `payInvoice({ invoice })` and returns `{ preimage }`. Used to pay the X402 invoice.
+  - store: a key/value store object to persist the payment proof for each URL. The store must implement a `getItem()`/`setItem()` function as the browser's localStorage. By default a memory storage is used.
+
+##### Examples
+
 ```js
-import { fetchWithL402, NoStorage } from "@getalby/lightning-tools/l402";
+import { fetchWithX402 } from "@getalby/lightning-tools/x402";
+import { NWCClient } from "@getalby/sdk";
 
-// do not store the tokens
-await fetchWithL402(
-  "https://lsat-weather-api.getalby.repl.co/kigali",
+// use a NWC client as the wallet to do the payments
+const nwc = new NWCClient({
+  nostrWalletConnectUrl: "nostr+walletconnect://...",
+});
+
+// the payment proof will not be stored by default. to reuse the proofs for subsequent requests provide a storage
+await fetchWithX402(
+  "https://x402.example.com/protected-resource",
+  {},
+  { wallet: nwc, store: window.localStorage },
+)
+  .then((res) => res.json())
+  .then(console.log)
+  .finally(() => nwc.close());
+```
+
+### fetch402
+
+`fetch402` is a single function that transparently handles both L402 and X402 protected resources. Use it when you don't know or don't care which protocol the server uses — it will detect the protocol from the response headers and pay accordingly.
+
+#### fetch402(url: string, fetchArgs, options)
+
+- url: the protected URL
+- fetchArgs: arguments are passed to the underlying `fetch()` function used to do the HTTP request
+- options:
+  - wallet: any object that implements `payInvoice({ invoice })` and returns `{ preimage }`. Used to pay L402 and X402 invoices.
+  - store: a key/value store object to persist the payment proof for each URL. The store must implement a `getItem()`/`setItem()` function as the browser's localStorage. By default no storage is used - pass `window.localStorage` or a similar store to enable caching.
+
+##### Examples
+
+
+```js
+import { fetch402 } from "@getalby/lightning-tools/402";
+import { NWCClient } from "@getalby/sdk";
+
+const nwc = new NWCClient({
+  nostrWalletConnectUrl: "nostr+walletconnect://...",
+});
+
+// use a NWC wallet — works for both L402 and X402
+await fetch402(
+  "https://example.com/protected-resource",
   {},
-  { store: new NoStorage() },
-);
+  { wallet: nwc, store: window.localStorage },
+)
+  .then((res) => res.json())
+  .then(console.log)
+  .finally(() => nwc.close());
 ```
 
 ### Basic invoice decoding
diff --git a/examples/402.js b/examples/402.js
new file mode 100644
index 0000000..9404918
--- /dev/null
+++ b/examples/402.js
@@ -0,0 +1,21 @@
+import { fetch402 } from "@getalby/lightning-tools/402";
+import { NWCClient } from "@getalby/sdk";
+
+// fetch402 works with both L402 and X402 endpoints —
+// it detects the protocol from the server's response headers automatically.
+const url = process.env.URL || "https://x402.albylabs.com/demo/quote";
+
+const nostrWalletConnectUrl = process.env.NWC_URL;
+
+if (!nostrWalletConnectUrl) {
+  throw new Error("Please set a NWC_URL env variable");
+}
+
+const nwc = new NWCClient({ nostrWalletConnectUrl });
+
+fetch402(url, {}, { wallet: nwc })
+  .then((response) => response.json())
+  .then((data) => {
+    console.info(data);
+  })
+  .finally(() => nwc.close());
diff --git a/examples/README.md b/examples/README.md
new file mode 100644
index 0000000..5dfd61e
--- /dev/null
+++ b/examples/README.md
@@ -0,0 +1,52 @@
+# Examples
+
+Runnable examples for `@getalby/lightning-tools`.
+
+## Setup
+
+```bash
+cd examples
+yarn
+```
+
+> `yarn` links the local package via `file:..` — if you change library source, rebuild first:
+>
+> ```bash
+> cd .. && yarn build && cd examples
+> ```
+
+## Running examples
+
+### x402 / L402 — paid API fetch
+
+These examples fetch a URL protected by an HTTP 402 payment wall. You need an [NWC](https://www.nwc.dev) connection string.
+
+```bash
+NWC_URL="nostr+walletconnect://..." yarn 402      # auto-detects L402 or x402
+NWC_URL="nostr+walletconnect://..." yarn x402     # x402 only
+NWC_URL="nostr+walletconnect://..." yarn l402     # L402 only
+```
+
+Override the default URL:
+
+```bash
+URL="https://your-402-endpoint.example.com" NWC_URL="nostr+walletconnect://..." yarn 402
+```
+
+### Lightning Address — request invoice
+
+Fetches LNURL-pay data for a lightning address and requests an invoice. No credentials needed.
+
+```bash
+yarn request-invoice
+```
+
+### Zaps via NWC
+
+Sends a zap to a lightning address using NWC for payment and a Nostr key for signing.
+
+```bash
+NOSTR_PRIVATE_KEY="your-hex-private-key" NWC_URL="nostr+walletconnect://..." yarn zaps-nwc
+```
+
+> **`zaps.js`** is a browser-only example (uses `window.webln`) and is not runnable as a Node script.
diff --git a/examples/l402.js b/examples/l402.js
index d1d1f0e..f76a9c4 100644
--- a/examples/l402.js
+++ b/examples/l402.js
@@ -1,8 +1,7 @@
 import { fetchWithL402 } from "@getalby/lightning-tools/l402";
-import { NostrWebLNProvider } from "@getalby/sdk";
-import "websocket-polyfill";
+import { NWCClient } from "@getalby/sdk";
 
-const url = "https://lsat-weather-api.getalby.repl.co/kigali";
+const url = process.env.URL || "https://l402.example.com/protected-resource";
 
 const nostrWalletConnectUrl = process.env.NWC_URL;
 
@@ -10,16 +9,11 @@ if (!nostrWalletConnectUrl) {
   throw new Error("Please set a NWC_URL env variable");
 }
 
-const nwc = new NostrWebLNProvider({
-  nostrWalletConnectUrl,
-});
-nwc.on("sendPayment", (response) => {
-  console.info(`payment response:`, response);
-});
+const nwc = new NWCClient({ nostrWalletConnectUrl });
 
 fetchWithL402(url, {}, { wallet: nwc })
   .then((response) => response.json())
   .then((data) => {
     console.info(data);
-    nwc.close();
-  });
\ No newline at end of file
+  })
+  .finally(() => nwc.close());
diff --git a/examples/package.json b/examples/package.json
new file mode 100644
index 0000000..fa3dd94
--- /dev/null
+++ b/examples/package.json
@@ -0,0 +1,18 @@
+{
+  "name": "@getalby/lightning-tools-examples",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "402": "node 402.js",
+    "l402": "node l402.js",
+    "x402": "node x402.js",
+    "request-invoice": "node request-invoice.js",
+    "zaps-nwc": "node zaps-nwc.js"
+  },
+  "dependencies": {
+    "@getalby/lightning-tools": "file:..",
+    "@getalby/sdk": "^7.0.0",
+    "@noble/hashes": "^2.0.1",
+    "nostr-tools": "^2.16.1"
+  }
+}
diff --git a/examples/x402.js b/examples/x402.js
new file mode 100644
index 0000000..c58ec11
--- /dev/null
+++ b/examples/x402.js
@@ -0,0 +1,19 @@
+import { fetchWithX402 } from "@getalby/lightning-tools/x402";
+import { NWCClient } from "@getalby/sdk";
+
+const url = process.env.URL || "https://x402.albylabs.com/demo/quote";
+
+const nostrWalletConnectUrl = process.env.NWC_URL;
+
+if (!nostrWalletConnectUrl) {
+  throw new Error("Please set a NWC_URL env variable");
+}
+
+const nwc = new NWCClient({ nostrWalletConnectUrl });
+
+fetchWithX402(url, {}, { wallet: nwc })
+  .then((response) => response.json())
+  .then((data) => {
+    console.info(data);
+  })
+  .finally(() => nwc.close());
diff --git a/examples/yarn.lock b/examples/yarn.lock
new file mode 100644
index 0000000..6c52535
--- /dev/null
+++ b/examples/yarn.lock
@@ -0,0 +1,76 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+"@getalby/lightning-tools@^6.0.0":
+  version "6.1.0"
+  resolved "https://registry.yarnpkg.com/@getalby/lightning-tools/-/lightning-tools-6.1.0.tgz#558b90a83b961cb6aa760e62de69f5b5ceeb2fe9"
+  integrity sha512-rGurar9X4Gm+9xwoNYS8s9YLK7ZYqvbqv4KbHLYV0LEeB0HxZHRgmxblGqg+fYfp6iiYHx+edIgUpt9rS3VwFw==
+
+"@getalby/lightning-tools@file:..":
+  version "7.0.2"
+
+"@getalby/sdk@^7.0.0":
+  version "7.0.0"
+  resolved "https://registry.yarnpkg.com/@getalby/sdk/-/sdk-7.0.0.tgz#6ab17f27bd9e762d383b70cfabd0cdeeded6bd53"
+  integrity sha512-0c8gyvFbRDHZIgHmOD/dfyPukxZLeidx/hx7SXlMIS/hsx4mXpKpo9Gx1zW90buElnd3k9TVB/S/bnFSEZPE7w==
+  dependencies:
+    "@getalby/lightning-tools" "^6.0.0"
+    nostr-tools "^2.17.0"
+
+"@noble/ciphers@2.1.1":
+  version "2.1.1"
+  resolved "https://registry.yarnpkg.com/@noble/ciphers/-/ciphers-2.1.1.tgz#c8c74fcda8c3d1f88797d0ecda24f9fc8b92b052"
+  integrity sha512-bysYuiVfhxNJuldNXlFEitTVdNnYUc+XNJZd7Qm2a5j1vZHgY+fazadNFWFaMK/2vye0JVlxV3gHmC0WDfAOQw==
+
+"@noble/curves@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@noble/curves/-/curves-2.0.1.tgz#64ba8bd5e8564a02942655602515646df1cdb3ad"
+  integrity sha512-vs1Az2OOTBiP4q0pwjW5aF0xp9n4MxVrmkFBxc6EKZc6ddYx5gaZiAsZoq0uRRXWbi3AT/sBqn05eRPtn1JCPw==
+  dependencies:
+    "@noble/hashes" "2.0.1"
+
+"@noble/hashes@2.0.1", "@noble/hashes@^2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@noble/hashes/-/hashes-2.0.1.tgz#fc1a928061d1232b0a52bb754393c37a5216c89e"
+  integrity sha512-XlOlEbQcE9fmuXxrVTXCTlG2nlRXa9Rj3rr5Ue/+tX+nmkgbX720YHh0VR3hBF9xDvwnb8D2shVGOwNx+ulArw==
+
+"@scure/base@2.0.0":
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/@scure/base/-/base-2.0.0.tgz#ba6371fddf92c2727e88ad6ab485db6e624f9a98"
+  integrity sha512-3E1kpuZginKkek01ovG8krQ0Z44E3DHPjc5S2rjJw9lZn3KSQOs8S7wqikF/AH7iRanHypj85uGyxk0XAyC37w==
+
+"@scure/bip32@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@scure/bip32/-/bip32-2.0.1.tgz#4ceea207cee8626d3fe8f0b6ab68b6af8f81c482"
+  integrity sha512-4Md1NI5BzoVP+bhyJaY3K6yMesEFzNS1sE/cP+9nuvE7p/b0kx9XbpDHHFl8dHtufcbdHRUUQdRqLIPHN/s7yA==
+  dependencies:
+    "@noble/curves" "2.0.1"
+    "@noble/hashes" "2.0.1"
+    "@scure/base" "2.0.0"
+
+"@scure/bip39@2.0.1":
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/@scure/bip39/-/bip39-2.0.1.tgz#47a6dc15e04faf200041239d46ae3bb7c3c96add"
+  integrity sha512-PsxdFj/d2AcJcZDX1FXN3dDgitDDTmwf78rKZq1a6c1P1Nan1X/Sxc7667zU3U+AN60g7SxxP0YCVw2H/hBycg==
+  dependencies:
+    "@noble/hashes" "2.0.1"
+    "@scure/base" "2.0.0"
+
+nostr-tools@^2.16.1, nostr-tools@^2.17.0:
+  version "2.23.3"
+  resolved "https://registry.yarnpkg.com/nostr-tools/-/nostr-tools-2.23.3.tgz#1a7501988b72499cf27c8f3951f00d11d9ac6025"
+  integrity sha512-AALyt9k8xPdF4UV2mlLJ2mgCn4kpTB0DZ8t2r6wjdUh6anfx2cTVBsHUlo9U0EY/cKC5wcNyiMAmRJV5OVEalA==
+  dependencies:
+    "@noble/ciphers" "2.1.1"
+    "@noble/curves" "2.0.1"
+    "@noble/hashes" "2.0.1"
+    "@scure/base" "2.0.0"
+    "@scure/bip32" "2.0.1"
+    "@scure/bip39" "2.0.1"
+    nostr-wasm "0.1.0"
+
+nostr-wasm@0.1.0:
+  version "0.1.0"
+  resolved "https://registry.yarnpkg.com/nostr-wasm/-/nostr-wasm-0.1.0.tgz#17af486745feb2b7dd29503fdd81613a24058d94"
+  integrity sha512-78BTryCLcLYv96ONU8Ws3Q1JzjlAt+43pWQhIl86xZmWeegYCNLPml7yQ+gG3vR6V5h4XGj+TxO+SS5dsThQIA==
diff --git a/examples/zaps-nwc.js b/examples/zaps-nwc.js
index 5163de8..30fa9e5 100644
--- a/examples/zaps-nwc.js
+++ b/examples/zaps-nwc.js
@@ -1,14 +1,12 @@
 import { LightningAddress } from "@getalby/lightning-tools/lnurl";
 import { NostrWebLNProvider } from "@getalby/sdk";
-import "websocket-polyfill";
 import { finalizeEvent, getPublicKey } from "nostr-tools";
 import { hexToBytes } from "@noble/hashes/utils";
 
 // your private key is required to sign zap request events
 const nostrPrivateKey = process.env.NOSTR_PRIVATE_KEY;
+
 // NWC url will be used to pay the zap invoice.
-// It can be created in advanced at nwc.getalby.com,
-// or use webln.NostrWebLNProvider.withNewSecret() to generate a new one
 const nostrWalletConnectUrl = process.env.NWC_URL;
 
 if (!nostrPrivateKey || !nostrWalletConnectUrl) {
@@ -16,9 +14,7 @@ if (!nostrPrivateKey || !nostrWalletConnectUrl) {
 }
 
 (async () => {
-  const nostrWeblnProvider = new NostrWebLNProvider({
-    nostrWalletConnectUrl,
-  });
+  const nostrWeblnProvider = new NostrWebLNProvider({ nostrWalletConnectUrl });
   // or use nostrWeblnProvider.initNWC(); to get a new NWC url
   const nostrProvider = {
     getPublicKey: () =>
diff --git a/jest.config.ts b/jest.config.ts
index 8ffd480..bd3876a 100644
--- a/jest.config.ts
+++ b/jest.config.ts
@@ -1,8 +1,9 @@
-/** @type {import('ts-jest').JestConfigWithTsJest} */
-module.exports = {
-  preset: 'ts-jest',
-  testEnvironment: 'node',
-  setupFiles: [
-    "./setupJest.ts"
-  ]
-};
\ No newline at end of file
+import type { Config } from "jest";
+
+const config: Config = {
+  preset: "ts-jest",
+  testEnvironment: "node",
+  setupFiles: ["./setupJest.ts"],
+};
+
+export default config;
\ No newline at end of file
diff --git a/package.json b/package.json
index 2c01983..8a6c096 100644
--- a/package.json
+++ b/package.json
@@ -39,11 +39,21 @@
       "require": "./dist/cjs/fiat.cjs",
       "types": "./dist/types/fiat.d.ts"
     },
+    "./402": {
+      "import": "./dist/esm/402.js",
+      "require": "./dist/cjs/402.cjs",
+      "types": "./dist/types/402.d.ts"
+    },
     "./l402": {
       "import": "./dist/esm/l402.js",
       "require": "./dist/cjs/l402.cjs",
       "types": "./dist/types/l402.d.ts"
     },
+    "./x402": {
+      "import": "./dist/esm/x402.js",
+      "require": "./dist/cjs/x402.cjs",
+      "types": "./dist/types/x402.d.ts"
+    },
     "./lnurl": {
       "import": "./dist/esm/lnurl.js",
       "require": "./dist/cjs/lnurl.cjs",
diff --git a/rollup.config.js b/rollup.config.js
index a662d28..ddf108e 100644
--- a/rollup.config.js
+++ b/rollup.config.js
@@ -19,7 +19,9 @@ const entries = [
   { name: "index", input: "src/index.ts" },
   { name: "bolt11", input: "src/bolt11/index.ts" },
   { name: "fiat", input: "src/fiat/index.ts" },
-  { name: "l402", input: "src/l402/index.ts" },
+  { name: "402", input: "src/402/index.ts" },
+  { name: "l402", input: "src/402/l402/index.ts" },
+  { name: "x402", input: "src/402/x402/index.ts" },
   { name: "lnurl", input: "src/lnurl/index.ts" },
   { name: "podcasting2", input: "src/podcasting2/index.ts" },
 ];
diff --git a/src/402/fetch402.ts b/src/402/fetch402.ts
new file mode 100644
index 0000000..e681818
--- /dev/null
+++ b/src/402/fetch402.ts
@@ -0,0 +1,88 @@
+import { KVStorage, NoStorage, Wallet } from "./utils";
+import { buildX402PaymentSignature } from "./x402/utils";
+import { HEADER_KEY, handleL402Payment } from "./l402/l402";
+import { handleX402Payment } from "./x402/x402";
+
+const noStorage = new NoStorage();
+
+export const fetch402 = async (
+  url: string,
+  fetchArgs: RequestInit,
+  options: {
+    wallet: Wallet;
+    store?: KVStorage;
+  },
+) => {
+  const wallet = options.wallet;
+  const store = options.store || noStorage;
+  if (!fetchArgs) {
+    fetchArgs = {};
+  }
+  fetchArgs.cache = "no-store";
+  fetchArgs.mode = "cors";
+  const headers = new Headers(fetchArgs.headers ?? undefined);
+  fetchArgs.headers = headers;
+
+  // Check cache — detect protocol from stored data structure
+  const cachedRaw = store.getItem(url);
+  if (cachedRaw) {
+    const cached = JSON.parse(cachedRaw);
+    if (cached?.token && cached?.preimage) {
+      // L402 cached
+      headers.set(
+        "Authorization",
+        `${HEADER_KEY} ${cached.token}:${cached.preimage}`,
+      );
+      return await fetch(url, fetchArgs);
+    }
+    if (
+      cached?.scheme &&
+      cached?.network &&
+      cached?.invoice &&
+      cached?.requirements
+    ) {
+      // X402 cached
+      headers.set(
+        "payment-signature",
+        buildX402PaymentSignature(
+          cached.scheme,
+          cached.network,
+          cached.invoice,
+          cached.requirements,
+        ),
+      );
+      return await fetch(url, fetchArgs);
+    }
+  }
+
+  // Initial request — advertise L402 support
+  headers.set("Accept-Authenticate", HEADER_KEY);
+  const initResp = await fetch(url, fetchArgs);
+
+  const l402Header = initResp.headers.get("www-authenticate");
+  if (l402Header) {
+    return handleL402Payment(
+      l402Header,
+      url,
+      fetchArgs,
+      headers,
+      wallet,
+      store,
+      HEADER_KEY,
+    );
+  }
+
+  const x402Header = initResp.headers.get("PAYMENT-REQUIRED");
+  if (x402Header) {
+    return handleX402Payment(
+      x402Header,
+      url,
+      fetchArgs,
+      headers,
+      wallet,
+      store,
+    );
+  }
+
+  return initResp;
+};
diff --git a/src/402/index.ts b/src/402/index.ts
new file mode 100644
index 0000000..7892759
--- /dev/null
+++ b/src/402/index.ts
@@ -0,0 +1,2 @@
+export * from "./fetch402";
+export * from "./utils";
diff --git a/src/l402/index.ts b/src/402/l402/index.ts
similarity index 100%
rename from src/l402/index.ts
rename to src/402/l402/index.ts
diff --git a/src/l402/l402.test.ts b/src/402/l402/l402.test.ts
similarity index 72%
rename from src/l402/l402.test.ts
rename to src/402/l402/l402.test.ts
index 827465a..4faee35 100644
--- a/src/l402/l402.test.ts
+++ b/src/402/l402/l402.test.ts
@@ -1,6 +1,7 @@
 import fetchMock from "jest-fetch-mock";
 import { fetchWithL402 } from "./l402";
-import { MemoryStorage, NoStorage, parseL402, makeAuthenticateHeader } from "./utils";
+import { MemoryStorage, NoStorage } from "../utils";
+import { parseL402, makeL402AuthenticateHeader } from "./utils";
 
 const MACAROON =
   "AgEEbHNhdAJCAAAClGOZrh7C569Yc7UMk8merfnMdIviyXr1qscW7VgpChNl21LkZ8Jex5QiPp+E1VaabeJDuWmlrh/j583axFpNAAIXc2VydmljZXM9cmFuZG9tbnVtYmVyOjAAAiZyYW5kb21udW1iZXJfY2FwYWJpbGl0aZVzPWFkZCxzdWJ0cmFjdAAABiAvFpzXGyc+8d/I9nMKKvAYP8w7kUlhuxS0eFN2sqmqHQ==";
@@ -15,7 +16,7 @@ const L402_URL = "https://example.com/protected";
 
 function makeWallet(preimage: string = PREIMAGE) {
   return {
-    sendPayment: jest.fn().mockResolvedValue({ preimage }),
+    payInvoice: jest.fn().mockResolvedValue({ preimage }),
   };
 }
 
@@ -62,18 +63,6 @@ describe("parseL402", () => {
 // fetchWithL402
 // ---------------------------------------------------------------------------
 describe("fetchWithL402", () => {
-  test("throws when no wallet is provided", async () => {
-    await expect(
-      fetchWithL402(L402_URL, {}, { store: new MemoryStorage() }),
-    ).rejects.toThrow("wallet is missing");
-  });
-
-  test("throws when wallet is explicitly undefined", async () => {
-    await expect(
-      fetchWithL402(L402_URL, {}, { wallet: undefined, store: new MemoryStorage() }),
-    ).rejects.toThrow("wallet is missing");
-  });
-
   test("returns initial response when no www-authenticate header (non-402)", async () => {
     const wallet = makeWallet();
     const store = new MemoryStorage();
@@ -85,7 +74,7 @@ describe("fetchWithL402", () => {
 
     expect(response.status).toBe(200);
     expect(await response.json()).toEqual({ data: "free content" });
-    expect(wallet.sendPayment).not.toHaveBeenCalled();
+    expect(wallet.payInvoice).not.toHaveBeenCalled();
     expect(fetchMock).toHaveBeenCalledTimes(1);
   });
 
@@ -96,7 +85,12 @@ describe("fetchWithL402", () => {
     // First fetch: 402 with www-authenticate header
     fetchMock.mockResponseOnce("Payment Required", {
       status: 402,
-      headers: { "www-authenticate": makeAuthenticateHeader({ macaroon: MACAROON, invoice: INVOICE }) },
+      headers: {
+        "www-authenticate": makeL402AuthenticateHeader({
+          macaroon: MACAROON,
+          invoice: INVOICE,
+        }),
+      },
     });
 
     // Second fetch: success after payment
@@ -105,14 +99,14 @@ describe("fetchWithL402", () => {
 
     const response = await fetchWithL402(L402_URL, {}, { wallet, store });
 
-    expect(wallet.sendPayment).toHaveBeenCalledTimes(1);
-    expect(wallet.sendPayment).toHaveBeenCalledWith(INVOICE);
+    expect(wallet.payInvoice).toHaveBeenCalledTimes(1);
+    expect(wallet.payInvoice).toHaveBeenCalledWith({ invoice: INVOICE });
     expect(fetchMock).toHaveBeenCalledTimes(2);
 
     // Verify the second request includes the Authorization header
     const secondCallInit = fetchMock.mock.calls[1][1] as RequestInit;
-    const secondHeaders = secondCallInit.headers as Record<string, string>;
-    expect(secondHeaders["Authorization"]).toBe(
+    const secondHeaders = secondCallInit.headers as Headers;
+    expect(secondHeaders.get("Authorization")).toBe(
       `L402 ${MACAROON}:${PREIMAGE}`,
     );
 
@@ -126,7 +120,12 @@ describe("fetchWithL402", () => {
 
     fetchMock.mockResponseOnce("Payment Required", {
       status: 402,
-      headers: { "www-authenticate": makeAuthenticateHeader({ macaroon: MACAROON, invoice: INVOICE }) },
+      headers: {
+        "www-authenticate": makeL402AuthenticateHeader({
+          macaroon: MACAROON,
+          invoice: INVOICE,
+        }),
+      },
     });
     fetchMock.mockResponseOnce(JSON.stringify({ ok: true }), { status: 200 });
 
@@ -154,39 +153,17 @@ describe("fetchWithL402", () => {
 
     const response = await fetchWithL402(L402_URL, {}, { wallet, store });
 
-    expect(wallet.sendPayment).not.toHaveBeenCalled();
+    expect(wallet.payInvoice).not.toHaveBeenCalled();
     expect(fetchMock).toHaveBeenCalledTimes(1);
 
     // Verify the Authorization header was set from the cache
     const callInit = fetchMock.mock.calls[0][1] as RequestInit;
-    const headers = callInit.headers as Record<string, string>;
-    expect(headers["Authorization"]).toBe(
-      `L402 ${MACAROON}:${PREIMAGE}`,
-    );
+    const headers = callInit.headers as Headers;
+    expect(headers.get("Authorization")).toBe(`L402 ${MACAROON}:${PREIMAGE}`);
 
     expect(await response.json()).toEqual({ data: "cached access" });
   });
 
-  test("uses custom LSAT headerKey", async () => {
-    const wallet = makeWallet();
-    const store = new MemoryStorage();
-
-    fetchMock.mockResponseOnce("Payment Required", {
-      status: 402,
-      headers: { "www-authenticate": makeAuthenticateHeader({ macaroon: MACAROON, invoice: INVOICE, key: "LSAT" }) },
-    });
-    fetchMock.mockResponseOnce(JSON.stringify({ ok: true }), { status: 200 });
-
-    await fetchWithL402(L402_URL, {}, { wallet, store, headerKey: "LSAT" });
-
-    // Verify the second request uses LSAT in the Authorization header
-    const secondCallInit = fetchMock.mock.calls[1][1] as RequestInit;
-    const secondHeaders = secondCallInit.headers as Record<string, string>;
-    expect(secondHeaders["Authorization"]).toBe(
-      `LSAT ${MACAROON}:${PREIMAGE}`,
-    );
-  });
-
   test("works with NoStorage (never caches)", async () => {
     const wallet = makeWallet();
     const store = new NoStorage();
@@ -194,7 +171,12 @@ describe("fetchWithL402", () => {
     // First request flow
     fetchMock.mockResponseOnce("Payment Required", {
       status: 402,
-      headers: { "www-authenticate": makeAuthenticateHeader({ macaroon: MACAROON, invoice: INVOICE }) },
+      headers: {
+        "www-authenticate": makeL402AuthenticateHeader({
+          macaroon: MACAROON,
+          invoice: INVOICE,
+        }),
+      },
     });
     fetchMock.mockResponseOnce(JSON.stringify({ first: true }), {
       status: 200,
@@ -205,7 +187,12 @@ describe("fetchWithL402", () => {
     // Second request flow — should NOT use cache since NoStorage always returns null
     fetchMock.mockResponseOnce("Payment Required", {
       status: 402,
-      headers: { "www-authenticate": makeAuthenticateHeader({ macaroon: MACAROON, invoice: INVOICE }) },
+      headers: {
+        "www-authenticate": makeL402AuthenticateHeader({
+          macaroon: MACAROON,
+          invoice: INVOICE,
+        }),
+      },
     });
     fetchMock.mockResponseOnce(JSON.stringify({ second: true }), {
       status: 200,
@@ -213,22 +200,25 @@ describe("fetchWithL402", () => {
 
     await fetchWithL402(L402_URL, {}, { wallet, store });
 
-    // wallet.sendPayment should have been called twice (no caching)
-    expect(wallet.sendPayment).toHaveBeenCalledTimes(2);
+    // wallet.payInvoice should have been called twice (no caching)
+    expect(wallet.payInvoice).toHaveBeenCalledTimes(2);
     expect(fetchMock).toHaveBeenCalledTimes(4);
   });
 
-  test("propagates wallet.sendPayment errors", async () => {
+  test("propagates wallet.payInvoice errors", async () => {
     const wallet = {
-      sendPayment: jest
-        .fn()
-        .mockRejectedValue(new Error("payment failed")),
+      payInvoice: jest.fn().mockRejectedValue(new Error("payment failed")),
     };
     const store = new MemoryStorage();
 
     fetchMock.mockResponseOnce("Payment Required", {
       status: 402,
-      headers: { "www-authenticate": makeAuthenticateHeader({ macaroon: MACAROON, invoice: INVOICE }) },
+      headers: {
+        "www-authenticate": makeL402AuthenticateHeader({
+          macaroon: MACAROON,
+          invoice: INVOICE,
+        }),
+      },
     });
 
     await expect(
@@ -243,7 +233,12 @@ describe("fetchWithL402", () => {
 
     fetchMock.mockResponseOnce("Payment Required", {
       status: 402,
-      headers: { "www-authenticate": makeAuthenticateHeader({ macaroon: MACAROON, invoice: INVOICE }) },
+      headers: {
+        "www-authenticate": makeL402AuthenticateHeader({
+          macaroon: MACAROON,
+          invoice: INVOICE,
+        }),
+      },
     });
     fetchMock.mockResponseOnce(JSON.stringify({ ok: true }), { status: 200 });
 
@@ -256,9 +251,9 @@ describe("fetchWithL402", () => {
     // Both fetch calls should have the custom header and method
     for (const call of fetchMock.mock.calls) {
       const fetchInit = call[1] as RequestInit;
-      const headers = fetchInit.headers as Record<string, string>;
+      const headers = fetchInit.headers as Headers;
       expect(fetchInit.method).toBe("POST");
-      expect(headers["X-Custom"]).toBe("value");
+      expect(headers.get("X-Custom")).toBe("value");
     }
   });
 
@@ -282,14 +277,19 @@ describe("fetchWithL402", () => {
     // First request: full L402 handshake
     fetchMock.mockResponseOnce("Payment Required", {
       status: 402,
-      headers: { "www-authenticate": makeAuthenticateHeader({ macaroon: MACAROON, invoice: INVOICE }) },
+      headers: {
+        "www-authenticate": makeL402AuthenticateHeader({
+          macaroon: MACAROON,
+          invoice: INVOICE,
+        }),
+      },
     });
     fetchMock.mockResponseOnce(JSON.stringify({ first: true }), {
       status: 200,
     });
 
     await fetchWithL402(L402_URL, {}, { wallet, store });
-    expect(wallet.sendPayment).toHaveBeenCalledTimes(1);
+    expect(wallet.payInvoice).toHaveBeenCalledTimes(1);
 
     // Second request: should use cached token, no new payment
     fetchMock.mockResponseOnce(JSON.stringify({ second: true }), {
@@ -298,12 +298,12 @@ describe("fetchWithL402", () => {
 
     const response = await fetchWithL402(L402_URL, {}, { wallet, store });
 
-    expect(wallet.sendPayment).toHaveBeenCalledTimes(1); // still only 1
+    expect(wallet.payInvoice).toHaveBeenCalledTimes(1); // still only 1
     expect(await response.json()).toEqual({ second: true });
 
     const lastCallInit = fetchMock.mock.calls[2][1] as RequestInit;
-    const lastHeaders = lastCallInit.headers as Record<string, string>;
-    expect(lastHeaders["Authorization"]).toBe(
+    const lastHeaders = lastCallInit.headers as Headers;
+    expect(lastHeaders.get("Authorization")).toBe(
       `L402 ${MACAROON}:${PREIMAGE}`,
     );
   });
diff --git a/src/402/l402/l402.ts b/src/402/l402/l402.ts
new file mode 100644
index 0000000..10896fd
--- /dev/null
+++ b/src/402/l402/l402.ts
@@ -0,0 +1,80 @@
+import { KVStorage, NoStorage, Wallet } from "../utils";
+import { parseL402 } from "./utils";
+
+const noStorage = new NoStorage();
+
+export const HEADER_KEY = "L402";
+
+export const handleL402Payment = async (
+  l402Header: string,
+  url: string,
+  fetchArgs: RequestInit,
+  headers: Headers,
+  wallet: Wallet,
+  store: KVStorage,
+  headerKey: string,
+): Promise<Response> => {
+  const details = parseL402(l402Header);
+  const token = details.token || details.macaroon;
+  const invoice = details.invoice;
+
+  if (!token) {
+    throw new Error("L402: missing token/macaroon in WWW-Authenticate header");
+  }
+  if (!invoice) {
+    throw new Error("L402: missing invoice in WWW-Authenticate header");
+  }
+
+  const invResp = await wallet.payInvoice({ invoice });
+  store.setItem(url, JSON.stringify({ token, preimage: invResp.preimage }));
+  headers.set("Authorization", `${headerKey} ${token}:${invResp.preimage}`);
+  return fetch(url, fetchArgs);
+};
+
+export const fetchWithL402 = async (
+  url: string,
+  fetchArgs: RequestInit,
+  options: {
+    wallet: Wallet;
+    headerKey?: string;
+    store?: KVStorage;
+  },
+) => {
+  const headerKey = options.headerKey || HEADER_KEY;
+  const wallet = options.wallet;
+  if (!wallet) {
+    throw new Error("wallet is missing");
+  }
+  const store = options.store || noStorage;
+  if (!fetchArgs) {
+    fetchArgs = {};
+  }
+  fetchArgs.cache = "no-store";
+  fetchArgs.mode = "cors";
+  const headers = new Headers(fetchArgs.headers ?? undefined);
+  fetchArgs.headers = headers;
+
+  const cachedL402Data = store.getItem(url);
+  if (cachedL402Data) {
+    const data = JSON.parse(cachedL402Data);
+    headers.set("Authorization", `${headerKey} ${data.token}:${data.preimage}`);
+    return await fetch(url, fetchArgs);
+  }
+
+  headers.set("Accept-Authenticate", headerKey);
+  const initResp = await fetch(url, fetchArgs);
+  const header = initResp.headers.get("www-authenticate");
+  if (!header) {
+    return initResp;
+  }
+
+  return handleL402Payment(
+    header,
+    url,
+    fetchArgs,
+    headers,
+    wallet,
+    store,
+    headerKey,
+  );
+};
diff --git a/src/l402/utils.ts b/src/402/l402/utils.ts
similarity index 54%
rename from src/l402/utils.ts
rename to src/402/l402/utils.ts
index 0129c31..1365fa8 100644
--- a/src/l402/utils.ts
+++ b/src/402/l402/utils.ts
@@ -1,34 +1,3 @@
-export interface KVStorage {
-  getItem(key: string): string | null;
-  setItem(key: string, value: string): void;
-}
-
-export class MemoryStorage implements KVStorage {
-  storage;
-
-  constructor(initial?: Record<string, unknown>) {
-    this.storage = initial || {};
-  }
-
-  getItem(key: string) {
-    return this.storage[key];
-  }
-
-  setItem(key: string, value: unknown) {
-    this.storage[key] = value;
-  }
-}
-
-export class NoStorage implements KVStorage {
-  constructor(initial?: unknown) {}
-
-  getItem(key: string) {
-    return null;
-  }
-
-  setItem(key: string, value: unknown) {}
-}
-
 export const parseL402 = (input: string): Record<string, string> => {
   // Remove the L402 and LSAT identifiers
   const string = input.replace("L402", "").replace("LSAT", "").trim();
@@ -50,8 +19,12 @@ export const parseL402 = (input: string): Record<string, string> => {
   return keyValuePairs;
 };
 
-export const makeAuthenticateHeader = (args: { macaroon: string, invoice: string, key?: string }) => {
+export const makeL402AuthenticateHeader = (args: {
+  macaroon: string;
+  invoice: string;
+  key?: string;
+}) => {
   const key = args.key || "L402";
 
   return `${key} macaroon="${args.macaroon}", invoice="${args.invoice}"`;
-}
+};
diff --git a/src/402/utils.ts b/src/402/utils.ts
new file mode 100644
index 0000000..5472c5f
--- /dev/null
+++ b/src/402/utils.ts
@@ -0,0 +1,34 @@
+export interface KVStorage {
+  getItem(key: string): string | null;
+  setItem(key: string, value: string): void;
+}
+
+export interface Wallet {
+  payInvoice(args: { invoice: string }): Promise<{ preimage: string }>;
+}
+
+export class MemoryStorage implements KVStorage {
+  storage;
+
+  constructor(initial?: Record<string, unknown>) {
+    this.storage = initial || {};
+  }
+
+  getItem(key: string) {
+    return this.storage[key];
+  }
+
+  setItem(key: string, value: unknown) {
+    this.storage[key] = value;
+  }
+}
+
+export class NoStorage implements KVStorage {
+  constructor(initial?: unknown) {}
+
+  getItem(key: string) {
+    return null;
+  }
+
+  setItem(key: string, value: unknown) {}
+}
diff --git a/src/402/x402/index.ts b/src/402/x402/index.ts
new file mode 100644
index 0000000..bbf6158
--- /dev/null
+++ b/src/402/x402/index.ts
@@ -0,0 +1,2 @@
+export * from "./x402";
+export * from "./utils";
diff --git a/src/402/x402/utils.ts b/src/402/x402/utils.ts
new file mode 100644
index 0000000..dbbd66b
--- /dev/null
+++ b/src/402/x402/utils.ts
@@ -0,0 +1,27 @@
+export interface X402Requirements {
+  scheme: string;
+  network: string;
+  extra: {
+    invoice: string;
+    paymentMethod?: string;
+    [key: string]: unknown;
+  };
+  [key: string]: unknown;
+}
+
+export const buildX402PaymentSignature = (
+  scheme: string,
+  network: string,
+  invoice: string,
+  requirements: X402Requirements,
+): string => {
+  const json = JSON.stringify({
+    x402Version: 2,
+    scheme,
+    network,
+    payload: { invoice },
+    accepted: requirements,
+  });
+  // btoa only handles latin1; encode via UTF-8 to be safe
+  return btoa(unescape(encodeURIComponent(json)));
+};
diff --git a/src/402/x402/x402.test.ts b/src/402/x402/x402.test.ts
new file mode 100644
index 0000000..17b810c
--- /dev/null
+++ b/src/402/x402/x402.test.ts
@@ -0,0 +1,379 @@
+import fetchMock from "jest-fetch-mock";
+import { fetchWithX402 } from "./x402";
+import { MemoryStorage, NoStorage } from "../utils";
+
+const INVOICE =
+  "lnbc4020n1p5m6028dq80q6rqvsnp4qt5w34u6kntf5lc50jj27rvs89sgrpcpj7s6vfts042gkhxx2j6swpp5g6tquvmswkv5xf0ru7ju2qvdrf83l2ewha3qzzt0a7vurs5q30rssp54kt5hfzjngjersx8fgt60feuu8e7vnat67f3ksr98twdj7z0m0ls9qyysgqcqzp2xqyz5vqrzjqdc22wfv6lyplagj37n9dmndkrzdz8rh3lxkewvvk6arkjpefats2rf47yqqwysqqcqqqqlgqqqqqqgqfqrzjq26922n6s5n5undqrf78rjjhgpcczafws45tx8237y7pzx3fg8ww8apyqqqqqqqqjyqqqqlgqqqqr4gq2q3z5pu33awfm98ac3ysdhy046xmen4zqval67tccu35x9mxgvl6w3wmq6y03ae7pme6qr20mp5gvuqntnu8yy7nlf6gyt9zshanj2zhgqe4xde3";
+const PREIMAGE =
+  "8196e90022ce688d911554d02af67d3d6a72143961c1e1aa12c4720538ea0549";
+
+const X402_URL = "https://example.com/protected";
+
+const REQUIREMENTS = {
+  scheme: "exact",
+  network: "bip122:000000000019d6689c085ae165831e93",
+  amount: "402000",
+  asset: "btc",
+  extra: { invoice: INVOICE, paymentMethod: "lightning" },
+};
+
+function makePaymentRequiredHeader(
+  requirements = REQUIREMENTS,
+  accepts = [requirements],
+): string {
+  return btoa(unescape(encodeURIComponent(JSON.stringify({ accepts }))));
+}
+
+function parsePaymentSignature(header: string): Record<string, unknown> {
+  return JSON.parse(decodeURIComponent(escape(atob(header))));
+}
+
+function makeWallet(preimage: string = PREIMAGE) {
+  return {
+    payInvoice: jest.fn().mockResolvedValue({ preimage }),
+  };
+}
+
+beforeEach(() => {
+  fetchMock.resetMocks();
+});
+
+// ---------------------------------------------------------------------------
+// fetchWithX402
+// ---------------------------------------------------------------------------
+describe("fetchWithX402", () => {
+  test("returns initial response when no PAYMENT-REQUIRED header", async () => {
+    const wallet = makeWallet();
+
+    fetchMock.mockResponseOnce(JSON.stringify({ data: "free content" }), {
+      status: 200,
+    });
+
+    const response = await fetchWithX402(X402_URL, {}, { wallet });
+
+    expect(response.status).toBe(200);
+    expect(await response.json()).toEqual({ data: "free content" });
+    expect(wallet.payInvoice).not.toHaveBeenCalled();
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  test("pays invoice and retries fetch on 402 challenge", async () => {
+    const wallet = makeWallet();
+
+    fetchMock.mockResponseOnce("Payment Required", {
+      status: 402,
+      headers: { "PAYMENT-REQUIRED": makePaymentRequiredHeader() },
+    });
+    fetchMock.mockResponseOnce(JSON.stringify({ data: "paid content" }), {
+      status: 200,
+    });
+
+    const response = await fetchWithX402(X402_URL, {}, { wallet });
+
+    expect(wallet.payInvoice).toHaveBeenCalledTimes(1);
+    expect(wallet.payInvoice).toHaveBeenCalledWith({ invoice: INVOICE });
+    expect(fetchMock).toHaveBeenCalledTimes(2);
+    expect(response.status).toBe(200);
+    expect(await response.json()).toEqual({ data: "paid content" });
+  });
+
+  test("sets correct payment-signature header on retry", async () => {
+    const wallet = makeWallet();
+
+    fetchMock.mockResponseOnce("Payment Required", {
+      status: 402,
+      headers: { "PAYMENT-REQUIRED": makePaymentRequiredHeader() },
+    });
+    fetchMock.mockResponseOnce(JSON.stringify({ ok: true }), { status: 200 });
+
+    await fetchWithX402(X402_URL, {}, { wallet });
+
+    const secondCallInit = fetchMock.mock.calls[1][1] as RequestInit;
+    const headers = secondCallInit.headers as Headers;
+    const sig = parsePaymentSignature(headers.get("payment-signature")!);
+
+    const payload = sig.payload as { invoice: string };
+    expect(payload.invoice).toEqual(INVOICE);
+    expect(sig.accepted).toEqual(REQUIREMENTS);
+  });
+
+  test("stores payment data after successful payment", async () => {
+    const wallet = makeWallet();
+    const store = new MemoryStorage();
+
+    fetchMock.mockResponseOnce("Payment Required", {
+      status: 402,
+      headers: { "PAYMENT-REQUIRED": makePaymentRequiredHeader() },
+    });
+    fetchMock.mockResponseOnce(JSON.stringify({ ok: true }), { status: 200 });
+
+    await fetchWithX402(X402_URL, {}, { wallet, store });
+
+    const stored = JSON.parse(store.getItem(X402_URL) as string);
+    expect(stored).toMatchObject({
+      scheme: REQUIREMENTS.scheme,
+      network: REQUIREMENTS.network,
+      invoice: INVOICE,
+      requirements: REQUIREMENTS,
+    });
+  });
+
+  test("uses cached payment data without calling wallet", async () => {
+    const wallet = makeWallet();
+    const store = new MemoryStorage();
+
+    store.setItem(
+      X402_URL,
+      JSON.stringify({
+        scheme: REQUIREMENTS.scheme,
+        network: REQUIREMENTS.network,
+        invoice: INVOICE,
+        requirements: REQUIREMENTS,
+      }),
+    );
+
+    fetchMock.mockResponseOnce(JSON.stringify({ data: "cached access" }), {
+      status: 200,
+    });
+
+    const response = await fetchWithX402(X402_URL, {}, { wallet, store });
+
+    expect(wallet.payInvoice).not.toHaveBeenCalled();
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+    expect(await response.json()).toEqual({ data: "cached access" });
+
+    const callInit = fetchMock.mock.calls[0][1] as RequestInit;
+    const headers = callInit.headers as Headers;
+    const sig = parsePaymentSignature(headers.get("payment-signature")!);
+    const payload = sig.payload as { invoice: string };
+    expect(payload.invoice).toEqual(INVOICE);
+  });
+
+  test("second request reuses cached data without re-paying", async () => {
+    const wallet = makeWallet();
+    const store = new MemoryStorage();
+
+    fetchMock.mockResponseOnce("Payment Required", {
+      status: 402,
+      headers: { "PAYMENT-REQUIRED": makePaymentRequiredHeader() },
+    });
+    fetchMock.mockResponseOnce(JSON.stringify({ first: true }), {
+      status: 200,
+    });
+
+    await fetchWithX402(X402_URL, {}, { wallet, store });
+    expect(wallet.payInvoice).toHaveBeenCalledTimes(1);
+
+    fetchMock.mockResponseOnce(JSON.stringify({ second: true }), {
+      status: 200,
+    });
+
+    const response = await fetchWithX402(X402_URL, {}, { wallet, store });
+
+    expect(wallet.payInvoice).toHaveBeenCalledTimes(1); // still only 1
+    expect(await response.json()).toEqual({ second: true });
+  });
+
+  test("works with NoStorage (never caches, pays every time)", async () => {
+    const wallet = makeWallet();
+    const store = new NoStorage();
+
+    fetchMock.mockResponseOnce("Payment Required", {
+      status: 402,
+      headers: { "PAYMENT-REQUIRED": makePaymentRequiredHeader() },
+    });
+    fetchMock.mockResponseOnce(JSON.stringify({ first: true }), {
+      status: 200,
+    });
+
+    await fetchWithX402(X402_URL, {}, { wallet, store });
+
+    fetchMock.mockResponseOnce("Payment Required", {
+      status: 402,
+      headers: { "PAYMENT-REQUIRED": makePaymentRequiredHeader() },
+    });
+    fetchMock.mockResponseOnce(JSON.stringify({ second: true }), {
+      status: 200,
+    });
+
+    await fetchWithX402(X402_URL, {}, { wallet, store });
+
+    expect(wallet.payInvoice).toHaveBeenCalledTimes(2);
+    expect(fetchMock).toHaveBeenCalledTimes(4);
+  });
+
+  test("falls through on incomplete cache entry (missing invoice)", async () => {
+    const wallet = makeWallet();
+    const store = new MemoryStorage();
+
+    store.setItem(
+      X402_URL,
+      JSON.stringify({
+        scheme: "exact",
+        network: "bip122:000000000019d6689c085ae165831e93",
+        // no invoice, no requirements
+      }),
+    );
+
+    fetchMock.mockResponseOnce("Payment Required", {
+      status: 402,
+      headers: { "PAYMENT-REQUIRED": makePaymentRequiredHeader() },
+    });
+    fetchMock.mockResponseOnce(JSON.stringify({ ok: true }), { status: 200 });
+
+    await fetchWithX402(X402_URL, {}, { wallet, store });
+
+    expect(wallet.payInvoice).toHaveBeenCalledTimes(1);
+  });
+
+  test("throws on invalid base64 PAYMENT-REQUIRED header", async () => {
+    const wallet = makeWallet();
+
+    fetchMock.mockResponseOnce("Payment Required", {
+      status: 402,
+      headers: { "PAYMENT-REQUIRED": "not-valid-base64!!!" },
+    });
+
+    await expect(fetchWithX402(X402_URL, {}, { wallet })).rejects.toThrow(
+      "x402: invalid PAYMENT-REQUIRED header (not valid base64-encoded JSON)",
+    );
+  });
+
+  test("throws on valid base64 but non-JSON PAYMENT-REQUIRED header", async () => {
+    const wallet = makeWallet();
+
+    fetchMock.mockResponseOnce("Payment Required", {
+      status: 402,
+      headers: { "PAYMENT-REQUIRED": btoa("this is not json") },
+    });
+
+    await expect(fetchWithX402(X402_URL, {}, { wallet })).rejects.toThrow(
+      "x402: invalid PAYMENT-REQUIRED header (not valid base64-encoded JSON)",
+    );
+  });
+
+  test("throws when accepts array is empty", async () => {
+    const wallet = makeWallet();
+
+    fetchMock.mockResponseOnce("Payment Required", {
+      status: 402,
+      headers: {
+        "PAYMENT-REQUIRED": makePaymentRequiredHeader(REQUIREMENTS, []),
+      },
+    });
+
+    await expect(fetchWithX402(X402_URL, {}, { wallet })).rejects.toThrow(
+      "x402: PAYMENT-REQUIRED header contains no payment options",
+    );
+  });
+
+  test("throws when no accepted entry has a lightning network", async () => {
+    const wallet = makeWallet();
+    const nonLightning = {
+      scheme: "exact",
+      network: "bip122:something",
+      extra: { invoice: INVOICE },
+    };
+
+    fetchMock.mockResponseOnce("Payment Required", {
+      status: 402,
+      headers: {
+        "PAYMENT-REQUIRED": makePaymentRequiredHeader(nonLightning as never, [
+          nonLightning as never,
+        ]),
+      },
+    });
+
+    await expect(fetchWithX402(X402_URL, {}, { wallet })).rejects.toThrow(
+      "x402: unsupported x402 network, only Bitcoin lightning network is supported.",
+    );
+  });
+
+  test("throws when requirements missing invoice", async () => {
+    const wallet = makeWallet();
+    const bad = { scheme: "exact", network: "lightning:mainnet", extra: {} };
+
+    fetchMock.mockResponseOnce("Payment Required", {
+      status: 402,
+      headers: { "PAYMENT-REQUIRED": makePaymentRequiredHeader(bad as never) },
+    });
+
+    await expect(fetchWithX402(X402_URL, {}, { wallet })).rejects.toThrow(
+      "x402: unsupported x402 network, only Bitcoin lightning network is supported.",
+    );
+  });
+
+  test("picks first lightning entry when accepts contains mixed networks", async () => {
+    const wallet = makeWallet();
+    const nonLightning = {
+      scheme: "exact",
+      network: "bitcoin:mainnet",
+      extra: { invoice: "other" },
+    };
+
+    fetchMock.mockResponseOnce("Payment Required", {
+      status: 402,
+      headers: {
+        "PAYMENT-REQUIRED": makePaymentRequiredHeader(REQUIREMENTS, [
+          nonLightning as never,
+          REQUIREMENTS,
+        ]),
+      },
+    });
+    fetchMock.mockResponseOnce(JSON.stringify({ ok: true }), { status: 200 });
+
+    await fetchWithX402(X402_URL, {}, { wallet });
+
+    expect(wallet.payInvoice).toHaveBeenCalledWith({ invoice: INVOICE });
+  });
+
+  test("propagates wallet payment errors", async () => {
+    const wallet = {
+      payInvoice: jest.fn().mockRejectedValue(new Error("payment failed")),
+    };
+
+    fetchMock.mockResponseOnce("Payment Required", {
+      status: 402,
+      headers: { "PAYMENT-REQUIRED": makePaymentRequiredHeader() },
+    });
+
+    await expect(fetchWithX402(X402_URL, {}, { wallet })).rejects.toThrow(
+      "payment failed",
+    );
+  });
+
+  test("sets cache to no-store and mode to cors", async () => {
+    const wallet = makeWallet();
+
+    fetchMock.mockResponseOnce(JSON.stringify({ ok: true }), { status: 200 });
+
+    await fetchWithX402(X402_URL, {}, { wallet });
+
+    const fetchInit = fetchMock.mock.calls[0][1] as RequestInit;
+    expect(fetchInit.cache).toBe("no-store");
+    expect(fetchInit.mode).toBe("cors");
+  });
+
+  test("passes custom fetchArgs through to all fetch calls", async () => {
+    const wallet = makeWallet();
+
+    fetchMock.mockResponseOnce("Payment Required", {
+      status: 402,
+      headers: { "PAYMENT-REQUIRED": makePaymentRequiredHeader() },
+    });
+    fetchMock.mockResponseOnce(JSON.stringify({ ok: true }), { status: 200 });
+
+    await fetchWithX402(
+      X402_URL,
+      { method: "POST", headers: { "X-Custom": "value" } },
+      { wallet },
+    );
+
+    for (const call of fetchMock.mock.calls) {
+      const fetchInit = call[1] as RequestInit;
+      const headers = fetchInit.headers as Headers;
+      expect(fetchInit.method).toBe("POST");
+      expect(headers.get("X-Custom")).toBe("value");
+    }
+  });
+});
diff --git a/src/402/x402/x402.ts b/src/402/x402/x402.ts
new file mode 100644
index 0000000..5acc022
--- /dev/null
+++ b/src/402/x402/x402.ts
@@ -0,0 +1,123 @@
+import { KVStorage, NoStorage, Wallet } from "../utils";
+import { buildX402PaymentSignature, X402Requirements } from "./utils";
+import { Invoice } from "../../bolt11";
+
+const noStorage = new NoStorage();
+
+export const handleX402Payment = async (
+  x402Header: string,
+  url: string,
+  fetchArgs: RequestInit,
+  headers: Headers,
+  wallet: Wallet,
+  store: KVStorage,
+): Promise<Response> => {
+  let parsed: { accepts?: unknown[] };
+  try {
+    parsed = JSON.parse(decodeURIComponent(escape(atob(x402Header))));
+  } catch (_) {
+    throw new Error(
+      "x402: invalid PAYMENT-REQUIRED header (not valid base64-encoded JSON)",
+    );
+  }
+
+  if (!Array.isArray(parsed.accepts) || parsed.accepts.length === 0) {
+    throw new Error(
+      "x402: PAYMENT-REQUIRED header contains no payment options",
+    );
+  }
+
+  const requirements = (parsed.accepts as X402Requirements[]).find((e) => {
+    return e.extra?.paymentMethod === "lightning";
+  });
+  if (!requirements) {
+    throw new Error(
+      "x402: unsupported x402 network, only Bitcoin lightning network is supported.",
+    );
+  }
+  if (!requirements.extra?.invoice) {
+    throw new Error("x402: payment requirements missing lightning invoice");
+  }
+
+  const invoice = new Invoice({ pr: requirements.extra.invoice });
+  if (invoice.amountRaw != requirements.amount) {
+    throw new Error(
+      `Invalid invoice amount: ${invoice.amountRaw}. expected ${requirements.amount}`,
+    );
+  }
+
+  await wallet.payInvoice!({ invoice: invoice.paymentRequest });
+
+  store.setItem(
+    url,
+    JSON.stringify({
+      scheme: requirements.scheme,
+      network: requirements.network,
+      invoice: invoice.paymentRequest,
+      requirements,
+    }),
+  );
+
+  headers.set(
+    "payment-signature",
+    buildX402PaymentSignature(
+      requirements.scheme,
+      requirements.network,
+      invoice.paymentRequest,
+      requirements,
+    ),
+  );
+  return fetch(url, fetchArgs);
+};
+
+export const fetchWithX402 = async (
+  url: string,
+  fetchArgs: RequestInit,
+  options: { wallet: Wallet; store?: KVStorage },
+) => {
+  const wallet = options.wallet;
+  const store = options.store || noStorage;
+  if (!fetchArgs) {
+    fetchArgs = {};
+  }
+  fetchArgs.cache = "no-store";
+  fetchArgs.mode = "cors";
+  const headers = new Headers(fetchArgs.headers ?? undefined);
+  fetchArgs.headers = headers;
+
+  const cachedRaw = store.getItem(url);
+  if (cachedRaw) {
+    let cached: {
+      scheme: string;
+      network: string;
+      invoice: string;
+      requirements: X402Requirements;
+    } | null = null;
+    cached = JSON.parse(cachedRaw);
+    if (
+      cached?.scheme &&
+      cached?.network &&
+      cached?.invoice &&
+      cached?.requirements
+    ) {
+      headers.set(
+        "payment-signature",
+        buildX402PaymentSignature(
+          cached.scheme,
+          cached.network,
+          cached.invoice,
+          cached.requirements,
+        ),
+      );
+      return await fetch(url, fetchArgs);
+    }
+  }
+
+  const initResp = await fetch(url, fetchArgs);
+  const header = initResp.headers.get("PAYMENT-REQUIRED");
+  if (!header) {
+    return initResp;
+  }
+
+  return handleX402Payment(header, url, fetchArgs, headers, wallet, store);
+};
diff --git a/src/bolt11/Invoice.test.ts b/src/bolt11/Invoice.test.ts
index 897ad74..99afe83 100644
--- a/src/bolt11/Invoice.test.ts
+++ b/src/bolt11/Invoice.test.ts
@@ -23,6 +23,8 @@ describe("Invoice", () => {
       "9c0e57f7f1f4823ce6751fc3fd260e55fe12ccb7dbd70ab58e660c03f569ab34",
     );
     expect(decodedInvoice.satoshi).toBe(1);
+    expect(decodedInvoice.millisatoshi).toBe(1000);
+    expect(decodedInvoice.amountRaw).toBe("1000");
     expect(decodedInvoice.expiry).toBe(86400);
     expect(decodedInvoice.timestamp).toBe(1699966882);
     expect(decodedInvoice.createdDate.toISOString()).toBe(
diff --git a/src/bolt11/Invoice.ts b/src/bolt11/Invoice.ts
index f476cac..ba43593 100644
--- a/src/bolt11/Invoice.ts
+++ b/src/bolt11/Invoice.ts
@@ -9,6 +9,8 @@ export class Invoice {
   preimage: string | null;
   verify: string | null;
   satoshi: number;
+  millisatoshi: number;
+  amountRaw: string;
   expiry: number | undefined; // expiry in seconds (not a timestamp)
   timestamp: number; // created date in seconds
   createdDate: Date;
@@ -27,6 +29,8 @@ export class Invoice {
     }
     this.paymentHash = decodedInvoice.paymentHash;
     this.satoshi = decodedInvoice.satoshi;
+    this.millisatoshi = decodedInvoice.millisatoshi;
+    this.amountRaw = decodedInvoice.amountRaw;
     this.timestamp = decodedInvoice.timestamp;
     this.expiry = decodedInvoice.expiry;
     this.createdDate = new Date(this.timestamp * 1000);
diff --git a/src/bolt11/utils.ts b/src/bolt11/utils.ts
index b7a5f60..b54fa54 100644
--- a/src/bolt11/utils.ts
+++ b/src/bolt11/utils.ts
@@ -9,6 +9,8 @@ export const fromHexString = (hexString: string) =>
 type DecodedInvoice = {
   paymentHash: string;
   satoshi: number;
+  millisatoshi: number;
+  amountRaw: string;
   timestamp: number;
   expiry: number | undefined;
   description: string | undefined;
@@ -32,10 +34,14 @@ export const decodeInvoice = (
     const paymentHash = hashTag.value;
 
     let satoshi = 0;
+    let millisatoshi = 0;
+    let amountRaw = "0";
 
     const amountTag = decoded.sections.find((value) => value.name === "amount");
 
     if (amountTag?.name === "amount" && amountTag.value) {
+      amountRaw = amountTag.value;
+      millisatoshi = parseInt(amountTag.value);
       satoshi = parseInt(amountTag.value) / 1000; // millisats
     }
 
@@ -66,6 +72,8 @@ export const decodeInvoice = (
     return {
       paymentHash,
       satoshi,
+      millisatoshi,
+      amountRaw,
       timestamp,
       expiry,
       description,
diff --git a/src/index.ts b/src/index.ts
index 4a5c620..85d2297 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -1,5 +1,7 @@
 export * from "./bolt11";
 export * from "./lnurl";
 export * from "./podcasting2";
-export * from "./l402";
+export * from "./402/l402";
+export * from "./402/x402";
+export * from "./402";
 export * from "./fiat";
diff --git a/src/l402/l402.ts b/src/l402/l402.ts
deleted file mode 100644
index 9977650..0000000
--- a/src/l402/l402.ts
+++ /dev/null
@@ -1,69 +0,0 @@
-import { KVStorage, MemoryStorage, parseL402 } from "./utils";
-
-const memoryStorage = new MemoryStorage();
-
-const HEADER_KEY = "L402";
-
-interface Wallet {
-  sendPayment(paymentRequest: string): Promise<{ preimage: string }>;
-}
-
-export const fetchWithL402 = async (
-  url: string,
-  fetchArgs: RequestInit,
-  options: {
-    headerKey?: string;
-    wallet?: Wallet;
-    store?: KVStorage;
-  },
-) => {
-  if (!options) {
-    options = {};
-  }
-  const headerKey = options.headerKey || HEADER_KEY;
-  const wallet: Wallet | undefined = options.wallet;
-  if (!wallet) {
-    throw new Error("wallet is missing");
-  }
-  const store = options.store || memoryStorage;
-  if (!fetchArgs) {
-    fetchArgs = {};
-  }
-  fetchArgs.cache = "no-store";
-  fetchArgs.mode = "cors";
-  if (!fetchArgs.headers) {
-    fetchArgs.headers = {};
-  }
-  const cachedL402Data = store.getItem(url);
-  if (cachedL402Data) {
-    const data = JSON.parse(cachedL402Data);
-    fetchArgs.headers["Authorization"] =
-      `${headerKey} ${data.token}:${data.preimage}`;
-    return await fetch(url, fetchArgs);
-  }
-
-  fetchArgs.headers["Accept-Authenticate"] = headerKey;
-  const initResp = await fetch(url, fetchArgs);
-  const header = initResp.headers.get("www-authenticate");
-  if (!header) {
-    return initResp;
-  }
-
-  const details = parseL402(header);
-  const token = details.token || details.macaroon;
-  const inv = details.invoice;
-
-  const invResp = await wallet.sendPayment(inv);
-
-  store.setItem(
-    url,
-    JSON.stringify({
-      token: token,
-      preimage: invResp.preimage,
-    }),
-  );
-
-  fetchArgs.headers["Authorization"] =
-    `${headerKey} ${token}:${invResp.preimage}`;
-  return await fetch(url, fetchArgs);
-};