@puga-labs/x402-mantle-sdk 0.3.1 → 0.3.2

package/dist/chunk-WAKJRVUP.js

@@ -0,0 +1,135 @@
+import {
+  createMantleClient
+} from "./chunk-E46A7I6B.js";
+
+// src/client/react/useEthersWallet.ts
+import { useState, useEffect, useCallback } from "react";
+import { ethers } from "ethers";
+function useEthersWallet(options) {
+  const [address, setAddress] = useState(void 0);
+  const [isConnected, setIsConnected] = useState(false);
+  const [provider, setProvider] = useState(
+    void 0
+  );
+  const [chainId, setChainId] = useState(void 0);
+  const [error, setError] = useState(void 0);
+  const connect = useCallback(async () => {
+    try {
+      setError(void 0);
+      if (typeof window === "undefined" || !window.ethereum) {
+        throw new Error(
+          "No Ethereum wallet detected. Please install MetaMask or another wallet."
+        );
+      }
+      const browserProvider = new ethers.BrowserProvider(
+        window.ethereum
+      );
+      setProvider(browserProvider);
+      const accounts = await window.ethereum.request({
+        method: "eth_requestAccounts"
+      });
+      if (!accounts || accounts.length === 0) {
+        throw new Error("No accounts returned from wallet");
+      }
+      const userAddress = accounts[0];
+      setAddress(userAddress);
+      setIsConnected(true);
+      const network = await browserProvider.getNetwork();
+      setChainId(Number(network.chainId));
+    } catch (err) {
+      const errorObj = err instanceof Error ? err : new Error(String(err));
+      setError(errorObj);
+      setIsConnected(false);
+      setAddress(void 0);
+      setChainId(void 0);
+      throw errorObj;
+    }
+  }, []);
+  const disconnect = useCallback(() => {
+    setAddress(void 0);
+    setIsConnected(false);
+    setChainId(void 0);
+    setError(void 0);
+  }, []);
+  useEffect(() => {
+    if (typeof window === "undefined" || !window.ethereum) return;
+    const ethereum = window.ethereum;
+    const handleAccountsChanged = (accounts) => {
+      const accountsArray = accounts;
+      if (!accountsArray || accountsArray.length === 0) {
+        disconnect();
+      } else {
+        setAddress(accountsArray[0]);
+        setIsConnected(true);
+      }
+    };
+    if (ethereum.on) {
+      ethereum.on("accountsChanged", handleAccountsChanged);
+    }
+    return () => {
+      if (ethereum.removeListener) {
+        ethereum.removeListener("accountsChanged", handleAccountsChanged);
+      }
+    };
+  }, [disconnect]);
+  useEffect(() => {
+    if (typeof window === "undefined" || !window.ethereum) return;
+    const ethereum = window.ethereum;
+    const handleChainChanged = (chainIdHex) => {
+      const newChainId = parseInt(chainIdHex, 16);
+      setChainId(newChainId);
+    };
+    if (ethereum.on) {
+      ethereum.on("chainChanged", handleChainChanged);
+    }
+    return () => {
+      if (ethereum.removeListener) {
+        ethereum.removeListener("chainChanged", handleChainChanged);
+      }
+    };
+  }, []);
+  useEffect(() => {
+    if (options?.autoConnect) {
+      connect().catch((err) => {
+        console.warn("[useEthersWallet] Auto-connect failed:", err);
+      });
+    }
+  }, [options?.autoConnect, connect]);
+  return {
+    address,
+    isConnected,
+    provider,
+    chainId,
+    connect,
+    disconnect,
+    error
+  };
+}
+
+// src/client/react/useMantleX402.ts
+function useMantleX402(opts) {
+  const { address, isConnected } = useEthersWallet({
+    autoConnect: opts?.autoConnect ?? false
+  });
+  const client = createMantleClient({
+    facilitatorUrl: opts?.facilitatorUrl,
+    resourceUrl: opts?.resourceUrl,
+    projectKey: opts?.projectKey,
+    getAccount: () => {
+      if (!isConnected || !address) return void 0;
+      return address;
+    },
+    getProvider: () => {
+      if (typeof window !== "undefined" && window.ethereum) {
+        return window.ethereum;
+      }
+      return void 0;
+    }
+  });
+  return client;
+}
+
+export {
+  useEthersWallet,
+  useMantleX402
+};

