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

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/createMantleClient-DS1Ghqrz.d.cts

@@ -0,0 +1,51 @@
+/**
+ * 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 Response data from the protected endpoint.
+     * @throws Error if wallet is not connected or payment fails.
+     */
+    postWithPayment<TResp = any>(url: string, body?: any): Promise<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 MantleClient as M, type MantleClientConfig as a, createMantleClient as c };

package/dist/createMantleClient-DS1Ghqrz.d.ts

@@ -0,0 +1,51 @@
+/**
+ * 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 Response data from the protected endpoint.
+     * @throws Error if wallet is not connected or payment fails.
+     */
+    postWithPayment<TResp = any>(url: string, body?: any): Promise<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 MantleClient as M, type MantleClientConfig as a, createMantleClient as c };

package/dist/createMantleClient-DVFkbBfS.d.ts

@@ -0,0 +1,87 @@
+import { d as PaymentHeaderBase64, P as PaymentRequirements } from './types-2zqbJvcz.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/createMantleClient-NN0Nitp9.d.cts

@@ -0,0 +1,87 @@
+import { d as PaymentHeaderBase64, P as PaymentRequirements } from './types-2zqbJvcz.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/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 };

package/dist/express-eQOPxfnI.d.cts

@@ -0,0 +1,66 @@
+import { Request, Response, NextFunction } from 'express';
+import { b as RoutesConfig, M as MinimalPaywallOptions } from './types-CrOsOHcX.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). 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 };