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

package/dist/web-standards-BNQyWzBC.d.cts

@@ -0,0 +1,77 @@
+import { M as MinimalPaywallOptions } from './types-CrOsOHcX.cjs';
+
+/**
+ * Web Standards route handler type.
+ * Takes a Request and returns a Response.
+ */
+type WebHandler = (request: Request) => Promise<Response>;
+/**
+ * Wrapper function that adds x402 payment verification to Web Standards handler.
+ */
+type WebPaywallWrapper = (handler: WebHandler) => WebHandler;
+/**
+ * Create Web Standards middleware for x402 payment verification.
+ * Uses Mantle mainnet defaults (USDC, exact scheme, etc.).
+ *
+ * Compatible with:
+ * - Hono
+ * - Cloudflare Workers
+ * - Deno
+ * - Bun
+ * - Any platform supporting Web Request/Response API
+ *
+ * @example
+ * ```typescript
+ * // Hono example
+ * import { Hono } from 'hono'
+ * import { mantlePaywall } from '@puga-labs/x402-mantle-sdk/server/web'
+ *
+ * const app = new Hono()
+ * const pay = mantlePaywall({
+ *   priceUsd: 0.01,
+ *   payTo: '0x...',
+ * });
+ *
+ * app.post('/api/generate', pay(async (req) => {
+ *   const body = await req.json();
+ *   // Your handler code here
+ *   return new Response(JSON.stringify({ success: true }), {
+ *     headers: { 'Content-Type': 'application/json' }
+ *   });
+ * }));
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Cloudflare Workers example
+ * import { mantlePaywall } from '@puga-labs/x402-mantle-sdk/server/web'
+ *
+ * const pay = mantlePaywall({
+ *   priceUsd: 0.01,
+ *   payTo: '0x...',
+ * });
+ *
+ * export default {
+ *   async fetch(request: Request) {
+ *     const handler = pay(async (req) => {
+ *       // Your handler code here
+ *       return new Response('Hello World');
+ *     });
+ *     return handler(request);
+ *   }
+ * }
+ * ```
+ *
+ * @param opts - Minimal configuration (price, payTo, optional facilitator/telemetry).
+ * @returns Function that wraps Web Standards handlers with payment verification.
+ */
+declare function mantlePaywall(opts: MinimalPaywallOptions): WebPaywallWrapper;
+
+type webStandards_WebHandler = WebHandler;
+type webStandards_WebPaywallWrapper = WebPaywallWrapper;
+declare const webStandards_mantlePaywall: typeof mantlePaywall;
+declare namespace webStandards {
+  export { type webStandards_WebHandler as WebHandler, type webStandards_WebPaywallWrapper as WebPaywallWrapper, webStandards_mantlePaywall as mantlePaywall };
+}
+
+export { type WebHandler as W, type WebPaywallWrapper as a, mantlePaywall as m, webStandards as w };

package/dist/web-standards-D8j1kZxd.d.ts

@@ -0,0 +1,77 @@
+import { M as MinimalPaywallOptions } from './types-CqQ6OgRi.js';
+
+/**
+ * Web Standards route handler type.
+ * Takes a Request and returns a Response.
+ */
+type WebHandler = (request: Request) => Promise<Response>;
+/**
+ * Wrapper function that adds x402 payment verification to Web Standards handler.
+ */
+type WebPaywallWrapper = (handler: WebHandler) => WebHandler;
+/**
+ * Create Web Standards middleware for x402 payment verification.
+ * Uses Mantle mainnet defaults (USDC, exact scheme, etc.).
+ *
+ * Compatible with:
+ * - Hono
+ * - Cloudflare Workers
+ * - Deno
+ * - Bun
+ * - Any platform supporting Web Request/Response API
+ *
+ * @example
+ * ```typescript
+ * // Hono example
+ * import { Hono } from 'hono'
+ * import { mantlePaywall } from '@puga-labs/x402-mantle-sdk/server/web'
+ *
+ * const app = new Hono()
+ * const pay = mantlePaywall({
+ *   priceUsd: 0.01,
+ *   payTo: '0x...',
+ * });
+ *
+ * app.post('/api/generate', pay(async (req) => {
+ *   const body = await req.json();
+ *   // Your handler code here
+ *   return new Response(JSON.stringify({ success: true }), {
+ *     headers: { 'Content-Type': 'application/json' }
+ *   });
+ * }));
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Cloudflare Workers example
+ * import { mantlePaywall } from '@puga-labs/x402-mantle-sdk/server/web'
+ *
+ * const pay = mantlePaywall({
+ *   priceUsd: 0.01,
+ *   payTo: '0x...',
+ * });
+ *
+ * export default {
+ *   async fetch(request: Request) {
+ *     const handler = pay(async (req) => {
+ *       // Your handler code here
+ *       return new Response('Hello World');
+ *     });
+ *     return handler(request);
+ *   }
+ * }
+ * ```
+ *
+ * @param opts - Minimal configuration (price, payTo, optional facilitator/telemetry).
+ * @returns Function that wraps Web Standards handlers with payment verification.
+ */
+declare function mantlePaywall(opts: MinimalPaywallOptions): WebPaywallWrapper;
+
+type webStandards_WebHandler = WebHandler;
+type webStandards_WebPaywallWrapper = WebPaywallWrapper;
+declare const webStandards_mantlePaywall: typeof mantlePaywall;
+declare namespace webStandards {
+  export { type webStandards_WebHandler as WebHandler, type webStandards_WebPaywallWrapper as WebPaywallWrapper, webStandards_mantlePaywall as mantlePaywall };
+}
+
+export { type WebHandler as W, type WebPaywallWrapper as a, mantlePaywall as m, webStandards as w };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@puga-labs/x402-mantle-sdk",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "x402 payments SDK for Mantle (USDC, gasless, facilitator-based)",
   "license": "MIT",
   "author": "Evgenii Pugachev <cyprus.pugamuga@gmail.com>",