package/dist/chunk-WFUDGBKK.js

@@ -0,0 +1,68 @@
+import {
+  buildRouteKey,
+  checkPayment
+} from "./chunk-BRGW36P7.js";
+import {
+  MANTLE_DEFAULTS,
+  __export,
+  getDefaultAssetForNetwork,
+  usdCentsToAtomic
+} from "./chunk-HEZZ74SI.js";
+
+// src/server/adapters/web-standards.ts
+var web_standards_exports = {};
+__export(web_standards_exports, {
+  mantlePaywall: () => mantlePaywall
+});
+function mantlePaywall(opts) {
+  const { priceUsd, payTo, facilitatorUrl, telemetry, onPaymentSettled } = opts;
+  const priceUsdCents = Math.round(priceUsd * 100);
+  return function(handler) {
+    return async (request) => {
+      const url = new URL(request.url);
+      const method = request.method;
+      const path = url.pathname;
+      const routeKey = buildRouteKey(method, path);
+      const network = MANTLE_DEFAULTS.NETWORK;
+      const assetConfig = getDefaultAssetForNetwork(network);
+      const maxAmountRequiredBigInt = usdCentsToAtomic(
+        priceUsdCents,
+        assetConfig.decimals
+      );
+      const paymentRequirements = {
+        scheme: "exact",
+        network,
+        asset: assetConfig.address,
+        maxAmountRequired: maxAmountRequiredBigInt.toString(),
+        payTo,
+        price: `$${(priceUsdCents / 100).toFixed(2)}`,
+        currency: "USD"
+      };
+      const paymentHeader = request.headers.get("X-PAYMENT") || request.headers.get("x-payment") || null;
+      const result = await checkPayment({
+        paymentHeader,
+        paymentRequirements,
+        facilitatorUrl: facilitatorUrl || MANTLE_DEFAULTS.FACILITATOR_URL,
+        routeKey,
+        network,
+        asset: assetConfig.address,
+        telemetry,
+        onPaymentSettled
+      });
+      if (!result.isValid) {
+        return new Response(JSON.stringify(result.responseBody), {
+          status: result.statusCode,
+          headers: {
+            "Content-Type": "application/json"
+          }
+        });
+      }
+      return handler(request);
+    };
+  };
+}
+
+export {
+  mantlePaywall,
+  web_standards_exports
+};

package/dist/client.d.cts

