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

package/dist/chunk-26OQ36EN.js

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

package/dist/chunk-5TTSYEOF.js

@@ -0,0 +1,73 @@
+import {
+  buildRouteKey,
+  checkPayment,
+  validateAddress
+} from "./chunk-EKEVUVF3.js";
+import {
+  MANTLE_DEFAULTS,
+  __export,
+  getDefaultAssetForNetwork,
+  usdCentsToAtomic
+} from "./chunk-HEZZ74SI.js";
+
+// src/server/adapters/nextjs.ts
+var nextjs_exports = {};
+__export(nextjs_exports, {
+  isPaywallErrorResponse: () => isPaywallErrorResponse,
+  mantlePaywall: () => mantlePaywall
+});
+import { NextResponse } from "next/server";
+function mantlePaywall(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 NextResponse.json(result.responseBody, {
+          status: result.statusCode
+        });
+      }
+      return handler(req);
+    };
+  };
+}
+function isPaywallErrorResponse(response) {
+  return typeof response === "object" && response !== null && "error" in response && typeof response.error === "string";
+}
+
+export {
+  mantlePaywall,
+  isPaywallErrorResponse,
+  nextjs_exports
+};

package/dist/chunk-7SOCLVGM.js

@@ -0,0 +1,301 @@
+import {
+  __require,
+  getChainIdForNetwork
+} from "./chunk-HEZZ74SI.js";
+
+// src/shared/utils.ts
+function encodeJsonToBase64(value) {
+  const json = JSON.stringify(value);
+  if (typeof btoa === "function") {
+    const bytes = new TextEncoder().encode(json);
+    const binString = Array.from(
+      bytes,
+      (byte) => String.fromCodePoint(byte)
+    ).join("");
+    return btoa(binString);
+  }
+  if (typeof globalThis.Buffer !== "undefined") {
+    return globalThis.Buffer.from(json, "utf8").toString("base64");
+  }
+  throw new Error("No base64 implementation found in this environment");
+}
+function randomBytes32Hex() {
+  if (typeof crypto !== "undefined" && "getRandomValues" in crypto) {
+    const arr = new Uint8Array(32);
+    crypto.getRandomValues(arr);
+    return "0x" + Array.from(arr).map((b) => b.toString(16).padStart(2, "0")).join("");
+  }
+  try {
+    const nodeCrypto = __require("crypto");
+    const buf = nodeCrypto.randomBytes(32);
+    return "0x" + buf.toString("hex");
+  } catch {
+    throw new Error(
+      "No cryptographically secure random number generator found. This environment does not support crypto.getRandomValues or Node.js crypto module."
+    );
+  }
+}
+
+// src/client/paymentClient.ts
+function joinUrl(base, path) {
+  const normalizedBase = base.replace(/\/+$/, "");
+  const normalizedPath = path.startsWith("/") ? path : `/${path}`;
+  return `${normalizedBase}${normalizedPath}`;
+}
+function buildTypedDataForAuthorization(authorization, paymentRequirements) {
+  const chainId = getChainIdForNetwork(paymentRequirements.network);
+  const verifyingContract = paymentRequirements.asset;
+  const domain = {
+    name: "USD Coin",
+    version: "2",
+    chainId,
+    verifyingContract
+  };
+  const types = {
+    TransferWithAuthorization: [
+      { name: "from", type: "address" },
+      { name: "to", type: "address" },
+      { name: "value", type: "uint256" },
+      { name: "validAfter", type: "uint256" },
+      { name: "validBefore", type: "uint256" },
+      { name: "nonce", type: "bytes32" }
+    ]
+  };
+  return {
+    domain,
+    types,
+    primaryType: "TransferWithAuthorization",
+    message: authorization
+  };
+}
+async function signAuthorizationWithProvider(provider, authorization, paymentRequirements) {
+  const { BrowserProvider } = await import("ethers");
+  const chainId = getChainIdForNetwork(paymentRequirements.network);
+  const browserProvider = new BrowserProvider(provider, chainId);
+  const signer = await browserProvider.getSigner();
+  const from = await signer.getAddress();
+  const authWithFrom = {
+    ...authorization,
+    from
+  };
+  const typedData = buildTypedDataForAuthorization(
+    authWithFrom,
+    paymentRequirements
+  );
+  const signature = await signer.signTypedData(
+    typedData.domain,
+    typedData.types,
+    typedData.message
+  );
+  return { signature, from };
+}
+function createPaymentClient(config) {
+  const {
+    resourceUrl,
+    facilitatorUrl,
+    provider,
+    userAddress: userAddressOverride,
+    projectKey
+  } = config;
+  if (!resourceUrl) {
+    throw new Error("resourceUrl is required");
+  }
+  if (!facilitatorUrl) {
+    throw new Error("facilitatorUrl is required");
+  }
+  if (!provider) {
+    throw new Error("provider is required (e.g. window.ethereum)");
+  }
+  return {
+    async callWithPayment(path, options) {
+      const method = options?.method ?? "GET";
+      const headers = {
+        ...options?.headers ?? {}
+      };
+      let body;
+      if (options?.body !== void 0) {
+        headers["Content-Type"] = headers["Content-Type"] ?? "application/json";
+        body = JSON.stringify(options.body);
+      }
+      const initialUrl = joinUrl(resourceUrl, path);
+      const initialRes = await fetch(initialUrl, {
+        method,
+        headers,
+        body
+      });
+      if (initialRes.status !== 402) {
+        const json = await initialRes.json().catch((err) => {
+          console.error("[x402] Failed to parse initial response JSON:", err);
+          return null;
+        });
+        return {
+          response: json,
+          txHash: void 0
+        };
+      }
+      const bodyJson = await initialRes.json();
+      const paymentRequirements = bodyJson.paymentRequirements;
+      if (!paymentRequirements) {
+        throw new Error(
+          "402 response did not include paymentRequirements field"
+        );
+      }
+      const nowSec = Math.floor(Date.now() / 1e3);
+      const validAfter = "0";
+      const validBefore = String(nowSec + 10 * 60);
+      const nonce = randomBytes32Hex();
+      const valueAtomic = options?.valueOverrideAtomic ?? paymentRequirements.maxAmountRequired;
+      let authorization = {
+        from: "0x0000000000000000000000000000000000000000",
+        to: paymentRequirements.payTo,
+        value: valueAtomic,
+        validAfter,
+        validBefore,
+        nonce
+      };
+      let signature;
+      let from;
+      try {
+        const signed = await signAuthorizationWithProvider(
+          provider,
+          authorization,
+          paymentRequirements
+        );
+        signature = signed.signature;
+        from = signed.from;
+      } catch (err) {
+        const code = err?.code;
+        if (code === 4001 || code === "ACTION_REJECTED") {
+          const userErr = new Error("User rejected payment signature");
+          userErr.code = "USER_REJECTED_SIGNATURE";
+          userErr.userRejected = true;
+          throw userErr;
+        }
+        throw err;
+      }
+      authorization = {
+        ...authorization,
+        from
+      };
+      if (userAddressOverride && userAddressOverride.toLowerCase() !== from.toLowerCase()) {
+        console.warn(
+          "[SDK WARNING] userAddress override differs from signer address",
+          { override: userAddressOverride, signer: from }
+        );
+      }
+      const paymentHeaderObject = {
+        x402Version: 1,
+        scheme: paymentRequirements.scheme,
+        network: paymentRequirements.network,
+        payload: {
+          signature,
+          authorization
+        }
+      };
+      const paymentHeader = encodeJsonToBase64(paymentHeaderObject);
+      const settleUrl = joinUrl(facilitatorUrl, "/settle");
+      const settleRes = await fetch(settleUrl, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          ...projectKey ? { "X-Project-Key": projectKey } : {}
+        },
+        body: JSON.stringify({
+          x402Version: 1,
+          paymentHeader,
+          paymentRequirements
+        })
+      });
+      if (!settleRes.ok) {
+        const text = await settleRes.text().catch((err) => {
+          console.error("[x402] Failed to read settle response text:", err);
+          return "";
+        });
+        throw new Error(
+          `Facilitator /settle failed with HTTP ${settleRes.status}: ${text}`
+        );
+      }
+      const settleJson = await settleRes.json();
+      if (!settleJson.success) {
+        throw new Error(
+          `Facilitator /settle returned error: ${settleJson.error ?? "unknown error"}`
+        );
+      }
+      const txHash = settleJson.txHash ?? void 0;
+      const retryHeaders = {
+        ...headers,
+        "X-PAYMENT": paymentHeader
+      };
+      const retryRes = await fetch(initialUrl, {
+        method,
+        headers: retryHeaders,
+        body
+      });
+      if (!retryRes.ok) {
+        const text = await retryRes.text().catch((err) => {
+          console.error("[x402] Failed to read retry response text:", err);
+          return "";
+        });
+        throw new Error(
+          `Protected request with X-PAYMENT failed: HTTP ${retryRes.status} ${text}`
+        );
+      }
+      const finalJson = await retryRes.json();
+      return {
+        response: finalJson,
+        txHash,
+        paymentHeader,
+        paymentRequirements
+      };
+    }
+  };
+}
+
+// src/client/createMantleClient.ts
+function createMantleClient(config) {
+  const resourceUrl = config?.resourceUrl ?? (typeof window !== "undefined" ? window.location.origin : "");
+  const facilitatorUrl = config?.facilitatorUrl ?? (typeof process !== "undefined" ? process.env?.NEXT_PUBLIC_FACILITATOR_URL : void 0) ?? "http://localhost:8080";
+  return {
+    async postWithPayment(url, body) {
+      const provider = config?.getProvider?.();
+      if (!provider) {
+        throw new Error("Wallet provider not available");
+      }
+      let account = await config?.getAccount?.();
+      if (!account && provider?.request) {
+        try {
+          const accounts = await provider.request({
+            method: "eth_accounts"
+          });
+          if (Array.isArray(accounts) && accounts.length > 0) {
+            account = accounts[0];
+          }
+        } catch (err) {
+          console.warn("[x402] Failed to hydrate account from provider:", err);
+        }
+      }
+      if (!account) {
+        throw new Error(
+          "Wallet not connected. Please connect your wallet first."
+        );
+      }
+      const client = createPaymentClient({
+        resourceUrl,
+        facilitatorUrl,
+        provider,
+        userAddress: account,
+        projectKey: config?.projectKey
+      });
+      const result = await client.callWithPayment(url, {
+        method: "POST",
+        body
+      });
+      return result;
+    }
+  };
+}
+
+export {
+  createPaymentClient,
+  createMantleClient
+};

