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

package/dist/server-web.d.ts

@@ -0,0 +1,4 @@
+export { W as WebHandler, a as WebPaywallWrapper, m as mantlePaywall } from './web-standards-D8j1kZxd.js';
+export { M as MinimalPaywallOptions, c as PaymentCheckInput, d as PaymentCheckResult, P as PaymentLogEntry, R as RouteKey, a as RoutePricingConfig, b as RoutesConfig, T as TelemetryConfig } from './types-CqQ6OgRi.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';

package/dist/server-web.js

@@ -0,0 +1,11 @@
+import {
+  mantlePaywall
+} from "./chunk-ZROK2XOB.js";
+import "./chunk-ZLCKBFVJ.js";
+import {
+  MANTLE_DEFAULTS
+} from "./chunk-HEZZ74SI.js";
+export {
+  MANTLE_DEFAULTS,
+  mantlePaywall
+};

package/dist/server.cjs

@@ -20,12 +20,69 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/server.ts
 var server_exports = {};
 __export(server_exports, {
-  MANTLE_DEFAULTS: () => MANTLE_DEFAULTS,
+  DEFAULT_TELEMETRY_ENDPOINT: () => DEFAULT_TELEMETRY_ENDPOINT,
+  buildRouteKey: () => buildRouteKey,
+  checkPayment: () => checkPayment,
   createPaymentMiddleware: () => createPaymentMiddleware,
-  mantlePaywall: () => mantlePaywall
+  createTelemetryEvent: () => createTelemetryEvent,
+  decodePaymentHeader: () => decodePaymentHeader,
+  express: () => express_exports,
+  mantlePaywall: () => mantlePaywall,
+  nextjs: () => nextjs_exports,
+  sendTelemetry: () => sendTelemetry,
+  validateAddress: () => validateAddress,
+  web: () => web_standards_exports
 });
 module.exports = __toCommonJS(server_exports);
 
+// 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/shared/constants.ts
 var MANTLE_MAINNET_NETWORK_ID = "mantle-mainnet";
 var MANTLE_MAINNET_USDC = {
@@ -113,28 +170,135 @@ async function sendTelemetry(event, endpoint) {
   }
 }
 
-// src/server/paymentMiddleware.ts
-function getRouteKey(req) {
-  const method = (req.method || "GET").toUpperCase();
-  const path = req.path || "/";
-  return `${method} ${path}`;
-}
-function decodePaymentHeader(paymentHeaderBase64) {
+// src/server/core/verifyPayment.ts
+async function checkPayment(input) {
+  const {
+    paymentHeader,
+    paymentRequirements,
+    facilitatorUrl,
+    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 {
-    if (typeof Buffer !== "undefined") {
-      const json = Buffer.from(paymentHeaderBase64, "base64").toString("utf8");
-      return JSON.parse(json);
+    const verifyUrl = `${facilitatorUrl.replace(/\/+$/, "")}/verify`;
+    const verifyRes = await fetch(verifyUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      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
+      };
     }
-    if (typeof atob === "function") {
-      const json = atob(paymentHeaderBase64);
-      return JSON.parse(json);
+    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
+      };
     }
-    throw new Error("No base64 decoding available in this environment");
+    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) {
-    const msg = err instanceof Error ? err.message : "Unknown error";
-    throw new Error(`Failed to decode paymentHeader: ${msg}`);
+    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
+    };
   }
 }
