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

package/dist/index.js

@@ -1,575 +1,26 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// src/shared/constants.ts
-var MANTLE_MAINNET_NETWORK_ID = "mantle-mainnet";
-var MANTLE_MAINNET_CHAIN_ID = 5e3;
-var MANTLE_MAINNET_USDC = {
-  symbol: "USDC",
-  address: "0x09Bc4E0D864854c6aFB6eB9A9cdF58aC190D0dF9",
-  decimals: 6
-};
-var MANTLE_DEFAULTS = {
-  NETWORK: "mantle-mainnet",
-  CHAIN_ID: 5e3,
-  USDC_ADDRESS: "0x09Bc4E0D864854c6aFB6eB9A9cdF58aC190D0dF9",
-  USDC_DECIMALS: 6,
-  CURRENCY: "USD",
-  SCHEME: "exact",
-  FACILITATOR_URL: (typeof process !== "undefined" ? process.env?.NEXT_PUBLIC_FACILITATOR_URL : void 0) || "http://localhost:8080"
-};
-function getDefaultAssetForNetwork(network) {
-  switch (network) {
-    case MANTLE_MAINNET_NETWORK_ID:
-    default:
-      return MANTLE_MAINNET_USDC;
-  }
-}
-function getChainIdForNetwork(network) {
-  switch (network) {
-    case MANTLE_MAINNET_NETWORK_ID:
-    default:
-      return MANTLE_MAINNET_CHAIN_ID;
-  }
-}
-function usdCentsToAtomic(cents, decimals) {
-  if (cents < 0) {
-    throw new Error("priceUsdCents must be non-negative");
-  }
-  if (decimals < 2) {
-    throw new Error("token decimals must be >= 2 for USD cent conversion");
-  }
-  const base = BigInt(10) ** BigInt(decimals - 2);
-  return BigInt(cents) * base;
-}
-
-// src/server/constants.ts
-var DEFAULT_TELEMETRY_ENDPOINT = void 0;
-
-// 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/paymentMiddleware.ts
-function getRouteKey(req) {
-  const method = (req.method || "GET").toUpperCase();
-  const path = req.path || "/";
-  return `${method} ${path}`;
-}
-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 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");
-  }
-  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 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");
-    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
-      });
-      return;
-    }
-  };
-}
-
-// src/server/mantlePaywall.ts
-function mantlePaywall(opts) {
-  const { priceUsd, payTo, facilitatorUrl, telemetry, onPaymentSettled } = opts;
-  const priceUsdCents = Math.round(priceUsd * 100);
-  return (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);
-  };
-}
-
-// 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}`;
-}
-async function getUserAddressFromProvider(provider) {
-  const p = provider;
-  if (!p || typeof p.request !== "function") {
-    throw new Error("provider must implement EIP-1193 request()");
-  }
-  const accounts = await p.request({
-    method: "eth_requestAccounts"
-  });
-  if (!accounts || accounts.length === 0) {
-    throw new Error("No accounts returned from provider");
-  }
-  return accounts[0];
-}
-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, address, authorization, paymentRequirements) {
-  const p = provider;
-  if (!p || typeof p.request !== "function") {
-    throw new Error("provider must implement EIP-1193 request()");
-  }
-  const typedData = buildTypedDataForAuthorization(
-    authorization,
-    paymentRequirements
-  );
-  const params = [address, JSON.stringify(typedData)];
-  const signature = await p.request({
-    method: "eth_signTypedData_v4",
-    params
-  });
-  if (typeof signature !== "string" || !signature.startsWith("0x")) {
-    throw new Error("Invalid signature returned from provider");
-  }
-  return signature;
-}
-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,
-          paymentHeader: "",
-          paymentRequirements: {
-            scheme: "exact",
-            network: "mantle-mainnet",
-            asset: "",
-            maxAmountRequired: "0",
-            payTo: ""
-          },
-          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 fromAddress = userAddressOverride ?? await getUserAddressFromProvider(provider);
-      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;
-      const authorization = {
-        from: fromAddress,
-        to: paymentRequirements.payTo,
-        value: valueAtomic,
-        validAfter,
-        validBefore,
-        nonce
-      };
-      const signature = await signAuthorizationWithProvider(
-        provider,
-        fromAddress,
-        authorization,
-        paymentRequirements
-      );
-      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 post(url, body) {
-      const account = await config?.getAccount?.();
-      if (!account) {
-        throw new Error(
-          "Wallet not connected. Please connect your wallet first."
-        );
-      }
-      const provider = config?.getProvider?.();
-      if (!provider) {
-        throw new Error("Wallet provider not available");
-      }
-      const client = createPaymentClient({
-        resourceUrl,
-        facilitatorUrl,
-        provider,
-        userAddress: account,
-        projectKey: config?.projectKey
-      });
-      const result = await client.callWithPayment(url, {
-        method: "POST",
-        body
-      });
-      return result.response;
-    }
-  };
-}
-
-// src/client/react/useMantleX402.ts
-import { useAccount, useWalletClient } from "wagmi";
-function useMantleX402(opts) {
-  const { address, isConnected } = useAccount();
-  const { data: walletClient } = useWalletClient();
-  const client = createMantleClient({
-    facilitatorUrl: opts?.facilitatorUrl,
-    resourceUrl: opts?.resourceUrl,
-    projectKey: opts?.projectKey,
-    getAccount: () => {
-      if (!isConnected || !address) return void 0;
-      return address;
-    },
-    getProvider: () => walletClient
-  });
-  return client;
-}
+import {
+  useEthersWallet,
+  useMantleX402
+} from "./chunk-23QNUJIB.js";
+import {
+  createMantleClient,
+  createPaymentClient
+} from "./chunk-E46A7I6B.js";
+import "./chunk-WO2MYZXT.js";
+import {
+  createPaymentMiddleware,
+  mantlePaywall
+} from "./chunk-PPVS3X5Z.js";
+import "./chunk-U73CZU3X.js";
+import {
+  MANTLE_DEFAULTS
+} from "./chunk-HEZZ74SI.js";
 export {
   MANTLE_DEFAULTS,
   createMantleClient,
   createPaymentClient,
   createPaymentMiddleware,
   mantlePaywall,
+  useEthersWallet,
   useMantleX402
 };

