x402z-client-web 0.1.2

package/README.md

@@ -0,0 +1,117 @@
+# x402z-client-web
+
+Browser helpers for the erc7984-mind-v1 x402 scheme.
+
+## Install
+
+```bash
+pnpm add x402z-client-web x402z-shared-web
+```
+
+## Folder map
+
+- `src/http/`: HTTP client helpers
+- `src/scheme/`: scheme implementation + registration
+- `src/index.ts`: public exports
+
+## Usage (Browser)
+
+```ts
+import { createX402zClient } from "x402z-client-web";
+import {
+  createRelayer,
+  createBrowserSigner,
+  getBrowserEthereumProvider,
+  getSepoliaConfig,
+} from "x402z-shared-web";
+import type { FhevmInstanceConfig } from "x402z-shared-web";
+
+const provider = getBrowserEthereumProvider();
+const relayerConfig: FhevmInstanceConfig = {
+  ...(getSepoliaConfig() as object),
+  network: provider,
+};
+const relayer = await createRelayer(relayerConfig);
+const signer = await createBrowserSigner(provider);
+
+const client = createX402zClient({
+  preferredMethods: ["erc7984-mind-v1.CONFIDENTIAL_USDC.sepolia"] as const,
+  signer,
+  relayer,
+});
+
+const paid = await client.pay("https://example.com/demo");
+console.log(paid.response.status);
+```
+
+`createX402zClient` builds the confidential payment input automatically using the
+`confidential.batcherAddress` provided by the server’s payment requirements.
+`createRelayer` calls `initSDK()` automatically on first use.
+
+## Choosing Payment Methods (Client)
+
+The client picks the **first** preferred method that matches the server’s `accepts` list
+by `scheme + network + asset`.
+
+You can specify preferred methods in two ways:
+
+1) **Name string** (scheme + token + network alias):
+```ts
+preferredMethods: ["exact.USDC.base", "erc7984-mind-v1.CONFIDENTIAL_USDC.sepolia"] as const
+```
+
+2) **Config entry** (from `SCHEME_CONFIG`):
+```ts
+import { SCHEME_CONFIG } from "x402z-scheme-config";
+
+preferredMethods: [
+  SCHEME_CONFIG.exact.USDC.base,
+  SCHEME_CONFIG["erc7984-mind-v1"].CONFIDENTIAL_USDC.sepolia,
+]
+```
+
+If `preferredMethods` is omitted, the client defaults to `SCHEME_CONFIG_NAMES`
+(all known methods, in order).
+
+## API
+
+- `createX402zClient(config)`
+  - `preferredMethods` (optional): ordered list of preferred methods.
+    - Name form: `"exact.USDC.base"` (matches scheme/token/network alias from `x402z-scheme-config`).
+    - Config form: `SCHEME_CONFIG.exact.USDC.base`.
+  - `signer` (required): signer used for both exact and confidential schemes
+  - `relayer` (required when using `erc7984-mind-v1`): relayer instance (browser)
+  - `fetch` (optional): custom fetch implementation
+- `client.pay(url, options?)`: performs the 402 handshake and retries with payment headers
+  - returns `{ response, paymentRequired?, confidentialRequirements? }`
+
+## Examples
+
+See `examples/README.md` for the full-process web examples (`examples/full-process/web-vite` and `examples/full-process/web-next`).
+
+## Notes
+
+- Web builds use `@zama-fhe/relayer-sdk/web` (no CDN script tag or bundle).
+- Requires an injected wallet that supports `eth_signTypedData_v4` (e.g. MetaMask).
+- Confidential scheme name: `erc7984-mind-v1`
+- Exact scheme name: `exact`
+
+## API surface
+
+Exports:
+- `createX402zClient`: convenience client wrapper for browser pay flows.
+- `X402zEvmClientScheme`: client scheme implementation for erc7984-mind-v1.
+- `registerX402zEvmClientScheme`: registers the scheme with x402 client.
+
+Types:
+- `X402zClient`: client instance type.
+- `PreferredPaymentMethod`: preferred payment method selector (object form or scheme-config name string).
+- `X402zClientOptions`: options for `createX402zClient`.
+- `X402zConfidentialClientOptions`: options for confidential payments.
+- `X402zExactClientOptions`: options for exact payments.
+- `PayOptions`: per-request payment options.
+- `X402zClientSchemeOptions`: scheme config for client registration.
+- `X402zClientRegistrationOptions`: registration options for the scheme.
+- `ConfidentialRequirementsExtra`: scheme requirements extension payload.
+- `RelayerInstance`: relayer instance type.
+- re-exported types from `@x402/core/types`: shared x402 types.

