@wazabiai/x402 0.1.0

package/dist/index.js

@@ -0,0 +1,750 @@
+import { z } from 'zod';
+import axios from 'axios';
+import { createWalletClient, http, verifyTypedData } from 'viem';
+import { privateKeyToAccount } from 'viem/accounts';
+import { bsc } from 'viem/chains';
+
+/* @wazabiai/x402 - x402 v2 Payment Protocol SDK */
+
+var X402_VERSION = "2.0.0";
+var X402_DOMAIN_NAME = "x402";
+var X402_HEADERS = {
+  PAYMENT_REQUIRED: "x-payment-required",
+  PAYMENT_SIGNATURE: "x-payment-signature",
+  PAYMENT_PAYLOAD: "x-payment-payload"
+};
+var PaymentRequirementSchema = z.object({
+  /** Payment amount in smallest token unit (wei/satoshi) as string */
+  amount: z.string().regex(/^\d+$/, "Amount must be a numeric string"),
+  /** Token contract address */
+  token: z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid token address"),
+  /** CAIP-2 network identifier */
+  network_id: z.string().regex(/^eip155:\d+$/, "Invalid CAIP-2 network ID"),
+  /** Recipient address for payment */
+  pay_to: z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid recipient address"),
+  /** Optional: Payment description */
+  description: z.string().optional(),
+  /** Optional: Resource identifier being accessed */
+  resource: z.string().optional(),
+  /** Optional: Expiration timestamp (Unix epoch seconds) */
+  expires_at: z.number().int().positive().optional(),
+  /** Optional: Unique nonce to prevent replay attacks */
+  nonce: z.string().optional(),
+  /** Protocol version */
+  version: z.string().optional()
+});
+var PaymentPayloadSchema = z.object({
+  /** Payment amount in smallest token unit */
+  amount: z.string().regex(/^\d+$/, "Amount must be a numeric string"),
+  /** Token contract address */
+  token: z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid token address"),
+  /** Chain ID (numeric) */
+  chainId: z.number().int().positive(),
+  /** Recipient address */
+  payTo: z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid recipient address"),
+  /** Payer address (signer) */
+  payer: z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid payer address"),
+  /** Unix timestamp when payment expires */
+  deadline: z.number().int().positive(),
+  /** Unique nonce to prevent replay attacks */
+  nonce: z.string(),
+  /** Optional: Resource being accessed */
+  resource: z.string().optional()
+});
+var PAYMENT_TYPES = {
+  Payment: [
+    { name: "amount", type: "uint256" },
+    { name: "token", type: "address" },
+    { name: "chainId", type: "uint256" },
+    { name: "payTo", type: "address" },
+    { name: "payer", type: "address" },
+    { name: "deadline", type: "uint256" },
+    { name: "nonce", type: "string" },
+    { name: "resource", type: "string" }
+  ]
+};
+var SignedPaymentSchema = z.object({
+  payload: PaymentPayloadSchema,
+  signature: z.string().regex(/^0x[a-fA-F0-9]+$/, "Invalid signature format"),
+  signer: z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid signer address")
+});
+var X402Error = class _X402Error extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "X402Error";
+    Object.setPrototypeOf(this, _X402Error.prototype);
+  }
+};
+var PaymentRequiredError = class _PaymentRequiredError extends X402Error {
+  constructor(requirement, message = "Payment required") {
+    super(message, "PAYMENT_REQUIRED", { requirement });
+    this.requirement = requirement;
+    this.name = "PaymentRequiredError";
+    Object.setPrototypeOf(this, _PaymentRequiredError.prototype);
+  }
+};
+var PaymentVerificationError = class _PaymentVerificationError extends X402Error {
+  constructor(message, details) {
+    super(message, "PAYMENT_VERIFICATION_FAILED", details);
+    this.details = details;
+    this.name = "PaymentVerificationError";
+    Object.setPrototypeOf(this, _PaymentVerificationError.prototype);
+  }
+};
+var UnsupportedNetworkError = class _UnsupportedNetworkError extends X402Error {
+  constructor(networkId, supportedNetworks) {
+    super(
+      `Network ${networkId} is not supported. Supported networks: ${supportedNetworks.join(", ")}`,
+      "UNSUPPORTED_NETWORK",
+      { networkId, supportedNetworks }
+    );
+    this.name = "UnsupportedNetworkError";
+    Object.setPrototypeOf(this, _UnsupportedNetworkError.prototype);
+  }
+};
+var PaymentExpiredError = class _PaymentExpiredError extends X402Error {
+  constructor(deadline) {
+    super(
+      `Payment has expired. Deadline: ${new Date(deadline * 1e3).toISOString()}`,
+      "PAYMENT_EXPIRED",
+      { deadline }
+    );
+    this.name = "PaymentExpiredError";
+    Object.setPrototypeOf(this, _PaymentExpiredError.prototype);
+  }
+};
+function extractChainId(caipId) {
+  const match = caipId.match(/^eip155:(\d+)$/);
+  if (!match?.[1]) {
+    throw new X402Error(`Invalid CAIP-2 identifier: ${caipId}`, "INVALID_CAIP_ID");
+  }
+  return parseInt(match[1], 10);
+}
+function createCaipId(chainId) {
+  return `eip155:${chainId}`;
+}
+function generateNonce() {
+  const bytes = new Uint8Array(16);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function calculateDeadline(durationSeconds = 300) {
+  return Math.floor(Date.now() / 1e3) + durationSeconds;
+}
+
+// src/chains/bnb.ts
+var BSC_CHAIN_ID = 56;
+var BSC_CAIP_ID = "eip155:56";
+var BSC_RPC_URLS = [
+  "https://bsc-dataseed.binance.org",
+  "https://bsc-dataseed1.binance.org",
+  "https://bsc-dataseed2.binance.org",
+  "https://bsc-dataseed3.binance.org",
+  "https://bsc-dataseed4.binance.org",
+  "https://bsc-dataseed1.defibit.io",
+  "https://bsc-dataseed1.ninicoin.io"
+];
+var BSC_DEFAULT_RPC = BSC_RPC_URLS[0];
+var BSC_BLOCK_EXPLORER = "https://bscscan.com";
+var BSC_USDT = {
+  address: "0x55d398326f99059fF775485246999027B3197955",
+  symbol: "USDT",
+  decimals: 18,
+  name: "Tether USD"
+};
+var BSC_USDC = {
+  address: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
+  symbol: "USDC",
+  decimals: 18,
+  name: "USD Coin"
+};
+var BSC_BUSD = {
+  address: "0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56",
+  symbol: "BUSD",
+  decimals: 18,
+  name: "Binance USD"
+};
+var BSC_WBNB = {
+  address: "0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+  symbol: "BNB",
+  decimals: 18,
+  name: "Wrapped BNB"
+};
+var BSC_DEFAULT_TOKEN = BSC_USDT;
+var BSC_TOKENS = {
+  USDT: BSC_USDT,
+  USDC: BSC_USDC,
+  BUSD: BSC_BUSD,
+  WBNB: BSC_WBNB
+};
+var BSC_TOKEN_BY_ADDRESS = {
+  [BSC_USDT.address.toLowerCase()]: BSC_USDT,
+  [BSC_USDC.address.toLowerCase()]: BSC_USDC,
+  [BSC_BUSD.address.toLowerCase()]: BSC_BUSD,
+  [BSC_WBNB.address.toLowerCase()]: BSC_WBNB
+};
+var BSC_NETWORK_CONFIG = {
+  caipId: BSC_CAIP_ID,
+  chainId: BSC_CHAIN_ID,
+  name: "BNB Smart Chain",
+  rpcUrl: BSC_DEFAULT_RPC,
+  nativeCurrency: {
+    name: "BNB",
+    symbol: "BNB",
+    decimals: 18
+  },
+  blockExplorer: BSC_BLOCK_EXPLORER,
+  tokens: BSC_TOKENS
+};
+function getTokenByAddress(address) {
+  return BSC_TOKEN_BY_ADDRESS[address.toLowerCase()];
+}
+function getTokenBySymbol(symbol) {
+  const upperSymbol = symbol.toUpperCase();
+  return BSC_TOKENS[upperSymbol];
+}
+function isTokenSupported(address) {
+  return address.toLowerCase() in BSC_TOKEN_BY_ADDRESS;
+}
+function formatTokenAmount(amount, tokenAddress) {
+  const token = getTokenByAddress(tokenAddress);
+  const decimals = token?.decimals ?? 18;
+  const amountBigInt = typeof amount === "string" ? BigInt(amount) : amount;
+  const divisor = BigInt(10 ** decimals);
+  const wholePart = amountBigInt / divisor;
+  const fractionalPart = amountBigInt % divisor;
+  const fractionalStr = fractionalPart.toString().padStart(decimals, "0");
+  const trimmedFractional = fractionalStr.replace(/0+$/, "").padEnd(2, "0");
+  return `${wholePart}.${trimmedFractional}`;
+}
+function parseTokenAmount(amount, tokenAddress) {
+  const token = getTokenByAddress(tokenAddress);
+  const decimals = token?.decimals ?? 18;
+  const [whole, fractional = ""] = amount.split(".");
+  const paddedFractional = fractional.padEnd(decimals, "0").slice(0, decimals);
+  return BigInt(whole + paddedFractional);
+}
+function getTxUrl(txHash) {
+  return `${BSC_BLOCK_EXPLORER}/tx/${txHash}`;
+}
+function getAddressUrl(address) {
+  return `${BSC_BLOCK_EXPLORER}/address/${address}`;
+}
+function getTokenUrl(tokenAddress) {
+  return `${BSC_BLOCK_EXPLORER}/token/${tokenAddress}`;
+}
+
+// src/chains/index.ts
+var SUPPORTED_NETWORKS = {
+  [BSC_CAIP_ID]: BSC_NETWORK_CONFIG
+};
+function getNetworkConfig(caipId) {
+  return SUPPORTED_NETWORKS[caipId];
+}
+function isNetworkSupported(caipId) {
+  return caipId in SUPPORTED_NETWORKS;
+}
+function getSupportedNetworkIds() {
+  return Object.keys(SUPPORTED_NETWORKS);
+}
+var X402Client = class {
+  axiosInstance;
+  walletClient = null;
+  account = null;
+  config;
+  constructor(config = {}) {
+    this.config = {
+      supportedNetworks: [BSC_CAIP_ID],
+      defaultDeadline: 300,
+      // 5 minutes
+      autoRetry: true,
+      maxRetries: 1,
+      ...config
+    };
+    this.axiosInstance = axios.create({
+      timeout: 3e4,
+      validateStatus: (status) => status < 500,
+      // Don't throw on 402
+      ...config.axiosConfig
+    });
+    if (config.privateKey) {
+      const normalizedKey = config.privateKey.startsWith("0x") ? config.privateKey : `0x${config.privateKey}`;
+      this.account = privateKeyToAccount(normalizedKey);
+      this.walletClient = createWalletClient({
+        account: this.account,
+        chain: bsc,
+        transport: http(config.rpcUrl ?? BSC_DEFAULT_RPC)
+      });
+    }
+  }
+  /**
+   * Get the signer address if available
+   */
+  get signerAddress() {
+    return this.account?.address ?? null;
+  }
+  /**
+   * Check if the client can sign payments
+   */
+  get canSign() {
+    return this.account !== null;
+  }
+  /**
+   * Make an HTTP request with automatic 402 payment handling
+   */
+  async fetch(url, options = {}) {
+    let lastError = null;
+    let attempts = 0;
+    while (attempts <= this.config.maxRetries) {
+      try {
+        const response = await this.axiosInstance.request({
+          url,
+          ...options
+        });
+        if (response.status === 402) {
+          const requirement = this.parsePaymentRequirement(response);
+          if (this.config.onPaymentRequired) {
+            await this.config.onPaymentRequired(requirement);
+          }
+          if (!this.config.autoRetry || attempts >= this.config.maxRetries) {
+            throw new PaymentRequiredError(requirement);
+          }
+          if (!this.canSign) {
+            throw new PaymentRequiredError(
+              requirement,
+              "Payment required but no signer configured. Provide a privateKey in client config."
+            );
+          }
+          if (!this.config.supportedNetworks.includes(requirement.network_id)) {
+            throw new UnsupportedNetworkError(
+              requirement.network_id,
+              this.config.supportedNetworks
+            );
+          }
+          const signedPayment = await this.signPayment(requirement);
+          if (this.config.onPaymentSigned) {
+            await this.config.onPaymentSigned(signedPayment);
+          }
+          const retryOptions = this.addPaymentHeaders(options, signedPayment);
+          attempts++;
+          options = retryOptions;
+          continue;
+        }
+        return response;
+      } catch (error) {
+        if (error instanceof PaymentRequiredError || error instanceof UnsupportedNetworkError) {
+          throw error;
+        }
+        lastError = error;
+        attempts++;
+      }
+    }
+    throw lastError ?? new Error("Request failed after all retries");
+  }
+  /**
+   * Convenience methods for common HTTP verbs
+   */
+  async get(url, options) {
+    return this.fetch(url, { ...options, method: "GET" });
+  }
+  async post(url, data, options) {
+    return this.fetch(url, { ...options, method: "POST", data });
+  }
+  async put(url, data, options) {
+    return this.fetch(url, { ...options, method: "PUT", data });
+  }
+  async delete(url, options) {
+    return this.fetch(url, { ...options, method: "DELETE" });
+  }
+  /**
+   * Sign a payment requirement and return the signed payment
+   */
+  async signPayment(requirement) {
+    if (!this.walletClient || !this.account) {
+      throw new PaymentVerificationError(
+        "Cannot sign payment: no wallet configured"
+      );
+    }
+    const chainId = extractChainId(requirement.network_id);
+    const nonce = requirement.nonce ?? generateNonce();
+    const deadline = requirement.expires_at ?? calculateDeadline(this.config.defaultDeadline);
+    const payload = {
+      amount: requirement.amount,
+      token: requirement.token,
+      chainId,
+      payTo: requirement.pay_to,
+      payer: this.account.address,
+      deadline,
+      nonce,
+      resource: requirement.resource ?? ""
+    };
+    const domain = {
+      name: X402_DOMAIN_NAME,
+      version: X402_VERSION,
+      chainId
+    };
+    const signature = await this.walletClient.signTypedData({
+      account: this.account,
+      domain,
+      types: PAYMENT_TYPES,
+      primaryType: "Payment",
+      message: {
+        amount: BigInt(payload.amount),
+        token: payload.token,
+        chainId: BigInt(payload.chainId),
+        payTo: payload.payTo,
+        payer: payload.payer,
+        deadline: BigInt(payload.deadline),
+        nonce: payload.nonce,
+        resource: payload.resource ?? ""
+      }
+    });
+    return {
+      payload,
+      signature,
+      signer: this.account.address
+    };
+  }
+  /**
+   * Parse payment requirement from 402 response
+   */
+  parsePaymentRequirement(response) {
+    const headerValue = response.headers[X402_HEADERS.PAYMENT_REQUIRED] || response.headers[X402_HEADERS.PAYMENT_REQUIRED.toLowerCase()];
+    let requirementData;
+    if (headerValue) {
+      try {
+        requirementData = JSON.parse(
+          typeof headerValue === "string" ? headerValue : String(headerValue)
+        );
+      } catch {
+        throw new PaymentVerificationError(
+          "Invalid payment requirement header: failed to parse JSON"
+        );
+      }
+    } else if (response.data && typeof response.data === "object") {
+      requirementData = response.data;
+    } else {
+      throw new PaymentVerificationError(
+        "No payment requirement found in response headers or body"
+      );
+    }
+    const result = PaymentRequirementSchema.safeParse(requirementData);
+    if (!result.success) {
+      throw new PaymentVerificationError(
+        `Invalid payment requirement: ${result.error.message}`,
+        { errors: result.error.errors }
+      );
+    }
+    return result.data;
+  }
+  /**
+   * Add payment headers to request options
+   */
+  addPaymentHeaders(options, payment) {
+    const headers = {
+      ...options.headers,
+      [X402_HEADERS.PAYMENT_SIGNATURE]: payment.signature,
+      [X402_HEADERS.PAYMENT_PAYLOAD]: JSON.stringify(payment.payload)
+    };
+    return {
+      ...options,
+      headers
+    };
+  }
+};
+function createX402Client(config) {
+  return new X402Client(config);
+}
+function createX402ClientFromEnv(config) {
+  const privateKey = process.env["X402_PRIVATE_KEY"];
+  if (!privateKey) {
+    console.warn("X402_PRIVATE_KEY not found in environment. Client will be read-only.");
+  }
+  return new X402Client({
+    ...config,
+    privateKey
+  });
+}
+async function verifyPaymentSignatureLocal(payment, expectedRecipient, chainId) {
+  try {
+    const { payload, signature, signer } = payment;
+    const now = Math.floor(Date.now() / 1e3);
+    if (payload.deadline < now) {
+      return {
+        valid: false,
+        error: `Payment expired at ${new Date(payload.deadline * 1e3).toISOString()}`
+      };
+    }
+    if (payload.chainId !== chainId) {
+      return {
+        valid: false,
+        error: `Chain ID mismatch: expected ${chainId}, got ${payload.chainId}`
+      };
+    }
+    if (payload.payTo.toLowerCase() !== expectedRecipient.toLowerCase()) {
+      return {
+        valid: false,
+        error: `Recipient mismatch: expected ${expectedRecipient}, got ${payload.payTo}`
+      };
+    }
+    const domain = {
+      name: X402_DOMAIN_NAME,
+      version: X402_VERSION,
+      chainId
+    };
+    const isValid = await verifyTypedData({
+      address: signer,
+      domain,
+      types: PAYMENT_TYPES,
+      primaryType: "Payment",
+      message: {
+        amount: BigInt(payload.amount),
+        token: payload.token,
+        chainId: BigInt(payload.chainId),
+        payTo: payload.payTo,
+        payer: payload.payer,
+        deadline: BigInt(payload.deadline),
+        nonce: payload.nonce,
+        resource: payload.resource ?? ""
+      },
+      signature
+    });
+    if (!isValid) {
+      return {
+        valid: false,
+        error: "Signature verification failed"
+      };
+    }
+    return {
+      valid: true,
+      signer,
+      payload
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error instanceof Error ? error.message : "Unknown verification error"
+    };
+  }
+}
+async function verifyPaymentWithFacilitator(payment, facilitatorUrl, networkId) {
+  try {
+    const request = {
+      signature: payment.signature,
+      payload: payment.payload,
+      networkId
+    };
+    const response = await axios.post(
+      `${facilitatorUrl}/verify`,
+      request,
+      {
+        timeout: 1e4,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+    if (response.data.valid) {
+      return {
+        valid: true,
+        signer: response.data.signer,
+        payload: payment.payload
+      };
+    }
+    return {
+      valid: false,
+      error: response.data.error ?? "Facilitator rejected payment"
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      error: error instanceof Error ? `Facilitator error: ${error.message}` : "Facilitator verification failed"
+    };
+  }
+}
+function x402Middleware(config) {
+  const {
+    recipientAddress,
+    amount,
+    tokenAddress = BSC_USDT.address,
+    facilitatorUrl,
+    description,
+    networkId = BSC_CAIP_ID,
+    deadlineDuration = 300,
+    nonceGenerator = generateNonce,
+    verifyPayment: customVerify,
+    excludeRoutes = [],
+    onError
+  } = config;
+  const chainId = extractChainId(networkId);
+  return async (req, res, next) => {
+    try {
+      const path = req.path;
+      if (excludeRoutes.some((route) => path.startsWith(route))) {
+        next();
+        return;
+      }
+      const signatureHeader = req.headers[X402_HEADERS.PAYMENT_SIGNATURE] || req.headers[X402_HEADERS.PAYMENT_SIGNATURE.toLowerCase()];
+      const payloadHeader = req.headers[X402_HEADERS.PAYMENT_PAYLOAD] || req.headers[X402_HEADERS.PAYMENT_PAYLOAD.toLowerCase()];
+      if (!signatureHeader) {
+        const requirement = {
+          amount,
+          token: tokenAddress,
+          network_id: networkId,
+          pay_to: recipientAddress,
+          description,
+          resource: req.originalUrl,
+          expires_at: calculateDeadline(deadlineDuration),
+          nonce: nonceGenerator(),
+          version: X402_VERSION
+        };
+        res.status(402);
+        res.setHeader(X402_HEADERS.PAYMENT_REQUIRED, JSON.stringify(requirement));
+        res.json({
+          error: "Payment Required",
+          requirement
+        });
+        return;
+      }
+      let payload;
+      try {
+        if (!payloadHeader) {
+          throw new Error("Missing payment payload header");
+        }
+        const parsedPayload = JSON.parse(
+          typeof payloadHeader === "string" ? payloadHeader : String(payloadHeader)
+        );
+        const result = PaymentPayloadSchema.safeParse(parsedPayload);
+        if (!result.success) {
+          throw new Error(`Invalid payload: ${result.error.message}`);
+        }
+        payload = result.data;
+      } catch (error) {
+        res.status(400).json({
+          error: "Invalid Payment",
+          message: error instanceof Error ? error.message : "Failed to parse payment payload"
+        });
+        return;
+      }
+      const signedPayment = {
+        payload,
+        signature: typeof signatureHeader === "string" ? signatureHeader : String(signatureHeader),
+        signer: payload.payer
+      };
+      let verificationResult;
+      if (facilitatorUrl) {
+        verificationResult = await verifyPaymentWithFacilitator(
+          signedPayment,
+          facilitatorUrl,
+          networkId
+        );
+      } else {
+        verificationResult = await verifyPaymentSignatureLocal(
+          signedPayment,
+          recipientAddress,
+          chainId
+        );
+      }
+      if (!verificationResult.valid) {
+        res.status(402).json({
+          error: "Payment Verification Failed",
+          message: verificationResult.error
+        });
+        return;
+      }
+      if (customVerify) {
+        const customValid = await customVerify(signedPayment, req);
+        if (!customValid) {
+          res.status(402).json({
+            error: "Payment Rejected",
+            message: "Custom verification failed"
+          });
+          return;
+        }
+      }
+      if (BigInt(payload.amount) < BigInt(amount)) {
+        res.status(402).json({
+          error: "Insufficient Payment",
+          message: `Expected ${amount}, received ${payload.amount}`
+        });
+        return;
+      }
+      req.x402 = {
+        payment: signedPayment,
+        verified: true,
+        signer: verificationResult.signer
+      };
+      next();
+    } catch (error) {
+      if (onError && error instanceof Error) {
+        onError(error, req, res);
+        return;
+      }
+      console.error("[x402] Middleware error:", error);
+      res.status(500).json({
+        error: "Internal Server Error",
+        message: "Payment processing failed"
+      });
+    }
+  };
+}
+function createPaymentRequirement(config) {
+  const {
+    recipientAddress,
+    amount,
+    tokenAddress = BSC_USDT.address,
+    description,
+    networkId = BSC_CAIP_ID,
+    resource,
+    deadline,
+    nonce
+  } = config;
+  return {
+    amount,
+    token: tokenAddress,
+    network_id: networkId,
+    pay_to: recipientAddress,
+    description,
+    resource,
+    expires_at: deadline ?? calculateDeadline(300),
+    nonce: nonce ?? generateNonce(),
+    version: X402_VERSION
+  };
+}
+async function verifyPayment(payment, recipientAddress, networkId = BSC_CAIP_ID, facilitatorUrl) {
+  const chainId = extractChainId(networkId);
+  if (facilitatorUrl) {
+    return verifyPaymentWithFacilitator(payment, facilitatorUrl, networkId);
+  }
+  return verifyPaymentSignatureLocal(payment, recipientAddress, chainId);
+}
+function parsePaymentFromRequest(req) {
+  try {
+    const signatureHeader = req.headers[X402_HEADERS.PAYMENT_SIGNATURE] || req.headers[X402_HEADERS.PAYMENT_SIGNATURE.toLowerCase()];
+    const payloadHeader = req.headers[X402_HEADERS.PAYMENT_PAYLOAD] || req.headers[X402_HEADERS.PAYMENT_PAYLOAD.toLowerCase()];
+    if (!signatureHeader || !payloadHeader) {
+      return null;
+    }
+    const payload = JSON.parse(
+      typeof payloadHeader === "string" ? payloadHeader : String(payloadHeader)
+    );
+    const result = SignedPaymentSchema.safeParse({
+      payload,
+      signature: typeof signatureHeader === "string" ? signatureHeader : String(signatureHeader),
+      signer: payload.payer
+    });
+    return result.success ? result.data : null;
+  } catch {
+    return null;
+  }
+}
+
+export { BSC_BLOCK_EXPLORER, BSC_BUSD, BSC_CAIP_ID, BSC_CHAIN_ID, BSC_DEFAULT_RPC, BSC_DEFAULT_TOKEN, BSC_NETWORK_CONFIG, BSC_RPC_URLS, BSC_TOKENS, BSC_TOKEN_BY_ADDRESS, BSC_USDC, BSC_USDT, BSC_WBNB, PAYMENT_TYPES, PaymentExpiredError, PaymentPayloadSchema, PaymentRequiredError, PaymentRequirementSchema, PaymentVerificationError, SUPPORTED_NETWORKS, SignedPaymentSchema, UnsupportedNetworkError, X402Client, X402Error, X402_DOMAIN_NAME, X402_HEADERS, X402_VERSION, calculateDeadline, createCaipId, createPaymentRequirement, createX402Client, createX402ClientFromEnv, extractChainId, formatTokenAmount, generateNonce, getAddressUrl, getNetworkConfig, getSupportedNetworkIds, getTokenByAddress, getTokenBySymbol, getTokenUrl, getTxUrl, isNetworkSupported, isTokenSupported, parsePaymentFromRequest, parseTokenAmount, verifyPayment, x402Middleware };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map