@@ -1,7 +1,7 @@
-import { P as PaymentClientConfig, b as PaymentClient } from './createMantleClient-NN0Nitp9.cjs';
-export { C as CallWithPaymentResult, M as MantleClient, a as MantleClientConfig, c as createMantleClient } from './createMantleClient-NN0Nitp9.cjs';
-export { A as AssetConfig, a as Authorization, E as EIP1193Provider, N as NetworkId, d as PaymentHeaderBase64, c as PaymentHeaderObject, b as PaymentHeaderPayload, P as PaymentRequirements } from './types-2zqbJvcz.cjs';
-export { M as MANTLE_DEFAULTS } from './constants-DzCGK0Q3.cjs';
+import { P as PaymentClientConfig, b as PaymentClient } from './createMantleClient-CO0uWPb-.cjs';
+export { C as CallWithPaymentResult, M as MantleClient, a as MantleClientConfig, c as createMantleClient } from './createMantleClient-CO0uWPb-.cjs';
+export { A as AssetConfig, a as Authorization, E as EIP1193Provider, N as NetworkId, d as PaymentHeaderBase64, c as PaymentHeaderObject, b as PaymentHeaderPayload, P as PaymentRequirements } from './types-BFUqKBBO.cjs';
+export { M as MANTLE_DEFAULTS } from './constants-CsIL25uQ.cjs';
 
 /**
  * Creates a high-level payment client that:

package/dist/client.d.ts

@@ -1,7 +1,7 @@
-import { P as PaymentClientConfig, b as PaymentClient } from './createMantleClient-DVFkbBfS.js';
-export { C as CallWithPaymentResult, M as MantleClient, a as MantleClientConfig, c as createMantleClient } from './createMantleClient-DVFkbBfS.js';
-export { A as AssetConfig, a as Authorization, E as EIP1193Provider, N as NetworkId, d as PaymentHeaderBase64, c as PaymentHeaderObject, b as PaymentHeaderPayload, P as PaymentRequirements } from './types-2zqbJvcz.js';
-export { M as MANTLE_DEFAULTS } from './constants-CVFF0ray.js';
+import { P as PaymentClientConfig, b as PaymentClient } from './createMantleClient-CuiPsTa6.js';
+export { C as CallWithPaymentResult, M as MantleClient, a as MantleClientConfig, c as createMantleClient } from './createMantleClient-CuiPsTa6.js';
+export { A as AssetConfig, a as Authorization, E as EIP1193Provider, N as NetworkId, d as PaymentHeaderBase64, c as PaymentHeaderObject, b as PaymentHeaderPayload, P as PaymentRequirements } from './types-BFUqKBBO.js';
+export { M as MANTLE_DEFAULTS } from './constants-0ncqvV_O.js';
 
 /**
  * Creates a high-level payment client that:

package/dist/client.js

@@ -1,10 +1,10 @@
 import {
   createMantleClient,
   createPaymentClient
-} from "./chunk-CTI5CRDY.js";
+} from "./chunk-E46A7I6B.js";
 import {
   MANTLE_DEFAULTS
-} from "./chunk-XAQGMFSR.js";
+} from "./chunk-HEZZ74SI.js";
 export {
   MANTLE_DEFAULTS,
   createMantleClient,

package/dist/constants-0ncqvV_O.d.ts

@@ -0,0 +1,17 @@
+import './types-BFUqKBBO.js';
+
+/**
+ * Default values for Mantle mainnet x402 payments.
+ * These are used by the simplified API (mantlePaywall, createMantleClient).
+ */
+declare const MANTLE_DEFAULTS: {
+    readonly NETWORK: "mantle-mainnet";
+    readonly CHAIN_ID: 5000;
+    readonly USDC_ADDRESS: "0x09Bc4E0D864854c6aFB6eB9A9cdF58aC190D0dF9";
+    readonly USDC_DECIMALS: 6;
+    readonly CURRENCY: "USD";
+    readonly SCHEME: "exact";
+    readonly FACILITATOR_URL: string;
+};
+
+export { MANTLE_DEFAULTS as M };

package/dist/constants-CsIL25uQ.d.cts

@@ -0,0 +1,17 @@
+import './types-BFUqKBBO.cjs';
+
+/**
+ * Default values for Mantle mainnet x402 payments.
+ * These are used by the simplified API (mantlePaywall, createMantleClient).
+ */
+declare const MANTLE_DEFAULTS: {
+    readonly NETWORK: "mantle-mainnet";
+    readonly CHAIN_ID: 5000;
+    readonly USDC_ADDRESS: "0x09Bc4E0D864854c6aFB6eB9A9cdF58aC190D0dF9";
+    readonly USDC_DECIMALS: 6;
+    readonly CURRENCY: "USD";
+    readonly SCHEME: "exact";
+    readonly FACILITATOR_URL: string;
+};
+
+export { MANTLE_DEFAULTS as M };

package/dist/createMantleClient-CO0uWPb-.d.cts