package/dist/chunk-EKEVUVF3.js

@@ -0,0 +1,237 @@
+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,
+    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"
+      },
+      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-F2OTZ3BB.js

@@ -0,0 +1,70 @@
+import {
+  buildRouteKey,
+  checkPayment,
+  validateAddress
+} from "./chunk-EKEVUVF3.js";
+import {
+  MANTLE_DEFAULTS,
+  __export,
+  getDefaultAssetForNetwork,
+  usdCentsToAtomic
+} from "./chunk-HEZZ74SI.js";
+
+// src/server/adapters/web-standards.ts
+var web_standards_exports = {};
+__export(web_standards_exports, {
+  mantlePaywall: () => mantlePaywall
+});
+function mantlePaywall(opts) {
+  const { priceUsd, payTo, facilitatorUrl, telemetry, onPaymentSettled } = opts;
+  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);
+    };
+  };
+}
+
+export {
+  mantlePaywall,
+  web_standards_exports
+};

package/dist/chunk-MBJTUNDL.js

@@ -0,0 +1,99 @@
+import {
+  buildRouteKey,
+  checkPayment,
+  validateAddress
+} from "./chunk-EKEVUVF3.js";
+import {
+  MANTLE_DEFAULTS,
+  __export,
+  getDefaultAssetForNetwork,
+  usdCentsToAtomic
+} from "./chunk-HEZZ74SI.js";
+
+// 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) {
+    throw new Error("facilitatorUrl is required");
+  }
+  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 = buildRouteKey(req.method, req.path);
+    const routeConfig = routes[routeKey];
+    if (!routeConfig) {
+      next();
+      return;
+    }
+    const { priceUsdCents, network } = routeConfig;
+    const assetConfig = getDefaultAssetForNetwork(network);
+    const maxAmountRequiredBigInt = usdCentsToAtomic(
+      priceUsdCents,
+      assetConfig.decimals
+    );
+    const paymentRequirements = {
+      scheme: "exact",
+      network,
+      asset: assetConfig.address,
+      maxAmountRequired: maxAmountRequiredBigInt.toString(),
+      payTo: receiverAddress,
+      price: `$${(priceUsdCents / 100).toFixed(2)}`,
+      currency: "USD"
+    };
+    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();
+  };
+}
+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();
+    const path = req.path || "/";
+    const routeKey = `${method} ${path}`;
+    const middleware = createPaymentMiddleware({
+      facilitatorUrl: facilitatorUrl || MANTLE_DEFAULTS.FACILITATOR_URL,
+      receiverAddress: payTo,
+      routes: {
+        [routeKey]: {
+          priceUsdCents,
+          network: MANTLE_DEFAULTS.NETWORK
+        }
+      },
+      telemetry,
+      onPaymentSettled
+    });
+    return middleware(req, res, next);
+  };
+}
+
+export {
+  createPaymentMiddleware,
+  mantlePaywall,
+  express_exports
+};