+
+// src/server/adapters/express.ts
+var express_exports = {};
+__export(express_exports, {
+  createPaymentMiddleware: () => createPaymentMiddleware,
+  mantlePaywall: () => mantlePaywall
+});
 function createPaymentMiddleware(config) {
   const { facilitatorUrl, receiverAddress, routes, onPaymentSettled, telemetry } = config;
   if (!facilitatorUrl) {
@@ -143,11 +307,12 @@ function createPaymentMiddleware(config) {
   if (!receiverAddress) {
     throw new Error("receiverAddress is required");
   }
+  validateAddress(receiverAddress, "receiverAddress");
   if (!routes || Object.keys(routes).length === 0) {
     throw new Error("routes config must not be empty");
   }
   return async function paymentMiddleware(req, res, next) {
-    const routeKey = getRouteKey(req);
+    const routeKey = buildRouteKey(req.method, req.path);
     const routeConfig = routes[routeKey];
     if (!routeConfig) {
       next();
@@ -168,102 +333,27 @@ function createPaymentMiddleware(config) {
       price: `$${(priceUsdCents / 100).toFixed(2)}`,
       currency: "USD"
     };
-    const paymentHeader = req.header("X-PAYMENT") ?? req.header("x-payment");
-    if (!paymentHeader) {
-      res.status(402).json({
-        error: "Payment Required",
-        paymentRequirements,
-        paymentHeader: null
-      });
-      return;
-    }
-    try {
-      const verifyUrl = `${facilitatorUrl.replace(/\/+$/, "")}/verify`;
-      const verifyRes = await fetch(verifyUrl, {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json"
-        },
-        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
-        );
-        res.status(500).json({
-          error: "Payment verification error",
-          details: `Facilitator responded with HTTP ${verifyRes.status}`
-        });
-        return;
-      }
-      const verifyJson = await verifyRes.json();
-      if (!verifyJson.isValid) {
-        res.status(402).json({
-          error: "Payment verification failed",
-          invalidReason: verifyJson.invalidReason ?? null,
-          paymentRequirements,
-          paymentHeader: null
-        });
-        return;
-      }
-      if (onPaymentSettled) {
-        try {
-          const headerObj = decodePaymentHeader(paymentHeader);
-          const { authorization } = headerObj.payload;
-          const logEntry = {
-            id: authorization.nonce,
-            from: authorization.from,
-            to: authorization.to,
-            valueAtomic: authorization.value,
-            network,
-            asset: assetConfig.address,
-            route: routeKey,
-            timestamp: Date.now(),
-            facilitatorUrl,
-            // Pass from config closure
-            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
-          );
-        }
-      }
-      next();
-      return;
-    } catch (err) {
-      console.error(
-        "[x402-mantle-sdk] Error while calling facilitator /verify:",
-        err
-      );
-      const message = err instanceof Error ? err.message : "Unknown verification error";
-      res.status(500).json({
-        error: "Payment verification error",
-        details: message
-      });
+    const paymentHeader = req.header("X-PAYMENT") || req.header("x-payment") || null;
+    const result = await checkPayment({
+      paymentHeader,
+      paymentRequirements,
+      facilitatorUrl,
+      routeKey,
+      network,
+      asset: assetConfig.address,
+      telemetry,
+      onPaymentSettled
+    });
+    if (!result.isValid) {
+      res.status(result.statusCode).json(result.responseBody);
       return;
     }
+    next();
   };
 }
-
-// src/server/mantlePaywall.ts
 function mantlePaywall(opts) {
   const { priceUsd, payTo, facilitatorUrl, telemetry, onPaymentSettled } = opts;
+  validateAddress(payTo, "payTo");
   const priceUsdCents = Math.round(priceUsd * 100);
   return async (req, res, next) => {
     const method = (req.method || "GET").toUpperCase();
@@ -284,9 +374,124 @@ function mantlePaywall(opts) {
     return middleware(req, res, next);
   };
 }
+
+// src/server/adapters/nextjs.ts
+var nextjs_exports = {};
+__export(nextjs_exports, {
+  mantlePaywall: () => mantlePaywall2
+});
+var import_server = require("next/server");
+function mantlePaywall2(opts) {
+  const { priceUsd, payTo, facilitatorUrl, telemetry, onPaymentSettled } = opts;
+  validateAddress(payTo, "payTo");
+  const priceUsdCents = Math.round(priceUsd * 100);
+  return function(handler) {
+    return async (req) => {
+      const url = new URL(req.url);
+      const method = req.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 = req.headers.get("X-PAYMENT") || req.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 import_server.NextResponse.json(result.responseBody, {
+          status: result.statusCode
+        });
+      }
+      return handler(req);
+    };
+  };
+}
+
+// src/server/adapters/web-standards.ts
+var web_standards_exports = {};
+__export(web_standards_exports, {
+  mantlePaywall: () => mantlePaywall3
+});
+function mantlePaywall3(opts) {
+  const { priceUsd, payTo, facilitatorUrl, 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,
+        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);
+    };
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  MANTLE_DEFAULTS,
+  DEFAULT_TELEMETRY_ENDPOINT,
+  buildRouteKey,
+  checkPayment,
   createPaymentMiddleware,
-  mantlePaywall
+  createTelemetryEvent,
+  decodePaymentHeader,
+  express,
+  mantlePaywall,
+  nextjs,
+  sendTelemetry,
+  validateAddress,
+  web
 });

package/dist/server.d.cts

@@ -1,116 +1,79 @@
-import { Request, Response, NextFunction } from 'express';
-import { N as NetworkId, P as PaymentRequirements } from './types-2zqbJvcz.cjs';
-export { A as AssetConfig, a as Authorization, E as EIP1193Provider, d as PaymentHeaderBase64, c as PaymentHeaderObject, b as PaymentHeaderPayload } from './types-2zqbJvcz.cjs';
-export { M as MANTLE_DEFAULTS } from './constants-DzCGK0Q3.cjs';
+import { c as PaymentCheckInput, d as PaymentCheckResult } from './types-CrOsOHcX.cjs';
+export { M as MinimalPaywallOptions, P as PaymentLogEntry, R as RouteKey, a as RoutePricingConfig, b as RoutesConfig, T as TelemetryConfig } from './types-CrOsOHcX.cjs';
+import { c as PaymentHeaderObject } from './types-BFUqKBBO.cjs';
+export { M as MantleMiddleware, c as createPaymentMiddleware, e as express, m as mantlePaywall } from './express-eQOPxfnI.cjs';
+export { n as nextjs } from './nextjs-Duecps0q.cjs';
+export { w as web } from './web-standards-BNQyWzBC.cjs';
+import { P as PaymentLogEntry, T as TelemetryConfig, c as TelemetryEvent } from './types-CoOdbZSp.cjs';
+import 'express';
+import 'next/server';
 
-/** Unique key for a protected route, e.g. "GET /api/protected". */
-type RouteKey = string;
-/** Pricing config for a single route. */
-interface RoutePricingConfig {
-    /** Price in USD cents, e.g. 1 => $0.01. */
-    priceUsdCents: number;
-    /** Network identifier (e.g. "mantle-mainnet"). */
-    network: NetworkId;
-}
-/** Map of route keys to pricing config. */
-type RoutesConfig = Record<RouteKey, RoutePricingConfig>;
-/** Log entry for a successfully settled payment. */
-interface PaymentLogEntry {
-    id: string;
-    from: string;
-    to: string;
-    valueAtomic: string;
-    network: NetworkId;
-    asset: string;
-    route?: RouteKey;
-    txHash?: string;
-    timestamp: number;
-    facilitatorUrl?: string;
-    paymentRequirements?: PaymentRequirements;
-}
-/** Config for optional telemetry (billing/analytics). */
-interface TelemetryConfig {
-    /** Project key from nosubs.ai dashboard. */
-    projectKey: string;
-    /**
-     * Telemetry endpoint URL.
-     * If not specified, uses DEFAULT_TELEMETRY_ENDPOINT (see server/constants.ts).
-     * If both are undefined, telemetry is not sent.
-     */
-    endpoint?: string;
-}
-/** Telemetry event payload for payment_verified. */
-interface TelemetryEvent {
-    event: "payment_verified";
-    ts: number;
-    projectKey: string;
-    network: string;
-    buyer: string;
-    payTo: string;
-    amountAtomic: string;
-    asset: string;
-    decimals: number;
-    nonce: string;
-    route: string;
-    facilitatorType: "hosted" | "self-hosted";
-    facilitatorUrl?: string;
-    facilitatorAddress?: string;
-    txHash?: string;
-    priceUsd?: string;
-}
-/** 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.
-     * You can use this to push logs into your DB / analytics pipeline.
-     */
-    onPaymentSettled?: (entry: PaymentLogEntry) => void;
-    /** Optional: Send usage telemetry for billing/analytics. */
-    telemetry?: TelemetryConfig;
-}
 /**
- * Minimal config for mantlePaywall() - simplified API for single-route protection.
- * This is the "sweet path" for Mantle mainnet + USDC with sensible defaults.
+ * Validate Ethereum address format.
+ * Throws descriptive error if invalid.
+ *
+ * @param address - Address to validate
+ * @param paramName - Parameter name for error messages (default: "address")
+ * @throws Error if address is invalid
+ *
+ * @example
+ * ```typescript
+ * validateAddress("0x1234567890123456789012345678901234567890", "payTo");
+ * // Valid - no error thrown
+ *
+ * validateAddress("invalid", "payTo");
+ * // Throws: "payTo must start with \"0x\"..."
+ * ```
  */