package/dist/index.d.mts

@@ -0,0 +1,67 @@
+import { PaymentRequirements, SchemeNetworkClient, PaymentPayload, Network, PaymentRequired } from '@x402/core/types';
+export * from '@x402/core/types';
+import { SelectPaymentRequirements, PaymentPolicy, x402Client } from '@x402/core/client';
+import { ClientEvmSigner } from '@x402/evm';
+import { ConfidentialPaymentInput, RelayerInstance } from 'x402z-shared-web';
+export { ConfidentialRequirementsExtra, RelayerInstance } from 'x402z-shared-web';
+import { SchemeConfigName, ExactTokenConfig, ConfidentialTokenConfig } from 'x402z-scheme-config';
+
+type X402zClientSchemeOptions = {
+    signer: ClientEvmSigner;
+    buildPayment: (requirements: PaymentRequirements) => ConfidentialPaymentInput | Promise<ConfidentialPaymentInput>;
+    eip712?: {
+        name: string;
+        version: string;
+    };
+    hashEncryptedAmountInput?: (encryptedAmountInput: `0x${string}`) => `0x${string}`;
+    clock?: () => number;
+};
+declare class X402zEvmClientScheme implements SchemeNetworkClient {
+    private readonly config;
+    readonly scheme = "erc7984-mind-v1";
+    private readonly hashFn;
+    private readonly clock;
+    constructor(config: X402zClientSchemeOptions);
+    createPaymentPayload(x402Version: number, paymentRequirements: PaymentRequirements): Promise<Pick<PaymentPayload, "x402Version" | "payload">>;
+}
+
+type PreferredPaymentMethod = SchemeConfigName | ExactTokenConfig | ConfidentialTokenConfig;
+type BaseClientOptions = {
+    fetch?: typeof fetch;
+    debug?: boolean;
+};
+type X402zClientOptions = {
+    preferredMethods?: readonly PreferredPaymentMethod[];
+    signer: ClientEvmSigner;
+    relayer?: RelayerInstance;
+    networks?: Network[];
+    paymentRequirementsSelector?: SelectPaymentRequirements;
+    policies?: PaymentPolicy[];
+    eip712?: X402zClientSchemeOptions["eip712"];
+    hashEncryptedAmountInput?: X402zClientSchemeOptions["hashEncryptedAmountInput"];
+    clock?: X402zClientSchemeOptions["clock"];
+    onPaymentSelected?: (info: {
+        method: PreferredPaymentMethod;
+        requirements: PaymentRequirements;
+    }) => void;
+} & BaseClientOptions;
+type PayOptions = {
+    headers?: Record<string, string>;
+};
+type PayResult = {
+    response: Response;
+    paymentRequired?: PaymentRequired;
+    confidentialRequirements?: PaymentRequirements;
+};
+type X402zClient = {
+    relayer?: RelayerInstance;
+    pay: (url: string, options?: PayOptions) => Promise<PayResult>;
+};
+declare function createX402zClient(config: X402zClientOptions): X402zClient;
+
+type X402zClientRegistrationOptions = X402zClientSchemeOptions & {
+    networks?: Network[];
+};
+declare function registerX402zEvmClientScheme(client: x402Client, config: X402zClientRegistrationOptions): x402Client;
+
+export { type PayOptions, type PayResult, type PreferredPaymentMethod, type X402zClient, type X402zClientOptions, type X402zClientRegistrationOptions, type X402zClientSchemeOptions, X402zEvmClientScheme, createX402zClient, registerX402zEvmClientScheme };

package/dist/index.d.ts