@@ -0,0 +1,87 @@
+import { d as PaymentHeaderBase64, P as PaymentRequirements } from './types-BFUqKBBO.cjs';
+
+/** Config for the client-side payment helper. */
+interface PaymentClientConfig {
+    /** Base URL of your protected resource server. */
+    resourceUrl: string;
+    /** Facilitator URL (hosted or self-hosted). */
+    facilitatorUrl: string;
+    /** EIP-1193 provider (window.ethereum) or similar. */
+    provider: unknown;
+    /** Optional user address override; otherwise derived from provider. */
+    userAddress?: string;
+    /** Optional: Project key for hosted facilitator billing. */
+    projectKey?: string;
+}
+/** Result of a callWithPayment() client operation. */
+interface CallWithPaymentResult<TResponseBody = unknown> {
+    response: TResponseBody;
+    txHash?: string;
+    paymentHeader?: PaymentHeaderBase64;
+    paymentRequirements?: PaymentRequirements;
+}
+/** Shape of the client instance returned by createPaymentClient. */
+interface PaymentClient {
+    callWithPayment<TBody = unknown, TResp = unknown>(path: string, options?: {
+        method?: "GET" | "POST" | "PUT" | "DELETE";
+        body?: TBody;
+        headers?: Record<string, string>;
+        /**
+         * Optional override if you want to send less than maxAmountRequired.
+         * In most cases you won't need this and will just pay maxAmountRequired.
+         */
+        valueOverrideAtomic?: string;
+    }): Promise<CallWithPaymentResult<TResp>>;
+}
+
+/**
+ * Configuration for createMantleClient().
+ * All fields are optional - the client auto-detects sensible defaults.
+ */
+interface MantleClientConfig {
+    /** Optional facilitator URL (auto-detects from NEXT_PUBLIC_FACILITATOR_URL or defaults to localhost:8080). */
+    facilitatorUrl?: string;
+    /** Optional resource URL (defaults to current origin in browser, or empty string for relative paths). */
+    resourceUrl?: string;
+    /** Function to get user's wallet address (required for payments). */
+    getAccount?: () => Promise<string | undefined> | string | undefined;
+    /** Function to get wallet provider/client (e.g., viem WalletClient or window.ethereum). */
+    getProvider?: () => any;
+    /** Optional project key for hosted facilitator billing. */
+    projectKey?: string;
+}
+/**
+ * Simplified Mantle payment client interface.
+ * Provides a clean API for making paid POST requests.
+ */
+interface MantleClient {
+    /**
+     * Make a paid POST request to a protected endpoint.
+     * Automatically handles x402 flow (402 response, signing, payment, retry).
+     *
+     * @param url - API endpoint path (e.g., "/api/generate-image").
+     * @param body - Request body (will be JSON stringified).
+     * @returns Full payment result including response body and tx hash.
+     * @throws Error if wallet is not connected or payment fails.
+     */
+    postWithPayment<TResp = any>(url: string, body?: any): Promise<CallWithPaymentResult<TResp>>;
+}
+/**
+ * Create a simplified Mantle payment client with auto-detected defaults.
+ *
+ * Usage:
+ * ```typescript
+ * const client = createMantleClient({
+ *   getAccount: () => account?.address,
+ *   getProvider: () => walletClient,
+ * });
+ *
+ * const data = await client.postWithPayment("/api/generate", { prompt: "..." });
+ * ```
+ *
+ * @param config - Optional configuration (auto-detects facilitatorUrl and resourceUrl).
+ * @returns MantleClient instance with simplified postWithPayment() method.
+ */
+declare function createMantleClient(config?: MantleClientConfig): MantleClient;
+
+export { type CallWithPaymentResult as C, type MantleClient as M, type PaymentClientConfig as P, type MantleClientConfig as a, type PaymentClient as b, createMantleClient as c };

package/dist/createMantleClient-CuiPsTa6.d.ts

