x402-mantle-sdk 0.1.0

package/dist/server/index.js

@@ -0,0 +1,617 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/server/constants.ts
+var constants_exports = {};
+__export(constants_exports, {
+  AMOUNT_TOLERANCE: () => AMOUNT_TOLERANCE,
+  DEFAULT_PLATFORM_URL: () => DEFAULT_PLATFORM_URL,
+  ERC20_TRANSFER_SIGNATURE: () => ERC20_TRANSFER_SIGNATURE,
+  NETWORKS: () => NETWORKS,
+  TOKENS: () => TOKENS,
+  getAvailableNetworks: () => getAvailableNetworks,
+  getChainId: () => getChainId,
+  getNetworkConfig: () => getNetworkConfig,
+  getNetworksByEnvironment: () => getNetworksByEnvironment,
+  getRpcUrl: () => getRpcUrl,
+  getTokenConfig: () => getTokenConfig,
+  isMainnet: () => isMainnet,
+  isTestnet: () => isTestnet,
+  registerCustomNetwork: () => registerCustomNetwork,
+  registerCustomTokens: () => registerCustomTokens
+});
+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 getRpcUrl(network, customRpcUrl) {
+  if (customRpcUrl) {
+    return customRpcUrl;
+  }
+  const envRpc = process.env.X402_RPC_URL || process.env[`X402_RPC_URL_${network.toUpperCase()}`];
+  if (envRpc) {
+    return envRpc;
+  }
+  return getNetworkConfig(network).rpcUrl;
+}
+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;
+  });
+}
+var NETWORKS, TOKENS, ERC20_TRANSFER_SIGNATURE, DEFAULT_PLATFORM_URL, AMOUNT_TOLERANCE, customNetworks, customTokens;
+var init_constants = __esm({
+  "src/server/constants.ts"() {
+    "use strict";
+    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"
+      }
+    };
+    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"
+        }
+      }
+    };
+    ERC20_TRANSFER_SIGNATURE = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+    DEFAULT_PLATFORM_URL = "https://api.x402.dev";
+    AMOUNT_TOLERANCE = BigInt(1e15);
+    customNetworks = /* @__PURE__ */ new Map();
+    customTokens = /* @__PURE__ */ new Map();
+  }
+});
+
+// src/server/platform.ts
+init_constants();
+var cachedConfig = null;
+var validationPromise = null;
+function getPlatformBaseUrl() {
+  return process.env.X402_PLATFORM_URL || process.env.NEXT_PUBLIC_X402_PLATFORM_URL || DEFAULT_PLATFORM_URL;
+}
+async function validateProject(appId) {
+  const baseUrl = getPlatformBaseUrl();
+  const url = `${baseUrl}/v1/validate?appId=${encodeURIComponent(appId)}`;
+  const response = await fetch(url, {
+    method: "GET",
+    headers: { "Content-Type": "application/json" }
+  });
+  if (!response.ok) {
+    if (response.status === 404) {
+      throw new Error("Project not found: Invalid X402_APP_ID");
+    }
+    if (response.status === 401) {
+      throw new Error("Unauthorized: Invalid X402_APP_ID");
+    }
+    throw new Error(`Platform validation failed: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  if (!data.appId || !data.payTo || !data.network) {
+    throw new Error("Invalid platform response: missing required fields");
+  }
+  if (data.status !== "ACTIVE") {
+    throw new Error(`Project is not active: status is ${data.status}`);
+  }
+  return {
+    appId: data.appId,
+    name: data.name,
+    payTo: data.payTo,
+    network: data.network,
+    status: data.status
+  };
+}
+async function initializePlatform() {
+  if (cachedConfig) {
+    return cachedConfig;
+  }
+  if (validationPromise) {
+    return validationPromise;
+  }
+  const appId = process.env.X402_APP_ID || process.env.NEXT_PUBLIC_X402_APP_ID;
+  if (!appId || typeof appId !== "string" || appId.trim().length === 0) {
+    throw new Error("X402_APP_ID is required. Set it in your environment variables.");
+  }
+  validationPromise = validateProject(appId.trim());
+  try {
+    cachedConfig = await validationPromise;
+    return cachedConfig;
+  } catch (error) {
+    validationPromise = null;
+    throw error;
+  }
+}
+function getProjectConfig() {
+  if (!cachedConfig) {
+    throw new Error("Platform not initialized. Call initializePlatform() first.");
+  }
+  return cachedConfig;
+}
+function clearCache() {
+  cachedConfig = null;
+  validationPromise = null;
+}
+
+// src/server/blockchain.ts
+init_constants();
+async function callRPC(url, method, params) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      jsonrpc: "2.0",
+      id: 1,
+      method,
+      params
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`RPC call failed: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  if (data.error) {
+    throw new Error(`RPC error: ${data.error.message}`);
+  }
+  return data.result;
+}
+async function getTransactionReceipt(rpcUrl, txHash) {
+  const receipt = await callRPC(
+    rpcUrl,
+    "eth_getTransactionReceipt",
+    [txHash]
+  );
+  if (!receipt) {
+    return null;
+  }
+  return {
+    transactionHash: receipt.transactionHash,
+    blockNumber: parseInt(receipt.blockNumber, 16),
+    status: receipt.status === "0x1" ? "success" : "failed",
+    from: receipt.from,
+    to: receipt.to,
+    value: receipt.value || "0x0",
+    logs: receipt.logs || []
+  };
+}
+function decodeERC20Transfer(log) {
+  if (log.topics[0]?.toLowerCase() !== ERC20_TRANSFER_SIGNATURE.toLowerCase()) {
+    return null;
+  }
+  if (log.topics.length !== 3) {
+    return null;
+  }
+  return {
+    from: ("0x" + log.topics[1].slice(-40)).toLowerCase(),
+    to: ("0x" + log.topics[2].slice(-40)).toLowerCase(),
+    value: BigInt(log.data),
+    tokenAddress: log.address.toLowerCase()
+  };
+}
+function weiToTokenUnits(wei, decimals = 18) {
+  const divisor = 10n ** BigInt(decimals);
+  const whole = wei / divisor;
+  const remainder = wei % divisor;
+  if (remainder === 0n) {
+    return whole.toString();
+  }
+  const remainderStr = remainder.toString().padStart(decimals, "0");
+  const trimmed = remainderStr.replace(/0+$/, "");
+  return `${whole}.${trimmed}`;
+}
+function parseAmountToWei(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);
+}
+async function verifyPaymentOnChain(transactionHash, config, requiredAmount, requiredToken, customRpcUrl) {
+  try {
+    const rpcUrl = getRpcUrl(config.network, customRpcUrl);
+    const receipt = await getTransactionReceipt(rpcUrl, transactionHash);
+    if (!receipt) {
+      return {
+        valid: false,
+        error: "Transaction not found or not yet confirmed"
+      };
+    }
+    if (receipt.status !== "success") {
+      return {
+        valid: false,
+        error: "Transaction failed"
+      };
+    }
+    const recipient = config.payTo.toLowerCase();
+    if (requiredToken.toUpperCase() === "MNT") {
+      const valueWei = BigInt(receipt.value);
+      const requiredWei2 = parseAmountToWei(requiredAmount, 18);
+      if (receipt.to?.toLowerCase() !== recipient) {
+        return {
+          valid: false,
+          error: `Recipient mismatch: expected ${config.payTo}, got ${receipt.to}`
+        };
+      }
+      if (valueWei < requiredWei2 - AMOUNT_TOLERANCE || valueWei > requiredWei2 + AMOUNT_TOLERANCE) {
+        return {
+          valid: false,
+          error: `Amount mismatch: expected ${requiredAmount} MNT, got ${weiToTokenUnits(valueWei)} MNT`
+        };
+      }
+      return {
+        valid: true,
+        transactionHash: receipt.transactionHash,
+        amount: weiToTokenUnits(valueWei),
+        token: "MNT",
+        blockNumber: receipt.blockNumber
+      };
+    }
+    const tokenConfig = getTokenConfig(requiredToken, config.network);
+    if (!tokenConfig) {
+      return {
+        valid: false,
+        error: `Unknown token: ${requiredToken}`
+      };
+    }
+    let transfer = null;
+    for (const log of receipt.logs) {
+      if (log.address.toLowerCase() !== tokenConfig.address.toLowerCase()) {
+        continue;
+      }
+      const decoded = decodeERC20Transfer(log);
+      if (decoded && decoded.to === recipient) {
+        transfer = decoded;
+        break;
+      }
+    }
+    if (!transfer) {
+      return {
+        valid: false,
+        error: `No ${requiredToken} transfer found to ${config.payTo}`
+      };
+    }
+    const requiredWei = parseAmountToWei(requiredAmount, tokenConfig.decimals);
+    const toleranceAdjusted = AMOUNT_TOLERANCE / 10n ** BigInt(18 - tokenConfig.decimals);
+    if (transfer.value < requiredWei - toleranceAdjusted || transfer.value > requiredWei + toleranceAdjusted) {
+      return {
+        valid: false,
+        error: `Amount mismatch: expected ${requiredAmount} ${requiredToken}, got ${weiToTokenUnits(transfer.value, tokenConfig.decimals)} ${requiredToken}`
+      };
+    }
+    return {
+      valid: true,
+      transactionHash: receipt.transactionHash,
+      amount: weiToTokenUnits(transfer.value, tokenConfig.decimals),
+      token: requiredToken,
+      blockNumber: receipt.blockNumber
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error instanceof Error ? error.message : "Failed to verify payment on blockchain"
+    };
+  }
+}
+
+// src/server/verify.ts
+async function verifyPayment(receipt, config, requiredAmount, requiredToken, _useBlockchain = true, customRpcUrl) {
+  const result = await verifyPaymentOnChain(
+    receipt.transactionHash,
+    config,
+    requiredAmount,
+    requiredToken,
+    customRpcUrl
+  );
+  return {
+    valid: result.valid,
+    transactionHash: result.transactionHash,
+    amount: result.amount,
+    token: result.token,
+    error: result.error
+  };
+}
+function extractPaymentReceipt(headers) {
+  const getHeader = (name) => {
+    if (headers instanceof Headers) {
+      return headers.get(name);
+    }
+    const value = headers[name.toLowerCase()] || headers[name];
+    return Array.isArray(value) ? value[0] || null : value || null;
+  };
+  const transactionHash = getHeader("x-402-transaction-hash") || getHeader("X-402-Transaction-Hash");
+  if (!transactionHash) {
+    return null;
+  }
+  return {
+    transactionHash,
+    timestamp: getHeader("x-402-timestamp") || getHeader("X-402-Timestamp") || void 0
+  };
+}
+
+// src/server/middleware.ts
+init_constants();
+function resolveNetwork(options, projectNetwork) {
+  if (options.network) {
+    return options.network;
+  }
+  if (options.testnet) {
+    return "mantle-sepolia";
+  }
+  return projectNetwork;
+}
+function createPaymentRequiredResponse(options, config, chainId) {
+  const network = resolveNetwork(options, config.network);
+  return {
+    status: 402,
+    headers: {
+      "Content-Type": "application/json",
+      "X-402-Amount": options.price,
+      "X-402-Token": options.token,
+      "X-402-Network": network,
+      "X-402-Chain-Id": chainId.toString(),
+      "X-402-Recipient": config.payTo
+    },
+    body: {
+      error: "Payment Required",
+      amount: options.price,
+      token: options.token,
+      network,
+      chainId,
+      recipient: config.payTo
+    }
+  };
+}
+async function processPaymentMiddleware(options, headers) {
+  try {
+    if (options.customNetwork) {
+      const networkId = options.network || "custom-network";
+      registerCustomNetwork(networkId, options.customNetwork);
+    }
+    if (options.customTokens) {
+      const config2 = getProjectConfig();
+      const network2 = resolveNetwork(options, config2.network);
+      registerCustomTokens(network2, options.customTokens);
+    }
+    const config = getProjectConfig();
+    const network = resolveNetwork(options, config.network);
+    const { getChainId: getChainId3 } = await Promise.resolve().then(() => (init_constants(), constants_exports));
+    const chainId = getChainId3(network);
+    const receipt = extractPaymentReceipt(headers);
+    if (!receipt) {
+      return {
+        allowed: false,
+        paymentRequired: createPaymentRequiredResponse(options, config, chainId)
+      };
+    }
+    const verification = await verifyPayment(
+      receipt,
+      { ...config, network },
+      options.price,
+      options.token,
+      true,
+      options.rpcUrl
+    );
+    if (!verification.valid) {
+      return {
+        allowed: false,
+        error: {
+          status: 402,
+          message: verification.error || "Payment verification failed"
+        }
+      };
+    }
+    return { allowed: true };
+  } catch (error) {
+    return {
+      allowed: false,
+      error: {
+        status: 500,
+        message: error instanceof Error ? error.message : "Internal server error"
+      }
+    };
+  }
+}
+
+// src/server/hono.ts
+function x402(options) {
+  if (!options.price || !options.token) {
+    throw new Error("x402 middleware requires price and token options");
+  }
+  let initPromise = null;
+  let initialized = false;
+  const ensureInitialized = async () => {
+    if (initialized) return;
+    if (initPromise) {
+      await initPromise;
+      return;
+    }
+    initPromise = initializePlatform().then(() => {
+      initialized = true;
+      initPromise = null;
+    });
+    await initPromise;
+  };
+  return async (c, next) => {
+    try {
+      await ensureInitialized();
+      const result = await processPaymentMiddleware(options, c.req.header());
+      if (!result.allowed) {
+        if (result.paymentRequired) {
+          return c.json(result.paymentRequired.body, 402, result.paymentRequired.headers);
+        }
+        if (result.error) {
+          return c.json({ error: result.error.message }, result.error.status);
+        }
+      }
+      await next();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Internal server error";
+      return c.json({ error: message }, 500);
+    }
+  };
+}
+
+// src/server/index.ts
+init_constants();
+export {
+  DEFAULT_PLATFORM_URL,
+  NETWORKS,
+  TOKENS,
+  clearCache,
+  extractPaymentReceipt,
+  getAvailableNetworks,
+  getChainId,
+  getNetworkConfig,
+  getNetworksByEnvironment,
+  getProjectConfig,
+  getRpcUrl,
+  getTokenConfig,
+  initializePlatform,
+  isMainnet,
+  isTestnet,
+  processPaymentMiddleware,
+  registerCustomNetwork,
+  registerCustomTokens,
+  verifyPayment,
+  verifyPaymentOnChain,
+  x402
+};
+//# sourceMappingURL=index.js.map