-interface MinimalPaywallOptions {
-    /** Price in USD (e.g. 0.01 for 1 cent). */
-    priceUsd: number;
-    /** Recipient address (developer wallet). */
-    payTo: `0x${string}`;
-    /** Optional facilitator URL (defaults to localhost:8080 or NEXT_PUBLIC_FACILITATOR_URL). */
-    facilitatorUrl?: string;
-    /** Optional telemetry config. */
-    telemetry?: TelemetryConfig;
-    /** Optional payment settled hook. */
-    onPaymentSettled?: (entry: PaymentLogEntry) => void;
-}
+declare function validateAddress(address: string, paramName?: string): void;
 /**
- * Express middleware function type for Mantle paywall.
- * Async function that returns Promise<void>.
+ * Decode base64 payment header into JSON object.
+ * Works in both Node.js and browser environments.
  */
-type MantleMiddleware = (req: Request, res: Response, next: NextFunction) => Promise<void>;
+declare function decodePaymentHeader(paymentHeaderBase64: string): PaymentHeaderObject;
+/**
+ * Build a route key from HTTP method and path.
+ * @param method - HTTP method (GET, POST, etc.)
+ * @param path - URL path (e.g. "/api/protected")
+ * @returns Route key string (e.g. "POST /api/protected")
+ */
+declare function buildRouteKey(method: string, path: string): string;
 
