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

package/dist/index.cjs

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
@@ -25,6 +35,7 @@ __export(index_exports, {
   createPaymentClient: () => createPaymentClient,
   createPaymentMiddleware: () => createPaymentMiddleware,
   mantlePaywall: () => mantlePaywall,
+  useEthersWallet: () => useEthersWallet,
   useMantleX402: () => useMantleX402
 });
 module.exports = __toCommonJS(index_exports);
@@ -276,7 +287,7 @@ function createPaymentMiddleware(config) {
 function mantlePaywall(opts) {
   const { priceUsd, payTo, facilitatorUrl, telemetry, onPaymentSettled } = opts;
   const priceUsdCents = Math.round(priceUsd * 100);
-  return (req, res, next) => {
+  return async (req, res, next) => {
     const method = (req.method || "GET").toUpperCase();
     const path = req.path || "/";
     const routeKey = `${method} ${path}`;
@@ -335,19 +346,6 @@ function joinUrl(base, path) {
   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;
@@ -374,24 +372,26 @@ function buildTypedDataForAuthorization(authorization, paymentRequirements) {
     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()");
-  }
+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(
-    authorization,
+    authWithFrom,
     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;
+  const signature = await signer.signTypedData(
+    typedData.domain,
+    typedData.types,
+    typedData.message
+  );
+  return { signature, from };
 }
 function createPaymentClient(config) {
   const {
@@ -434,14 +434,6 @@ function createPaymentClient(config) {
         });
         return {
           response: json,
-          paymentHeader: "",
-          paymentRequirements: {
-            scheme: "exact",
-            network: "mantle-mainnet",
-            asset: "",
-            maxAmountRequired: "0",
-            payTo: ""
-          },
           txHash: void 0
         };
       }
@@ -452,26 +444,34 @@ function createPaymentClient(config) {
           "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,
+      let authorization = {
+        from: "0x0000000000000000000000000000000000000000",
         to: paymentRequirements.payTo,
         value: valueAtomic,
         validAfter,
         validBefore,
         nonce
       };
-      const signature = await signAuthorizationWithProvider(
+      const { signature, from } = await signAuthorizationWithProvider(
         provider,
-        fromAddress,
         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 }
+        );
+      }
       const paymentHeaderObject = {
         x402Version: 1,
         scheme: paymentRequirements.scheme,
@@ -545,7 +545,7 @@ 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) {
+    async postWithPayment(url, body) {
       const account = await config?.getAccount?.();
       if (!account) {
         throw new Error(
@@ -567,16 +567,120 @@ function createMantleClient(config) {
         method: "POST",
         body
       });
-      return result.response;
+      return result;
     }
   };
 }
 
+// src/client/react/useEthersWallet.ts
+var import_react = require("react");
+var import_ethers = require("ethers");
+function useEthersWallet(options) {
+  const [address, setAddress] = (0, import_react.useState)(void 0);
+  const [isConnected, setIsConnected] = (0, import_react.useState)(false);
+  const [provider, setProvider] = (0, import_react.useState)(
+    void 0
+  );
+  const [chainId, setChainId] = (0, import_react.useState)(void 0);
+  const [error, setError] = (0, import_react.useState)(void 0);
+  const connect = (0, import_react.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 import_ethers.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 = (0, import_react.useCallback)(() => {
+    setAddress(void 0);
+    setIsConnected(false);
+    setChainId(void 0);
+    setError(void 0);
+  }, []);
+  (0, import_react.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]);
+  (0, import_react.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);
+      }
+    };
+  }, []);
+  (0, import_react.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
-var import_wagmi = require("wagmi");
 function useMantleX402(opts) {
-  const { address, isConnected } = (0, import_wagmi.useAccount)();
-  const { data: walletClient } = (0, import_wagmi.useWalletClient)();
+  const { address, isConnected } = useEthersWallet({
+    autoConnect: opts?.autoConnect ?? false
+  });
   const client = createMantleClient({
     facilitatorUrl: opts?.facilitatorUrl,
     resourceUrl: opts?.resourceUrl,
@@ -585,7 +689,12 @@ function useMantleX402(opts) {
       if (!isConnected || !address) return void 0;
       return address;
     },
-    getProvider: () => walletClient
+    getProvider: () => {
+      if (typeof window !== "undefined" && window.ethereum) {
+        return window.ethereum;
+      }
+      return void 0;
+    }
   });
   return client;
 }
@@ -596,5 +705,6 @@ function useMantleX402(opts) {
   createPaymentClient,
   createPaymentMiddleware,
   mantlePaywall,
+  useEthersWallet,
   useMantleX402
 });

package/dist/index.d.cts

@@ -1,290 +1,8 @@
-import { Request, Response, NextFunction } from 'express';
-
-/** Network identifier used in x402 paymentRequirements / paymentHeader. */
-type NetworkId = "mantle-mainnet" | (string & {});
-/** Basic ERC-20 asset config (e.g. USDC on Mantle). */
-interface AssetConfig {
-    symbol: string;
-    address: string;
-    decimals: number;
-}
-/** x402-style payment requirements (returned in 402 response). */
-interface PaymentRequirements {
-    scheme: "exact";
-    network: NetworkId;
-    asset: string;
-    maxAmountRequired: string;
-    payTo: string;
-    price?: string;
-    currency?: string;
-}
-/** EIP-3009 TransferWithAuthorization payload. */
-interface Authorization {
-    from: string;
-    to: string;
-    value: string;
-    validAfter: string;
-    validBefore: string;
-    nonce: string;
-}
-/** Inner payload of x402-style payment header. */
-interface PaymentHeaderPayload {
-    signature: string;
-    authorization: Authorization;
-}
-/** Structured x402-style payment header (before base64 encoding). */
-interface PaymentHeaderObject {
-    x402Version: number;
-    scheme: "exact";
-    network: NetworkId;
-    payload: PaymentHeaderPayload;
-}
-/** Base64-encoded payment header, sent in X-PAYMENT. */
-type PaymentHeaderBase64 = string;
-
-/**
- * Default values for Mantle mainnet x402 payments.
- * These are used by the simplified API (mantlePaywall, createMantleClient).
- */
-declare const MANTLE_DEFAULTS: {
-    readonly NETWORK: "mantle-mainnet";
-    readonly CHAIN_ID: 5000;
-    readonly USDC_ADDRESS: "0x09Bc4E0D864854c6aFB6eB9A9cdF58aC190D0dF9";
-    readonly USDC_DECIMALS: 6;
-    readonly CURRENCY: "USD";
-    readonly SCHEME: "exact";
-    readonly FACILITATOR_URL: string;
-};
-
-/** 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: 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.
- */
-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 createPaymentMiddleware(config: PaymentMiddlewareConfig): (req: Request, res: Response, next: NextFunction) => Promise<void>;
-
-/**
- * Simplified wrapper for protecting a single route with x402 payments.
- * Uses Mantle mainnet defaults (USDC, exact scheme, etc.).
- *
- * Usage:
- * ```typescript
- * const pay = mantlePaywall({ priceUsd: 0.01, payTo: "0x..." });
- * export const POST = pay(async (req) => { ... });
- * ```
- *
- * @param opts - Minimal configuration (price, payTo, optional facilitator/telemetry).
- * @returns Express middleware function for single-route protection.
- */
-declare function mantlePaywall(opts: MinimalPaywallOptions): (req: Request, res: Response, next: NextFunction) => Promise<void>;
-
-/** Config for the client-side payment helper. */
-interface PaymentClientConfig {
-    /** Base URL of your protected resource server. */
-    resourceUrl: string;
-    /** Facilitator URL (hosted or self-hosted). */
-    facilitatorUrl: string;
-    /** EIP-1193 provider (window.ethereum) or similar. */
-    provider: unknown;
-    /** Optional user address override; otherwise derived from provider. */
-    userAddress?: string;
-    /** Optional: Project key for hosted facilitator billing. */
-    projectKey?: string;
-}
-/** Result of a callWithPayment() client operation. */
-interface CallWithPaymentResult<TResponseBody = unknown> {
-    response: TResponseBody;
-    txHash?: string;
-    paymentHeader: PaymentHeaderBase64;
-    paymentRequirements: PaymentRequirements;
-}
-/** Shape of the client instance returned by createPaymentClient. */
-interface PaymentClient {
-    callWithPayment<TBody = unknown, TResp = unknown>(path: string, options?: {
-        method?: "GET" | "POST" | "PUT" | "DELETE";
-        body?: TBody;
-        headers?: Record<string, string>;
-        /**
-         * Optional override if you want to send less than maxAmountRequired.
-         * In most cases you won't need this and will just pay maxAmountRequired.
-         */
-        valueOverrideAtomic?: string;
-    }): Promise<CallWithPaymentResult<TResp>>;
-}
-
-/**
- * Creates a high-level payment client that:
- *  - makes an initial request
- *  - if it receives 402 + paymentRequirements, builds & signs an authorization
- *  - calls facilitator /settle
- *  - retries the original request with X-PAYMENT header
- *
- * This logic is x402 and tailored for Mantle + USDC.
- */
-declare function createPaymentClient(config: PaymentClientConfig): PaymentClient;
-
-/**
- * Configuration for createMantleClient().
- * All fields are optional - the client auto-detects sensible defaults.
- */
-interface MantleClientConfig {
-    /** Optional facilitator URL (auto-detects from NEXT_PUBLIC_FACILITATOR_URL or defaults to localhost:8080). */
-    facilitatorUrl?: string;
-    /** Optional resource URL (defaults to current origin in browser, or empty string for relative paths). */
-    resourceUrl?: string;
-    /** Function to get user's wallet address (required for payments). */
-    getAccount?: () => Promise<string | undefined> | string | undefined;
-    /** Function to get wallet provider/client (e.g., viem WalletClient or window.ethereum). */
-    getProvider?: () => any;
-    /** Optional project key for hosted facilitator billing. */
-    projectKey?: string;
-}
-/**
- * Simplified Mantle payment client interface.
- * Provides a clean API for making paid POST requests.
- */
-interface MantleClient {
-    /**
-     * Make a paid POST request to a protected endpoint.
-     * Automatically handles x402 flow (402 response, signing, payment, retry).
-     *
-     * @param url - API endpoint path (e.g., "/api/generate-image").
-     * @param body - Request body (will be JSON stringified).
-     * @returns Response data from the protected endpoint.
-     * @throws Error if wallet is not connected or payment fails.
-     */
-    post<TResp = any>(url: string, body?: any): Promise<TResp>;
-}
-/**
- * Create a simplified Mantle payment client with auto-detected defaults.
- *
- * Usage:
- * ```typescript
- * const client = createMantleClient({
- *   getAccount: () => account?.address,
- *   getProvider: () => walletClient,
- * });
- *
- * const data = await client.post("/api/generate", { prompt: "..." });
- * ```
- *
- * @param config - Optional configuration (auto-detects facilitatorUrl and resourceUrl).
- * @returns MantleClient instance with simplified post() method.
- */
-declare function createMantleClient(config?: MantleClientConfig): MantleClient;
-
-/**
- * Options for useMantleX402 React hook.
- */
-interface UseMantleX402Options {
-    /** Optional facilitator URL (auto-detects from NEXT_PUBLIC_FACILITATOR_URL). */
-    facilitatorUrl?: string;
-    /** Optional resource URL (defaults to current origin). */
-    resourceUrl?: string;
-    /** Optional project key for hosted facilitator billing. */
-    projectKey?: string;
-}
-/**
- * React hook for simplified Mantle x402 payments with wagmi integration.
- *
- * Automatically connects to the user's wallet via wagmi hooks and provides
- * a clean API for making paid requests.
- *
- * Usage:
- * ```typescript
- * const { post } = useMantleX402();
- *
- * const data = await post("/api/generate-image", {
- *   prompt: "A beautiful sunset"
- * });
- * ```
- *
- * @param opts - Optional configuration (facilitatorUrl, resourceUrl, projectKey).
- * @returns MantleClient instance with post() method.
- */
-declare function useMantleX402(opts?: UseMantleX402Options): MantleClient;
-
-export { type AssetConfig, type Authorization, type CallWithPaymentResult, MANTLE_DEFAULTS, type MantleClient, type MantleClientConfig, type MinimalPaywallOptions, type NetworkId, type PaymentClient, type PaymentClientConfig, type PaymentHeaderBase64, type PaymentHeaderObject, type PaymentHeaderPayload, type PaymentLogEntry, type PaymentMiddlewareConfig, type PaymentRequirements, type RouteKey, type RoutePricingConfig, type RoutesConfig, type TelemetryConfig, type TelemetryEvent, type UseMantleX402Options, createMantleClient, createPaymentClient, createPaymentMiddleware, mantlePaywall, useMantleX402 };
+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-2zqbJvcz.cjs';
+export { M as MANTLE_DEFAULTS } from './constants-DzCGK0Q3.cjs';
+export { MantleMiddleware, MinimalPaywallOptions, PaymentLogEntry, PaymentMiddlewareConfig, RouteKey, RoutePricingConfig, RoutesConfig, TelemetryConfig, TelemetryEvent, createPaymentMiddleware, mantlePaywall } from './server.cjs';
+export { C as CallWithPaymentResult, M as MantleClient, a as MantleClientConfig, b as PaymentClient, P as PaymentClientConfig, c as createMantleClient } from './createMantleClient-NN0Nitp9.cjs';
+export { createPaymentClient } from './client.cjs';
+export { UseEthersWalletOptions, UseEthersWalletReturn, UseMantleX402Options, useEthersWallet, useMantleX402 } from './react.cjs';
+import 'express';
+import 'ethers';