@@ -0,0 +1,87 @@
+import { d as PaymentHeaderBase64, P as PaymentRequirements } from './types-BFUqKBBO.js';
+
+/** Config for the client-side payment helper. */
+interface PaymentClientConfig {
+    /** Base URL of your protected resource server. */
+    resourceUrl: string;
+    /** Facilitator URL (hosted or self-hosted). */
+    facilitatorUrl: string;
+    /** EIP-1193 provider (window.ethereum) or similar. */
+    provider: unknown;
+    /** Optional user address override; otherwise derived from provider. */
+    userAddress?: string;
+    /** Optional: Project key for hosted facilitator billing. */
+    projectKey?: string;
+}
+/** Result of a callWithPayment() client operation. */
+interface CallWithPaymentResult<TResponseBody = unknown> {
+    response: TResponseBody;
+    txHash?: string;
+    paymentHeader?: PaymentHeaderBase64;
+    paymentRequirements?: PaymentRequirements;
+}
+/** Shape of the client instance returned by createPaymentClient. */
+interface PaymentClient {
+    callWithPayment<TBody = unknown, TResp = unknown>(path: string, options?: {
+        method?: "GET" | "POST" | "PUT" | "DELETE";
+        body?: TBody;
+        headers?: Record<string, string>;
+        /**
+         * Optional override if you want to send less than maxAmountRequired.
+         * In most cases you won't need this and will just pay maxAmountRequired.
+         */
+        valueOverrideAtomic?: string;
+    }): Promise<CallWithPaymentResult<TResp>>;
+}
+
+/**
+ * Configuration for createMantleClient().
+ * All fields are optional - the client auto-detects sensible defaults.
+ */
+interface MantleClientConfig {
+    /** Optional facilitator URL (auto-detects from NEXT_PUBLIC_FACILITATOR_URL or defaults to localhost:8080). */
+    facilitatorUrl?: string;
+    /** Optional resource URL (defaults to current origin in browser, or empty string for relative paths). */
+    resourceUrl?: string;
+    /** Function to get user's wallet address (required for payments). */
+    getAccount?: () => Promise<string | undefined> | string | undefined;
+    /** Function to get wallet provider/client (e.g., viem WalletClient or window.ethereum). */
+    getProvider?: () => any;
+    /** Optional project key for hosted facilitator billing. */
+    projectKey?: string;
+}
+/**
+ * Simplified Mantle payment client interface.
+ * Provides a clean API for making paid POST requests.
+ */
+interface MantleClient {
+    /**
+     * Make a paid POST request to a protected endpoint.
+     * Automatically handles x402 flow (402 response, signing, payment, retry).
+     *
+     * @param url - API endpoint path (e.g., "/api/generate-image").
+     * @param body - Request body (will be JSON stringified).
+     * @returns Full payment result including response body and tx hash.
+     * @throws Error if wallet is not connected or payment fails.
+     */
+    postWithPayment<TResp = any>(url: string, body?: any): Promise<CallWithPaymentResult<TResp>>;
+}
+/**
+ * Create a simplified Mantle payment client with auto-detected defaults.
+ *
+ * Usage:
+ * ```typescript
+ * const client = createMantleClient({
+ *   getAccount: () => account?.address,
+ *   getProvider: () => walletClient,
+ * });
+ *
+ * const data = await client.postWithPayment("/api/generate", { prompt: "..." });
+ * ```
+ *
+ * @param config - Optional configuration (auto-detects facilitatorUrl and resourceUrl).
+ * @returns MantleClient instance with simplified postWithPayment() method.
+ */
+declare function createMantleClient(config?: MantleClientConfig): MantleClient;
+
+export { type CallWithPaymentResult as C, type MantleClient as M, type PaymentClientConfig as P, type MantleClientConfig as a, type PaymentClient as b, createMantleClient as c };

package/dist/express-Ck7eryef.d.cts