@@ -0,0 +1,67 @@
+import { PaymentRequirements, SchemeNetworkClient, PaymentPayload, Network, PaymentRequired } from '@x402/core/types';
+export * from '@x402/core/types';
+import { SelectPaymentRequirements, PaymentPolicy, x402Client } from '@x402/core/client';
+import { ClientEvmSigner } from '@x402/evm';
+import { ConfidentialPaymentInput, RelayerInstance } from 'x402z-shared-web';
+export { ConfidentialRequirementsExtra, RelayerInstance } from 'x402z-shared-web';
+import { SchemeConfigName, ExactTokenConfig, ConfidentialTokenConfig } from 'x402z-scheme-config';
+
+type X402zClientSchemeOptions = {
+    signer: ClientEvmSigner;
+    buildPayment: (requirements: PaymentRequirements) => ConfidentialPaymentInput | Promise<ConfidentialPaymentInput>;
+    eip712?: {
+        name: string;
+        version: string;
+    };
+    hashEncryptedAmountInput?: (encryptedAmountInput: `0x${string}`) => `0x${string}`;
+    clock?: () => number;
+};
+declare class X402zEvmClientScheme implements SchemeNetworkClient {
+    private readonly config;
+    readonly scheme = "erc7984-mind-v1";
+    private readonly hashFn;
+    private readonly clock;
+    constructor(config: X402zClientSchemeOptions);
+    createPaymentPayload(x402Version: number, paymentRequirements: PaymentRequirements): Promise<Pick<PaymentPayload, "x402Version" | "payload">>;
+}
+
+type PreferredPaymentMethod = SchemeConfigName | ExactTokenConfig | ConfidentialTokenConfig;
+type BaseClientOptions = {
+    fetch?: typeof fetch;
+    debug?: boolean;
+};
+type X402zClientOptions = {
+    preferredMethods?: readonly PreferredPaymentMethod[];
+    signer: ClientEvmSigner;
+    relayer?: RelayerInstance;
+    networks?: Network[];
+    paymentRequirementsSelector?: SelectPaymentRequirements;
+    policies?: PaymentPolicy[];
+    eip712?: X402zClientSchemeOptions["eip712"];
+    hashEncryptedAmountInput?: X402zClientSchemeOptions["hashEncryptedAmountInput"];
+    clock?: X402zClientSchemeOptions["clock"];
+    onPaymentSelected?: (info: {
+        method: PreferredPaymentMethod;
+        requirements: PaymentRequirements;
+    }) => void;
+} & BaseClientOptions;
+type PayOptions = {
+    headers?: Record<string, string>;
+};
+type PayResult = {
+    response: Response;
+    paymentRequired?: PaymentRequired;
+    confidentialRequirements?: PaymentRequirements;
+};
+type X402zClient = {
+    relayer?: RelayerInstance;
+    pay: (url: string, options?: PayOptions) => Promise<PayResult>;
+};
+declare function createX402zClient(config: X402zClientOptions): X402zClient;
+
+type X402zClientRegistrationOptions = X402zClientSchemeOptions & {
+    networks?: Network[];
+};
+declare function registerX402zEvmClientScheme(client: x402Client, config: X402zClientRegistrationOptions): x402Client;
+
+export { type PayOptions, type PayResult, type PreferredPaymentMethod, type X402zClient, type X402zClientOptions, type X402zClientRegistrationOptions, type X402zClientSchemeOptions, X402zEvmClientScheme, createX402zClient, registerX402zEvmClientScheme };

package/dist/index.js

