@relai-fi/x402 0.1.0

package/dist/index.cjs

@@ -0,0 +1,720 @@
+"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/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BASE_MAINNET_NETWORK: () => BASE_MAINNET_NETWORK,
+  CAIP2_TO_NETWORK: () => CAIP2_TO_NETWORK,
+  CHAIN_IDS: () => CHAIN_IDS,
+  EXPLORER_TX_URL: () => EXPLORER_TX_URL,
+  NETWORK_CAIP2: () => NETWORK_CAIP2,
+  NETWORK_LABELS: () => NETWORK_LABELS,
+  NETWORK_V1_TO_V2: () => NETWORK_V1_TO_V2,
+  NETWORK_V2_TO_V1: () => NETWORK_V2_TO_V1,
+  RELAI_FACILITATOR_URL: () => RELAI_FACILITATOR_URL,
+  RELAI_NETWORKS: () => RELAI_NETWORKS,
+  Relai: () => server_default,
+  SOLANA_MAINNET_NETWORK: () => SOLANA_MAINNET_NETWORK,
+  USDC_ADDRESSES: () => USDC_ADDRESSES,
+  USDC_BASE: () => USDC_BASE,
+  USDC_SOLANA: () => USDC_SOLANA,
+  convertPayloadToVersion: () => convertPayloadToVersion,
+  convertV1ToV2: () => convertV1ToV2,
+  convertV2ToV1: () => convertV2ToV1,
+  createX402Client: () => createX402Client,
+  default: () => Relai,
+  detectPayloadVersion: () => detectPayloadVersion,
+  formatUsd: () => formatUsd,
+  fromAtomicUnits: () => fromAtomicUnits,
+  isEvm: () => isEvm,
+  isEvmNetwork: () => isEvmNetwork,
+  isSolana: () => isSolana,
+  isSolanaNetwork: () => isSolanaNetwork,
+  networkV1ToV2: () => networkV1ToV2,
+  networkV2ToV1: () => networkV2ToV1,
+  normalizeNetwork: () => normalizeNetwork,
+  normalizePaymentHeader: () => normalizePaymentHeader,
+  toAtomicUnits: () => toAtomicUnits
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/server.ts
+var import_axios = __toESM(require("axios"), 1);
+
+// src/types.ts
+var RELAI_FACILITATOR_URL = "https://facilitator.x402.fi";
+var NETWORK_CAIP2 = {
+  "solana": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  "base": "eip155:8453",
+  "avalanche": "eip155:43114",
+  "skale-base": "eip155:1187947933"
+};
+var CAIP2_TO_NETWORK = Object.fromEntries(
+  Object.entries(NETWORK_CAIP2).map(([k, v]) => [v, k])
+);
+var CHAIN_IDS = {
+  "base": 8453,
+  "avalanche": 43114,
+  "skale-base": 1187947933
+};
+var USDC_ADDRESSES = {
+  "solana": "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+  "base": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  "avalanche": "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+  "skale-base": "0x85889c8c714505E0c94b30fcfcF64fE3Ac8FCb20"
+};
+var EXPLORER_TX_URL = {
+  "solana": (tx) => `https://solscan.io/tx/${tx}`,
+  "base": (tx) => `https://basescan.org/tx/${tx}`,
+  "avalanche": (tx) => `https://snowtrace.io/tx/${tx}`,
+  "skale-base": (tx) => `https://skale-base-explorer.skalenodes.com/tx/${tx}`
+};
+var NETWORK_LABELS = {
+  "solana": "Solana",
+  "base": "Base",
+  "avalanche": "Avalanche",
+  "skale-base": "SKALE Base"
+};
+var SOLANA_MAINNET_NETWORK = NETWORK_CAIP2["solana"];
+var BASE_MAINNET_NETWORK = NETWORK_CAIP2["base"];
+var USDC_SOLANA = USDC_ADDRESSES["solana"];
+var USDC_BASE = USDC_ADDRESSES["base"];
+var RELAI_NETWORKS = ["solana", "base", "avalanche", "skale-base"];
+function isSolana(network) {
+  return network === "solana" || network.startsWith("solana:");
+}
+function isEvm(network) {
+  return ["base", "avalanche", "skale-base"].includes(network) || network.startsWith("eip155:");
+}
+function normalizeNetwork(network) {
+  if (RELAI_NETWORKS.includes(network)) return network;
+  const fromCaip2 = CAIP2_TO_NETWORK[network];
+  if (fromCaip2) return fromCaip2;
+  if (network.startsWith("solana:")) return "solana";
+  if (network.startsWith("eip155:")) {
+    const chainId = parseInt(network.split(":")[1]);
+    const entry = Object.entries(CHAIN_IDS).find(([, id]) => id === chainId);
+    if (entry) return entry[0];
+  }
+  return null;
+}
+
+// src/server.ts
+var Relai = class {
+  constructor(config) {
+    this.config = {
+      network: "solana",
+      apiBaseUrl: "https://relai.fi/api",
+      facilitatorUrl: RELAI_FACILITATOR_URL,
+      ...config
+    };
+    if (!this.config.apiKey || typeof this.config.apiKey !== "string") {
+      throw new Error("[Relai] Missing required apiKey in configuration");
+    }
+    this.client = import_axios.default.create({
+      baseURL: this.config.apiBaseUrl,
+      timeout: 1e4,
+      headers: {
+        "Authorization": `Bearer ${this.config.apiKey}`,
+        "Content-Type": "application/json"
+      }
+    });
+  }
+  /**
+   * Express middleware to protect an endpoint with x402 micropayments.
+   * Returns a 402 with `accepts` for the configured network.
+   * Supports: Solana, Base, Avalanche, SKALE Base.
+   */
+  protect(options) {
+    return async (req, res, next) => {
+      try {
+        const resolvedPrice = typeof options.price === "function" ? await options.price(req) : options.price;
+        if (typeof resolvedPrice !== "number" || !isFinite(resolvedPrice) || resolvedPrice <= 0) {
+          return res.status(400).json({ error: "Invalid price configuration", code: "INVALID_PRICE" });
+        }
+        const paymentSignature = req.headers["x-payment-signature"] || req.headers["x-relai-payment"];
+        if (!paymentSignature) {
+          const network = this.config.network;
+          const caip2 = NETWORK_CAIP2[network] || NETWORK_CAIP2["solana"];
+          const asset = USDC_ADDRESSES[network] || USDC_ADDRESSES["solana"];
+          return res.status(402).json({
+            x402Version: 2,
+            error: "Payment required",
+            resource: {
+              url: `${req.protocol}://${req.get("host")}${req.originalUrl}`,
+              description: options.description || "API access",
+              mimeType: "application/json"
+            },
+            accepts: [{
+              scheme: "exact",
+              network: caip2,
+              maxAmountRequired: String(Math.floor(resolvedPrice * 1e6)),
+              asset,
+              payTo: options.payTo,
+              maxTimeoutSeconds: 60,
+              extra: {
+                name: "USD Coin",
+                version: "2",
+                decimals: 6,
+                facilitatorUrl: this.config.facilitatorUrl
+              }
+            }]
+          });
+        }
+        const verification = await this.verifyPayment(paymentSignature, resolvedPrice, options.maxTimeout);
+        if (!verification.verified) {
+          return res.status(402).json({
+            error: "Payment verification failed",
+            code: "PAYMENT_INVALID",
+            details: verification.error
+          });
+        }
+        req.payment = verification;
+        if (options.customRules) {
+          const customValid = await options.customRules(req);
+          if (!customValid) {
+            return res.status(403).json({ error: "Custom validation failed", code: "VALIDATION_FAILED" });
+          }
+        }
+        next();
+      } catch (error) {
+        console.error("Relai protection error:", error);
+        res.status(500).json({ error: "Internal server error", code: "SERVER_ERROR" });
+      }
+    };
+  }
+  async verifyPayment(signature, expectedPrice, timeoutMs) {
+    try {
+      const response = await this.client.post(
+        "/verify-payment",
+        { signature, expectedPrice, network: this.config.network },
+        { timeout: typeof timeoutMs === "number" ? Math.max(1, timeoutMs) : void 0 }
+      );
+      return response.data;
+    } catch (error) {
+      return { verified: false, error: error.response?.data?.error || "Verification failed" };
+    }
+  }
+  async getStats(apiId) {
+    const params = apiId ? { apiId } : {};
+    const response = await this.client.get("/stats", { params });
+    return response.data;
+  }
+  createProtectedEndpoint(options) {
+    return this.protect(options);
+  }
+};
+var server_default = Relai;
+
+// src/client.ts
+var import_web3 = require("@solana/web3.js");
+var import_spl_token = require("@solana/spl-token");
+var PERMIT_NETWORKS = /* @__PURE__ */ new Set([]);
+var DEFAULT_EVM_RPC_URLS = {
+  "skale-base": "https://skale-base.skalenodes.com/v1/base",
+  "base": "https://mainnet.base.org",
+  "avalanche": "https://api.avax.network/ext/bc/C/rpc"
+};
+function createX402Client(config) {
+  const {
+    wallets = {},
+    wallet: legacyWallet,
+    facilitatorUrl = RELAI_FACILITATOR_URL,
+    preferredNetwork,
+    solanaRpcUrl = "https://api.mainnet-beta.solana.com",
+    evmRpcUrls = {},
+    maxAmountAtomic,
+    verbose = false
+  } = config;
+  const log = verbose ? console.log.bind(console, "[relai-x402]") : () => {
+  };
+  const effectiveWallets = { ...wallets };
+  if (legacyWallet && !effectiveWallets.solana) {
+    effectiveWallets.solana = legacyWallet;
+  }
+  const hasSolanaWallet = Boolean(
+    effectiveWallets.solana?.publicKey && effectiveWallets.solana?.signTransaction
+  );
+  if (hasSolanaWallet) log("Solana wallet ready");
+  function selectAccept(accepts) {
+    if (preferredNetwork) {
+      const caip2 = NETWORK_CAIP2[preferredNetwork];
+      for (const a of accepts) {
+        const net = a.network || "";
+        if (net === preferredNetwork || net === caip2) {
+          const chain = isSolana(net) ? "solana" : "evm";
+          if (chain === "solana" && hasSolanaWallet || chain === "evm" && effectiveWallets.evm) {
+            return { accept: a, chain };
+          }
+        }
+      }
+    }
+    for (const a of accepts) {
+      const net = a.network || "";
+      if (isSolana(net) && hasSolanaWallet) return { accept: a, chain: "solana" };
+      if (isEvm(net) && effectiveWallets.evm) return { accept: a, chain: "evm" };
+    }
+    return null;
+  }
+  async function evmRpcCall(rpcUrl, to, data) {
+    const res = await fetch(rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        method: "eth_call",
+        params: [{ to, data }, "latest"],
+        id: 1
+      })
+    });
+    const json = await res.json();
+    if (json.error) throw new Error(`RPC error: ${json.error.message}`);
+    return json.result;
+  }
+  function getEvmRpcUrl(network) {
+    return evmRpcUrls[network] || DEFAULT_EVM_RPC_URLS[network] || "";
+  }
+  async function buildEvmPermitPayment(accept, requirements, url) {
+    const evmWallet = effectiveWallets.evm;
+    const extra = accept.extra || {};
+    const rawNetwork = accept.network || "";
+    const network = normalizeNetwork(rawNetwork);
+    const chainId = network ? CHAIN_IDS[network] : parseInt(rawNetwork.split(":")[1] || "8453");
+    const paymentAmount = accept.amount || accept.maxAmountRequired;
+    const spender = extra.feePayer || accept.payTo;
+    const usdcAddress = accept.asset;
+    const rpcUrl = getEvmRpcUrl(network || rawNetwork);
+    if (!rpcUrl) throw new Error(`[relai-x402] No EVM RPC URL for network ${network || rawNetwork}`);
+    log("Building EIP-2612 permit on chain", chainId);
+    const paddedAddress = evmWallet.address.toLowerCase().replace("0x", "").padStart(64, "0");
+    const nonceHex = await evmRpcCall(rpcUrl, usdcAddress, "0x7ecebe00" + paddedAddress);
+    const nonce = nonceHex ? parseInt(nonceHex, 16) : 0;
+    if (isNaN(nonce)) throw new Error(`[relai-x402] Failed to read permit nonce from ${usdcAddress} on ${rpcUrl}`);
+    log("  Permit nonce:", nonce);
+    const nameHex = await evmRpcCall(rpcUrl, usdcAddress, "0x06fdde03");
+    let tokenName = "USD Coin";
+    try {
+      const offset = parseInt(nameHex.slice(2, 66), 16) * 2;
+      const length = parseInt(nameHex.slice(2 + offset, 2 + offset + 64), 16);
+      const hex = nameHex.slice(2 + offset + 64, 2 + offset + 64 + length * 2);
+      tokenName = decodeURIComponent(hex.replace(/[0-9a-f]{2}/g, "%$&"));
+    } catch {
+      tokenName = extra.name || "USD Coin";
+    }
+    log("  Token name:", tokenName);
+    const deadline = Math.floor(Date.now() / 1e3) + 600;
+    const domain = {
+      name: tokenName,
+      version: extra.version || "2",
+      chainId,
+      verifyingContract: usdcAddress
+    };
+    const types = {
+      Permit: [
+        { name: "owner", type: "address" },
+        { name: "spender", type: "address" },
+        { name: "value", type: "uint256" },
+        { name: "nonce", type: "uint256" },
+        { name: "deadline", type: "uint256" }
+      ]
+    };
+    const message = {
+      owner: evmWallet.address,
+      spender,
+      value: paymentAmount,
+      nonce: String(nonce),
+      deadline: String(deadline)
+    };
+    log("Signing EIP-2612 permit:", message);
+    const signature = await evmWallet.signTypedData({
+      domain,
+      types,
+      message,
+      primaryType: "Permit"
+    });
+    const sigHex = signature.replace("0x", "");
+    const r = "0x" + sigHex.slice(0, 64);
+    const s = "0x" + sigHex.slice(64, 128);
+    const v = parseInt(sigHex.slice(128, 130), 16);
+    log("  Permit signed: v=%d r=%s s=%s", v, r, s);
+    const paymentPayload = {
+      x402Version: 2,
+      scheme: "exact",
+      network: network || rawNetwork,
+      payload: {
+        userAddress: evmWallet.address,
+        permit: { deadline: String(deadline), v, r, s },
+        amount: paymentAmount
+      }
+    };
+    return btoa(JSON.stringify(paymentPayload));
+  }
+  async function buildEvmPayment(accept, requirements, url) {
+    const evmWallet = effectiveWallets.evm;
+    const extra = accept.extra || {};
+    const rawNetwork = accept.network || "";
+    const network = normalizeNetwork(rawNetwork);
+    const chainId = network ? CHAIN_IDS[network] : parseInt(rawNetwork.split(":")[1] || "8453");
+    const paymentAmount = accept.amount || accept.maxAmountRequired;
+    const domain = {
+      name: extra.name || "USD Coin",
+      version: extra.version || "2",
+      chainId,
+      verifyingContract: accept.asset
+    };
+    const validAfter = 0;
+    const validBefore = Math.floor(Date.now() / 1e3) + 3600;
+    const nonce = "0x" + [...crypto.getRandomValues(new Uint8Array(32))].map((b) => b.toString(16).padStart(2, "0")).join("");
+    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" }
+      ]
+    };
+    const spender = extra.feePayer || accept.payTo;
+    const message = {
+      from: evmWallet.address,
+      to: spender,
+      value: paymentAmount,
+      validAfter: String(validAfter),
+      validBefore: String(validBefore),
+      nonce
+    };
+    log("Signing EIP-3009 transferWithAuthorization on chain", chainId);
+    const signature = await evmWallet.signTypedData({
+      domain,
+      types,
+      message,
+      primaryType: "TransferWithAuthorization"
+    });
+    const paymentPayload = {
+      x402Version: 2,
+      resource: requirements.resource || { url },
+      accepted: accept,
+      payload: {
+        authorization: message,
+        signature
+      },
+      facilitatorUrl
+    };
+    return btoa(JSON.stringify(paymentPayload));
+  }
+  async function buildSolanaPayment(accept, requirements, url) {
+    const solWallet = effectiveWallets.solana;
+    const extra = accept.extra || {};
+    if (!extra.feePayer) {
+      throw new Error("[relai-x402] Missing feePayer in Solana payment requirements");
+    }
+    const connection = new import_web3.Connection(solanaRpcUrl, "confirmed");
+    const userPubkey = new import_web3.PublicKey(solWallet.publicKey.toString());
+    const merchantPubkey = new import_web3.PublicKey(accept.payTo);
+    const feePayerPubkey = new import_web3.PublicKey(extra.feePayer);
+    const mintPubkey = new import_web3.PublicKey(accept.asset);
+    const paymentAmount = BigInt(accept.amount || accept.maxAmountRequired);
+    log("Building Solana SPL transfer");
+    log("  User:", userPubkey.toBase58());
+    log("  Merchant:", merchantPubkey.toBase58());
+    log("  FeePayer:", feePayerPubkey.toBase58());
+    log("  Mint:", mintPubkey.toBase58());
+    log("  Amount:", paymentAmount.toString());
+    const mintInfo = await (0, import_spl_token.getMint)(connection, mintPubkey);
+    const programId = mintInfo.address.equals(mintPubkey) ? mintInfo.owner?.toBase58?.() === import_spl_token.TOKEN_2022_PROGRAM_ID.toBase58() ? import_spl_token.TOKEN_2022_PROGRAM_ID : import_spl_token.TOKEN_PROGRAM_ID : import_spl_token.TOKEN_PROGRAM_ID;
+    const sourceAta = await (0, import_spl_token.getAssociatedTokenAddress)(
+      mintPubkey,
+      userPubkey,
+      false,
+      programId
+    );
+    const destinationAta = await (0, import_spl_token.getAssociatedTokenAddress)(
+      mintPubkey,
+      merchantPubkey,
+      true,
+      programId
+    );
+    log("  Source ATA:", sourceAta.toBase58());
+    log("  Dest ATA:", destinationAta.toBase58());
+    const transferIx = (0, import_spl_token.createTransferCheckedInstruction)(
+      sourceAta,
+      mintPubkey,
+      destinationAta,
+      userPubkey,
+      paymentAmount,
+      mintInfo.decimals,
+      [],
+      programId
+    );
+    const { blockhash } = await connection.getLatestBlockhash("confirmed");
+    const message = new import_web3.TransactionMessage({
+      payerKey: feePayerPubkey,
+      recentBlockhash: blockhash,
+      instructions: [transferIx]
+    }).compileToV0Message();
+    const transaction = new import_web3.VersionedTransaction(message);
+    const signedTx = await solWallet.signTransaction(transaction);
+    log("Transaction signed by user");
+    const serializedTx = Buffer.from(signedTx.serialize()).toString("base64");
+    const paymentPayload = {
+      x402Version: 2,
+      resource: requirements.resource || { url },
+      accepted: accept,
+      payload: {
+        transaction: serializedTx
+      }
+    };
+    return btoa(JSON.stringify(paymentPayload));
+  }
+  async function x402Fetch(input, init) {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    log("Request:", url);
+    const response = await fetch(input, init);
+    if (response.status !== 402) return response;
+    log("Got 402 Payment Required");
+    let requirements;
+    try {
+      requirements = await response.clone().json();
+    } catch {
+      throw new Error("[relai-x402] Failed to parse 402 response body");
+    }
+    const accepts = requirements.accepts || [];
+    if (!accepts.length) throw new Error("[relai-x402] No payment options in 402 response");
+    const selected = selectAccept(accepts);
+    if (!selected) {
+      const networks = accepts.map((a) => a.network).join(", ");
+      throw new Error(`[relai-x402] No wallet available for networks: ${networks}`);
+    }
+    const { accept, chain } = selected;
+    const amount = accept.amount || accept.maxAmountRequired;
+    log(`Selected: ${chain} / ${accept.network} / amount=${amount}`);
+    if (maxAmountAtomic && BigInt(amount) > BigInt(maxAmountAtomic)) {
+      throw new Error(`[relai-x402] Amount ${amount} exceeds max ${maxAmountAtomic}`);
+    }
+    if (chain === "solana" && hasSolanaWallet) {
+      const paymentHeader = await buildSolanaPayment(accept, requirements, url);
+      log("Retrying with X-PAYMENT header (Solana)");
+      return fetch(input, {
+        ...init,
+        headers: {
+          ...init?.headers || {},
+          "X-PAYMENT": paymentHeader
+        }
+      });
+    }
+    if (chain === "evm") {
+      const evmNetwork = normalizeNetwork(accept.network || "");
+      const usePermit = evmNetwork && PERMIT_NETWORKS.has(evmNetwork);
+      const paymentHeader = usePermit ? await buildEvmPermitPayment(accept, requirements, url) : await buildEvmPayment(accept, requirements, url);
+      log("Retrying with X-PAYMENT header");
+      return fetch(input, {
+        ...init,
+        headers: {
+          ...init?.headers || {},
+          "X-PAYMENT": paymentHeader
+        }
+      });
+    }
+    throw new Error("[relai-x402] Unexpected state \u2014 no payment handler matched");
+  }
+  return { fetch: x402Fetch };
+}
+
+// src/utils/payload-converter.ts
+var NETWORK_V1_TO_V2 = {
+  "solana": "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  "solana-devnet": "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1",
+  "base": "eip155:8453",
+  "base-sepolia": "eip155:84532",
+  "ethereum": "eip155:1",
+  "polygon": "eip155:137",
+  "avalanche": "eip155:43114",
+  "skale-base": "eip155:1187947933",
+  "peaq": "eip155:3338",
+  "sei": "eip155:1329"
+};
+var NETWORK_V2_TO_V1 = Object.fromEntries(
+  Object.entries(NETWORK_V1_TO_V2).map(([k, v]) => [v, k])
+);
+function networkV2ToV1(caip2Network) {
+  if (!caip2Network) return "solana";
+  if (NETWORK_V2_TO_V1[caip2Network]) {
+    return NETWORK_V2_TO_V1[caip2Network];
+  }
+  if (caip2Network.startsWith("solana:")) {
+    const chainId = caip2Network.split(":")[1];
+    if (chainId === "5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp") return "solana";
+    if (chainId === "EtWTRABZaYq6iMfeYKouRu166VU2xqa1") return "solana-devnet";
+    return "solana";
+  }
+  if (caip2Network.startsWith("eip155:")) {
+    const chainId = caip2Network.split(":")[1];
+    const mapping = {
+      "1": "ethereum",
+      "137": "polygon",
+      "8453": "base",
+      "84532": "base-sepolia",
+      "43114": "avalanche",
+      "1187947933": "skale-base",
+      "3338": "peaq",
+      "1329": "sei"
+    };
+    return mapping[chainId] || caip2Network;
+  }
+  return caip2Network;
+}
+function networkV1ToV2(v1Network) {
+  if (!v1Network) return "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+  return NETWORK_V1_TO_V2[v1Network] || v1Network;
+}
+function detectPayloadVersion(payload) {
+  if (!payload || typeof payload !== "object") return null;
+  const p = payload;
+  if (p.x402Version === 1) return 1;
+  if (p.x402Version === 2) return 2;
+  if ("accepted" in p && "resource" in p) return 2;
+  if ("scheme" in p && "network" in p && !("accepted" in p)) return 1;
+  return null;
+}
+function convertV2ToV1(v2Payload) {
+  const accepted = v2Payload.accepted || {};
+  return {
+    x402Version: 1,
+    scheme: accepted.scheme || "exact",
+    network: networkV2ToV1(accepted.network),
+    payload: v2Payload.payload
+  };
+}
+function convertV1ToV2(v1Payload, resourceInfo = {}) {
+  return {
+    x402Version: 2,
+    resource: {
+      url: resourceInfo.url || "",
+      description: resourceInfo.description || "",
+      mimeType: resourceInfo.mimeType || "application/json"
+    },
+    accepted: {
+      scheme: v1Payload.scheme || "exact",
+      network: networkV1ToV2(v1Payload.network)
+    },
+    payload: v1Payload.payload
+  };
+}
+function convertPayloadToVersion(payload, targetVersion, options = {}) {
+  const sourceVersion = detectPayloadVersion(payload);
+  if (!sourceVersion) {
+    console.warn("[payload-converter] Could not detect source payload version");
+    return null;
+  }
+  if (sourceVersion === targetVersion) {
+    return payload;
+  }
+  if (sourceVersion === 2 && targetVersion === 1) {
+    return convertV2ToV1(payload);
+  }
+  if (sourceVersion === 1 && targetVersion === 2) {
+    return convertV1ToV2(payload, options.resourceInfo);
+  }
+  return null;
+}
+function normalizePaymentHeader(base64Header, targetVersion, options = {}) {
+  if (!base64Header) return null;
+  try {
+    const decoded = JSON.parse(
+      typeof window !== "undefined" ? atob(base64Header) : Buffer.from(base64Header, "base64").toString()
+    );
+    const converted = convertPayloadToVersion(decoded, targetVersion, options);
+    if (!converted) {
+      return null;
+    }
+    const encoded = typeof window !== "undefined" ? btoa(JSON.stringify(converted)) : Buffer.from(JSON.stringify(converted)).toString("base64");
+    return {
+      header: encoded,
+      payload: converted
+    };
+  } catch (e) {
+    console.error("[payload-converter] Failed to normalize header:", e);
+    return null;
+  }
+}
+function isSolanaNetwork(network) {
+  return network === "solana" || network === "solana-devnet" || network.startsWith("solana:");
+}
+function isEvmNetwork(network) {
+  const evmNetworks = ["base", "base-sepolia", "ethereum", "polygon", "avalanche", "skale-base", "peaq", "sei"];
+  return evmNetworks.includes(network) || network.startsWith("eip155:");
+}
+function toAtomicUnits(usd, decimals = 6) {
+  return Math.floor(usd * Math.pow(10, decimals)).toString();
+}
+function fromAtomicUnits(atomic, decimals = 6) {
+  const value = typeof atomic === "bigint" ? atomic : BigInt(atomic);
+  return Number(value) / Math.pow(10, decimals);
+}
+function formatUsd(usd, maxDecimals = 4) {
+  if (usd < 1e-4) return "<$0.0001";
+  return `$${usd.toFixed(maxDecimals).replace(/\.?0+$/, "")}`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BASE_MAINNET_NETWORK,
+  CAIP2_TO_NETWORK,
+  CHAIN_IDS,
+  EXPLORER_TX_URL,
+  NETWORK_CAIP2,
+  NETWORK_LABELS,
+  NETWORK_V1_TO_V2,
+  NETWORK_V2_TO_V1,
+  RELAI_FACILITATOR_URL,
+  RELAI_NETWORKS,
+  Relai,
+  SOLANA_MAINNET_NETWORK,
+  USDC_ADDRESSES,
+  USDC_BASE,
+  USDC_SOLANA,
+  convertPayloadToVersion,
+  convertV1ToV2,
+  convertV2ToV1,
+  createX402Client,
+  detectPayloadVersion,
+  formatUsd,
+  fromAtomicUnits,
+  isEvm,
+  isEvmNetwork,
+  isSolana,
+  isSolanaNetwork,
+  networkV1ToV2,
+  networkV2ToV1,
+  normalizeNetwork,
+  normalizePaymentHeader,
+  toAtomicUnits
+});
+//# sourceMappingURL=index.cjs.map