@@ -0,0 +1,66 @@
+import { Request, Response, NextFunction } from 'express';
+import { b as RoutesConfig, M as MinimalPaywallOptions } from './types-xkNm0uzE.cjs';
+
+/**
+ * Express middleware function type for Mantle paywall.
+ */
+type MantleMiddleware = (req: Request, res: Response, next: NextFunction) => Promise<void>;
+/** Config for createPaymentMiddleware. */
+interface PaymentMiddlewareConfig {
+    /** Base URL of facilitator, e.g. https://facilitator.nosubs.ai */
+    facilitatorUrl: string;
+    /** Recipient address (developer). */
+    receiverAddress: `0x${string}`;
+    /** Map of protected routes and their pricing. */
+    routes: RoutesConfig;
+    /**
+     * Optional hook called whenever a payment is successfully settled.
+     */
+    onPaymentSettled?: MinimalPaywallOptions["onPaymentSettled"];
+    /** Optional: Send usage telemetry for billing/analytics. */
+    telemetry?: MinimalPaywallOptions["telemetry"];
+}
+/**
+ * Create Express middleware for x402 payment verification on multiple routes.
+ *
+ * @example
+ * ```typescript
+ * const middleware = createPaymentMiddleware({
+ *   facilitatorUrl: 'https://facilitator.nosubs.ai',
+ *   receiverAddress: '0x...',
+ *   routes: {
+ *     'POST /api/generate': { priceUsdCents: 1, network: 'mantle-mainnet' },
+ *     'GET /api/data': { priceUsdCents: 5, network: 'mantle-mainnet' },
+ *   }
+ * });
+ *
+ * app.use(middleware);
+ * ```
+ */
+declare function createPaymentMiddleware(config: PaymentMiddlewareConfig): MantleMiddleware;
+/**
+ * Simplified wrapper for protecting a single route with x402 payments.
+ * Uses Mantle mainnet defaults (USDC, exact scheme, etc.).
+ *
+ * @example
+ * ```typescript
+ * const pay = mantlePaywall({ priceUsd: 0.01, payTo: "0x..." });
+ * app.post('/api/generate', pay, async (req, res) => {
+ *   // Your handler code here
+ * });
+ * ```
+ *
+ * @param opts - Minimal configuration (price, payTo, optional facilitator/telemetry).
+ * @returns Express middleware function for single-route protection.
+ */
+declare function mantlePaywall(opts: MinimalPaywallOptions): MantleMiddleware;
+
+type express_MantleMiddleware = MantleMiddleware;
+type express_PaymentMiddlewareConfig = PaymentMiddlewareConfig;
+declare const express_createPaymentMiddleware: typeof createPaymentMiddleware;
+declare const express_mantlePaywall: typeof mantlePaywall;
+declare namespace express {
+  export { type express_MantleMiddleware as MantleMiddleware, type express_PaymentMiddlewareConfig as PaymentMiddlewareConfig, express_createPaymentMiddleware as createPaymentMiddleware, express_mantlePaywall as mantlePaywall };
+}
+
+export { type MantleMiddleware as M, type PaymentMiddlewareConfig as P, createPaymentMiddleware as c, express as e, mantlePaywall as m };

package/dist/express-CmEg5hR3.d.ts

@@ -0,0 +1,66 @@
+import { Request, Response, NextFunction } from 'express';
+import { b as RoutesConfig, M as MinimalPaywallOptions } from './types-C7EPJ6Hd.js';
+
+/**
+ * Express middleware function type for Mantle paywall.
+ */
+type MantleMiddleware = (req: Request, res: Response, next: NextFunction) => Promise<void>;
+/** Config for createPaymentMiddleware. */
+interface PaymentMiddlewareConfig {
+    /** Base URL of facilitator, e.g. https://facilitator.nosubs.ai */
+    facilitatorUrl: string;
+    /** Recipient address (developer). */
+    receiverAddress: `0x${string}`;
+    /** Map of protected routes and their pricing. */
+    routes: RoutesConfig;
+    /**
+     * Optional hook called whenever a payment is successfully settled.
+     */
+    onPaymentSettled?: MinimalPaywallOptions["onPaymentSettled"];
+    /** Optional: Send usage telemetry for billing/analytics. */
+    telemetry?: MinimalPaywallOptions["telemetry"];
+}
+/**
+ * Create Express middleware for x402 payment verification on multiple routes.
+ *
+ * @example
+ * ```typescript
+ * const middleware = createPaymentMiddleware({
+ *   facilitatorUrl: 'https://facilitator.nosubs.ai',
+ *   receiverAddress: '0x...',
+ *   routes: {
+ *     'POST /api/generate': { priceUsdCents: 1, network: 'mantle-mainnet' },
+ *     'GET /api/data': { priceUsdCents: 5, network: 'mantle-mainnet' },
+ *   }
+ * });
+ *
+ * app.use(middleware);
+ * ```
+ */
+declare function createPaymentMiddleware(config: PaymentMiddlewareConfig): MantleMiddleware;
+/**
+ * Simplified wrapper for protecting a single route with x402 payments.
+ * Uses Mantle mainnet defaults (USDC, exact scheme, etc.).
+ *
+ * @example
+ * ```typescript
+ * const pay = mantlePaywall({ priceUsd: 0.01, payTo: "0x..." });
+ * app.post('/api/generate', pay, async (req, res) => {
+ *   // Your handler code here
+ * });
+ * ```
+ *
+ * @param opts - Minimal configuration (price, payTo, optional facilitator/telemetry).
+ * @returns Express middleware function for single-route protection.
+ */
+declare function mantlePaywall(opts: MinimalPaywallOptions): MantleMiddleware;
+
+type express_MantleMiddleware = MantleMiddleware;
+type express_PaymentMiddlewareConfig = PaymentMiddlewareConfig;
+declare const express_createPaymentMiddleware: typeof createPaymentMiddleware;
+declare const express_mantlePaywall: typeof mantlePaywall;
+declare namespace express {
+  export { type express_MantleMiddleware as MantleMiddleware, type express_PaymentMiddlewareConfig as PaymentMiddlewareConfig, express_createPaymentMiddleware as createPaymentMiddleware, express_mantlePaywall as mantlePaywall };
+}
+
+export { type MantleMiddleware as M, type PaymentMiddlewareConfig as P, createPaymentMiddleware as c, express as e, mantlePaywall as m };

