x402-anthropic 0.1.0

package/.github/workflows/node.yml

@@ -0,0 +1,28 @@
+name: node
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        node-version: ["20", "22"]
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: ${{ matrix.node-version }}
+          cache: "npm"
+
+      - run: npm ci
+
+      - run: npm run build
+
+      - run: npm test

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 kinance
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,113 @@
+# x402-anthropic-typescript
+
+[![npm](https://img.shields.io/npm/v/x402-anthropic)](https://www.npmjs.com/package/x402-anthropic)
+[![TypeScript](https://img.shields.io/badge/typescript-5.0+-blue)](https://typescriptlang.org)
+[![License](https://img.shields.io/badge/license-MIT-green)](https://github.com/kinance/x402-anthropic-typescript/blob/main/LICENSE)
+[![CI](https://github.com/kinance/x402-anthropic-typescript/actions/workflows/node.yml/badge.svg)](https://github.com/kinance/x402-anthropic-typescript/actions)
+
+x402 payment transport for the [Anthropic TypeScript SDK](https://github.com/anthropics/anthropic-sdk-js).
+
+Wrap the standard `Anthropic` client with a crypto wallet. When the server responds with **HTTP 402**, the library automatically signs a USDC payment and retries — zero code changes needed. Follows the pattern introduced by [qntx/x402-openai-typescript](https://github.com/qntx/x402-openai-typescript).
+
+## Install
+
+```bash
+npm install x402-anthropic @x402/evm viem        # EVM (Base, Ethereum)
+npm install x402-anthropic @x402/svm @solana/kit  # SVM (Solana)
+npm install x402-anthropic @x402/evm @x402/svm viem @solana/kit  # all chains
+```
+
+## Quick start
+
+```ts
+import { X402Anthropic, EVMWallet } from "x402-anthropic";
+
+const client = new X402Anthropic({
+  wallet: new EVMWallet("0x..."),
+  baseURL: "https://your-x402-gateway.example.com",
+});
+
+const message = await client.messages.create({
+  model: "claude-opus-4-5",
+  max_tokens: 1024,
+  messages: [{ role: "user", content: "Hello!" }],
+});
+console.log(message.content[0]);
+```
+
+Swap `EVMWallet` for `SVMWallet` to pay on Solana — the API is identical.
+
+## Usage
+
+### Streaming
+
+```ts
+const stream = await client.messages.stream({
+  model: "claude-opus-4-5",
+  max_tokens: 1024,
+  messages: [{ role: "user", content: "Tell me a story." }],
+});
+for await (const text of stream.textStream) {
+  process.stdout.write(text);
+}
+```
+
+### Payment policies
+
+```ts
+import { X402Anthropic, EVMWallet, preferNetwork, maxAmount } from "x402-anthropic";
+
+const client = new X402Anthropic({
+  wallet: new EVMWallet("0x..."),
+  policies: [preferNetwork("eip155:8453"), maxAmount(1_000_000n)],  // Base, max $1 USDC
+  baseURL: "...",
+});
+```
+
+## API reference
+
+### `X402Anthropic`
+
+Drop-in replacement for `Anthropic` from `@anthropic-ai/sdk`.
+
+| Parameter | Type | Description |
+| :-- | :-- | :-- |
+| `wallet` | `Wallet` | Wallet adapter for signing payments |
+| `policies` | `Policy[]` | Payment policies (chain preference, amount cap) |
+| `baseURL` | `string` | Gateway URL (required — points at your x402 server) |
+
+All standard Anthropic options (`timeout`, `maxRetries`, `apiKey`, …) are forwarded.
+
+### Wallet adapters
+
+| Class | Chain | Peer deps |
+| :-- | :-- | :-- |
+| `EVMWallet(privateKey)` | Base, Ethereum, any EVM | `@x402/evm viem` |
+| `SVMWallet(privateKey)` | Solana | `@x402/svm @solana/kit` |
+
+Implement the `Wallet` interface to add a new chain.
+
+### Policy helpers
+
+| Function | Effect |
+| :-- | :-- |
+| `preferNetwork(caip2)` | Prefer a specific chain (falls back to any if unavailable) |
+| `preferScheme(scheme)` | Prefer a payment scheme (e.g. `"exact"`) |
+| `maxAmount(units)` | Skip payment requirements above this USDC unit amount |
+
+## Examples
+
+```bash
+EVM_PRIVATE_KEY="0x..."        npx tsx examples/basic.ts
+EVM_PRIVATE_KEY="0x..."        npx tsx examples/streaming.ts
+```
+
+## Related
+
+- [x402-anthropic-python](https://github.com/kinance/x402-anthropic-python) — Python version of this library
+- [qntx/x402-openai-typescript](https://github.com/qntx/x402-openai-typescript) — OpenAI SDK equivalent
+- [coinbase/x402](https://github.com/coinbase/x402) — x402 protocol spec and reference implementation
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,11 @@
+import Anthropic from "@anthropic-ai/sdk";
+import type { Wallet } from "./wallet.js";
+import type { Policy } from "./policies.js";
+interface X402AnthropicOptions extends Omit<ConstructorParameters<typeof Anthropic>[0], "fetch"> {
+    wallet: Wallet;
+    policies?: Policy[];
+}
+export declare class X402Anthropic extends Anthropic {
+    constructor({ wallet, policies, ...options }: X402AnthropicOptions);
+}
+export {};

package/dist/client.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.X402Anthropic = void 0;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+const fetch_1 = require("@x402/fetch");
+function createLazyX402Fetch(walletFn) {
+    let fetchPromise = null;
+    return async (input, init) => {
+        if (!fetchPromise) {
+            fetchPromise = walletFn()
+                .then((client) => (0, fetch_1.wrapFetchWithPayment)(globalThis.fetch, client))
+                .catch((err) => { fetchPromise = null; throw err; });
+        }
+        const wrappedFetch = await fetchPromise;
+        return wrappedFetch(input, init);
+    };
+}
+class X402Anthropic extends sdk_1.default {
+    constructor({ wallet, policies = [], ...options }) {
+        const x402Fetch = createLazyX402Fetch(async () => {
+            const client = new fetch_1.x402Client();
+            await wallet.register(client);
+            for (const policy of policies) {
+                client.registerPolicy(policy);
+            }
+            return client;
+        });
+        super({
+            apiKey: "x402",
+            ...options,
+            fetch: x402Fetch,
+        });
+    }
+}
+exports.X402Anthropic = X402Anthropic;

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { X402Anthropic } from "./client.js";
+export { EVMWallet, SVMWallet } from "./wallet.js";
+export type { Wallet } from "./wallet.js";
+export { preferNetwork, preferScheme, maxAmount } from "./policies.js";
+export type { Policy } from "./policies.js";

package/dist/index.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxAmount = exports.preferScheme = exports.preferNetwork = exports.SVMWallet = exports.EVMWallet = exports.X402Anthropic = void 0;
+var client_js_1 = require("./client.js");
+Object.defineProperty(exports, "X402Anthropic", { enumerable: true, get: function () { return client_js_1.X402Anthropic; } });
+var wallet_js_1 = require("./wallet.js");
+Object.defineProperty(exports, "EVMWallet", { enumerable: true, get: function () { return wallet_js_1.EVMWallet; } });
+Object.defineProperty(exports, "SVMWallet", { enumerable: true, get: function () { return wallet_js_1.SVMWallet; } });
+var policies_js_1 = require("./policies.js");
+Object.defineProperty(exports, "preferNetwork", { enumerable: true, get: function () { return policies_js_1.preferNetwork; } });
+Object.defineProperty(exports, "preferScheme", { enumerable: true, get: function () { return policies_js_1.preferScheme; } });
+Object.defineProperty(exports, "maxAmount", { enumerable: true, get: function () { return policies_js_1.maxAmount; } });

package/dist/policies.d.ts

@@ -0,0 +1,5 @@
+import type { PaymentRequirements } from "@x402/fetch";
+export type Policy = (x402Version: number, requirements: PaymentRequirements[]) => PaymentRequirements[];
+export declare function preferNetwork(network: string): Policy;
+export declare function preferScheme(scheme: string): Policy;
+export declare function maxAmount(maxUnits: bigint | number): Policy;

package/dist/policies.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preferNetwork = preferNetwork;
+exports.preferScheme = preferScheme;
+exports.maxAmount = maxAmount;
+function preferNetwork(network) {
+    return (_version, reqs) => {
+        const preferred = reqs.filter((r) => r.network === network);
+        return preferred.length > 0 ? preferred : reqs;
+    };
+}
+function preferScheme(scheme) {
+    return (_version, reqs) => {
+        const preferred = reqs.filter((r) => r.scheme === scheme);
+        return preferred.length > 0 ? preferred : reqs;
+    };
+}
+function maxAmount(maxUnits) {
+    const max = BigInt(maxUnits);
+    return (_version, reqs) => {
+        const affordable = reqs.filter((r) => {
+            const amount = BigInt(r.amount ??
+                r.maxAmountRequired ??
+                "0");
+            return amount <= max;
+        });
+        return affordable.length > 0 ? affordable : reqs;
+    };
+}

package/dist/wallet.d.ts

@@ -0,0 +1,16 @@
+import { x402Client } from "@x402/fetch";
+export interface Wallet {
+    register(client: x402Client): Promise<void> | void;
+}
+export declare class EVMWallet implements Wallet {
+    #private;
+    constructor(privateKey: `0x${string}`);
+    register(client: x402Client): Promise<void>;
+    toString(): string;
+}
+export declare class SVMWallet implements Wallet {
+    #private;
+    constructor(privateKey: string, network?: `${string}:${string}`);
+    register(client: x402Client): Promise<void>;
+    toString(): string;
+}

package/dist/wallet.js

@@ -0,0 +1,58 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _EVMWallet_privateKey, _EVMWallet_address, _SVMWallet_privateKey, _SVMWallet_network, _SVMWallet_pubkey;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SVMWallet = exports.EVMWallet = void 0;
+class EVMWallet {
+    constructor(privateKey) {
+        _EVMWallet_privateKey.set(this, void 0);
+        _EVMWallet_address.set(this, void 0);
+        __classPrivateFieldSet(this, _EVMWallet_privateKey, privateKey, "f");
+    }
+    async register(client) {
+        const { privateKeyToAccount } = await import("viem/accounts");
+        const { ExactEvmScheme, toClientEvmSigner } = await import("@x402/evm");
+        const account = privateKeyToAccount(__classPrivateFieldGet(this, _EVMWallet_privateKey, "f"));
+        __classPrivateFieldSet(this, _EVMWallet_address, account.address, "f");
+        const signer = toClientEvmSigner(account);
+        client.register("eip155:*", new ExactEvmScheme(signer));
+    }
+    toString() {
+        return __classPrivateFieldGet(this, _EVMWallet_address, "f") ? `EVMWallet(${__classPrivateFieldGet(this, _EVMWallet_address, "f")})` : "EVMWallet(unregistered)";
+    }
+}
+exports.EVMWallet = EVMWallet;
+_EVMWallet_privateKey = new WeakMap(), _EVMWallet_address = new WeakMap();
+class SVMWallet {
+    constructor(privateKey, network) {
+        _SVMWallet_privateKey.set(this, void 0);
+        _SVMWallet_network.set(this, void 0);
+        _SVMWallet_pubkey.set(this, void 0);
+        __classPrivateFieldSet(this, _SVMWallet_privateKey, privateKey, "f");
+        __classPrivateFieldSet(this, _SVMWallet_network, network, "f");
+    }
+    async register(client) {
+        const { createKeyPairSignerFromBytes } = await import("@solana/kit");
+        const { base58 } = await import("@scure/base");
+        const { ExactSvmScheme, toClientSvmSigner, SOLANA_MAINNET_CAIP2 } = await import("@x402/svm");
+        const keyBytes = base58.decode(__classPrivateFieldGet(this, _SVMWallet_privateKey, "f"));
+        const signer = await createKeyPairSignerFromBytes(keyBytes);
+        __classPrivateFieldSet(this, _SVMWallet_pubkey, String(signer.address), "f");
+        client.register(__classPrivateFieldGet(this, _SVMWallet_network, "f") ?? SOLANA_MAINNET_CAIP2, new ExactSvmScheme(toClientSvmSigner(signer)));
+    }
+    toString() {
+        return __classPrivateFieldGet(this, _SVMWallet_pubkey, "f") ? `SVMWallet(${__classPrivateFieldGet(this, _SVMWallet_pubkey, "f")})` : "SVMWallet(unregistered)";
+    }
+}
+exports.SVMWallet = SVMWallet;
+_SVMWallet_privateKey = new WeakMap(), _SVMWallet_network = new WeakMap(), _SVMWallet_pubkey = new WeakMap();

package/examples/basic.ts

@@ -0,0 +1,15 @@
+import { X402Anthropic, EVMWallet } from "@kinance/x402-anthropic";
+
+const wallet = new EVMWallet("0x_YOUR_PRIVATE_KEY");
+const client = new X402Anthropic({
+  wallet,
+  baseURL: "https://your-x402-gateway.example.com",
+});
+
+const message = await client.messages.create({
+  model: "claude-opus-4-5",
+  max_tokens: 1024,
+  messages: [{ role: "user", content: "Hello, Claude!" }],
+});
+
+console.log(message.content[0].type === "text" ? message.content[0].text : "");

package/examples/streaming.ts

@@ -0,0 +1,18 @@
+import { X402Anthropic, EVMWallet } from "@kinance/x402-anthropic";
+
+const wallet = new EVMWallet("0x_YOUR_PRIVATE_KEY");
+const client = new X402Anthropic({
+  wallet,
+  baseURL: "https://your-x402-gateway.example.com",
+});
+
+const stream = await client.messages.stream({
+  model: "claude-opus-4-5",
+  max_tokens: 1024,
+  messages: [{ role: "user", content: "Tell me a short story." }],
+});
+
+for await (const text of stream.textStream) {
+  process.stdout.write(text);
+}
+console.log();

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "x402-anthropic",
+  "version": "0.1.0",
+  "description": "x402 payment transport for the Anthropic TypeScript SDK",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit"
+  },
+  "keywords": ["anthropic", "x402", "payments", "claude", "http402"],
+  "license": "MIT",
+  "dependencies": {
+    "@x402/fetch": "^2.5.0"
+  },
+  "optionalDependencies": {
+    "@x402/evm": "^2.3.0",
+    "@x402/svm": "^2.3.0"
+  },
+  "devDependencies": {
+    "@anthropic-ai/sdk": "^0.52.0",
+    "typescript": "^5.4.0",
+    "vitest": "^1.6.0",
+    "@types/node": "^20.0.0"
+  },
+  "peerDependencies": {
+    "@anthropic-ai/sdk": ">=0.40.0"
+  }
+}

package/src/client.ts

@@ -0,0 +1,44 @@
+import Anthropic from "@anthropic-ai/sdk";
+import { x402Client, wrapFetchWithPayment } from "@x402/fetch";
+import type { Wallet } from "./wallet.js";
+import type { Policy } from "./policies.js";
+
+type FetchFn = typeof globalThis.fetch;
+
+interface X402AnthropicOptions extends Omit<ConstructorParameters<typeof Anthropic>[0], "fetch"> {
+  wallet: Wallet;
+  policies?: Policy[];
+}
+
+function createLazyX402Fetch(walletFn: () => Promise<x402Client>): FetchFn {
+  let fetchPromise: Promise<FetchFn> | null = null;
+
+  return async (input, init) => {
+    if (!fetchPromise) {
+      fetchPromise = walletFn()
+        .then((client) => wrapFetchWithPayment(globalThis.fetch, client) as FetchFn)
+        .catch((err) => { fetchPromise = null; throw err; });
+    }
+    const wrappedFetch = await fetchPromise;
+    return wrappedFetch(input, init);
+  };
+}
+
+export class X402Anthropic extends Anthropic {
+  constructor({ wallet, policies = [], ...options }: X402AnthropicOptions) {
+    const x402Fetch = createLazyX402Fetch(async () => {
+      const client = new x402Client();
+      await wallet.register(client);
+      for (const policy of policies) {
+        client.registerPolicy(policy);
+      }
+      return client;
+    });
+
+    super({
+      apiKey: "x402",
+      ...options,
+      fetch: x402Fetch as FetchFn,
+    });
+  }
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export { X402Anthropic } from "./client.js";
+export { EVMWallet, SVMWallet } from "./wallet.js";
+export type { Wallet } from "./wallet.js";
+export { preferNetwork, preferScheme, maxAmount } from "./policies.js";
+export type { Policy } from "./policies.js";

package/src/policies.ts

@@ -0,0 +1,32 @@
+import type { PaymentRequirements } from "@x402/fetch";
+
+export type Policy = (x402Version: number, requirements: PaymentRequirements[]) => PaymentRequirements[];
+
+export function preferNetwork(network: string): Policy {
+  return (_version, reqs) => {
+    const preferred = reqs.filter((r) => r.network === network);
+    return preferred.length > 0 ? preferred : reqs;
+  };
+}
+
+export function preferScheme(scheme: string): Policy {
+  return (_version, reqs) => {
+    const preferred = reqs.filter((r) => r.scheme === scheme);
+    return preferred.length > 0 ? preferred : reqs;
+  };
+}
+
+export function maxAmount(maxUnits: bigint | number): Policy {
+  const max = BigInt(maxUnits);
+  return (_version, reqs) => {
+    const affordable = reqs.filter((r) => {
+      const amount = BigInt(
+        (r as { amount?: string }).amount ??
+          (r as { maxAmountRequired?: string }).maxAmountRequired ??
+          "0"
+      );
+      return amount <= max;
+    });
+    return affordable.length > 0 ? affordable : reqs;
+  };
+}

package/src/wallet.ts

@@ -0,0 +1,52 @@
+import { x402Client } from "@x402/fetch";
+
+export interface Wallet {
+  register(client: x402Client): Promise<void> | void;
+}
+
+export class EVMWallet implements Wallet {
+  readonly #privateKey: `0x${string}`;
+  #address: string | undefined;
+
+  constructor(privateKey: `0x${string}`) {
+    this.#privateKey = privateKey;
+  }
+
+  async register(client: x402Client): Promise<void> {
+    const { privateKeyToAccount } = await import("viem/accounts");
+    const { ExactEvmScheme, toClientEvmSigner } = await import("@x402/evm");
+    const account = privateKeyToAccount(this.#privateKey);
+    this.#address = account.address;
+    const signer = toClientEvmSigner(account);
+    client.register("eip155:*", new ExactEvmScheme(signer));
+  }
+
+  toString(): string {
+    return this.#address ? `EVMWallet(${this.#address})` : "EVMWallet(unregistered)";
+  }
+}
+
+export class SVMWallet implements Wallet {
+  readonly #privateKey: string;
+  readonly #network: `${string}:${string}` | undefined;
+  #pubkey: string | undefined;
+
+  constructor(privateKey: string, network?: `${string}:${string}`) {
+    this.#privateKey = privateKey;
+    this.#network = network;
+  }
+
+  async register(client: x402Client): Promise<void> {
+    const { createKeyPairSignerFromBytes } = await import("@solana/kit");
+    const { base58 } = await import("@scure/base");
+    const { ExactSvmScheme, toClientSvmSigner, SOLANA_MAINNET_CAIP2 } = await import("@x402/svm");
+    const keyBytes = base58.decode(this.#privateKey);
+    const signer = await createKeyPairSignerFromBytes(keyBytes);
+    this.#pubkey = String(signer.address);
+    client.register(this.#network ?? SOLANA_MAINNET_CAIP2, new ExactSvmScheme(toClientSvmSigner(signer)));
+  }
+
+  toString(): string {
+    return this.#pubkey ? `SVMWallet(${this.#pubkey})` : "SVMWallet(unregistered)";
+  }
+}

package/tests/client.test.ts

@@ -0,0 +1,133 @@
+import { describe, it, expect, vi } from "vitest";
+import { x402Client } from "@x402/fetch";
+import { X402Anthropic } from "../src/index.js";
+import { preferNetwork } from "../src/policies.js";
+
+// ---------------------------------------------------------------------------
+// Constructor / config
+// ---------------------------------------------------------------------------
+
+describe("X402Anthropic constructor", () => {
+  it("constructs without throwing", () => {
+    const wallet = { register: vi.fn() };
+    expect(() => new X402Anthropic({ wallet, baseURL: "https://example.com" })).not.toThrow();
+  });
+
+  it("sets apiKey to 'x402' by default", () => {
+    const wallet = { register: vi.fn() };
+    const client = new X402Anthropic({ wallet, baseURL: "https://example.com" });
+    expect((client as unknown as { apiKey: string }).apiKey).toBe("x402");
+  });
+
+  it("allows apiKey override", () => {
+    const wallet = { register: vi.fn() };
+    const client = new X402Anthropic({ wallet, apiKey: "custom", baseURL: "https://example.com" });
+    expect((client as unknown as { apiKey: string }).apiKey).toBe("custom");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Lazy fetch singleton — wallet.register() called exactly once
+// ---------------------------------------------------------------------------
+
+describe("lazy fetch singleton", () => {
+  it("calls wallet.register exactly once across multiple fetches", async () => {
+    const register = vi.fn();
+    const wallet = { register };
+
+    // Intercept the fetch to avoid real network calls
+    const fakeFetch = vi.fn().mockResolvedValue(new Response("{}", { status: 200 }));
+    // Patch globalThis.fetch for this test
+    const originalFetch = globalThis.fetch;
+    globalThis.fetch = fakeFetch;
+
+    // We access the internal fetch via the _options.fetch slot
+    // Instead, directly test the createLazyX402Fetch behaviour by extracting the lazy fn
+    // from the module so we can call it multiple times without a full client.
+    const { default: Anthropic } = await import("@anthropic-ai/sdk");
+    const client = new X402Anthropic({ wallet, baseURL: "https://httpbin.org" });
+
+    // Trigger the lazy fetch twice by calling the stored fetch function directly.
+    // The internal fetch is stored at client._options.fetch.
+    const lazyFetch = (client as unknown as { _options: { fetch?: typeof globalThis.fetch } })
+      ._options?.fetch;
+
+    if (lazyFetch) {
+      await lazyFetch("https://httpbin.org/get", { method: "GET" }).catch(() => {});
+      await lazyFetch("https://httpbin.org/get", { method: "GET" }).catch(() => {});
+    }
+
+    expect(register).toHaveBeenCalledTimes(1);
+    globalThis.fetch = originalFetch;
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Policy registration
+// ---------------------------------------------------------------------------
+
+describe("policy registration", () => {
+  it("calls registerPolicy for each supplied policy", async () => {
+    const registerSpy = vi.fn();
+    const registerPolicySpy = vi.fn();
+
+    // Mock the x402Client constructor
+    const mockX402Client = {
+      register: registerSpy,
+      registerPolicy: registerPolicySpy,
+    };
+
+    // We need to intercept x402Client instantiation inside createLazyX402Fetch.
+    // The simplest way: pass a wallet whose register() captures the client arg.
+    let capturedClient: unknown = null;
+    const wallet = {
+      register: vi.fn(async (client: unknown) => {
+        capturedClient = client;
+      }),
+    };
+
+    const policy = preferNetwork("eip155:8453");
+    const client = new X402Anthropic({
+      wallet,
+      policies: [policy],
+      baseURL: "https://httpbin.org",
+    });
+
+    const lazyFetch = (client as unknown as { _options: { fetch?: Function } })
+      ._options?.fetch;
+
+    if (lazyFetch) {
+      // Trigger initialization — the fetch will fail (no real server) but init runs.
+      await lazyFetch("https://httpbin.org/get").catch(() => {});
+    }
+
+    // wallet.register should have been called once
+    expect(wallet.register).toHaveBeenCalledTimes(1);
+    // The x402Client passed to wallet.register should be a real x402Client instance
+    expect(capturedClient).toBeInstanceOf(x402Client);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Policy helpers
+// ---------------------------------------------------------------------------
+
+describe("preferNetwork policy", () => {
+  const base = "eip155:8453";
+  const eth = "eip155:1";
+
+  it("filters to preferred network when present", () => {
+    const policy = preferNetwork(base);
+    const reqs = [{ network: eth }, { network: base }] as Parameters<typeof policy>[1];
+    const result = policy(2, reqs);
+    expect(result).toHaveLength(1);
+    expect(result[0].network).toBe(base);
+  });
+
+  it("returns all when preferred network is absent (fallthrough)", () => {
+    const policy = preferNetwork(base);
+    const reqs = [{ network: eth }, { network: "eip155:137" }] as Parameters<typeof policy>[1];
+    const result = policy(2, reqs);
+    expect(result).toHaveLength(2);
+  });
+});

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "outDir": "dist",
+    "declaration": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"],
+  "exclude": ["node_modules", "dist", "tests", "examples"]
+}