@puga-labs/x402-mantle-sdk 0.3.8 → 0.3.10

package/dist/express-DxxlKmmF.d.ts

@@ -0,0 +1,68 @@
+import { Request, Response, NextFunction } from 'express';
+import { b as RoutesConfig, M as MinimalPaywallOptions } from './types-vicT7qsY.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 API key for hosted facilitator billing. */
+    apiKey?: string;
+    /**
+     * 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/index.cjs

@@ -159,9 +159,20 @@ function createTelemetryEvent(entry, config) {
     priceUsd: entry.paymentRequirements?.price
   };
 }
-async function sendTelemetry(event, endpoint) {
+async function sendTelemetry(event, endpoint, debug) {
   const targetEndpoint = endpoint ?? DEFAULT_TELEMETRY_ENDPOINT;
+  if (debug) {
+    console.log(`[x402-debug:telemetry] \u{1F4E4} Sending telemetry event:`, {
+      event: event.event,
+      endpoint: targetEndpoint,
+      projectKey: event.projectKey.substring(0, 10) + "...",
+      route: event.route,
+      responseStatus: event.responseStatus,
+      serviceDelivered: event.serviceDelivered
+    });
+  }
   if (!targetEndpoint) {
+    if (debug) console.log(`[x402-debug:telemetry] \u26A0\uFE0F No endpoint configured, skipping`);
     return;
   }
   try {
@@ -173,17 +184,29 @@ async function sendTelemetry(event, endpoint) {
       },
       body: JSON.stringify(event)
     });
+    if (debug) {
+      console.log(`[x402-debug:telemetry] ${response.ok ? "\u2705" : "\u274C"} Telemetry sent: HTTP ${response.status}`);
+    }
     if (!response.ok) {
       console.warn(
         `[x402-telemetry] Failed to send event: HTTP ${response.status}`
       );
     }
   } catch (err) {
+    if (debug) {
+      console.error(`[x402-debug:telemetry] \u274C Error sending:`, err);
+    }
     console.error("[x402-telemetry] Error sending telemetry:", err);
   }
 }
 
 // src/server/core/verifyPayment.ts
+function debugLog(config, prefix, message, data) {
+  if (config?.debug) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    console.log(`[${timestamp}] [x402-debug:${prefix}]`, message, data || "");
+  }
+}
 async function checkPayment(input) {
   const {
     paymentHeader,
@@ -253,12 +276,13 @@ async function checkPayment(input) {
         isValid: false
       };
     }
-    if (onPaymentSettled) {
+    let baseLogEntry = null;
+    if (onPaymentSettled || telemetry) {
       try {
         const headerObj = decodePaymentHeader(paymentHeader);
         const { authorization } = headerObj.payload;
         const assetConfig = getDefaultAssetForNetwork(network);
-        const logEntry = {
+        baseLogEntry = {
           id: authorization.nonce,
           from: authorization.from,
           to: authorization.to,
@@ -270,12 +294,12 @@ async function checkPayment(input) {
           facilitatorUrl,
           paymentRequirements
         };
-        onPaymentSettled(logEntry);
-        if (telemetry) {
-          const event = createTelemetryEvent(logEntry, telemetry);
-          sendTelemetry(event, telemetry.endpoint).catch(
-            (err) => console.error("[x402-telemetry] Async send failed:", err)
-          );
+        debugLog(telemetry, "verify", "\u2705 Payment verified", {
+          nonce: authorization.nonce,
+          route: routeKey
+        });
+        if (onPaymentSettled) {
+          onPaymentSettled(baseLogEntry);
         }
       } catch (err) {
         console.error(
@@ -284,11 +308,41 @@ async function checkPayment(input) {
         );
       }
     }
+    const sendTelemetryAfterResponse = telemetry && baseLogEntry ? (responseStatus, error) => {
+      try {
+        debugLog(telemetry, "callback", "\u{1F4E4} Telemetry callback invoked", {
+          responseStatus,
+          hasError: !!error
+        });
+        const event = createTelemetryEvent(baseLogEntry, telemetry);
+        event.responseStatus = responseStatus;
+        event.errorMessage = error;
+        event.serviceDelivered = responseStatus >= 200 && responseStatus < 300;
+        sendTelemetry(event, telemetry.endpoint, telemetry.debug).catch(
+          (err) => console.error("[x402-telemetry] Async send failed:", err)
+        );
+      } catch (err) {
+        console.error("[x402-telemetry] Error creating telemetry event:", err);
+      }
+    } : void 0;
+    if (telemetry && baseLogEntry) {
+      debugLog(telemetry, "callback", "\u2705 Telemetry callback created", {
+        route: routeKey,
+        hasTelemetryConfig: !!telemetry,
+        hasLogEntry: !!baseLogEntry
+      });
+    } else if (telemetry) {
+      debugLog(telemetry, "callback", "\u26A0\uFE0F Telemetry callback NOT created", {
+        hasTelemetryConfig: !!telemetry,
+        hasLogEntry: !!baseLogEntry
+      });
+    }
     return {
       status: "verified",
       statusCode: 200,
       responseBody: null,
-      isValid: true
+      isValid: true,
+      sendTelemetryAfterResponse
     };
   } catch (err) {
     console.error(
@@ -309,6 +363,12 @@ async function checkPayment(input) {
 }
 
 // src/server/adapters/express.ts
+function debugLog2(config, prefix, message, data) {
+  if (config?.debug) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    console.log(`[${timestamp}] [x402-debug:${prefix}]`, message, data || "");
+  }
+}
 function createPaymentMiddleware(config) {
   const { facilitatorUrl, receiverAddress, routes, apiKey, onPaymentSettled, telemetry } = config;
   if (!facilitatorUrl) {
@@ -359,6 +419,25 @@ function createPaymentMiddleware(config) {
       res.status(result.statusCode).json(result.responseBody);
       return;
     }
+    debugLog2(telemetry, "handler", "\u25B6\uFE0F Handler execution started (Express middleware)");
+    if (result.sendTelemetryAfterResponse) {
+      res.on("finish", () => {
+        const statusCode = res.statusCode;
+        debugLog2(telemetry, "handler", `\u2705 Handler completed: ${statusCode}`);
+        const errorMessage = statusCode >= 400 ? `Handler returned ${statusCode}` : void 0;
+        debugLog2(telemetry, "callback", `\u{1F4E4} Calling telemetry callback with status ${statusCode}`);
+        result.sendTelemetryAfterResponse(statusCode, errorMessage);
+      });
+      res.on("close", () => {
+        if (!res.writableEnded) {
+          debugLog2(telemetry, "handler", "\u274C Response closed without finishing");
+          debugLog2(telemetry, "callback", "\u{1F4E4} Calling telemetry callback with error");
+          result.sendTelemetryAfterResponse(500, "Response closed without finishing");
+        }
+      });
+    } else {
+      debugLog2(telemetry, "callback", "\u26A0\uFE0F No telemetry callback to call");
+    }
     next();
   };
 }

package/dist/index.d.cts

@@ -1,10 +1,10 @@
 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';
-export { M as MantleMiddleware, e as MinimalPaywallOptions, P as PaymentLogEntry, d as PaymentMiddlewareConfig, R as RouteKey, a as RoutePricingConfig, b as RoutesConfig, T as TelemetryConfig, c as TelemetryEvent } from './types-BWfKovFm.cjs';
-export { c as createPaymentMiddleware, m as mantlePaywall } from './express-Pukmnwuu.cjs';
+export { M as MantleMiddleware, e as MinimalPaywallOptions, P as PaymentLogEntry, d as PaymentMiddlewareConfig, R as RouteKey, a as RoutePricingConfig, b as RoutesConfig, T as TelemetryConfig, c as TelemetryEvent } from './types-DrBw0xwj.cjs';
+export { c as createPaymentMiddleware, m as mantlePaywall } from './express-BWE0nQty.cjs';
 export { C as CallWithPaymentResult, M as MantleClient, a as MantleClientConfig, b as PaymentClient, P as PaymentClientConfig, c as createMantleClient } from './createMantleClient-CO0uWPb-.cjs';
 export { createPaymentClient } from './client.cjs';
 export { UseEthersWalletOptions, UseEthersWalletReturn, UseMantleX402Options, useEthersWallet, useMantleX402 } from './react.cjs';
 import 'express';
-import './types-BmK0G74m.cjs';
+import './types-BkGUHT4x.cjs';
 import 'ethers';

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 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';
-export { M as MantleMiddleware, e as MinimalPaywallOptions, P as PaymentLogEntry, d as PaymentMiddlewareConfig, R as RouteKey, a as RoutePricingConfig, b as RoutesConfig, T as TelemetryConfig, c as TelemetryEvent } from './types-DgfVPQFb.js';
-export { c as createPaymentMiddleware, m as mantlePaywall } from './express-D8L5Dg1D.js';
+export { M as MantleMiddleware, e as MinimalPaywallOptions, P as PaymentLogEntry, d as PaymentMiddlewareConfig, R as RouteKey, a as RoutePricingConfig, b as RoutesConfig, T as TelemetryConfig, c as TelemetryEvent } from './types-DEpSrXCf.js';
+export { c as createPaymentMiddleware, m as mantlePaywall } from './express-BvuN0Lx1.js';
 export { C as CallWithPaymentResult, M as MantleClient, a as MantleClientConfig, b as PaymentClient, P as PaymentClientConfig, c as createMantleClient } from './createMantleClient-CuiPsTa6.js';
 export { createPaymentClient } from './client.js';
 export { UseEthersWalletOptions, UseEthersWalletReturn, UseMantleX402Options, useEthersWallet, useMantleX402 } from './react.js';
 import 'express';
-import './types-CXdNC0Ra.js';
+import './types-Ba0v9XsC.js';
 import 'ethers';

package/dist/index.js

@@ -10,8 +10,8 @@ import "./chunk-WO2MYZXT.js";
 import {
   createPaymentMiddleware,
   mantlePaywall
-} from "./chunk-B4GST723.js";
-import "./chunk-OW2BDRGZ.js";
+} from "./chunk-3DGAB7HD.js";
+import "./chunk-UVYA6H32.js";
 import {
   MANTLE_DEFAULTS
 } from "./chunk-HEZZ74SI.js";

package/dist/nextjs-Bujo9Okf.d.cts

@@ -0,0 +1,89 @@
+import { NextRequest } from 'next/server';
+import { M as MinimalPaywallOptions } from './types-BkGUHT4x.cjs';
+import { P as PaymentRequirements } from './types-BFUqKBBO.cjs';
+
+/**
+ * Error response returned when payment verification fails.
+ * This can be due to missing payment, invalid payment, or verification errors.
+ */
+interface PaywallErrorResponse {
+    error: string;
+    paymentRequirements?: PaymentRequirements;
+    paymentHeader?: null;
+    invalidReason?: string | null;
+    details?: string;
+}
+/**
+ * Simple promise-or-value helper.
+ */
+type Awaitable<T> = T | Promise<T>;
+/**
+ * Next.js App Router route handler type.
+ *
+ * Accepts anything that is a valid `Response` to avoid forcing users
+ * to annotate union bodies on every handler.
+ */
+type NextJSHandler = (req: NextRequest) => Awaitable<Response>;
+/**
+ * Wrapper function that adds x402 payment verification to Next.js route handler.
+ * Returns a handler that may return either the original handler's response
+ * or a PaywallErrorResponse if payment verification fails.
+ */
+type NextJSPaywallWrapper = (handler: NextJSHandler) => NextJSHandler;
+/**
+ * Create Next.js App Router middleware for x402 payment verification.
+ * Uses Mantle mainnet defaults (USDC, exact scheme, etc.).
+ *
+ * @example
+ * ```typescript
+ * // app/api/generate-image/route.ts
+ * import { mantlePaywall } from '@puga-labs/x402-mantle-sdk/server/nextjs'
+ *
+ * const pay = mantlePaywall({
+ *   priceUsd: 0.01,
+ *   payTo: process.env.PAY_TO!,
+ * });
+ *
+ * // No 'as any' needed! TypeScript correctly infers the union type
+ * export const POST = pay(async (req: NextRequest) => {
+ *   const { prompt } = await req.json();
+ *   // Your handler code here
+ *   return NextResponse.json({ success: true, imageUrl: "..." });
+ * });
+ * // TypeScript knows POST returns: NextResponse<{ success: boolean; imageUrl: string } | PaywallErrorResponse>
+ * ```
+ *
+ * @param opts - Minimal configuration (price, payTo, optional facilitator/telemetry).
+ * @returns Function that wraps Next.js route handlers with payment verification.
+ */
+declare function mantlePaywall(opts: MinimalPaywallOptions): NextJSPaywallWrapper;
+/**
+ * Type guard to check if a response is a paywall error response.
+ * Useful for handling the union type returned by the paywall wrapper.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch('/api/protected');
+ * const data = await response.json();
+ *
+ * if (isPaywallErrorResponse(data)) {
+ *   // Handle error: data.error, data.paymentRequirements, etc.
+ *   console.error('Payment required:', data.paymentRequirements);
+ * } else {
+ *   // Handle success: data has type T
+ *   console.log('Success:', data);
+ * }
+ * ```
+ */
+declare function isPaywallErrorResponse(response: unknown): response is PaywallErrorResponse;
+
+type nextjs_NextJSHandler = NextJSHandler;
+type nextjs_NextJSPaywallWrapper = NextJSPaywallWrapper;
+type nextjs_PaywallErrorResponse = PaywallErrorResponse;
+declare const nextjs_isPaywallErrorResponse: typeof isPaywallErrorResponse;
+declare const nextjs_mantlePaywall: typeof mantlePaywall;
+declare namespace nextjs {
+  export { type nextjs_NextJSHandler as NextJSHandler, type nextjs_NextJSPaywallWrapper as NextJSPaywallWrapper, type nextjs_PaywallErrorResponse as PaywallErrorResponse, nextjs_isPaywallErrorResponse as isPaywallErrorResponse, nextjs_mantlePaywall as mantlePaywall };
+}
+
+export { type NextJSHandler as N, type PaywallErrorResponse as P, type NextJSPaywallWrapper as a, isPaywallErrorResponse as i, mantlePaywall as m, nextjs as n };