package/dist/nextjs-Bp8DxYDN.d.ts

@@ -0,0 +1,45 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { M as MinimalPaywallOptions } from './types-CqQ6OgRi.js';
+
+/**
+ * Next.js App Router route handler type.
+ */
+type NextJSHandler<T = any> = (req: NextRequest) => Promise<NextResponse<T>>;
+/**
+ * Wrapper function that adds x402 payment verification to Next.js route handler.
+ */
+type NextJSPaywallWrapper = <T>(handler: NextJSHandler<T>) => NextJSHandler<T>;
+/**
+ * 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 as `0x${string}`,
+ * });
+ *
+ * export const POST = pay(async (req: NextRequest) => {
+ *   const { prompt } = await req.json();
+ *   // Your handler code here
+ *   return NextResponse.json({ success: true });
+ * });
+ * ```
+ *
+ * @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 nextjs_NextJSHandler<T = any> = NextJSHandler<T>;
+type nextjs_NextJSPaywallWrapper = NextJSPaywallWrapper;
+declare const nextjs_mantlePaywall: typeof mantlePaywall;
+declare namespace nextjs {
+  export { type nextjs_NextJSHandler as NextJSHandler, type nextjs_NextJSPaywallWrapper as NextJSPaywallWrapper, nextjs_mantlePaywall as mantlePaywall };
+}
+
+export { type NextJSHandler as N, type NextJSPaywallWrapper as a, mantlePaywall as m, nextjs as n };

package/dist/nextjs-CliiaTPe.d.cts

@@ -0,0 +1,45 @@
+import { NextRequest, NextResponse } from 'next/server';
+import { M as MinimalPaywallOptions } from './types-xkNm0uzE.cjs';
+
+/**
+ * Next.js App Router route handler type.
+ */
+type NextJSHandler<T = any> = (req: NextRequest) => Promise<NextResponse<T>>;
+/**
+ * Wrapper function that adds x402 payment verification to Next.js route handler.
+ */
+type NextJSPaywallWrapper = <T>(handler: NextJSHandler<T>) => NextJSHandler<T>;
+/**
+ * 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 as `0x${string}`,
+ * });
+ *
+ * export const POST = pay(async (req: NextRequest) => {
+ *   const { prompt } = await req.json();
+ *   // Your handler code here
+ *   return NextResponse.json({ success: true });
+ * });
+ * ```
+ *
+ * @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 nextjs_NextJSHandler<T = any> = NextJSHandler<T>;
+type nextjs_NextJSPaywallWrapper = NextJSPaywallWrapper;
+declare const nextjs_mantlePaywall: typeof mantlePaywall;
+declare namespace nextjs {
+  export { type nextjs_NextJSHandler as NextJSHandler, type nextjs_NextJSPaywallWrapper as NextJSPaywallWrapper, nextjs_mantlePaywall as mantlePaywall };
+}
+
+export { type NextJSHandler as N, type NextJSPaywallWrapper as a, mantlePaywall as m, nextjs as n };