@puga-labs/x402-mantle-sdk 0.3.7 → 0.3.9

package/dist/chunk-OW2BDRGZ.js

@@ -0,0 +1,239 @@
+import {
+  getDefaultAssetForNetwork
+} from "./chunk-HEZZ74SI.js";
+
+// src/server/core/utils.ts
+function validateAddress(address, paramName = "address") {
+  if (!address) {
+    throw new Error(`${paramName} is required`);
+  }
+  if (typeof address !== "string") {
+    throw new Error(`${paramName} must be a string, got ${typeof address}`);
+  }
+  if (!address.startsWith("0x")) {
+    const preview = address.length > 10 ? `${address.substring(0, 10)}...` : address;
+    throw new Error(
+      `${paramName} must start with "0x", got: ${preview}`
+    );
+  }
+  if (address.length !== 42) {
+    throw new Error(
+      `${paramName} must be 42 characters (0x + 40 hex), got ${address.length} characters`
+    );
+  }
+  const hexPart = address.slice(2);
+  if (!/^[0-9a-fA-F]{40}$/.test(hexPart)) {
+    throw new Error(
+      `${paramName} must contain only hexadecimal characters (0-9, a-f, A-F) after "0x"`
+    );
+  }
+}
+function decodePaymentHeader(paymentHeaderBase64) {
+  try {
+    if (typeof Buffer !== "undefined") {
+      const json = Buffer.from(paymentHeaderBase64, "base64").toString("utf8");
+      return JSON.parse(json);
+    }
+    if (typeof atob === "function") {
+      const json = atob(paymentHeaderBase64);
+      return JSON.parse(json);
+    }
+    throw new Error("No base64 decoding available in this environment");
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : "Unknown error";
+    throw new Error(`Failed to decode paymentHeader: ${msg}`);
+  }
+}
+function buildRouteKey(method, path) {
+  const normalizedMethod = (method || "GET").toUpperCase();
+  const normalizedPath = path || "/";
+  return `${normalizedMethod} ${normalizedPath}`;
+}
+
+// src/server/constants.ts
+var DEFAULT_TELEMETRY_ENDPOINT = "https://x402mantlesdk.xyz/api/telemetry/settled";
+
+// src/server/telemetry.ts
+function createTelemetryEvent(entry, config) {
+  const assetConfig = getDefaultAssetForNetwork(entry.network);
+  return {
+    event: "payment_verified",
+    ts: entry.timestamp,
+    projectKey: config.projectKey,
+    network: entry.network,
+    buyer: entry.from,
+    payTo: entry.to,
+    amountAtomic: entry.valueAtomic,
+    asset: entry.asset,
+    decimals: assetConfig.decimals,
+    nonce: entry.id,
+    route: entry.route ?? "unknown",
+    // Facilitator metadata
+    facilitatorType: "hosted",
+    // SDK always uses hosted mode
+    facilitatorUrl: entry.facilitatorUrl,
+    // From PaymentLogEntry
+    // facilitatorAddress is undefined for SDK (not available)
+    // Optional metadata
+    txHash: entry.txHash,
+    priceUsd: entry.paymentRequirements?.price
+  };
+}
+async function sendTelemetry(event, endpoint) {
+  const targetEndpoint = endpoint ?? DEFAULT_TELEMETRY_ENDPOINT;
+  if (!targetEndpoint) {
+    return;
+  }
+  try {
+    const response = await fetch(targetEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${event.projectKey}`
+      },
+      body: JSON.stringify(event)
+    });
+    if (!response.ok) {
+      console.warn(
+        `[x402-telemetry] Failed to send event: HTTP ${response.status}`
+      );
+    }
+  } catch (err) {
+    console.error("[x402-telemetry] Error sending telemetry:", err);
+  }
+}
+
+// src/server/core/verifyPayment.ts
+async function checkPayment(input) {
+  const {
+    paymentHeader,
+    paymentRequirements,
+    facilitatorUrl,
+    apiKey,
+    routeKey,
+    network,
+    asset,
+    telemetry,
+    onPaymentSettled
+  } = input;
+  if (!paymentHeader || paymentHeader.trim() === "") {
+    return {
+      status: "require_payment",
+      statusCode: 402,
+      responseBody: {
+        error: "Payment Required",
+        paymentRequirements,
+        paymentHeader: null
+      },
+      isValid: false
+    };
+  }
+  try {
+    const verifyUrl = `${facilitatorUrl.replace(/\/+$/, "")}/verify`;
+    const verifyRes = await fetch(verifyUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...apiKey && { "Authorization": `Bearer ${apiKey}` }
+      },
+      body: JSON.stringify({
+        x402Version: 1,
+        paymentHeader,
+        paymentRequirements
+      })
+    });
+    if (!verifyRes.ok) {
+      const text = await verifyRes.text().catch(() => "");
+      console.error(
+        "[x402-mantle-sdk] Facilitator /verify returned non-OK:",
+        verifyRes.status,
+        text
+      );
+      return {
+        status: "verification_error",
+        statusCode: 500,
+        responseBody: {
+          error: "Payment verification error",
+          details: `Facilitator responded with HTTP ${verifyRes.status}`
+        },
+        isValid: false
+      };
+    }
+    const verifyJson = await verifyRes.json();
+    if (!verifyJson.isValid) {
+      return {
+        status: "invalid_payment",
+        statusCode: 402,
+        responseBody: {
+          error: "Payment verification failed",
+          invalidReason: verifyJson.invalidReason ?? null,
+          paymentRequirements,
+          paymentHeader: null
+        },
+        isValid: false
+      };
+    }
+    if (onPaymentSettled) {
+      try {
+        const headerObj = decodePaymentHeader(paymentHeader);
+        const { authorization } = headerObj.payload;
+        const assetConfig = getDefaultAssetForNetwork(network);
+        const logEntry = {
+          id: authorization.nonce,
+          from: authorization.from,
+          to: authorization.to,
+          valueAtomic: authorization.value,
+          network,
+          asset,
+          route: routeKey,
+          timestamp: Date.now(),
+          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)
+          );
+        }
+      } catch (err) {
+        console.error(
+          "[x402-mantle-sdk] Error calling onPaymentSettled hook:",
+          err
+        );
+      }
+    }
+    return {
+      status: "verified",
+      statusCode: 200,
+      responseBody: null,
+      isValid: true
+    };
+  } catch (err) {
+    console.error(
+      "[x402-mantle-sdk] Error while calling facilitator /verify:",
+      err
+    );
+    const message = err instanceof Error ? err.message : "Unknown verification error";
+    return {
+      status: "verification_error",
+      statusCode: 500,
+      responseBody: {
+        error: "Payment verification error",
+        details: message
+      },
+      isValid: false
+    };
+  }
+}
+
+export {
+  validateAddress,
+  decodePaymentHeader,
+  buildRouteKey,
+  DEFAULT_TELEMETRY_ENDPOINT,
+  createTelemetryEvent,
+  sendTelemetry,
+  checkPayment
+};

package/dist/chunk-T4DIHTBP.js

@@ -0,0 +1,83 @@
+import {
+  buildRouteKey,
+  checkPayment,
+  validateAddress
+} from "./chunk-IXIFGPJ2.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, apiKey, telemetry, onPaymentSettled } = opts;
+  validateAddress(payTo, "payTo");
+  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,
+        apiKey,
+        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"
+          }
+        });
+      }
+      try {
+        const response = await handler(request);
+        if (result.sendTelemetryAfterResponse) {
+          result.sendTelemetryAfterResponse(response.status);
+        }
+        return response;
+      } catch (err) {
+        const errorMessage = err instanceof Error ? err.message : "Unknown error";
+        if (result.sendTelemetryAfterResponse) {
+          result.sendTelemetryAfterResponse(500, errorMessage);
+        }
+        throw err;
+      }
+    };
+  };
+}
+
+export {
+  mantlePaywall,
+  web_standards_exports
+};

package/dist/chunk-T63MVWX3.js

@@ -0,0 +1,71 @@
+import {
+  buildRouteKey,
+  checkPayment,
+  validateAddress
+} from "./chunk-OW2BDRGZ.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, apiKey, telemetry, onPaymentSettled } = opts;
+  validateAddress(payTo, "payTo");
+  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,
+        apiKey,
+        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/express-D8L5Dg1D.d.ts

@@ -0,0 +1,68 @@
+import { Request, Response, NextFunction } from 'express';
+import { b as RoutesConfig, M as MinimalPaywallOptions } from './types-CXdNC0Ra.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/express-DqyVgO5n.d.cts

@@ -0,0 +1,68 @@
+import { Request, Response, NextFunction } from 'express';
+import { b as RoutesConfig, M as MinimalPaywallOptions } from './types-B87bD2yo.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 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/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/express-Pukmnwuu.d.cts

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