package/dist/nextjs-CzSejZe8.d.ts

@@ -0,0 +1,89 @@
+import { NextRequest } from 'next/server';
+import { M as MinimalPaywallOptions } from './types-Ba0v9XsC.js';
+import { P as PaymentRequirements } from './types-BFUqKBBO.js';
+
+/**
+ * Error response returned when payment verification fails.
+ * This can be due to missing payment, invalid payment, or verification errors.
+ */
+interface PaywallErrorResponse {
+    error: string;
+    paymentRequirements?: PaymentRequirements;
+    paymentHeader?: null;
+    invalidReason?: string | null;
+    details?: string;
+}
+/**
+ * Simple promise-or-value helper.
+ */
+type Awaitable<T> = T | Promise<T>;
+/**
+ * Next.js App Router route handler type.
+ *
+ * Accepts anything that is a valid `Response` to avoid forcing users
+ * to annotate union bodies on every handler.
+ */
+type NextJSHandler = (req: NextRequest) => Awaitable<Response>;
+/**
+ * Wrapper function that adds x402 payment verification to Next.js route handler.
+ * Returns a handler that may return either the original handler's response
+ * or a PaywallErrorResponse if payment verification fails.
+ */
+type NextJSPaywallWrapper = (handler: NextJSHandler) => NextJSHandler;
+/**
+ * Create Next.js App Router middleware for x402 payment verification.
+ * Uses Mantle mainnet defaults (USDC, exact scheme, etc.).
+ *
+ * @example
+ * ```typescript
+ * // app/api/generate-image/route.ts
+ * import { mantlePaywall } from '@puga-labs/x402-mantle-sdk/server/nextjs'
+ *
+ * const pay = mantlePaywall({
+ *   priceUsd: 0.01,
+ *   payTo: process.env.PAY_TO!,
+ * });
+ *
+ * // No 'as any' needed! TypeScript correctly infers the union type
+ * export const POST = pay(async (req: NextRequest) => {
+ *   const { prompt } = await req.json();
+ *   // Your handler code here
+ *   return NextResponse.json({ success: true, imageUrl: "..." });
+ * });
+ * // TypeScript knows POST returns: NextResponse<{ success: boolean; imageUrl: string } | PaywallErrorResponse>
+ * ```
+ *
+ * @param opts - Minimal configuration (price, payTo, optional facilitator/telemetry).
+ * @returns Function that wraps Next.js route handlers with payment verification.
+ */
+declare function mantlePaywall(opts: MinimalPaywallOptions): NextJSPaywallWrapper;
+/**
+ * Type guard to check if a response is a paywall error response.
+ * Useful for handling the union type returned by the paywall wrapper.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch('/api/protected');
+ * const data = await response.json();
+ *
+ * if (isPaywallErrorResponse(data)) {
+ *   // Handle error: data.error, data.paymentRequirements, etc.
+ *   console.error('Payment required:', data.paymentRequirements);
+ * } else {
+ *   // Handle success: data has type T
+ *   console.log('Success:', data);
+ * }
+ * ```
+ */
+declare function isPaywallErrorResponse(response: unknown): response is PaywallErrorResponse;
+
+type nextjs_NextJSHandler = NextJSHandler;
+type nextjs_NextJSPaywallWrapper = NextJSPaywallWrapper;
+type nextjs_PaywallErrorResponse = PaywallErrorResponse;
+declare const nextjs_isPaywallErrorResponse: typeof isPaywallErrorResponse;
+declare const nextjs_mantlePaywall: typeof mantlePaywall;
+declare namespace nextjs {
+  export { type nextjs_NextJSHandler as NextJSHandler, type nextjs_NextJSPaywallWrapper as NextJSPaywallWrapper, type nextjs_PaywallErrorResponse as PaywallErrorResponse, nextjs_isPaywallErrorResponse as isPaywallErrorResponse, nextjs_mantlePaywall as mantlePaywall };
+}
+
+export { type NextJSHandler as N, type PaywallErrorResponse as P, type NextJSPaywallWrapper as a, isPaywallErrorResponse as i, mantlePaywall as m, nextjs as n };

