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

package/dist/client.cjs

@@ -0,0 +1,328 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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/client.ts
+var client_exports = {};
+__export(client_exports, {
+  MANTLE_DEFAULTS: () => MANTLE_DEFAULTS,
+  createMantleClient: () => createMantleClient,
+  createPaymentClient: () => createPaymentClient
+});
+module.exports = __toCommonJS(client_exports);
+
+// src/shared/constants.ts
+var MANTLE_MAINNET_NETWORK_ID = "mantle-mainnet";
+var MANTLE_MAINNET_CHAIN_ID = 5e3;
+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 getChainIdForNetwork(network) {
+  switch (network) {
+    case MANTLE_MAINNET_NETWORK_ID:
+    default:
+      return MANTLE_MAINNET_CHAIN_ID;
+  }
+}
+
+// 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 }
+        );
+      }
+      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;
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MANTLE_DEFAULTS,
+  createMantleClient,
+  createPaymentClient
+});

package/dist/client.d.cts

@@ -0,0 +1,17 @@
+import { P as PaymentClientConfig, b as PaymentClient } from './createMantleClient-CO0uWPb-.cjs';
+export { C as CallWithPaymentResult, M as MantleClient, a as MantleClientConfig, c as createMantleClient } from './createMantleClient-CO0uWPb-.cjs';
+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-BFUqKBBO.cjs';
+export { M as MANTLE_DEFAULTS } from './constants-CsIL25uQ.cjs';
+
+/**
+ * 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 { PaymentClient, PaymentClientConfig, createPaymentClient };

package/dist/client.d.ts

@@ -0,0 +1,17 @@
+import { P as PaymentClientConfig, b as PaymentClient } from './createMantleClient-CuiPsTa6.js';
+export { C as CallWithPaymentResult, M as MantleClient, a as MantleClientConfig, c as createMantleClient } from './createMantleClient-CuiPsTa6.js';
+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-BFUqKBBO.js';
+export { M as MANTLE_DEFAULTS } from './constants-0ncqvV_O.js';
+
+/**
+ * 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 { PaymentClient, PaymentClientConfig, createPaymentClient };

package/dist/client.js

@@ -0,0 +1,12 @@
+import {
+  createMantleClient,
+  createPaymentClient
+} from "./chunk-E46A7I6B.js";
+import {
+  MANTLE_DEFAULTS
+} from "./chunk-HEZZ74SI.js";
+export {
+  MANTLE_DEFAULTS,
+  createMantleClient,
+  createPaymentClient
+};

package/dist/constants-0ncqvV_O.d.ts

@@ -0,0 +1,17 @@
+import './types-BFUqKBBO.js';
+
+/**
+ * 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;
+};
+
+export { MANTLE_DEFAULTS as M };

package/dist/constants-C7aY8u5b.d.cts

@@ -0,0 +1,77 @@
+/** 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: `0x${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;
+/**
+ * EIP-1193 provider interface (window.ethereum, MetaMask, etc.)
+ * Standard interface for Ethereum wallet providers.
+ */
+interface EIP1193Provider {
+    request(args: {
+        method: string;
+        params?: unknown[];
+    }): Promise<unknown>;
+    on?(event: string, listener: (...args: unknown[]) => void): void;
+    removeListener?(event: string, listener: (...args: unknown[]) => void): void;
+}
+/**
+ * Window ethereum extension for TypeScript
+ */
+declare global {
+    interface Window {
+        ethereum?: EIP1193Provider;
+    }
+}
+
+/**
+ * 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;
+};
+
+export { type AssetConfig as A, type EIP1193Provider as E, MANTLE_DEFAULTS as M, type NetworkId as N, type PaymentRequirements as P, type Authorization as a, type PaymentHeaderPayload as b, type PaymentHeaderObject as c, type PaymentHeaderBase64 as d };

package/dist/constants-C7aY8u5b.d.ts

@@ -0,0 +1,77 @@
+/** 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: `0x${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;
+/**
+ * EIP-1193 provider interface (window.ethereum, MetaMask, etc.)
+ * Standard interface for Ethereum wallet providers.
+ */
+interface EIP1193Provider {
+    request(args: {
+        method: string;
+        params?: unknown[];
+    }): Promise<unknown>;
+    on?(event: string, listener: (...args: unknown[]) => void): void;
+    removeListener?(event: string, listener: (...args: unknown[]) => void): void;
+}
+/**
+ * Window ethereum extension for TypeScript
+ */
+declare global {
+    interface Window {
+        ethereum?: EIP1193Provider;
+    }
+}
+
+/**
+ * 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;
+};
+
+export { type AssetConfig as A, type EIP1193Provider as E, MANTLE_DEFAULTS as M, type NetworkId as N, type PaymentRequirements as P, type Authorization as a, type PaymentHeaderPayload as b, type PaymentHeaderObject as c, type PaymentHeaderBase64 as d };

package/dist/constants-CVFF0ray.d.ts

@@ -0,0 +1,17 @@
+import './types-2zqbJvcz.js';
+
+/**
+ * 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;
+};
+
+export { MANTLE_DEFAULTS as M };

package/dist/constants-CsIL25uQ.d.cts

@@ -0,0 +1,17 @@
+import './types-BFUqKBBO.cjs';
+
+/**
+ * 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;
+};
+
+export { MANTLE_DEFAULTS as M };

package/dist/constants-DzCGK0Q3.d.cts

@@ -0,0 +1,17 @@
+import './types-2zqbJvcz.cjs';
+
+/**
+ * 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;
+};
+
+export { MANTLE_DEFAULTS as M };

package/dist/createMantleClient-CO0uWPb-.d.cts

@@ -0,0 +1,87 @@
+import { d as PaymentHeaderBase64, P as PaymentRequirements } from './types-BFUqKBBO.cjs';
+
+/** 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>>;
+}
+
+/**
+ * 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 Full payment result including response body and tx hash.
+     * @throws Error if wallet is not connected or payment fails.
+     */
+    postWithPayment<TResp = any>(url: string, body?: any): Promise<CallWithPaymentResult<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.postWithPayment("/api/generate", { prompt: "..." });
+ * ```
+ *
+ * @param config - Optional configuration (auto-detects facilitatorUrl and resourceUrl).
+ * @returns MantleClient instance with simplified postWithPayment() method.
+ */
+declare function createMantleClient(config?: MantleClientConfig): MantleClient;
+
+export { type CallWithPaymentResult as C, type MantleClient as M, type PaymentClientConfig as P, type MantleClientConfig as a, type PaymentClient as b, createMantleClient as c };