@@ -0,0 +1,335 @@
+"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 index_exports = {};
+__export(index_exports, {
+  X402zEvmClientScheme: () => X402zEvmClientScheme,
+  createX402zClient: () => createX402zClient,
+  registerX402zEvmClientScheme: () => registerX402zEvmClientScheme
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/http/client.ts
+var import_client = require("@x402/core/client");
+var import_http = require("@x402/core/http");
+var import_client2 = require("@x402/evm/exact/client");
+var import_viem2 = require("viem");
+var import_x402z_shared_web2 = require("x402z-shared-web");
+var import_x402z_scheme_config = require("x402z-scheme-config");
+
+// src/scheme/scheme.ts
+var import_viem = require("viem");
+var import_x402z_shared_web = require("x402z-shared-web");
+var ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var DECIMAL_POINT = ".";
+function normalizeIntegerAmount(value, fallback) {
+  const normalized = (0, import_x402z_shared_web.normalizeAmount)(value);
+  if (!normalized.includes(DECIMAL_POINT)) {
+    return normalized;
+  }
+  const fallbackNormalized = (0, import_x402z_shared_web.normalizeAmount)(fallback);
+  if (fallbackNormalized.includes(DECIMAL_POINT)) {
+    throw new Error(`Invalid amount: ${normalized}`);
+  }
+  return fallbackNormalized;
+}
+var X402zEvmClientScheme = class {
+  constructor(config) {
+    this.config = config;
+    this.scheme = "erc7984-mind-v1";
+    this.hashFn = config.hashEncryptedAmountInput ?? import_x402z_shared_web.hashEncryptedAmountInput;
+    this.clock = config.clock ?? (() => Math.floor(Date.now() / 1e3));
+  }
+  async createPaymentPayload(x402Version, paymentRequirements) {
+    const input = await this.config.buildPayment(paymentRequirements);
+    const extra = paymentRequirements.extra;
+    const eip712 = extra?.eip712 ?? this.config.eip712;
+    if (!eip712?.name || !eip712?.version) {
+      throw new Error("Missing EIP-712 domain parameters (name, version) in requirements or config");
+    }
+    const now = this.clock();
+    const validAfter = input.validAfter ?? Math.max(0, now - 60);
+    const validBefore = input.validBefore ?? now + paymentRequirements.maxTimeoutSeconds;
+    const nonce = input.nonce ?? (0, import_x402z_shared_web.createNonce)();
+    const maxClearAmount = normalizeIntegerAmount(
+      input.maxClearAmount ?? extra?.confidential?.maxClearAmount ?? paymentRequirements.amount,
+      paymentRequirements.amount
+    );
+    const resourceHash = input.resourceHash ?? extra?.confidential?.resourceHash ?? ZERO_BYTES32;
+    const authorization = {
+      holder: this.config.signer.address,
+      payee: (0, import_viem.getAddress)(paymentRequirements.payTo),
+      maxClearAmount,
+      resourceHash,
+      validAfter: (0, import_x402z_shared_web.normalizeAmount)(validAfter),
+      validBefore: (0, import_x402z_shared_web.normalizeAmount)(validBefore),
+      nonce,
+      encryptedAmountHash: this.hashFn(input.encryptedAmountInput)
+    };
+    const chainId = parseInt(paymentRequirements.network.split(":")[1]);
+    const signature = await this.config.signer.signTypedData({
+      domain: {
+        name: eip712.name,
+        version: eip712.version,
+        chainId,
+        verifyingContract: (0, import_viem.getAddress)(paymentRequirements.asset)
+      },
+      types: import_x402z_shared_web.confidentialPaymentTypes,
+      primaryType: "ConfidentialPayment",
+      message: {
+        holder: (0, import_viem.getAddress)(authorization.holder),
+        payee: (0, import_viem.getAddress)(authorization.payee),
+        maxClearAmount: BigInt(authorization.maxClearAmount),
+        resourceHash: authorization.resourceHash,
+        validAfter: BigInt(authorization.validAfter),
+        validBefore: BigInt(authorization.validBefore),
+        nonce: authorization.nonce,
+        encryptedAmountHash: authorization.encryptedAmountHash
+      }
+    });
+    const payload = {
+      authorization,
+      signature,
+      encryptedAmountInput: input.encryptedAmountInput,
+      inputProof: input.inputProof
+    };
+    return {
+      x402Version,
+      payload
+    };
+  }
+};
+
+// src/scheme/register.ts
+function registerX402zEvmClientScheme(client, config) {
+  if (config.networks && config.networks.length > 0) {
+    for (const network of config.networks) {
+      client.register(network, new X402zEvmClientScheme(config));
+    }
+    return client;
+  }
+  client.register("eip155:*", new X402zEvmClientScheme(config));
+  return client;
+}
+
+// src/http/client.ts
+function resolvePreferredMethod(method) {
+  if (typeof method !== "string") {
+    return method;
+  }
+  const config = (0, import_x402z_scheme_config.getSchemeConfigByName)(method);
+  if (!config) {
+    throw new Error(`Unknown preferred method: ${method}`);
+  }
+  return config;
+}
+function matchesMethod(requirements, method) {
+  const resolved = resolvePreferredMethod(method);
+  const scheme = (0, import_x402z_scheme_config.isConfidentialTokenConfig)(resolved) ? "erc7984-mind-v1" : "exact";
+  if (requirements.scheme !== scheme) return false;
+  if (requirements.network !== resolved.network) return false;
+  if (requirements.asset && requirements.asset?.toLowerCase() !== resolved.asset.toLowerCase()) return false;
+  return true;
+}
+function filterPaymentRequired(paymentRequired, method) {
+  const accepts = paymentRequired.accepts.filter(
+    (requirement) => matchesMethod(requirement, method)
+  );
+  return { ...paymentRequired, accepts };
+}
+function createExactPayer(config, debugEnabled) {
+  const client = new import_client.x402Client(config.paymentRequirementsSelector);
+  (0, import_client2.registerExactEvmScheme)(client, {
+    signer: config.signer,
+    networks: config.networks,
+    policies: config.policies,
+    paymentRequirementsSelector: config.paymentRequirementsSelector
+  });
+  const httpClient = new import_http.x402HTTPClient(client);
+  return {
+    async buildHeaders(paymentRequired) {
+      const payload = await httpClient.createPaymentPayload(paymentRequired);
+      const payHeaders = httpClient.encodePaymentSignatureHeader(payload);
+      if (debugEnabled) {
+        console.debug("[x402z-client] payment payload", payload);
+        console.debug("[x402z-client] payment headers", payHeaders);
+      }
+      return { headers: payHeaders };
+    }
+  };
+}
+function createConfidentialPayer(config, debugEnabled) {
+  const buildPayment = async (requirements) => {
+    if (!(0, import_viem2.isAddress)(requirements.asset)) {
+      throw new Error(`Invalid token address from requirements: ${requirements.asset}`);
+    }
+    const extra = requirements.extra;
+    const batcherAddress = extra?.confidential?.batcherAddress;
+    if (!batcherAddress) {
+      throw new Error("Missing confidential.batcherAddress in payment requirements");
+    }
+    if (debugEnabled) {
+      console.debug("[x402z-client] encrypt input", {
+        tokenAddress: requirements.asset,
+        batcherAddress,
+        amount: requirements.amount
+      });
+    }
+    const encrypted = await (0, import_x402z_shared_web2.createEncryptedAmountInput)(
+      config.relayer,
+      requirements.asset,
+      batcherAddress,
+      Number(requirements.amount)
+    );
+    return {
+      encryptedAmountInput: encrypted.handle,
+      inputProof: encrypted.inputProof
+    };
+  };
+  const client = new import_client.x402Client();
+  registerX402zEvmClientScheme(client, {
+    signer: config.signer,
+    buildPayment,
+    eip712: config.eip712,
+    hashEncryptedAmountInput: config.hashEncryptedAmountInput,
+    clock: config.clock,
+    networks: config.networks
+  });
+  const httpClient = new import_http.x402HTTPClient(client);
+  const extractConfidentialRequirements = (paymentRequired) => {
+    const requirements = paymentRequired.accepts.find(
+      (requirement) => requirement.scheme === "erc7984-mind-v1"
+    );
+    if (!requirements) {
+      throw new Error("Missing erc7984-mind-v1 payment requirements");
+    }
+    return requirements;
+  };
+  return {
+    relayer: config.relayer,
+    extractConfidentialRequirements,
+    async buildHeaders(paymentRequired) {
+      const payload = await httpClient.createPaymentPayload(paymentRequired);
+      const payHeaders = httpClient.encodePaymentSignatureHeader(payload);
+      if (debugEnabled) {
+        console.debug("[x402z-client] payment payload", payload);
+        console.debug("[x402z-client] payment headers", payHeaders);
+      }
+      return { headers: payHeaders };
+    }
+  };
+}
+function createX402zClient(config) {
+  const fetchFn = config.fetch ?? globalThis.fetch;
+  const debugEnabled = config.debug ?? false;
+  if (!fetchFn) {
+    throw new Error("fetch is not available; provide a fetch implementation");
+  }
+  const preferredMethods = config.preferredMethods?.length ? [...config.preferredMethods] : import_x402z_scheme_config.SCHEME_CONFIG_NAMES;
+  const exactPayer = createExactPayer(
+    {
+      signer: config.signer,
+      networks: config.networks,
+      paymentRequirementsSelector: config.paymentRequirementsSelector,
+      policies: config.policies
+    },
+    debugEnabled
+  );
+  const confidentialPayer = config.relayer ? createConfidentialPayer(
+    {
+      signer: config.signer,
+      relayer: config.relayer,
+      eip712: config.eip712,
+      hashEncryptedAmountInput: config.hashEncryptedAmountInput,
+      clock: config.clock,
+      networks: config.networks
+    },
+    debugEnabled
+  ) : void 0;
+  const parserClient = new import_client.x402Client();
+  const parserHttp = new import_http.x402HTTPClient(parserClient);
+  const pay = async (url, options) => {
+    const initial = await fetchFn(url, { headers: options?.headers });
+    if (initial.status !== 402) {
+      return { response: initial };
+    }
+    const paymentRequired = parserHttp.getPaymentRequiredResponse(
+      (name) => initial.headers.get(name),
+      await initial.json().catch(() => ({}))
+    );
+    const selectedMethod = preferredMethods.find(
+      (method) => paymentRequired.accepts.some(
+        (requirement) => matchesMethod(requirement, method)
+      )
+    );
+    if (!selectedMethod) {
+      throw new Error("No preferred payment methods are supported by payment requirements");
+    }
+    const filteredRequirements = filterPaymentRequired(paymentRequired, selectedMethod);
+    if (filteredRequirements.accepts.length === 0) {
+      throw new Error("Missing payment requirements for selected method");
+    }
+    let headersResult;
+    let confidentialRequirements;
+    const selectedRequirements = filteredRequirements.accepts[0];
+    config.onPaymentSelected?.({
+      method: selectedMethod,
+      requirements: selectedRequirements
+    });
+    if (selectedRequirements.scheme === "exact") {
+      headersResult = await exactPayer.buildHeaders(filteredRequirements);
+    } else {
+      if (!confidentialPayer) {
+        throw new Error("Confidential scheme is selected but relayer is missing");
+      }
+      confidentialRequirements = confidentialPayer.extractConfidentialRequirements(filteredRequirements);
+      headersResult = await confidentialPayer.buildHeaders(filteredRequirements);
+    }
+    const mergedHeaders = { ...options?.headers ?? {}, ...headersResult.headers };
+    const paidResponse = await fetchFn(url, { headers: mergedHeaders });
+    if (debugEnabled) {
+      try {
+        const body = await paidResponse.clone().text();
+        console.debug("[x402z-client] response", {
+          status: paidResponse.status,
+          headers: Object.fromEntries(paidResponse.headers.entries()),
+          body
+        });
+      } catch (error) {
+        console.debug("[x402z-client] response", {
+          status: paidResponse.status,
+          headers: Object.fromEntries(paidResponse.headers.entries()),
+          body: "<unavailable>"
+        });
+      }
+    }
+    return { response: paidResponse, paymentRequired, confidentialRequirements };
+  };
+  return {
+    relayer: confidentialPayer?.relayer,
+    pay
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  X402zEvmClientScheme,
+  createX402zClient,
+  registerX402zEvmClientScheme
+});

package/dist/index.mjs

@@ -0,0 +1,313 @@
+// src/http/client.ts
+import { x402Client } from "@x402/core/client";
+import { x402HTTPClient } from "@x402/core/http";
+import { registerExactEvmScheme } from "@x402/evm/exact/client";
+import { isAddress } from "viem";
+import {
+  createEncryptedAmountInput
+} from "x402z-shared-web";
+import { getSchemeConfigByName, SCHEME_CONFIG_NAMES, isConfidentialTokenConfig } from "x402z-scheme-config";
+
+// src/scheme/scheme.ts
+import { getAddress } from "viem";
+import {
+  confidentialPaymentTypes,
+  createNonce,
+  hashEncryptedAmountInput,
+  normalizeAmount
+} from "x402z-shared-web";
+var ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var DECIMAL_POINT = ".";
+function normalizeIntegerAmount(value, fallback) {
+  const normalized = normalizeAmount(value);
+  if (!normalized.includes(DECIMAL_POINT)) {
+    return normalized;
+  }
+  const fallbackNormalized = normalizeAmount(fallback);
+  if (fallbackNormalized.includes(DECIMAL_POINT)) {
+    throw new Error(`Invalid amount: ${normalized}`);
+  }
+  return fallbackNormalized;
+}
+var X402zEvmClientScheme = class {
+  constructor(config) {
+    this.config = config;
+    this.scheme = "erc7984-mind-v1";
+    this.hashFn = config.hashEncryptedAmountInput ?? hashEncryptedAmountInput;
+    this.clock = config.clock ?? (() => Math.floor(Date.now() / 1e3));
+  }
+  async createPaymentPayload(x402Version, paymentRequirements) {
+    const input = await this.config.buildPayment(paymentRequirements);
+    const extra = paymentRequirements.extra;
+    const eip712 = extra?.eip712 ?? this.config.eip712;
+    if (!eip712?.name || !eip712?.version) {
+      throw new Error("Missing EIP-712 domain parameters (name, version) in requirements or config");
+    }
+    const now = this.clock();
+    const validAfter = input.validAfter ?? Math.max(0, now - 60);
+    const validBefore = input.validBefore ?? now + paymentRequirements.maxTimeoutSeconds;
+    const nonce = input.nonce ?? createNonce();
+    const maxClearAmount = normalizeIntegerAmount(
+      input.maxClearAmount ?? extra?.confidential?.maxClearAmount ?? paymentRequirements.amount,
+      paymentRequirements.amount
+    );
+    const resourceHash = input.resourceHash ?? extra?.confidential?.resourceHash ?? ZERO_BYTES32;
+    const authorization = {
+      holder: this.config.signer.address,
+      payee: getAddress(paymentRequirements.payTo),
+      maxClearAmount,
+      resourceHash,
+      validAfter: normalizeAmount(validAfter),
+      validBefore: normalizeAmount(validBefore),
+      nonce,
+      encryptedAmountHash: this.hashFn(input.encryptedAmountInput)
+    };
+    const chainId = parseInt(paymentRequirements.network.split(":")[1]);
+    const signature = await this.config.signer.signTypedData({
+      domain: {
+        name: eip712.name,
+        version: eip712.version,
+        chainId,
+        verifyingContract: getAddress(paymentRequirements.asset)
+      },
+      types: confidentialPaymentTypes,
+      primaryType: "ConfidentialPayment",
+      message: {
+        holder: getAddress(authorization.holder),
+        payee: getAddress(authorization.payee),
+        maxClearAmount: BigInt(authorization.maxClearAmount),
+        resourceHash: authorization.resourceHash,
+        validAfter: BigInt(authorization.validAfter),
+        validBefore: BigInt(authorization.validBefore),
+        nonce: authorization.nonce,
+        encryptedAmountHash: authorization.encryptedAmountHash
+      }
+    });
+    const payload = {
+      authorization,
+      signature,
+      encryptedAmountInput: input.encryptedAmountInput,
+      inputProof: input.inputProof
+    };
+    return {
+      x402Version,
+      payload
+    };
+  }
+};
+
+// src/scheme/register.ts
+function registerX402zEvmClientScheme(client, config) {
+  if (config.networks && config.networks.length > 0) {
+    for (const network of config.networks) {
+      client.register(network, new X402zEvmClientScheme(config));
+    }
+    return client;
+  }
+  client.register("eip155:*", new X402zEvmClientScheme(config));
+  return client;
+}
+
+// src/http/client.ts
+function resolvePreferredMethod(method) {
+  if (typeof method !== "string") {
+    return method;
+  }
+  const config = getSchemeConfigByName(method);
+  if (!config) {
+    throw new Error(`Unknown preferred method: ${method}`);
+  }
+  return config;
+}
+function matchesMethod(requirements, method) {
+  const resolved = resolvePreferredMethod(method);
+  const scheme = isConfidentialTokenConfig(resolved) ? "erc7984-mind-v1" : "exact";
+  if (requirements.scheme !== scheme) return false;
+  if (requirements.network !== resolved.network) return false;
+  if (requirements.asset && requirements.asset?.toLowerCase() !== resolved.asset.toLowerCase()) return false;
+  return true;
+}
+function filterPaymentRequired(paymentRequired, method) {
+  const accepts = paymentRequired.accepts.filter(
+    (requirement) => matchesMethod(requirement, method)
+  );
+  return { ...paymentRequired, accepts };
+}
+function createExactPayer(config, debugEnabled) {
+  const client = new x402Client(config.paymentRequirementsSelector);
+  registerExactEvmScheme(client, {
+    signer: config.signer,
+    networks: config.networks,
+    policies: config.policies,
+    paymentRequirementsSelector: config.paymentRequirementsSelector
+  });
+  const httpClient = new x402HTTPClient(client);
+  return {
+    async buildHeaders(paymentRequired) {
+      const payload = await httpClient.createPaymentPayload(paymentRequired);
+      const payHeaders = httpClient.encodePaymentSignatureHeader(payload);
+      if (debugEnabled) {
+        console.debug("[x402z-client] payment payload", payload);
+        console.debug("[x402z-client] payment headers", payHeaders);
+      }
+      return { headers: payHeaders };
+    }
+  };
+}
+function createConfidentialPayer(config, debugEnabled) {
+  const buildPayment = async (requirements) => {
+    if (!isAddress(requirements.asset)) {
+      throw new Error(`Invalid token address from requirements: ${requirements.asset}`);
+    }
+    const extra = requirements.extra;
+    const batcherAddress = extra?.confidential?.batcherAddress;
+    if (!batcherAddress) {
+      throw new Error("Missing confidential.batcherAddress in payment requirements");
+    }
+    if (debugEnabled) {
+      console.debug("[x402z-client] encrypt input", {
+        tokenAddress: requirements.asset,
+        batcherAddress,
+        amount: requirements.amount
+      });
+    }
+    const encrypted = await createEncryptedAmountInput(
+      config.relayer,
+      requirements.asset,
+      batcherAddress,
+      Number(requirements.amount)
+    );
+    return {
+      encryptedAmountInput: encrypted.handle,
+      inputProof: encrypted.inputProof
+    };
+  };
+  const client = new x402Client();
+  registerX402zEvmClientScheme(client, {
+    signer: config.signer,
+    buildPayment,
+    eip712: config.eip712,
+    hashEncryptedAmountInput: config.hashEncryptedAmountInput,
+    clock: config.clock,
+    networks: config.networks
+  });
+  const httpClient = new x402HTTPClient(client);
+  const extractConfidentialRequirements = (paymentRequired) => {
+    const requirements = paymentRequired.accepts.find(
+      (requirement) => requirement.scheme === "erc7984-mind-v1"
+    );
+    if (!requirements) {
+      throw new Error("Missing erc7984-mind-v1 payment requirements");
+    }
+    return requirements;
+  };
+  return {
+    relayer: config.relayer,
+    extractConfidentialRequirements,
+    async buildHeaders(paymentRequired) {
+      const payload = await httpClient.createPaymentPayload(paymentRequired);
+      const payHeaders = httpClient.encodePaymentSignatureHeader(payload);
+      if (debugEnabled) {
+        console.debug("[x402z-client] payment payload", payload);
+        console.debug("[x402z-client] payment headers", payHeaders);
+      }
+      return { headers: payHeaders };
+    }
+  };
+}
+function createX402zClient(config) {
+  const fetchFn = config.fetch ?? globalThis.fetch;
+  const debugEnabled = config.debug ?? false;
+  if (!fetchFn) {
+    throw new Error("fetch is not available; provide a fetch implementation");
+  }
+  const preferredMethods = config.preferredMethods?.length ? [...config.preferredMethods] : SCHEME_CONFIG_NAMES;
+  const exactPayer = createExactPayer(
+    {
+      signer: config.signer,
+      networks: config.networks,
+      paymentRequirementsSelector: config.paymentRequirementsSelector,
+      policies: config.policies
+    },
+    debugEnabled
+  );
+  const confidentialPayer = config.relayer ? createConfidentialPayer(
+    {
+      signer: config.signer,
+      relayer: config.relayer,
+      eip712: config.eip712,
+      hashEncryptedAmountInput: config.hashEncryptedAmountInput,
+      clock: config.clock,
+      networks: config.networks
+    },
+    debugEnabled
+  ) : void 0;
+  const parserClient = new x402Client();
+  const parserHttp = new x402HTTPClient(parserClient);
+  const pay = async (url, options) => {
+    const initial = await fetchFn(url, { headers: options?.headers });
+    if (initial.status !== 402) {
+      return { response: initial };
+    }
+    const paymentRequired = parserHttp.getPaymentRequiredResponse(
+      (name) => initial.headers.get(name),
+      await initial.json().catch(() => ({}))
+    );
+    const selectedMethod = preferredMethods.find(
+      (method) => paymentRequired.accepts.some(
+        (requirement) => matchesMethod(requirement, method)
+      )
+    );
+    if (!selectedMethod) {
+      throw new Error("No preferred payment methods are supported by payment requirements");
+    }
+    const filteredRequirements = filterPaymentRequired(paymentRequired, selectedMethod);
+    if (filteredRequirements.accepts.length === 0) {
+      throw new Error("Missing payment requirements for selected method");
+    }
+    let headersResult;
+    let confidentialRequirements;
+    const selectedRequirements = filteredRequirements.accepts[0];
+    config.onPaymentSelected?.({
+      method: selectedMethod,
+      requirements: selectedRequirements
+    });
+    if (selectedRequirements.scheme === "exact") {
+      headersResult = await exactPayer.buildHeaders(filteredRequirements);
+    } else {
+      if (!confidentialPayer) {
+        throw new Error("Confidential scheme is selected but relayer is missing");
+      }
+      confidentialRequirements = confidentialPayer.extractConfidentialRequirements(filteredRequirements);
+      headersResult = await confidentialPayer.buildHeaders(filteredRequirements);
+    }
+    const mergedHeaders = { ...options?.headers ?? {}, ...headersResult.headers };
+    const paidResponse = await fetchFn(url, { headers: mergedHeaders });
+    if (debugEnabled) {
+      try {
+        const body = await paidResponse.clone().text();
+        console.debug("[x402z-client] response", {
+          status: paidResponse.status,
+          headers: Object.fromEntries(paidResponse.headers.entries()),
+          body
+        });
+      } catch (error) {
+        console.debug("[x402z-client] response", {
+          status: paidResponse.status,
+          headers: Object.fromEntries(paidResponse.headers.entries()),
+          body: "<unavailable>"
+        });
+      }
+    }
+    return { response: paidResponse, paymentRequired, confidentialRequirements };
+  };
+  return {
+    relayer: confidentialPayer?.relayer,
+    pay
+  };
+}
+export {
+  X402zEvmClientScheme,
+  createX402zClient,
+  registerX402zEvmClientScheme
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "x402z-client-web",
+  "version": "0.1.2",
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "dependencies": {
+    "@x402/core": "^2.2.0",
+    "@x402/evm": "^2.2.0",
+    "viem": "^2.39.3",
+    "x402z-shared-web": "0.1.2",
+    "x402z-scheme-config": "0.1.2"
+  },
+  "devDependencies": {
+    "jest": "^29.7.0",
+    "ts-jest": "^29.2.5",
+    "@types/jest": "^29.5.12"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "test": "jest --config jest.config.cjs --passWithNoTests"
+  }
+}