package/dist/nextjs-DGcN_MGa.d.ts

@@ -0,0 +1,89 @@
+import { NextRequest } from 'next/server';
+import { M as MinimalPaywallOptions } from './types-vicT7qsY.js';
+import { P as PaymentRequirements } from './types-BFUqKBBO.js';
+
+/**
+ * Error response returned when payment verification fails.
+ * This can be due to missing payment, invalid payment, or verification errors.
+ */
+interface PaywallErrorResponse {
+    error: string;
+    paymentRequirements?: PaymentRequirements;
+    paymentHeader?: null;
+    invalidReason?: string | null;
+    details?: string;
+}
+/**
+ * Simple promise-or-value helper.
+ */
+type Awaitable<T> = T | Promise<T>;
+/**
+ * Next.js App Router route handler type.
+ *
+ * Accepts anything that is a valid `Response` to avoid forcing users
+ * to annotate union bodies on every handler.
+ */
+type NextJSHandler = (req: NextRequest) => Awaitable<Response>;
+/**
+ * Wrapper function that adds x402 payment verification to Next.js route handler.
+ * Returns a handler that may return either the original handler's response
+ * or a PaywallErrorResponse if payment verification fails.
+ */
+type NextJSPaywallWrapper = (handler: NextJSHandler) => NextJSHandler;
+/**
+ * Create Next.js App Router middleware for x402 payment verification.
+ * Uses Mantle mainnet defaults (USDC, exact scheme, etc.).
+ *
+ * @example
+ * ```typescript
+ * // app/api/generate-image/route.ts
+ * import { mantlePaywall } from '@puga-labs/x402-mantle-sdk/server/nextjs'
+ *
+ * const pay = mantlePaywall({
+ *   priceUsd: 0.01,
+ *   payTo: process.env.PAY_TO!,
+ * });
+ *
+ * // No 'as any' needed! TypeScript correctly infers the union type
+ * export const POST = pay(async (req: NextRequest) => {
+ *   const { prompt } = await req.json();
+ *   // Your handler code here
+ *   return NextResponse.json({ success: true, imageUrl: "..." });
+ * });
+ * // TypeScript knows POST returns: NextResponse<{ success: boolean; imageUrl: string } | PaywallErrorResponse>
+ * ```
+ *
+ * @param opts - Minimal configuration (price, payTo, optional facilitator/telemetry).
+ * @returns Function that wraps Next.js route handlers with payment verification.
+ */
+declare function mantlePaywall(opts: MinimalPaywallOptions): NextJSPaywallWrapper;
+/**
+ * Type guard to check if a response is a paywall error response.
+ * Useful for handling the union type returned by the paywall wrapper.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch('/api/protected');
+ * const data = await response.json();
+ *
+ * if (isPaywallErrorResponse(data)) {
+ *   // Handle error: data.error, data.paymentRequirements, etc.
+ *   console.error('Payment required:', data.paymentRequirements);
+ * } else {
+ *   // Handle success: data has type T
+ *   console.log('Success:', data);
+ * }
+ * ```
+ */
+declare function isPaywallErrorResponse(response: unknown): response is PaywallErrorResponse;
+
+type nextjs_NextJSHandler = NextJSHandler;
+type nextjs_NextJSPaywallWrapper = NextJSPaywallWrapper;
+type nextjs_PaywallErrorResponse = PaywallErrorResponse;
+declare const nextjs_isPaywallErrorResponse: typeof isPaywallErrorResponse;
+declare const nextjs_mantlePaywall: typeof mantlePaywall;
+declare namespace nextjs {
+  export { type nextjs_NextJSHandler as NextJSHandler, type nextjs_NextJSPaywallWrapper as NextJSPaywallWrapper, type nextjs_PaywallErrorResponse as PaywallErrorResponse, nextjs_isPaywallErrorResponse as isPaywallErrorResponse, nextjs_mantlePaywall as mantlePaywall };
+}
+
+export { type NextJSHandler as N, type PaywallErrorResponse as P, type NextJSPaywallWrapper as a, isPaywallErrorResponse as i, mantlePaywall as m, nextjs as n };

