x402z-client 0.0.3 → 0.0.6

package/README.md

@@ -30,8 +30,26 @@ const response = await client.pay("https://example.com/demo");
 console.log(response.status);
 ```
 
+## Usage (Browser)
+
+```ts
+import { createX402zWebClient } from "x402z-client/web";
+import { SepoliaConfig } from "x402z-shared/web";
+
+const client = await createX402zWebClient({
+  signer: {
+    address: "0x...",
+    signTypedData: async args => window.ethereum.request({ method: "eth_signTypedData_v4", params: [args] }),
+  },
+  relayerConfig: { ...SepoliaConfig, network: window.ethereum },
+});
+
+const response = await client.pay("https://example.com/demo");
+console.log(response.status);
+```
+
 `createX402zClient` builds the confidential payment input automatically using the
-`confidential.facilitatorAddress` provided by the server’s payment requirements.
+`confidential.batcherAddress` provided by the server’s payment requirements.
 
 ## API
 
@@ -39,6 +57,10 @@ console.log(response.status);
   - `signer` (required): EIP-712 signer for x402 payloads
   - `relayer` (required): Zama relayer instance used to build encrypted inputs
   - `fetch` (optional): custom fetch implementation
+- `createX402zWebClient(config)`
+  - `signer` (required): EIP-712 signer for x402 payloads
+  - `relayerConfig` (required): relayer instance config (browser)
+  - `fetch` (optional): custom fetch implementation
 - `client.pay(url, options?)`: performs the 402 handshake and retries with payment headers
 
 ## Notes

package/dist/chunk-WKGSJ5YZ.mjs

@@ -0,0 +1,104 @@
+// src/scheme.ts
+import { getAddress } from "viem";
+import {
+  confidentialPaymentTypes,
+  createNonce,
+  hashEncryptedAmountInput,
+  normalizeAmount
+} from "x402z-shared";
+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 ConfidentialEvmScheme = 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/register.ts
+function registerConfidentialEvmScheme(client, config) {
+  if (config.networks && config.networks.length > 0) {
+    for (const network of config.networks) {
+      client.register(network, new ConfidentialEvmScheme(config));
+    }
+    return client;
+  }
+  client.register("eip155:*", new ConfidentialEvmScheme(config));
+  return client;
+}
+
+export {
+  ConfidentialEvmScheme,
+  registerConfidentialEvmScheme
+};

package/dist/index.d.mts

@@ -1,33 +1,10 @@
-import { SchemeNetworkClient, PaymentRequirements, PaymentPayload, Network } from '@x402/core/types';
+import { C as ConfidentialClientRegisterConfig } from './register-DmPDc2uL.mjs';
+export { b as ConfidentialClientConfig, a as ConfidentialEvmScheme, r as registerConfidentialEvmScheme } from './register-DmPDc2uL.mjs';
+import { PaymentRequirements } from '@x402/core/types';
 export * from '@x402/core/types';
-import { ClientEvmSigner } from '@x402/evm';
-import { ConfidentialPaymentInput, RelayerInstance } from 'x402z-shared';
-import { x402Client } from '@x402/core/client';
+import { RelayerInstance, ConfidentialPaymentInput } from 'x402z-shared';
 export { AfterPaymentCreationHook, BeforePaymentCreationHook, OnPaymentCreationFailureHook, PaymentCreatedContext, PaymentCreationContext, PaymentCreationFailureContext, PaymentPolicy, SchemeRegistration, SelectPaymentRequirements, x402Client, x402ClientConfig, x402HTTPClient } from '@x402/core/client';
-
-type ConfidentialClientConfig = {
-    signer: ClientEvmSigner;
-    buildPayment: (requirements: PaymentRequirements) => ConfidentialPaymentInput | Promise<ConfidentialPaymentInput>;
-    eip712?: {
-        name: string;
-        version: string;
-    };
-    hashEncryptedAmountInput?: (encryptedAmountInput: `0x${string}`) => `0x${string}`;
-    clock?: () => number;
-};
-declare class ConfidentialEvmScheme implements SchemeNetworkClient {
-    private readonly config;
-    readonly scheme = "erc7984-mind-v1";
-    private readonly hashFn;
-    private readonly clock;
-    constructor(config: ConfidentialClientConfig);
-    createPaymentPayload(x402Version: number, paymentRequirements: PaymentRequirements): Promise<Pick<PaymentPayload, "x402Version" | "payload">>;
-}
-
-type ConfidentialClientRegisterConfig = ConfidentialClientConfig & {
-    networks?: Network[];
-};
-declare function registerConfidentialEvmScheme(client: x402Client, config: ConfidentialClientRegisterConfig): x402Client;
+import '@x402/evm';
 
 declare function buildPaymentInputFromRelayer(relayer: RelayerInstance, requirements: PaymentRequirements, amount: number): Promise<ConfidentialPaymentInput>;
 
@@ -43,4 +20,4 @@ declare function createX402zClient(config: X402zClientConfig): {
     pay(url: string, options?: PayOptions): Promise<Response>;
 };
 
-export { type ConfidentialClientConfig, type ConfidentialClientRegisterConfig, ConfidentialEvmScheme, type PayOptions, type X402zClientConfig, buildPaymentInputFromRelayer, createX402zClient, registerConfidentialEvmScheme };
+export { ConfidentialClientRegisterConfig, type PayOptions, type X402zClientConfig, buildPaymentInputFromRelayer, createX402zClient };

package/dist/index.d.ts

@@ -1,33 +1,10 @@
-import { SchemeNetworkClient, PaymentRequirements, PaymentPayload, Network } from '@x402/core/types';
+import { C as ConfidentialClientRegisterConfig } from './register-DmPDc2uL.js';
+export { b as ConfidentialClientConfig, a as ConfidentialEvmScheme, r as registerConfidentialEvmScheme } from './register-DmPDc2uL.js';
+import { PaymentRequirements } from '@x402/core/types';
 export * from '@x402/core/types';
-import { ClientEvmSigner } from '@x402/evm';
-import { ConfidentialPaymentInput, RelayerInstance } from 'x402z-shared';
-import { x402Client } from '@x402/core/client';
+import { RelayerInstance, ConfidentialPaymentInput } from 'x402z-shared';
 export { AfterPaymentCreationHook, BeforePaymentCreationHook, OnPaymentCreationFailureHook, PaymentCreatedContext, PaymentCreationContext, PaymentCreationFailureContext, PaymentPolicy, SchemeRegistration, SelectPaymentRequirements, x402Client, x402ClientConfig, x402HTTPClient } from '@x402/core/client';
-
-type ConfidentialClientConfig = {
-    signer: ClientEvmSigner;
-    buildPayment: (requirements: PaymentRequirements) => ConfidentialPaymentInput | Promise<ConfidentialPaymentInput>;
-    eip712?: {
-        name: string;
-        version: string;
-    };
-    hashEncryptedAmountInput?: (encryptedAmountInput: `0x${string}`) => `0x${string}`;
-    clock?: () => number;
-};
-declare class ConfidentialEvmScheme implements SchemeNetworkClient {
-    private readonly config;
-    readonly scheme = "erc7984-mind-v1";
-    private readonly hashFn;
-    private readonly clock;
-    constructor(config: ConfidentialClientConfig);
-    createPaymentPayload(x402Version: number, paymentRequirements: PaymentRequirements): Promise<Pick<PaymentPayload, "x402Version" | "payload">>;
-}
-
-type ConfidentialClientRegisterConfig = ConfidentialClientConfig & {
-    networks?: Network[];
-};
-declare function registerConfidentialEvmScheme(client: x402Client, config: ConfidentialClientRegisterConfig): x402Client;
+import '@x402/evm';
 
 declare function buildPaymentInputFromRelayer(relayer: RelayerInstance, requirements: PaymentRequirements, amount: number): Promise<ConfidentialPaymentInput>;
 
@@ -43,4 +20,4 @@ declare function createX402zClient(config: X402zClientConfig): {
     pay(url: string, options?: PayOptions): Promise<Response>;
 };
 
-export { type ConfidentialClientConfig, type ConfidentialClientRegisterConfig, ConfidentialEvmScheme, type PayOptions, type X402zClientConfig, buildPaymentInputFromRelayer, createX402zClient, registerConfidentialEvmScheme };
+export { ConfidentialClientRegisterConfig, type PayOptions, type X402zClientConfig, buildPaymentInputFromRelayer, createX402zClient };

package/dist/index.js

@@ -33,6 +33,18 @@ module.exports = __toCommonJS(index_exports);
 var import_viem = require("viem");
 var import_x402z_shared = require("x402z-shared");
 var ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var DECIMAL_POINT = ".";
+function normalizeIntegerAmount(value, fallback) {
+  const normalized = (0, import_x402z_shared.normalizeAmount)(value);
+  if (!normalized.includes(DECIMAL_POINT)) {
+    return normalized;
+  }
+  const fallbackNormalized = (0, import_x402z_shared.normalizeAmount)(fallback);
+  if (fallbackNormalized.includes(DECIMAL_POINT)) {
+    throw new Error(`Invalid amount: ${normalized}`);
+  }
+  return fallbackNormalized;
+}
 var ConfidentialEvmScheme = class {
   constructor(config) {
     this.config = config;
@@ -51,7 +63,10 @@ var ConfidentialEvmScheme = class {
     const validAfter = input.validAfter ?? Math.max(0, now - 60);
     const validBefore = input.validBefore ?? now + paymentRequirements.maxTimeoutSeconds;
     const nonce = input.nonce ?? (0, import_x402z_shared.createNonce)();
-    const maxClearAmount = input.maxClearAmount ?? extra?.confidential?.maxClearAmount ?? (0, import_x402z_shared.normalizeAmount)(paymentRequirements.amount);
+    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,
@@ -113,14 +128,14 @@ function registerConfidentialEvmScheme(client, config) {
 var import_x402z_shared2 = require("x402z-shared");
 async function buildPaymentInputFromRelayer(relayer, requirements, amount) {
   const extra = requirements.extra;
-  const facilitatorAddress = extra?.confidential?.facilitatorAddress;
-  if (!facilitatorAddress) {
-    throw new Error("Missing confidential.facilitatorAddress in payment requirements");
+  const batcherAddress = extra?.confidential?.batcherAddress;
+  if (!batcherAddress) {
+    throw new Error("Missing confidential.batcherAddress in payment requirements");
   }
   const encrypted = await (0, import_x402z_shared2.createEncryptedAmountInput)(
     relayer,
     requirements.asset,
-    facilitatorAddress,
+    batcherAddress,
     amount
   );
   return {
@@ -146,14 +161,14 @@ function createX402zClient(config) {
       throw new Error(`Invalid TOKEN_ADDRESS from requirements: ${requirements.asset}`);
     }
     const extra = requirements.extra;
-    const facilitatorAddress = extra?.confidential?.facilitatorAddress;
-    if (!facilitatorAddress) {
-      throw new Error("Missing confidential.facilitatorAddress in payment requirements");
+    const batcherAddress = extra?.confidential?.batcherAddress;
+    if (!batcherAddress) {
+      throw new Error("Missing confidential.batcherAddress in payment requirements");
     }
     const encrypted = await (0, import_x402z_shared3.createEncryptedAmountInput)(
       config.relayer,
       requirements.asset,
-      facilitatorAddress,
+      batcherAddress,
       Number(requirements.amount)
     );
     return {

package/dist/index.mjs

@@ -1,100 +1,20 @@
-// src/scheme.ts
-import { getAddress } from "viem";
 import {
-  confidentialPaymentTypes,
-  createNonce,
-  hashEncryptedAmountInput,
-  normalizeAmount
-} from "x402z-shared";
-var ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
-var ConfidentialEvmScheme = 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 = input.maxClearAmount ?? extra?.confidential?.maxClearAmount ?? normalizeAmount(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/register.ts
-function registerConfidentialEvmScheme(client, config) {
-  if (config.networks && config.networks.length > 0) {
-    for (const network of config.networks) {
-      client.register(network, new ConfidentialEvmScheme(config));
-    }
-    return client;
-  }
-  client.register("eip155:*", new ConfidentialEvmScheme(config));
-  return client;
-}
+  ConfidentialEvmScheme,
+  registerConfidentialEvmScheme
+} from "./chunk-WKGSJ5YZ.mjs";
 
 // src/relayer.ts
 import { createEncryptedAmountInput } from "x402z-shared";
 async function buildPaymentInputFromRelayer(relayer, requirements, amount) {
   const extra = requirements.extra;
-  const facilitatorAddress = extra?.confidential?.facilitatorAddress;
-  if (!facilitatorAddress) {
-    throw new Error("Missing confidential.facilitatorAddress in payment requirements");
+  const batcherAddress = extra?.confidential?.batcherAddress;
+  if (!batcherAddress) {
+    throw new Error("Missing confidential.batcherAddress in payment requirements");
   }
   const encrypted = await createEncryptedAmountInput(
     relayer,
     requirements.asset,
-    facilitatorAddress,
+    batcherAddress,
     amount
   );
   return {
@@ -122,14 +42,14 @@ function createX402zClient(config) {
       throw new Error(`Invalid TOKEN_ADDRESS from requirements: ${requirements.asset}`);
     }
     const extra = requirements.extra;
-    const facilitatorAddress = extra?.confidential?.facilitatorAddress;
-    if (!facilitatorAddress) {
-      throw new Error("Missing confidential.facilitatorAddress in payment requirements");
+    const batcherAddress = extra?.confidential?.batcherAddress;
+    if (!batcherAddress) {
+      throw new Error("Missing confidential.batcherAddress in payment requirements");
     }
     const encrypted = await createEncryptedAmountInput2(
       config.relayer,
       requirements.asset,
-      facilitatorAddress,
+      batcherAddress,
       Number(requirements.amount)
     );
     return {

package/dist/register-DmPDc2uL.d.mts

@@ -0,0 +1,30 @@
+import { x402Client } from '@x402/core/client';
+import { SchemeNetworkClient, PaymentRequirements, PaymentPayload, Network } from '@x402/core/types';
+import { ClientEvmSigner } from '@x402/evm';
+import { ConfidentialPaymentInput } from 'x402z-shared';
+
+type ConfidentialClientConfig = {
+    signer: ClientEvmSigner;
+    buildPayment: (requirements: PaymentRequirements) => ConfidentialPaymentInput | Promise<ConfidentialPaymentInput>;
+    eip712?: {
+        name: string;
+        version: string;
+    };
+    hashEncryptedAmountInput?: (encryptedAmountInput: `0x${string}`) => `0x${string}`;
+    clock?: () => number;
+};
+declare class ConfidentialEvmScheme implements SchemeNetworkClient {
+    private readonly config;
+    readonly scheme = "erc7984-mind-v1";
+    private readonly hashFn;
+    private readonly clock;
+    constructor(config: ConfidentialClientConfig);
+    createPaymentPayload(x402Version: number, paymentRequirements: PaymentRequirements): Promise<Pick<PaymentPayload, "x402Version" | "payload">>;
+}
+
+type ConfidentialClientRegisterConfig = ConfidentialClientConfig & {
+    networks?: Network[];
+};
+declare function registerConfidentialEvmScheme(client: x402Client, config: ConfidentialClientRegisterConfig): x402Client;
+
+export { type ConfidentialClientRegisterConfig as C, ConfidentialEvmScheme as a, type ConfidentialClientConfig as b, registerConfidentialEvmScheme as r };

package/dist/register-DmPDc2uL.d.ts

@@ -0,0 +1,30 @@
+import { x402Client } from '@x402/core/client';
+import { SchemeNetworkClient, PaymentRequirements, PaymentPayload, Network } from '@x402/core/types';
+import { ClientEvmSigner } from '@x402/evm';
+import { ConfidentialPaymentInput } from 'x402z-shared';
+
+type ConfidentialClientConfig = {
+    signer: ClientEvmSigner;
+    buildPayment: (requirements: PaymentRequirements) => ConfidentialPaymentInput | Promise<ConfidentialPaymentInput>;
+    eip712?: {
+        name: string;
+        version: string;
+    };
+    hashEncryptedAmountInput?: (encryptedAmountInput: `0x${string}`) => `0x${string}`;
+    clock?: () => number;
+};
+declare class ConfidentialEvmScheme implements SchemeNetworkClient {
+    private readonly config;
+    readonly scheme = "erc7984-mind-v1";
+    private readonly hashFn;
+    private readonly clock;
+    constructor(config: ConfidentialClientConfig);
+    createPaymentPayload(x402Version: number, paymentRequirements: PaymentRequirements): Promise<Pick<PaymentPayload, "x402Version" | "payload">>;
+}
+
+type ConfidentialClientRegisterConfig = ConfidentialClientConfig & {
+    networks?: Network[];
+};
+declare function registerConfidentialEvmScheme(client: x402Client, config: ConfidentialClientRegisterConfig): x402Client;
+
+export { type ConfidentialClientRegisterConfig as C, ConfidentialEvmScheme as a, type ConfidentialClientConfig as b, registerConfidentialEvmScheme as r };

package/dist/web.d.mts

@@ -0,0 +1,21 @@
+import * as _zama_fhe_relayer_sdk_web from '@zama-fhe/relayer-sdk/web';
+import { C as ConfidentialClientRegisterConfig } from './register-DmPDc2uL.mjs';
+import '@x402/core/client';
+import '@x402/core/types';
+import '@x402/evm';
+import 'x402z-shared';
+
+type X402zWebClientConfig = Omit<ConfidentialClientRegisterConfig, "buildPayment"> & {
+    relayerConfig: unknown;
+    fetch?: typeof fetch;
+    debug?: boolean;
+};
+type PayOptions = {
+    headers?: Record<string, string>;
+};
+declare function createX402zWebClient(config: X402zWebClientConfig): Promise<{
+    relayer: _zama_fhe_relayer_sdk_web.FhevmInstance;
+    pay(url: string, options?: PayOptions): Promise<Response>;
+}>;
+
+export { type PayOptions, type X402zWebClientConfig, createX402zWebClient };

package/dist/web.d.ts

@@ -0,0 +1,21 @@
+import * as _zama_fhe_relayer_sdk_web from '@zama-fhe/relayer-sdk/web';
+import { C as ConfidentialClientRegisterConfig } from './register-DmPDc2uL.js';
+import '@x402/core/client';
+import '@x402/core/types';
+import '@x402/evm';
+import 'x402z-shared';
+
+type X402zWebClientConfig = Omit<ConfidentialClientRegisterConfig, "buildPayment"> & {
+    relayerConfig: unknown;
+    fetch?: typeof fetch;
+    debug?: boolean;
+};
+type PayOptions = {
+    headers?: Record<string, string>;
+};
+declare function createX402zWebClient(config: X402zWebClientConfig): Promise<{
+    relayer: _zama_fhe_relayer_sdk_web.FhevmInstance;
+    pay(url: string, options?: PayOptions): Promise<Response>;
+}>;
+
+export { type PayOptions, type X402zWebClientConfig, createX402zWebClient };

package/dist/web.js

@@ -0,0 +1,204 @@
+"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/web.ts
+var web_exports = {};
+__export(web_exports, {
+  createX402zWebClient: () => createX402zWebClient
+});
+module.exports = __toCommonJS(web_exports);
+var import_client = require("@x402/core/client");
+var import_http = require("@x402/core/http");
+var import_viem2 = require("viem");
+var import_web = require("x402z-shared/web");
+
+// src/scheme.ts
+var import_viem = require("viem");
+var import_x402z_shared = require("x402z-shared");
+var ZERO_BYTES32 = "0x0000000000000000000000000000000000000000000000000000000000000000";
+var DECIMAL_POINT = ".";
+function normalizeIntegerAmount(value, fallback) {
+  const normalized = (0, import_x402z_shared.normalizeAmount)(value);
+  if (!normalized.includes(DECIMAL_POINT)) {
+    return normalized;
+  }
+  const fallbackNormalized = (0, import_x402z_shared.normalizeAmount)(fallback);
+  if (fallbackNormalized.includes(DECIMAL_POINT)) {
+    throw new Error(`Invalid amount: ${normalized}`);
+  }
+  return fallbackNormalized;
+}
+var ConfidentialEvmScheme = class {
+  constructor(config) {
+    this.config = config;
+    this.scheme = "erc7984-mind-v1";
+    this.hashFn = config.hashEncryptedAmountInput ?? import_x402z_shared.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.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.normalizeAmount)(validAfter),
+      validBefore: (0, import_x402z_shared.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.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/register.ts
+function registerConfidentialEvmScheme(client, config) {
+  if (config.networks && config.networks.length > 0) {
+    for (const network of config.networks) {
+      client.register(network, new ConfidentialEvmScheme(config));
+    }
+    return client;
+  }
+  client.register("eip155:*", new ConfidentialEvmScheme(config));
+  return client;
+}
+
+// src/web.ts
+async function createX402zWebClient(config) {
+  const { fetch: fetchOverride, ...registerConfig } = config;
+  const fetchFn = fetchOverride ?? globalThis.fetch;
+  const debugEnabled = config.debug ?? process.env.X402Z_DEBUG === "1";
+  if (!fetchFn) {
+    throw new Error("fetch is not available; provide a fetch implementation");
+  }
+  await (0, import_web.initSDK)();
+  const relayer = await (0, import_web.createRelayerInstance)(config.relayerConfig);
+  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");
+    }
+    const encrypted = await (0, import_web.createEncryptedAmountInput)(
+      relayer,
+      requirements.asset,
+      batcherAddress,
+      Number(requirements.amount)
+    );
+    return {
+      encryptedAmountInput: encrypted.handle,
+      inputProof: encrypted.inputProof
+    };
+  };
+  const client = new import_client.x402Client();
+  registerConfidentialEvmScheme(client, {
+    ...registerConfig,
+    buildPayment
+  });
+  const httpClient = new import_http.x402HTTPClient(client);
+  return {
+    relayer,
+    async pay(url, options) {
+      const initial = await fetchFn(url, { headers: options?.headers });
+      if (initial.status !== 402) {
+        return initial;
+      }
+      const paymentRequired = httpClient.getPaymentRequiredResponse(
+        (name) => initial.headers.get(name),
+        await initial.json().catch(() => ({}))
+      );
+      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);
+      }
+      const mergedHeaders = { ...options?.headers ?? {}, ...payHeaders };
+      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 paidResponse;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createX402zWebClient
+});

package/dist/web.mjs

@@ -0,0 +1,90 @@
+import {
+  registerConfidentialEvmScheme
+} from "./chunk-WKGSJ5YZ.mjs";
+
+// src/web.ts
+import { x402Client } from "@x402/core/client";
+import { x402HTTPClient } from "@x402/core/http";
+import { isAddress } from "viem";
+import {
+  createEncryptedAmountInput,
+  createRelayerInstance,
+  initSDK
+} from "x402z-shared/web";
+async function createX402zWebClient(config) {
+  const { fetch: fetchOverride, ...registerConfig } = config;
+  const fetchFn = fetchOverride ?? globalThis.fetch;
+  const debugEnabled = config.debug ?? process.env.X402Z_DEBUG === "1";
+  if (!fetchFn) {
+    throw new Error("fetch is not available; provide a fetch implementation");
+  }
+  await initSDK();
+  const relayer = await createRelayerInstance(config.relayerConfig);
+  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");
+    }
+    const encrypted = await createEncryptedAmountInput(
+      relayer,
+      requirements.asset,
+      batcherAddress,
+      Number(requirements.amount)
+    );
+    return {
+      encryptedAmountInput: encrypted.handle,
+      inputProof: encrypted.inputProof
+    };
+  };
+  const client = new x402Client();
+  registerConfidentialEvmScheme(client, {
+    ...registerConfig,
+    buildPayment
+  });
+  const httpClient = new x402HTTPClient(client);
+  return {
+    relayer,
+    async pay(url, options) {
+      const initial = await fetchFn(url, { headers: options?.headers });
+      if (initial.status !== 402) {
+        return initial;
+      }
+      const paymentRequired = httpClient.getPaymentRequiredResponse(
+        (name) => initial.headers.get(name),
+        await initial.json().catch(() => ({}))
+      );
+      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);
+      }
+      const mergedHeaders = { ...options?.headers ?? {}, ...payHeaders };
+      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 paidResponse;
+    }
+  };
+}
+export {
+  createX402zWebClient
+};

package/package.json

@@ -1,17 +1,29 @@
 {
   "name": "x402z-client",
-  "version": "0.0.3",
+  "version": "0.0.6",
   "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"
+    },
+    "./web": {
+      "types": "./dist/web.d.ts",
+      "import": "./dist/web.mjs",
+      "require": "./dist/web.js"
+    }
+  },
   "dependencies": {
     "@x402/core": "^2.0.0",
     "@x402/evm": "^2.0.0",
     "viem": "^2.39.3",
-    "x402z-shared": "0.0.3"
+    "x402z-shared": "0.0.6"
   },
   "devDependencies": {
     "jest": "^29.7.0",
@@ -19,7 +31,7 @@
     "@types/jest": "^29.5.12"
   },
   "scripts": {
-    "build": "tsup src/index.ts --format cjs,esm --dts",
+    "build": "tsup src/index.ts src/web.ts --format cjs,esm --dts",
     "test": "jest"
   }
 }