@puga-labs/x402-mantle-sdk 0.2.0 → 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,13 +17,26 @@ 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
 var index_exports = {};
 __export(index_exports, {
+  MANTLE_DEFAULTS: () => MANTLE_DEFAULTS,
+  createMantleClient: () => createMantleClient,
   createPaymentClient: () => createPaymentClient,
-  createPaymentMiddleware: () => createPaymentMiddleware
+  createPaymentMiddleware: () => createPaymentMiddleware,
+  mantlePaywall: () => mantlePaywall,
+  useEthersWallet: () => useEthersWallet,
+  useMantleX402: () => useMantleX402
 });
 module.exports = __toCommonJS(index_exports);
 
@@ -33,6 +48,15 @@ var MANTLE_MAINNET_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:
@@ -259,6 +283,30 @@ function createPaymentMiddleware(config) {
   };
 }
 
+// src/server/mantlePaywall.ts
+function mantlePaywall(opts) {
+  const { priceUsd, payTo, facilitatorUrl, telemetry, onPaymentSettled } = opts;
+  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);
+  };
+}
+
 // src/shared/utils.ts
 function encodeJsonToBase64(value) {
   const json = JSON.stringify(value);
@@ -298,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;
@@ -337,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 {
@@ -397,14 +434,6 @@ function createPaymentClient(config) {
         });
         return {
           response: json,
-          paymentHeader: "",
-          paymentRequirements: {
-            scheme: "exact",
-            network: "mantle-mainnet",
-            asset: "",
-            maxAmountRequired: "0",
-            payTo: ""
-          },
           txHash: void 0
         };
       }
@@ -415,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,
@@ -502,8 +539,172 @@ function createPaymentClient(config) {
     }
   };
 }
+
+// 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;
+    }
+  };
+}
+
+// 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
+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;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  MANTLE_DEFAULTS,
+  createMantleClient,
   createPaymentClient,
-  createPaymentMiddleware
+  createPaymentMiddleware,
+  mantlePaywall,
+  useEthersWallet,
+  useMantleX402
 });

package/dist/index.d.cts

@@ -1,164 +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;
-
-/** 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;
-}
-
-declare function createPaymentMiddleware(config: PaymentMiddlewareConfig): (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;
-
-export { type AssetConfig, type Authorization, type CallWithPaymentResult, 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, createPaymentClient, createPaymentMiddleware };
+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';