package/dist/nextjs-EoISXVEo.d.cts

@@ -0,0 +1,89 @@
+import { NextRequest } from 'next/server';
+import { M as MinimalPaywallOptions } from './types-B87bD2yo.cjs';
+import { P as PaymentRequirements } from './types-BFUqKBBO.cjs';
+
+/**
+ * Error response returned when payment verification fails.
+ * This can be due to missing payment, invalid payment, or verification errors.
+ */
+interface PaywallErrorResponse {
+    error: string;
+    paymentRequirements?: PaymentRequirements;
+    paymentHeader?: null;
+    invalidReason?: string | null;
+    details?: string;
+}
+/**
+ * Simple promise-or-value helper.
+ */
+type Awaitable<T> = T | Promise<T>;
+/**
+ * Next.js App Router route handler type.
+ *
+ * Accepts anything that is a valid `Response` to avoid forcing users
+ * to annotate union bodies on every handler.
+ */
+type NextJSHandler = (req: NextRequest) => Awaitable<Response>;
+/**
+ * Wrapper function that adds x402 payment verification to Next.js route handler.
+ * Returns a handler that may return either the original handler's response
+ * or a PaywallErrorResponse if payment verification fails.
+ */
+type NextJSPaywallWrapper = (handler: NextJSHandler) => NextJSHandler;
+/**
+ * Create Next.js App Router middleware for x402 payment verification.
+ * Uses Mantle mainnet defaults (USDC, exact scheme, etc.).
+ *
+ * @example
+ * ```typescript
+ * // app/api/generate-image/route.ts
+ * import { mantlePaywall } from '@puga-labs/x402-mantle-sdk/server/nextjs'
+ *
+ * const pay = mantlePaywall({
+ *   priceUsd: 0.01,
+ *   payTo: process.env.PAY_TO!,
+ * });
+ *
+ * // No 'as any' needed! TypeScript correctly infers the union type
+ * export const POST = pay(async (req: NextRequest) => {
+ *   const { prompt } = await req.json();
+ *   // Your handler code here
+ *   return NextResponse.json({ success: true, imageUrl: "..." });
+ * });
+ * // TypeScript knows POST returns: NextResponse<{ success: boolean; imageUrl: string } | PaywallErrorResponse>
+ * ```
+ *
+ * @param opts - Minimal configuration (price, payTo, optional facilitator/telemetry).
+ * @returns Function that wraps Next.js route handlers with payment verification.
+ */
+declare function mantlePaywall(opts: MinimalPaywallOptions): NextJSPaywallWrapper;
+/**
+ * Type guard to check if a response is a paywall error response.
+ * Useful for handling the union type returned by the paywall wrapper.
+ *
+ * @example
+ * ```typescript
+ * const response = await fetch('/api/protected');
+ * const data = await response.json();
+ *
+ * if (isPaywallErrorResponse(data)) {
+ *   // Handle error: data.error, data.paymentRequirements, etc.
+ *   console.error('Payment required:', data.paymentRequirements);
+ * } else {
+ *   // Handle success: data has type T
+ *   console.log('Success:', data);
+ * }
+ * ```
+ */
+declare function isPaywallErrorResponse(response: unknown): response is PaywallErrorResponse;
+
+type nextjs_NextJSHandler = NextJSHandler;
+type nextjs_NextJSPaywallWrapper = NextJSPaywallWrapper;
+type nextjs_PaywallErrorResponse = PaywallErrorResponse;
+declare const nextjs_isPaywallErrorResponse: typeof isPaywallErrorResponse;
+declare const nextjs_mantlePaywall: typeof mantlePaywall;
+declare namespace nextjs {
+  export { type nextjs_NextJSHandler as NextJSHandler, type nextjs_NextJSPaywallWrapper as NextJSPaywallWrapper, type nextjs_PaywallErrorResponse as PaywallErrorResponse, nextjs_isPaywallErrorResponse as isPaywallErrorResponse, nextjs_mantlePaywall as mantlePaywall };
+}
+
+export { type NextJSHandler as N, type PaywallErrorResponse as P, type NextJSPaywallWrapper as a, isPaywallErrorResponse as i, mantlePaywall as m, nextjs as n };