package/dist/client.cjs

@@ -206,11 +206,26 @@ function createPaymentClient(config) {
         validBefore,
         nonce
       };
-      const { signature, from } = await signAuthorizationWithProvider(
-        provider,
-        authorization,
-        paymentRequirements
-      );
+      let signature;
+      let from;
+      try {
+        const signed = await signAuthorizationWithProvider(
+          provider,
+          authorization,
+          paymentRequirements
+        );
+        signature = signed.signature;
+        from = signed.from;
+      } catch (err) {
+        const code = err?.code;
+        if (code === 4001 || code === "ACTION_REJECTED") {
+          const userErr = new Error("User rejected payment signature");
+          userErr.code = "USER_REJECTED_SIGNATURE";
+          userErr.userRejected = true;
+          throw userErr;
+        }
+        throw err;
+      }
       authorization = {
         ...authorization,
         from

package/dist/client.js

@@ -1,7 +1,7 @@
 import {
   createMantleClient,
   createPaymentClient
-} from "./chunk-VNO4LJWC.js";
+} from "./chunk-7SOCLVGM.js";
 import {
   MANTLE_DEFAULTS
 } from "./chunk-HEZZ74SI.js";

package/dist/index.cjs

@@ -131,7 +131,7 @@ function buildRouteKey(method, path) {
 }
 
 // src/server/constants.ts