@@ -47,6 +47,36 @@
         "default": "./dist/server.cjs"
       }
     },
+    "./server/express": {
+      "import": {
+        "types": "./dist/server-express.d.ts",
+        "default": "./dist/server-express.js"
+      },
+      "require": {
+        "types": "./dist/server-express.d.cts",
+        "default": "./dist/server-express.cjs"
+      }
+    },
+    "./server/nextjs": {
+      "import": {
+        "types": "./dist/server-nextjs.d.ts",
+        "default": "./dist/server-nextjs.js"
+      },
+      "require": {
+        "types": "./dist/server-nextjs.d.cts",
+        "default": "./dist/server-nextjs.cjs"
+      }
+    },
+    "./server/web": {
+      "import": {
+        "types": "./dist/server-web.d.ts",
+        "default": "./dist/server-web.js"
+      },
+      "require": {
+        "types": "./dist/server-web.d.cts",
+        "default": "./dist/server-web.cjs"
+      }
+    },
     "./react": {
       "import": {
         "types": "./dist/react.d.ts",
@@ -62,7 +92,7 @@
     "dist"
   ],
   "scripts": {
-    "build": "tsup src/index.ts src/client.ts src/server.ts src/react.ts --format cjs,esm --dts",
+    "build": "tsup src/index.ts src/client.ts src/server.ts src/server-express.ts src/server-nextjs.ts src/server-web.ts src/react.ts --format cjs,esm --dts",
     "dev": "tsup src/index.ts --format esm --watch",
     "clean": "rimraf dist",
     "lint": "eslint src --ext .ts",
@@ -77,13 +107,30 @@
   },
   "peerDependencies": {
     "ethers": "^6.0.0",
+    "express": "^4.0.0 || ^5.0.0",
+    "next": "^14.0.0 || ^15.0.0 || ^16.0.0",
     "react": "^18.0.0 || ^19.0.0"
   },
+  "peerDependenciesMeta": {
+    "express": {
+      "optional": true
+    },
+    "next": {
+      "optional": true
+    },
+    "ethers": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  },
   "devDependencies": {
     "@eslint/js": "^9.17.0",
     "@types/express": "^5.0.6",
     "@types/node": "^22.0.0",
     "@types/react": "^18.3.1",
+    "next": "^15.1.6",
     "@typescript-eslint/eslint-plugin": "^8.20.0",
     "@typescript-eslint/parser": "^8.20.0",
     "@vitest/coverage-v8": "^4.0.15",

package/dist/chunk-DA6ZBXNO.js

@@ -1,275 +0,0 @@
-import {
-  __require,
-  getChainIdForNetwork
-} from "./chunk-XAQGMFSR.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
-      };
-      const { signature, from } = await signAuthorizationWithProvider(
-        provider,
-        authorization,
-        paymentRequirements
-      );
-      authorization = {
-        ...authorization,
-        from
-      };
-      if (userAddressOverride && userAddressOverride.toLowerCase() !== from.toLowerCase()) {
-        console.warn(
-          "[SDK WARNING] userAddress override differs from signer address",
-          { override: userAddressOverride, signer: from }
-        );
-      }
-      console.log("[SDK] Using authorization.from:", authorization.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 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;
-    }
-  };
-}
-
-export {
-  createPaymentClient,
-  createMantleClient
-};

package/dist/chunk-FD4HG7KR.js

@@ -1,135 +0,0 @@
-import {
-  createMantleClient
-} from "./chunk-GWVWPS3R.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 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);
-      }
-    };
-    if (ethereum.on) {
-      ethereum.on("accountsChanged", handleAccountsChanged);
-    }
-    return () => {
-      if (ethereum.removeListener) {
-        ethereum.removeListener("accountsChanged", handleAccountsChanged);
-      }
-    };
-  }, [disconnect]);
-  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(() => {
-    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
-};