x402-mantle-sdk 0.1.0

package/dist/client/index.js

@@ -0,0 +1,793 @@
+// src/client/constants.ts
+var NETWORKS = {
+  mantle: {
+    chainId: 5e3,
+    rpcUrl: "https://rpc.mantle.xyz",
+    name: "Mantle",
+    environment: "mainnet",
+    nativeCurrency: { name: "Mantle", symbol: "MNT", decimals: 18 },
+    blockExplorer: "https://explorer.mantle.xyz"
+  },
+  "mantle-sepolia": {
+    chainId: 5003,
+    rpcUrl: "https://rpc.sepolia.mantle.xyz",
+    name: "Mantle Sepolia",
+    environment: "testnet",
+    nativeCurrency: { name: "Mantle", symbol: "MNT", decimals: 18 },
+    blockExplorer: "https://explorer.sepolia.mantle.xyz"
+  },
+  "mantle-testnet": {
+    chainId: 5003,
+    rpcUrl: "https://rpc.sepolia.mantle.xyz",
+    name: "Mantle Testnet",
+    environment: "testnet",
+    nativeCurrency: { name: "Mantle", symbol: "MNT", decimals: 18 },
+    blockExplorer: "https://explorer.sepolia.mantle.xyz"
+  }
+};
+var TOKENS = {
+  mantle: {
+    USDC: {
+      address: "0x09Bc4E0D864854c6aFB6eB9A9cdF58aC190D0dF9",
+      decimals: 6,
+      symbol: "USDC"
+    },
+    USDT: {
+      address: "0x201EBa5CC46D216Ce6DC03F6a759e8E766e956aE",
+      decimals: 6,
+      symbol: "USDT"
+    },
+    mETH: {
+      address: "0xcDA86A272531e8640cD7F1a92c01839911B90bb0",
+      decimals: 18,
+      symbol: "mETH"
+    },
+    WMNT: {
+      address: "0x78c1b0C915c4FAA5FffA6CAbf0219DA63d7f4cb8",
+      decimals: 18,
+      symbol: "WMNT"
+    }
+  },
+  "mantle-sepolia": {
+    USDC: {
+      address: "0x09Bc4E0D864854c6aFB6eB9A9cdF58aC190D0dF9",
+      decimals: 6,
+      symbol: "USDC"
+    },
+    mETH: {
+      address: "0xdEAddEaDdeadDEadDEADDEAddEADDEAddead1111",
+      decimals: 18,
+      symbol: "mETH"
+    },
+    WMNT: {
+      address: "0x78c1b0C915c4FAA5FffA6CAbf0219DA63d7f4cb8",
+      decimals: 18,
+      symbol: "WMNT"
+    }
+  },
+  "mantle-testnet": {
+    USDC: {
+      address: "0x09Bc4E0D864854c6aFB6eB9A9cdF58aC190D0dF9",
+      decimals: 6,
+      symbol: "USDC"
+    },
+    mETH: {
+      address: "0xdEAddEaDdeadDEadDEADDEAddEADDEAddead1111",
+      decimals: 18,
+      symbol: "mETH"
+    },
+    WMNT: {
+      address: "0x78c1b0C915c4FAA5FffA6CAbf0219DA63d7f4cb8",
+      decimals: 18,
+      symbol: "WMNT"
+    }
+  }
+};
+var TREASURY_ADDRESS = "0xB27705342ACE73736AE490540Ea031cc06C3eF49";
+var PLATFORM_FEE_BPS = 50n;
+var BPS_DENOMINATOR = 10000n;
+var TREASURY_ADMIN = "0xDacCF30F8BB2aEb8D76E68E03033629809ed08E1";
+var customNetworks = /* @__PURE__ */ new Map();
+var customTokens = /* @__PURE__ */ new Map();
+function registerCustomNetwork(networkId, config) {
+  customNetworks.set(networkId.toLowerCase(), {
+    chainId: config.chainId,
+    rpcUrl: config.rpcUrl,
+    name: config.name || networkId,
+    environment: config.environment || "testnet",
+    nativeCurrency: { name: "Native", symbol: "ETH", decimals: 18 },
+    blockExplorer: config.blockExplorer || ""
+  });
+}
+function registerCustomTokens(networkId, tokens) {
+  const networkKey = networkId.toLowerCase();
+  if (!customTokens.has(networkKey)) {
+    customTokens.set(networkKey, /* @__PURE__ */ new Map());
+  }
+  const tokenMap = customTokens.get(networkKey);
+  for (const [symbol, config] of Object.entries(tokens)) {
+    tokenMap.set(symbol.toUpperCase(), {
+      address: config.address,
+      decimals: config.decimals,
+      symbol: symbol.toUpperCase()
+    });
+  }
+}
+function isTestnet(network) {
+  const config = getNetworkConfig(network);
+  return config.environment === "testnet";
+}
+function isMainnet(network) {
+  const config = getNetworkConfig(network);
+  return config.environment === "mainnet";
+}
+function getNetworkConfig(network) {
+  const networkKey = network.toLowerCase();
+  const custom = customNetworks.get(networkKey);
+  if (custom) {
+    return custom;
+  }
+  const preset = NETWORKS[networkKey];
+  if (preset) {
+    return preset;
+  }
+  return NETWORKS.mantle;
+}
+function getTokenConfig(token, network) {
+  const networkKey = network.toLowerCase();
+  const tokenKey = token.toUpperCase();
+  if (tokenKey === "MNT") {
+    return null;
+  }
+  const customMap = customTokens.get(networkKey);
+  if (customMap?.has(tokenKey)) {
+    return customMap.get(tokenKey);
+  }
+  return TOKENS[networkKey]?.[tokenKey] || null;
+}
+function getChainId(network) {
+  return getNetworkConfig(network).chainId;
+}
+function getAvailableNetworks() {
+  const preset = Object.keys(NETWORKS);
+  const custom = Array.from(customNetworks.keys());
+  return [.../* @__PURE__ */ new Set([...preset, ...custom])];
+}
+function getNetworksByEnvironment(env) {
+  return getAvailableNetworks().filter((network) => {
+    const config = getNetworkConfig(network);
+    return config.environment === env;
+  });
+}
+
+// src/client/wallet.ts
+function getEthereumProvider() {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  return window.ethereum || null;
+}
+var MetaMaskProvider = class {
+  constructor() {
+    this.ethereum = getEthereumProvider();
+  }
+  isAvailable() {
+    return this.ethereum !== null && this.ethereum.isMetaMask === true;
+  }
+  async connect() {
+    if (!this.ethereum) {
+      throw new Error("MetaMask is not available");
+    }
+    const accounts = await this.ethereum.request({
+      method: "eth_requestAccounts"
+    });
+    if (!accounts || accounts.length === 0) {
+      throw new Error("No accounts found");
+    }
+    return accounts[0];
+  }
+  async getAccount() {
+    if (!this.ethereum) {
+      return null;
+    }
+    try {
+      const accounts = await this.ethereum.request({
+        method: "eth_accounts"
+      });
+      return accounts && accounts.length > 0 ? accounts[0] : null;
+    } catch {
+      return null;
+    }
+  }
+  async getChainId() {
+    if (!this.ethereum) {
+      return null;
+    }
+    try {
+      const chainIdHex = await this.ethereum.request({
+        method: "eth_chainId"
+      });
+      return parseInt(chainIdHex, 16);
+    } catch {
+      return null;
+    }
+  }
+  async switchNetwork(chainId) {
+    if (!this.ethereum) {
+      throw new Error("MetaMask is not available");
+    }
+    const chainIdHex = `0x${chainId.toString(16)}`;
+    try {
+      await this.ethereum.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: chainIdHex }]
+      });
+    } catch (error) {
+      const switchError = error;
+      if (switchError.code === 4902) {
+        throw new Error(`Network with chainId ${chainId} not found. Use addNetwork() first.`);
+      }
+      throw error;
+    }
+  }
+  async addNetwork(params) {
+    if (!this.ethereum) {
+      throw new Error("MetaMask is not available");
+    }
+    await this.ethereum.request({
+      method: "wallet_addEthereumChain",
+      params: [params]
+    });
+  }
+  async sendTransaction(tx) {
+    if (!this.ethereum) {
+      throw new Error("MetaMask is not available");
+    }
+    const txHash = await this.ethereum.request({
+      method: "eth_sendTransaction",
+      params: [tx]
+    });
+    return txHash;
+  }
+  async signMessage(message) {
+    if (!this.ethereum) {
+      throw new Error("MetaMask is not available");
+    }
+    const account = await this.getAccount();
+    if (!account) {
+      throw new Error("No account connected");
+    }
+    const signature = await this.ethereum.request({
+      method: "personal_sign",
+      params: [message, account]
+    });
+    return signature;
+  }
+};
+function detectWalletProvider() {
+  const metaMask = new MetaMaskProvider();
+  if (metaMask.isAvailable()) {
+    return metaMask;
+  }
+  return null;
+}
+async function connectWallet(provider) {
+  const wallet = provider || detectWalletProvider();
+  if (!wallet) {
+    throw new Error(
+      "No wallet provider found. Please install MetaMask or another compatible wallet."
+    );
+  }
+  return wallet.connect();
+}
+async function ensureNetwork(wallet, network, autoAdd = true) {
+  const config = getNetworkConfig(network);
+  const targetChainId = config.chainId;
+  const currentChainId = await wallet.getChainId();
+  if (currentChainId === targetChainId) {
+    return;
+  }
+  try {
+    await wallet.switchNetwork(targetChainId);
+  } catch (error) {
+    const switchError = error;
+    if (autoAdd && switchError.message?.includes("not found")) {
+      await wallet.addNetwork({
+        chainId: `0x${targetChainId.toString(16)}`,
+        chainName: config.name,
+        nativeCurrency: config.nativeCurrency,
+        rpcUrls: [config.rpcUrl],
+        blockExplorerUrls: config.blockExplorer ? [config.blockExplorer] : void 0
+      });
+    } else {
+      throw error;
+    }
+  }
+}
+function getAddNetworkParams(network) {
+  const config = getNetworkConfig(network);
+  return {
+    chainId: `0x${config.chainId.toString(16)}`,
+    chainName: config.name,
+    nativeCurrency: config.nativeCurrency,
+    rpcUrls: [config.rpcUrl],
+    blockExplorerUrls: config.blockExplorer ? [config.blockExplorer] : void 0
+  };
+}
+
+// src/client/payment.ts
+var ERC20_TRANSFER_SIG = "0xa9059cbb";
+function amountToWei(amount, decimals = 18) {
+  const parts = amount.split(".");
+  const whole = parts[0] || "0";
+  const fraction = (parts[1] || "").padEnd(decimals, "0").slice(0, decimals);
+  return BigInt(whole) * 10n ** BigInt(decimals) + BigInt(fraction);
+}
+function calculateSplit(amount) {
+  const feeAmount = amount * PLATFORM_FEE_BPS / BPS_DENOMINATOR;
+  const merchantAmount = amount - feeAmount;
+  return { merchantAmount, feeAmount };
+}
+function encodeERC20Transfer(to, amount) {
+  const toHex = to.slice(2).toLowerCase().padStart(64, "0");
+  const amountHex = amount.toString(16).padStart(64, "0");
+  return ERC20_TRANSFER_SIG + toHex + amountHex;
+}
+async function processPayment(request, wallet) {
+  const tokenConfig = getTokenConfig(request.token, request.network);
+  const decimals = tokenConfig?.decimals ?? 18;
+  const totalAmount = amountToWei(request.amount, decimals);
+  const { merchantAmount, feeAmount } = calculateSplit(totalAmount);
+  let txHash;
+  if (tokenConfig) {
+    const transferData = encodeERC20Transfer(request.recipient, totalAmount);
+    const tx = {
+      to: tokenConfig.address,
+      data: transferData
+    };
+    txHash = await wallet.sendTransaction(tx);
+  } else {
+    const merchantTx = {
+      to: request.recipient,
+      value: `0x${merchantAmount.toString(16)}`
+    };
+    txHash = await wallet.sendTransaction(merchantTx);
+    if (feeAmount > 0n) {
+      const feeTx = {
+        to: TREASURY_ADDRESS,
+        value: `0x${feeAmount.toString(16)}`
+      };
+      await wallet.sendTransaction(feeTx);
+    }
+  }
+  return {
+    transactionHash: txHash,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+
+// src/client/modal-vanilla.ts
+var STYLES = {
+  overlay: `
+    position: fixed;
+    inset: 0;
+    z-index: 9999;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: rgba(0, 0, 0, 0.5);
+    backdrop-filter: blur(4px);
+  `,
+  modal: `
+    width: 100%;
+    max-width: 28rem;
+    border-radius: 0.75rem;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+    background: rgba(24, 24, 27, 0.95);
+    padding: 1.5rem;
+    box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.3);
+    backdrop-filter: blur(16px);
+    color: #fafafa;
+  `,
+  header: `
+    display: flex;
+    align-items: center;
+    justify-content: space-between;
+    margin-bottom: 1.5rem;
+  `,
+  logo: `
+    width: 2rem;
+    height: 2rem;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    border-radius: 0.5rem;
+    background: rgba(255, 255, 255, 0.1);
+    font-family: monospace;
+    font-size: 0.75rem;
+    font-weight: bold;
+    color: #fafafa;
+  `,
+  title: `
+    font-size: 1.25rem;
+    font-weight: 300;
+    margin: 0;
+    margin-left: 0.5rem;
+    color: #fafafa;
+  `,
+  closeBtn: `
+    background: none;
+    border: none;
+    font-size: 1.5rem;
+    cursor: pointer;
+    color: rgba(250, 250, 250, 0.6);
+    line-height: 1;
+  `,
+  details: `
+    margin-bottom: 1.5rem;
+    padding: 1rem;
+    border-radius: 0.5rem;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+    background: rgba(255, 255, 255, 0.02);
+  `,
+  row: `
+    display: flex;
+    justify-content: space-between;
+    margin-bottom: 0.75rem;
+  `,
+  rowLast: `
+    display: flex;
+    justify-content: space-between;
+  `,
+  label: `
+    font-family: monospace;
+    font-size: 0.75rem;
+    color: rgba(250, 250, 250, 0.6);
+  `,
+  value: `
+    font-size: 0.875rem;
+    color: #fafafa;
+  `,
+  valueAmount: `
+    font-size: 1.125rem;
+    font-weight: 500;
+    color: #fafafa;
+  `,
+  valueMono: `
+    font-family: monospace;
+    font-size: 0.875rem;
+    color: #fafafa;
+  `,
+  button: `
+    width: 100%;
+    padding: 0.75rem 1rem;
+    border-radius: 0.5rem;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+    background: rgba(255, 255, 255, 0.05);
+    font-size: 0.875rem;
+    font-weight: 500;
+    cursor: pointer;
+    transition: background 0.2s;
+    color: #fafafa;
+  `,
+  buttonPrimary: `
+    flex: 1;
+    padding: 0.75rem 1rem;
+    border-radius: 0.5rem;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+    background: rgba(255, 255, 255, 0.1);
+    font-size: 0.875rem;
+    font-weight: 500;
+    cursor: pointer;
+    color: #fafafa;
+  `,
+  buttonSecondary: `
+    flex: 1;
+    padding: 0.75rem 1rem;
+    border-radius: 0.5rem;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+    background: rgba(255, 255, 255, 0.02);
+    font-size: 0.875rem;
+    cursor: pointer;
+    color: rgba(250, 250, 250, 0.8);
+  `,
+  walletBox: `
+    margin-bottom: 1rem;
+    padding: 0.75rem;
+    border-radius: 0.5rem;
+    border: 1px solid rgba(255, 255, 255, 0.1);
+    background: rgba(255, 255, 255, 0.02);
+  `,
+  walletLabel: `
+    margin: 0 0 0.25rem 0;
+    font-family: monospace;
+    font-size: 0.75rem;
+    color: rgba(250, 250, 250, 0.6);
+  `,
+  walletAddress: `
+    margin: 0;
+    font-family: monospace;
+    font-size: 0.875rem;
+    color: #fafafa;
+  `,
+  buttonGroup: `
+    display: flex;
+    gap: 0.75rem;
+  `
+};
+function formatAddress(address) {
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+async function createVanillaPaymentModal(request) {
+  return new Promise((resolve) => {
+    const overlay = document.createElement("div");
+    overlay.style.cssText = STYLES.overlay;
+    const modal = document.createElement("div");
+    modal.style.cssText = STYLES.modal;
+    let isProcessing = false;
+    const cleanup = () => {
+      if (document.body.contains(overlay)) {
+        document.body.removeChild(overlay);
+      }
+    };
+    const header = document.createElement("div");
+    header.style.cssText = STYLES.header;
+    const headerLeft = document.createElement("div");
+    headerLeft.style.cssText = "display: flex; align-items: center;";
+    const logo = document.createElement("div");
+    logo.style.cssText = STYLES.logo;
+    logo.textContent = "x402";
+    const title = document.createElement("h2");
+    title.style.cssText = STYLES.title;
+    title.textContent = "Payment Required";
+    headerLeft.appendChild(logo);
+    headerLeft.appendChild(title);
+    const closeBtn = document.createElement("button");
+    closeBtn.innerHTML = "×";
+    closeBtn.style.cssText = STYLES.closeBtn;
+    closeBtn.onclick = () => {
+      cleanup();
+      resolve(null);
+    };
+    header.appendChild(headerLeft);
+    header.appendChild(closeBtn);
+    const details = document.createElement("div");
+    details.style.cssText = STYLES.details;
+    const amountRow = document.createElement("div");
+    amountRow.style.cssText = STYLES.row;
+    amountRow.innerHTML = `
+      <span style="${STYLES.label}">Amount</span>
+      <span style="${STYLES.valueAmount}">${request.amount} ${request.token}</span>
+    `;
+    const networkRow = document.createElement("div");
+    networkRow.style.cssText = STYLES.row;
+    networkRow.innerHTML = `
+      <span style="${STYLES.label}">Network</span>
+      <span style="${STYLES.value}">${request.network}</span>
+    `;
+    const recipientRow = document.createElement("div");
+    recipientRow.style.cssText = STYLES.rowLast;
+    recipientRow.innerHTML = `
+      <span style="${STYLES.label}">Recipient</span>
+      <span style="${STYLES.valueMono}">${formatAddress(request.recipient)}</span>
+    `;
+    details.appendChild(amountRow);
+    details.appendChild(networkRow);
+    details.appendChild(recipientRow);
+    const content = document.createElement("div");
+    const connectBtn = document.createElement("button");
+    connectBtn.textContent = "Connect Wallet";
+    connectBtn.style.cssText = STYLES.button;
+    connectBtn.onmouseover = () => {
+      connectBtn.style.background = "rgba(255, 255, 255, 0.1)";
+    };
+    connectBtn.onmouseout = () => {
+      connectBtn.style.background = "rgba(255, 255, 255, 0.05)";
+    };
+    connectBtn.onclick = async () => {
+      try {
+        connectBtn.setAttribute("disabled", "true");
+        connectBtn.textContent = "Connecting...";
+        connectBtn.style.opacity = "0.7";
+        connectBtn.style.cursor = "not-allowed";
+        const wallet = detectWalletProvider();
+        if (!wallet) {
+          alert("No wallet found. Please install MetaMask.");
+          connectBtn.removeAttribute("disabled");
+          connectBtn.textContent = "Connect Wallet";
+          connectBtn.style.opacity = "1";
+          connectBtn.style.cursor = "pointer";
+          return;
+        }
+        const address = await connectWallet(wallet);
+        content.innerHTML = "";
+        const walletBox = document.createElement("div");
+        walletBox.style.cssText = STYLES.walletBox;
+        walletBox.innerHTML = `
+          <p style="${STYLES.walletLabel}">Connected Wallet</p>
+          <p style="${STYLES.walletAddress}">${formatAddress(address)}</p>
+        `;
+        const buttonGroup = document.createElement("div");
+        buttonGroup.style.cssText = STYLES.buttonGroup;
+        const cancelBtn = document.createElement("button");
+        cancelBtn.textContent = "Cancel";
+        cancelBtn.style.cssText = STYLES.buttonSecondary;
+        cancelBtn.onclick = () => {
+          cleanup();
+          resolve(null);
+        };
+        const payBtn = document.createElement("button");
+        payBtn.textContent = `Pay ${request.amount} ${request.token}`;
+        payBtn.style.cssText = STYLES.buttonPrimary;
+        payBtn.onclick = async () => {
+          if (isProcessing) return;
+          isProcessing = true;
+          payBtn.setAttribute("disabled", "true");
+          payBtn.textContent = "Processing...";
+          payBtn.style.opacity = "0.7";
+          payBtn.style.cursor = "not-allowed";
+          try {
+            const w = detectWalletProvider();
+            if (!w) throw new Error("Wallet not connected");
+            const payment = await processPayment(request, w);
+            cleanup();
+            resolve(payment);
+          } catch (error) {
+            alert(`Payment failed: ${error instanceof Error ? error.message : String(error)}`);
+            isProcessing = false;
+            payBtn.removeAttribute("disabled");
+            payBtn.textContent = `Pay ${request.amount} ${request.token}`;
+            payBtn.style.opacity = "1";
+            payBtn.style.cursor = "pointer";
+          }
+        };
+        buttonGroup.appendChild(cancelBtn);
+        buttonGroup.appendChild(payBtn);
+        content.appendChild(walletBox);
+        content.appendChild(buttonGroup);
+      } catch (error) {
+        alert(`Connection failed: ${error instanceof Error ? error.message : String(error)}`);
+        connectBtn.removeAttribute("disabled");
+        connectBtn.textContent = "Connect Wallet";
+        connectBtn.style.opacity = "1";
+        connectBtn.style.cursor = "pointer";
+      }
+    };
+    content.appendChild(connectBtn);
+    modal.appendChild(header);
+    modal.appendChild(details);
+    modal.appendChild(content);
+    overlay.appendChild(modal);
+    document.body.appendChild(overlay);
+    overlay.onclick = (e) => {
+      if (e.target === overlay) {
+        cleanup();
+        resolve(null);
+      }
+    };
+    const handleEscape = (e) => {
+      if (e.key === "Escape") {
+        cleanup();
+        resolve(null);
+        document.removeEventListener("keydown", handleEscape);
+      }
+    };
+    document.addEventListener("keydown", handleEscape);
+  });
+}
+
+// src/client/modal.ts
+async function createPaymentModal(request) {
+  if (typeof window === "undefined") {
+    return null;
+  }
+  return createVanillaPaymentModal(request);
+}
+
+// src/client/client.ts
+function parse402Response(response) {
+  if (response.status !== 402) {
+    return null;
+  }
+  const amount = response.headers.get("X-402-Amount") || response.headers.get("x-402-amount");
+  const token = response.headers.get("X-402-Token") || response.headers.get("x-402-token");
+  const network = response.headers.get("X-402-Network") || response.headers.get("x-402-network");
+  const recipient = response.headers.get("X-402-Recipient") || response.headers.get("x-402-recipient");
+  if (!amount || !token || !network || !recipient) {
+    return null;
+  }
+  return { amount, token, network, recipient };
+}
+function addPaymentHeaders(headers, payment) {
+  const newHeaders = new Headers(headers);
+  newHeaders.set("X-402-Transaction-Hash", payment.transactionHash);
+  if (payment.timestamp) {
+    newHeaders.set("X-402-Timestamp", payment.timestamp);
+  }
+  return newHeaders;
+}
+var X402Client = class {
+  constructor(options = {}) {
+    this.wallet = null;
+    this.options = {
+      autoRetry: true,
+      ...options
+    };
+  }
+  /**
+   * Initialize wallet connection
+   */
+  async initialize() {
+    if (this.options.walletProvider) {
+      this.wallet = this.options.walletProvider;
+    } else {
+      this.wallet = detectWalletProvider();
+    }
+  }
+  /**
+   * Fetch with automatic 402 handling
+   */
+  async fetch(input, init) {
+    const response = await globalThis.fetch(input, init);
+    const paymentRequest = parse402Response(response);
+    if (!paymentRequest) {
+      return response;
+    }
+    let payment = null;
+    if (this.options.paymentModal) {
+      payment = await this.options.paymentModal(paymentRequest);
+    } else {
+      payment = await createPaymentModal(paymentRequest);
+    }
+    if (!payment) {
+      return response;
+    }
+    if (this.options.autoRetry !== false) {
+      const newHeaders = addPaymentHeaders(init?.headers || {}, payment);
+      return globalThis.fetch(input, {
+        ...init,
+        headers: newHeaders
+      });
+    }
+    return new Response(JSON.stringify(payment), {
+      status: 200,
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+};
+function x402Client(options) {
+  return new X402Client(options);
+}
+async function x402Fetch(input, init, options) {
+  const client = x402Client(options);
+  await client.initialize();
+  return client.fetch(input, init);
+}
+export {
+  MetaMaskProvider,
+  NETWORKS,
+  PLATFORM_FEE_BPS,
+  TOKENS,
+  TREASURY_ADDRESS,
+  TREASURY_ADMIN,
+  X402Client,
+  connectWallet,
+  createPaymentModal,
+  createVanillaPaymentModal,
+  detectWalletProvider,
+  ensureNetwork,
+  getAddNetworkParams,
+  getAvailableNetworks,
+  getChainId,
+  getNetworkConfig,
+  getNetworksByEnvironment,
+  getTokenConfig,
+  isMainnet,
+  isTestnet,
+  processPayment,
+  registerCustomNetwork,
+  registerCustomTokens,
+  x402Client,
+  x402Fetch
+};
+//# sourceMappingURL=index.js.map