-var DEFAULT_TELEMETRY_ENDPOINT = void 0;
+var DEFAULT_TELEMETRY_ENDPOINT = "https://x402mantlesdk.xyz/api/telemetry/settled";
 
 // src/server/telemetry.ts
 function createTelemetryEvent(entry, config) {
@@ -533,11 +533,26 @@ function createPaymentClient(config) {
         validBefore,
         nonce
       };
-      const { signature, from } = await signAuthorizationWithProvider(
-        provider,
-        authorization,
-        paymentRequirements
-      );
+      let signature;
+      let from;
+      try {
+        const signed = await signAuthorizationWithProvider(
+          provider,
+          authorization,
+          paymentRequirements
+        );
+        signature = signed.signature;
+        from = signed.from;
+      } catch (err) {
+        const code = err?.code;
+        if (code === 4001 || code === "ACTION_REJECTED") {
+          const userErr = new Error("User rejected payment signature");
+          userErr.code = "USER_REJECTED_SIGNATURE";
+          userErr.userRejected = true;
+          throw userErr;
+        }
+        throw err;
+      }
       authorization = {
         ...authorization,
         from

package/dist/index.js

@@ -1,17 +1,17 @@
 import {
   useEthersWallet,
   useMantleX402
-} from "./chunk-APBCF3SX.js";
+} from "./chunk-26OQ36EN.js";
 import {
   createMantleClient,
   createPaymentClient
-} from "./chunk-VNO4LJWC.js";
+} from "./chunk-7SOCLVGM.js";
 import "./chunk-WO2MYZXT.js";
 import {
   createPaymentMiddleware,
   mantlePaywall
-} from "./chunk-QWQUSRLY.js";
-import "./chunk-ZLCKBFVJ.js";
+} from "./chunk-MBJTUNDL.js";
+import "./chunk-EKEVUVF3.js";
 import {
   MANTLE_DEFAULTS
 } from "./chunk-HEZZ74SI.js";

package/dist/react.cjs

@@ -353,11 +353,26 @@ function createPaymentClient(config) {
         validBefore,
         nonce
       };