-declare function createPaymentMiddleware(config: PaymentMiddlewareConfig): (req: Request, res: Response, next: NextFunction) => Promise<void>;
+/**
+ * Check payment header and verify with facilitator.
+ * This function is framework-agnostic and can be used with any HTTP framework.
+ *
+ * @param input - Payment check configuration
+ * @returns Result indicating whether to allow access or return error response
+ */
+declare function checkPayment(input: PaymentCheckInput): Promise<PaymentCheckResult>;
 
 /**
- * Simplified wrapper for protecting a single route with x402 payments.
- * Uses Mantle mainnet defaults (USDC, exact scheme, etc.).
+ * Default telemetry endpoint URL.
  *
- * Usage:
- * ```typescript
- * const pay = mantlePaywall({ priceUsd: 0.01, payTo: "0x..." });
- * export const POST = pay(async (req) => { ... });
- * ```
+ * Set to a valid URL when the official analytics backend is ready.
+ * If undefined, telemetry will only be sent if explicitly configured
+ * via TelemetryConfig.endpoint.
+ */
+declare const DEFAULT_TELEMETRY_ENDPOINT: string | undefined;
+
+/**
+ * Converts PaymentLogEntry to TelemetryEvent.
+ *
+ * This function transforms the internal PaymentLogEntry format
+ * to the telemetry event format expected by the analytics backend.
+ */
+declare function createTelemetryEvent(entry: PaymentLogEntry, config: TelemetryConfig): TelemetryEvent;
+/**
+ * Sends telemetry event to endpoint (fire-and-forget).
+ *
+ * This function sends the telemetry event asynchronously and never throws.
+ * Errors are logged but never propagate to the caller, ensuring that
+ * telemetry failures never break the payment flow.
  *
- * @param opts - Minimal configuration (price, payTo, optional facilitator/telemetry).
- * @returns Express middleware function for single-route protection.
+ * @param event - The telemetry event to send
+ * @param endpoint - The telemetry endpoint URL (optional, falls back to DEFAULT_TELEMETRY_ENDPOINT)
  */
-declare function mantlePaywall(opts: MinimalPaywallOptions): MantleMiddleware;
+declare function sendTelemetry(event: TelemetryEvent, endpoint?: string): Promise<void>;
 
-export { type MantleMiddleware, type MinimalPaywallOptions, NetworkId, type PaymentLogEntry, type PaymentMiddlewareConfig, PaymentRequirements, type RouteKey, type RoutePricingConfig, type RoutesConfig, type TelemetryConfig, type TelemetryEvent, createPaymentMiddleware, mantlePaywall };
+export { DEFAULT_TELEMETRY_ENDPOINT, PaymentCheckInput, PaymentCheckResult, buildRouteKey, checkPayment, createTelemetryEvent, decodePaymentHeader, sendTelemetry, validateAddress };