package/dist/express-D8EwEcOL.d.ts

@@ -0,0 +1,66 @@
+import { Request, Response, NextFunction } from 'express';
+import { b as RoutesConfig, M as MinimalPaywallOptions } from './types-CqQ6OgRi.js';
+
+/**
+ * Express middleware function type for Mantle paywall.
+ */
+type MantleMiddleware = (req: Request, res: Response, next: NextFunction) => Promise<void>;
+/** Config for createPaymentMiddleware. */
+interface PaymentMiddlewareConfig {
+    /** Base URL of facilitator, e.g. https://facilitator.nosubs.ai */
+    facilitatorUrl: string;
+    /** Recipient address (developer). Validated at runtime. */
+    receiverAddress: string;
+    /** Map of protected routes and their pricing. */
+    routes: RoutesConfig;
+    /**
+     * Optional hook called whenever a payment is successfully settled.
+     */
+    onPaymentSettled?: MinimalPaywallOptions["onPaymentSettled"];
+    /** Optional: Send usage telemetry for billing/analytics. */
+    telemetry?: MinimalPaywallOptions["telemetry"];
+}
+/**
+ * Create Express middleware for x402 payment verification on multiple routes.
+ *
+ * @example
+ * ```typescript
+ * const middleware = createPaymentMiddleware({
+ *   facilitatorUrl: 'https://facilitator.nosubs.ai',
+ *   receiverAddress: '0x...',
+ *   routes: {
+ *     'POST /api/generate': { priceUsdCents: 1, network: 'mantle-mainnet' },
+ *     'GET /api/data': { priceUsdCents: 5, network: 'mantle-mainnet' },
+ *   }
+ * });
+ *
+ * app.use(middleware);
+ * ```
+ */
+declare function createPaymentMiddleware(config: PaymentMiddlewareConfig): MantleMiddleware;
+/**
+ * Simplified wrapper for protecting a single route with x402 payments.
+ * Uses Mantle mainnet defaults (USDC, exact scheme, etc.).
+ *
+ * @example
+ * ```typescript
+ * const pay = mantlePaywall({ priceUsd: 0.01, payTo: "0x..." });
+ * app.post('/api/generate', pay, async (req, res) => {
+ *   // Your handler code here
+ * });
+ * ```
+ *
+ * @param opts - Minimal configuration (price, payTo, optional facilitator/telemetry).
+ * @returns Express middleware function for single-route protection.
+ */
+declare function mantlePaywall(opts: MinimalPaywallOptions): MantleMiddleware;
+
+type express_MantleMiddleware = MantleMiddleware;
+type express_PaymentMiddlewareConfig = PaymentMiddlewareConfig;
+declare const express_createPaymentMiddleware: typeof createPaymentMiddleware;
+declare const express_mantlePaywall: typeof mantlePaywall;
+declare namespace express {
+  export { type express_MantleMiddleware as MantleMiddleware, type express_PaymentMiddlewareConfig as PaymentMiddlewareConfig, express_createPaymentMiddleware as createPaymentMiddleware, express_mantlePaywall as mantlePaywall };
+}
+
+export { type MantleMiddleware as M, type PaymentMiddlewareConfig as P, createPaymentMiddleware as c, express as e, mantlePaywall as m };