-      const { signature, from } = await signAuthorizationWithProvider(
-        provider,
-        authorization,
-        paymentRequirements
-      );
+      let signature;
+      let from;
+      try {
+        const signed = await signAuthorizationWithProvider(
+          provider,
+          authorization,
+          paymentRequirements
+        );
+        signature = signed.signature;
+        from = signed.from;
+      } catch (err) {
+        const code = err?.code;
+        if (code === 4001 || code === "ACTION_REJECTED") {
+          const userErr = new Error("User rejected payment signature");
+          userErr.code = "USER_REJECTED_SIGNATURE";
+          userErr.userRejected = true;
+          throw userErr;
+        }
+        throw err;
+      }
       authorization = {
         ...authorization,
         from

package/dist/react.js

@@ -1,8 +1,8 @@
 import {
   useEthersWallet,
   useMantleX402
-} from "./chunk-APBCF3SX.js";
-import "./chunk-VNO4LJWC.js";
+} from "./chunk-26OQ36EN.js";
+import "./chunk-7SOCLVGM.js";
 import "./chunk-HEZZ74SI.js";
 export {
   useEthersWallet,

package/dist/server-express.cjs

@@ -109,7 +109,7 @@ function usdCentsToAtomic(cents, decimals) {
 }
 
 // src/server/constants.ts
-var DEFAULT_TELEMETRY_ENDPOINT = void 0;
+var DEFAULT_TELEMETRY_ENDPOINT = "https://x402mantlesdk.xyz/api/telemetry/settled";
 
 // src/server/telemetry.ts
 function createTelemetryEvent(entry, config) {

package/dist/server-express.js

@@ -1,8 +1,8 @@
 import {
   createPaymentMiddleware,
   mantlePaywall
-} from "./chunk-QWQUSRLY.js";
-import "./chunk-ZLCKBFVJ.js";
+} from "./chunk-MBJTUNDL.js";
+import "./chunk-EKEVUVF3.js";
 import {
   MANTLE_DEFAULTS
 } from "./chunk-HEZZ74SI.js";

package/dist/server-nextjs.cjs

@@ -112,7 +112,7 @@ function usdCentsToAtomic(cents, decimals) {
 }
 
 // src/server/constants.ts
-var DEFAULT_TELEMETRY_ENDPOINT = void 0;
+var DEFAULT_TELEMETRY_ENDPOINT = "https://x402mantlesdk.xyz/api/telemetry/settled";
 
 // src/server/telemetry.ts
 function createTelemetryEvent(entry, config) {

package/dist/server-nextjs.js

@@ -1,8 +1,8 @@
 import {
   isPaywallErrorResponse,
   mantlePaywall
-} from "./chunk-IT6VV6YL.js";
-import "./chunk-ZLCKBFVJ.js";
+} from "./chunk-5TTSYEOF.js";
+import "./chunk-EKEVUVF3.js";
 import {
   MANTLE_DEFAULTS
 } from "./chunk-HEZZ74SI.js";

package/dist/server-web.cjs

@@ -108,7 +108,7 @@ function usdCentsToAtomic(cents, decimals) {
 }
 
 // src/server/constants.ts
-var DEFAULT_TELEMETRY_ENDPOINT = void 0;
+var DEFAULT_TELEMETRY_ENDPOINT = "https://x402mantlesdk.xyz/api/telemetry/settled";
 
 // src/server/telemetry.ts
 function createTelemetryEvent(entry, config) {

package/dist/server-web.js

@@ -1,7 +1,7 @@
 import {
   mantlePaywall
-} from "./chunk-ZROK2XOB.js";
-import "./chunk-ZLCKBFVJ.js";
+} from "./chunk-F2OTZ3BB.js";
+import "./chunk-EKEVUVF3.js";
 import {
   MANTLE_DEFAULTS
 } from "./chunk-HEZZ74SI.js";

package/dist/server.cjs

@@ -118,7 +118,7 @@ function usdCentsToAtomic(cents, decimals) {
 }
 
 // src/server/constants.ts
-var DEFAULT_TELEMETRY_ENDPOINT = void 0;
+var DEFAULT_TELEMETRY_ENDPOINT = "https://x402mantlesdk.xyz/api/telemetry/settled";
 
 // src/server/telemetry.ts
 function createTelemetryEvent(entry, config) {

package/dist/server.js

@@ -3,13 +3,13 @@ import {
   createPaymentMiddleware,
   express_exports,
   mantlePaywall
-} from "./chunk-QWQUSRLY.js";
+} from "./chunk-MBJTUNDL.js";
 import {
   nextjs_exports
-} from "./chunk-IT6VV6YL.js";
+} from "./chunk-5TTSYEOF.js";
 import {
   web_standards_exports
-} from "./chunk-ZROK2XOB.js";
+} from "./chunk-F2OTZ3BB.js";
 import {
   DEFAULT_TELEMETRY_ENDPOINT,
   buildRouteKey,
@@ -18,7 +18,7 @@ import {
   decodePaymentHeader,
   sendTelemetry,
   validateAddress
-} from "./chunk-ZLCKBFVJ.js";
+} from "./chunk-EKEVUVF3.js";
 import "./chunk-HEZZ74SI.js";
 export {
   DEFAULT_TELEMETRY_ENDPOINT,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@puga-labs/x402-mantle-sdk",
-  "version": "0.3.6",
+  "version": "0.3.7",
   "description": "x402 payments SDK for Mantle (USDC, gasless, facilitator-based)",
   "license": "MIT",
   "author": "Evgenii Pugachev <cyprus.pugamuga@gmail.com>",