@mixrpay/merchant-sdk 0.2.0 → 0.3.1

package/dist/index.mjs

@@ -1,217 +1,3 @@
-// src/verify.ts
-import { recoverTypedDataAddress } from "viem";
-
-// src/utils.ts
-var USDC_CONTRACTS = {
-  8453: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-  // Base Mainnet
-  84532: "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
-  // Base Sepolia
-};
-var DEFAULT_FACILITATOR = "https://x402.org/facilitator";
-function getUSDCDomain(chainId) {
-  const verifyingContract = USDC_CONTRACTS[chainId];
-  if (!verifyingContract) {
-    throw new Error(`Unsupported chain ID: ${chainId}. Supported: ${Object.keys(USDC_CONTRACTS).join(", ")}`);
-  }
-  return {
-    name: "USD Coin",
-    version: "2",
-    chainId,
-    verifyingContract
-  };
-}
-var TRANSFER_WITH_AUTHORIZATION_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" }
-  ]
-};
-function usdToMinor(usd) {
-  return BigInt(Math.round(usd * 1e6));
-}
-function minorToUsd(minor) {
-  return Number(minor) / 1e6;
-}
-function generateNonce() {
-  const bytes = new Uint8Array(32);
-  crypto.getRandomValues(bytes);
-  return `0x${Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
-}
-function isValidAddress(address) {
-  return /^0x[a-fA-F0-9]{40}$/.test(address);
-}
-function normalizeAddress(address) {
-  if (!isValidAddress(address)) {
-    throw new Error(`Invalid address: ${address}`);
-  }
-  return address.toLowerCase();
-}
-function base64Decode(str) {
-  if (typeof Buffer !== "undefined") {
-    return Buffer.from(str, "base64").toString("utf-8");
-  }
-  return atob(str);
-}
-
-// src/verify.ts
-async function verifyX402Payment(paymentHeader, options) {
-  try {
-    let decoded;
-    try {
-      const jsonStr = base64Decode(paymentHeader);
-      decoded = JSON.parse(jsonStr);
-    } catch (e) {
-      return { valid: false, error: "Invalid payment header encoding" };
-    }
-    if (!decoded.payload?.authorization || !decoded.payload?.signature) {
-      return { valid: false, error: "Missing authorization or signature in payment" };
-    }
-    const { authorization, signature } = decoded.payload;
-    const chainId = options.chainId || 8453;
-    const message = {
-      from: authorization.from,
-      to: authorization.to,
-      value: BigInt(authorization.value),
-      validAfter: BigInt(authorization.validAfter),
-      validBefore: BigInt(authorization.validBefore),
-      nonce: authorization.nonce
-    };
-    const domain = getUSDCDomain(chainId);
-    let signerAddress;
-    try {
-      signerAddress = await recoverTypedDataAddress({
-        domain,
-        types: TRANSFER_WITH_AUTHORIZATION_TYPES,
-        primaryType: "TransferWithAuthorization",
-        message,
-        signature
-      });
-    } catch (e) {
-      return { valid: false, error: "Failed to recover signer from signature" };
-    }
-    if (signerAddress.toLowerCase() !== authorization.from.toLowerCase()) {
-      return {
-        valid: false,
-        error: `Signature mismatch: expected ${authorization.from}, got ${signerAddress}`
-      };
-    }
-    const paymentAmount = BigInt(authorization.value);
-    if (paymentAmount < options.expectedAmount) {
-      return {
-        valid: false,
-        error: `Insufficient payment: expected ${options.expectedAmount}, got ${paymentAmount}`
-      };
-    }
-    if (authorization.to.toLowerCase() !== options.expectedRecipient.toLowerCase()) {
-      return {
-        valid: false,
-        error: `Wrong recipient: expected ${options.expectedRecipient}, got ${authorization.to}`
-      };
-    }
-    const now = Math.floor(Date.now() / 1e3);
-    if (Number(authorization.validBefore) < now) {
-      return { valid: false, error: "Payment authorization has expired" };
-    }
-    if (Number(authorization.validAfter) > now) {
-      return { valid: false, error: "Payment authorization is not yet valid" };
-    }
-    let txHash;
-    let settledAt;
-    if (!options.skipSettlement) {
-      const facilitatorUrl = options.facilitator || DEFAULT_FACILITATOR;
-      try {
-        const settlementResponse = await fetch(`${facilitatorUrl}/settle`, {
-          method: "POST",
-          headers: { "Content-Type": "application/json" },
-          body: JSON.stringify({
-            authorization,
-            signature,
-            chainId
-          })
-        });
-        if (!settlementResponse.ok) {
-          const errorBody = await settlementResponse.text();
-          let errorMessage = "Settlement failed";
-          try {
-            const errorJson = JSON.parse(errorBody);
-            errorMessage = errorJson.message || errorJson.error || errorMessage;
-          } catch {
-            errorMessage = errorBody || errorMessage;
-          }
-          return { valid: false, error: `Settlement failed: ${errorMessage}` };
-        }
-        const settlement = await settlementResponse.json();
-        txHash = settlement.txHash || settlement.tx_hash;
-        settledAt = /* @__PURE__ */ new Date();
-      } catch (e) {
-        return {
-          valid: false,
-          error: `Settlement request failed: ${e.message}`
-        };
-      }
-    }
-    return {
-      valid: true,
-      payer: authorization.from,
-      amount: minorToUsd(paymentAmount),
-      amountMinor: paymentAmount,
-      txHash,
-      settledAt: settledAt || /* @__PURE__ */ new Date(),
-      nonce: authorization.nonce
-    };
-  } catch (error) {
-    return {
-      valid: false,
-      error: `Verification error: ${error.message}`
-    };
-  }
-}
-async function parseX402Payment(paymentHeader, chainId = 8453) {
-  try {
-    const jsonStr = base64Decode(paymentHeader);
-    const decoded = JSON.parse(jsonStr);
-    if (!decoded.payload?.authorization) {
-      return { valid: false, error: "Missing authorization in payment" };
-    }
-    const { authorization, signature } = decoded.payload;
-    const domain = getUSDCDomain(chainId);
-    const message = {
-      from: authorization.from,
-      to: authorization.to,
-      value: BigInt(authorization.value),
-      validAfter: BigInt(authorization.validAfter),
-      validBefore: BigInt(authorization.validBefore),
-      nonce: authorization.nonce
-    };
-    const signerAddress = await recoverTypedDataAddress({
-      domain,
-      types: TRANSFER_WITH_AUTHORIZATION_TYPES,
-      primaryType: "TransferWithAuthorization",
-      message,
-      signature
-    });
-    if (signerAddress.toLowerCase() !== authorization.from.toLowerCase()) {
-      return { valid: false, error: "Signature mismatch" };
-    }
-    const amountMinor = BigInt(authorization.value);
-    return {
-      valid: true,
-      payer: authorization.from,
-      recipient: authorization.to,
-      amount: minorToUsd(amountMinor),
-      amountMinor,
-      expiresAt: new Date(Number(authorization.validBefore) * 1e3)
-    };
-  } catch (error) {
-    return { valid: false, error: `Parse error: ${error.message}` };
-  }
-}
-
 // src/receipt.ts
 import * as jose from "jose";
 var DEFAULT_JWKS_URL = process.env.MIXRPAY_JWKS_URL || "https://mixrpay.com/.well-known/jwks";
@@ -280,1057 +66,18 @@ async function verifyPaymentReceipt(receipt, options) {
     throw error;
   }
 }
-function parsePaymentReceipt(receipt) {
-  const decoded = jose.decodeJwt(receipt);
-  return {
-    paymentId: decoded.paymentId,
-    amount: decoded.amount,
-    amountUsd: decoded.amountUsd,
-    payer: decoded.payer,
-    recipient: decoded.recipient,
-    chainId: decoded.chainId,
-    txHash: decoded.txHash,
-    settledAt: decoded.settledAt,
-    issuedAt: decoded.iat ? new Date(decoded.iat * 1e3) : void 0,
-    expiresAt: decoded.exp ? new Date(decoded.exp * 1e3) : void 0
-  };
-}
-function isReceiptExpired(receipt) {
-  const parsed = typeof receipt === "string" ? parsePaymentReceipt(receipt) : receipt;
-  if (!parsed.expiresAt) {
-    return false;
-  }
-  return parsed.expiresAt.getTime() < Date.now();
-}
-function clearJWKSCache() {
-  jwksCache.clear();
-}
-function getDefaultJWKSUrl() {
-  return DEFAULT_JWKS_URL;
-}
 
 // src/charges.ts
-import crypto2 from "crypto";
-var ChargesClient = class {
-  constructor(options) {
-    this.apiKey = options.apiKey;
-    this.baseUrl = options.baseUrl || process.env.MIXRPAY_BASE_URL || "https://mixrpay.com";
-  }
-  /**
-   * Create a new charge.
-   * 
-   * @example
-   * ```typescript
-   * const result = await charges.create({
-   *   sessionId: 'sk_xxx',
-   *   amountUsd: 0.05,
-   *   reference: 'image_gen_123',
-   *   metadata: { feature: 'image_generation' }
-   * });
-   * 
-   * if (result.success) {
-   *   console.log(`Charged ${result.charge.amountUsdc}`);
-   *   console.log(`TX: ${result.charge.explorerUrl}`);
-   * }
-   * ```
-   */
-  async create(params) {
-    const response = await fetch(`${this.baseUrl}/api/v1/charges`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${this.apiKey}`
-      },
-      body: JSON.stringify({
-        session_id: params.sessionId,
-        amount_usd: params.amountUsd,
-        reference: params.reference,
-        metadata: params.metadata
-      })
-    });
-    const data = await response.json();
-    if (!response.ok) {
-      return {
-        success: false,
-        error: data.error,
-        details: data.details
-      };
-    }
-    return {
-      success: data.success,
-      charge: data.charge_id ? {
-        id: data.charge_id,
-        status: data.status,
-        amountUsd: data.amount_usd ?? 0,
-        amountUsdc: data.amount_usdc ?? "0",
-        txHash: data.tx_hash,
-        explorerUrl: data.explorer_url,
-        fromAddress: "",
-        toAddress: "",
-        reference: params.reference,
-        createdAt: (/* @__PURE__ */ new Date()).toISOString()
-      } : void 0,
-      idempotentReplay: data.idempotent_replay,
-      error: data.error
-    };
-  }
-  /**
-   * Get a charge by ID.
-   * 
-   * @example
-   * ```typescript
-   * const charge = await charges.get('chg_xxx');
-   * console.log(charge.status); // 'confirmed'
-   * ```
-   */
-  async get(chargeId) {
-    const response = await fetch(`${this.baseUrl}/api/v1/charges?id=${chargeId}`, {
-      headers: {
-        "Authorization": `Bearer ${this.apiKey}`
-      }
-    });
-    if (!response.ok) {
-      if (response.status === 404) {
-        return null;
-      }
-      throw new Error(`Failed to get charge: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return {
-      id: data.id,
-      status: data.status,
-      amountUsd: data.amount_usd,
-      amountUsdc: data.amount_usdc,
-      txHash: data.tx_hash,
-      explorerUrl: data.explorer_url,
-      fromAddress: data.from_address,
-      toAddress: data.to_address,
-      reference: data.reference,
-      createdAt: data.created_at,
-      confirmedAt: data.confirmed_at,
-      sessionName: data.session_name,
-      userWallet: data.user_wallet
-    };
-  }
-  /**
-   * Get a charge by transaction hash.
-   */
-  async getByTxHash(txHash) {
-    const response = await fetch(`${this.baseUrl}/api/v1/charges?tx_hash=${txHash}`, {
-      headers: {
-        "Authorization": `Bearer ${this.apiKey}`
-      }
-    });
-    if (!response.ok) {
-      if (response.status === 404) {
-        return null;
-      }
-      throw new Error(`Failed to get charge: ${response.statusText}`);
-    }
-    const data = await response.json();
-    return {
-      id: data.id,
-      status: data.status,
-      amountUsd: data.amount_usd,
-      amountUsdc: data.amount_usdc,
-      txHash: data.tx_hash,
-      explorerUrl: data.explorer_url,
-      fromAddress: data.from_address,
-      toAddress: data.to_address,
-      reference: data.reference,
-      createdAt: data.created_at,
-      confirmedAt: data.confirmed_at,
-      sessionName: data.session_name,
-      userWallet: data.user_wallet
-    };
-  }
-};
+import crypto from "crypto";
 function verifySessionWebhook(payload, signature, secret) {
-  const expectedSignature = crypto2.createHmac("sha256", secret).update(payload).digest("hex");
-  return crypto2.timingSafeEqual(
+  const expectedSignature = crypto.createHmac("sha256", secret).update(payload).digest("hex");
+  return crypto.timingSafeEqual(
     Buffer.from(signature),
     Buffer.from(expectedSignature)
   );
 }
-function parseSessionGrant(payload) {
-  if (payload.event !== "session.granted") {
-    throw new Error(`Unexpected event type: ${payload.event}`);
-  }
-  return {
-    sessionId: payload.session_id,
-    userWallet: payload.user_wallet,
-    merchantWallet: payload.merchant_wallet,
-    limits: {
-      maxTotalUsd: payload.limits.max_total_usd,
-      maxPerTxUsd: payload.limits.max_per_tx_usd,
-      expiresAt: payload.limits.expires_at
-    },
-    grantedAt: payload.granted_at
-  };
-}
-
-// src/receipt-fetcher.ts
-var DEFAULT_MIXRPAY_API_URL = process.env.MIXRPAY_BASE_URL || "https://mixrpay.com";
-async function fetchPaymentReceipt(params) {
-  const apiUrl = params.apiUrl || DEFAULT_MIXRPAY_API_URL;
-  const endpoint = `${apiUrl}/api/v1/receipts`;
-  try {
-    const response = await fetch(endpoint, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json"
-      },
-      body: JSON.stringify({
-        tx_hash: params.txHash,
-        payer: params.payer,
-        recipient: params.recipient,
-        amount: params.amount.toString(),
-        chain_id: params.chainId
-      })
-    });
-    if (!response.ok) {
-      console.warn(`[x402] Receipt fetch failed: ${response.status} ${response.statusText}`);
-      return null;
-    }
-    const data = await response.json();
-    return data.receipt || null;
-  } catch (error) {
-    console.warn("[x402] Receipt fetch error:", error.message);
-    return null;
-  }
-}
-
-// src/middleware/express.ts
-function x402(options) {
-  return async (req, res, next) => {
-    try {
-      const context = {
-        path: req.path,
-        method: req.method,
-        headers: req.headers,
-        body: req.body
-      };
-      if (options.skip) {
-        const shouldSkip = await options.skip(context);
-        if (shouldSkip) {
-          return next();
-        }
-      }
-      const recipient = options.recipient || process.env.MIXRPAY_MERCHANT_ADDRESS;
-      if (!recipient) {
-        console.error("[x402] No recipient address configured. Set MIXRPAY_MERCHANT_ADDRESS env var or pass recipient option.");
-        return res.status(500).json({
-          error: "Payment configuration error",
-          message: "Merchant wallet address not configured"
-        });
-      }
-      const price = options.getPrice ? await options.getPrice(context) : options.price;
-      const priceMinor = usdToMinor(price);
-      const chainId = options.chainId || 8453;
-      const facilitator = options.facilitator || DEFAULT_FACILITATOR;
-      const paymentHeader = req.headers["x-payment"];
-      if (!paymentHeader) {
-        const nonce = generateNonce();
-        const expiresAt = Math.floor(Date.now() / 1e3) + 300;
-        const paymentRequired = {
-          recipient,
-          amount: priceMinor.toString(),
-          currency: "USDC",
-          chainId,
-          facilitator,
-          nonce,
-          expiresAt,
-          description: options.description
-        };
-        res.setHeader("X-Payment-Required", JSON.stringify(paymentRequired));
-        res.setHeader("WWW-Authenticate", `X-402 ${Buffer.from(JSON.stringify(paymentRequired)).toString("base64")}`);
-        return res.status(402).json({
-          error: "Payment required",
-          payment: paymentRequired
-        });
-      }
-      const result = await verifyX402Payment(paymentHeader, {
-        expectedAmount: priceMinor,
-        expectedRecipient: recipient,
-        chainId,
-        facilitator,
-        skipSettlement: options.testMode
-      });
-      if (!result.valid) {
-        return res.status(402).json({
-          error: "Invalid payment",
-          reason: result.error
-        });
-      }
-      req.x402Payment = result;
-      if (result.txHash) {
-        res.setHeader("X-Payment-TxHash", result.txHash);
-      }
-      const receiptMode = options.receiptMode || "webhook";
-      if ((receiptMode === "jwt" || receiptMode === "both") && result.txHash && result.payer) {
-        try {
-          const receipt = await fetchPaymentReceipt({
-            txHash: result.txHash,
-            payer: result.payer,
-            recipient,
-            amount: priceMinor,
-            chainId,
-            apiUrl: options.mixrpayApiUrl
-          });
-          if (receipt) {
-            result.receipt = receipt;
-            res.setHeader("X-Payment-Receipt", receipt);
-          }
-        } catch (receiptError) {
-          console.warn("[x402] Failed to fetch JWT receipt:", receiptError);
-        }
-      }
-      if (options.onPayment) {
-        await options.onPayment(result);
-      }
-      next();
-    } catch (error) {
-      console.error("[x402] Middleware error:", error);
-      return res.status(500).json({
-        error: "Payment processing error",
-        message: error.message
-      });
-    }
-  };
-}
-function mixrpay(options) {
-  return async (req, res, next) => {
-    try {
-      const context = {
-        path: req.path,
-        method: req.method,
-        headers: req.headers,
-        body: req.body
-      };
-      if (options.skip) {
-        const shouldSkip = await options.skip(context);
-        if (shouldSkip) {
-          return next();
-        }
-      }
-      const priceUsd = options.getPrice ? await options.getPrice(context) : options.priceUsd;
-      const sessionHeader = req.headers["x-mixr-session"];
-      const widgetHeader = req.headers["x-mixr-payment"];
-      const x402Header = req.headers["x-payment"];
-      let result;
-      if (sessionHeader) {
-        result = await verifySessionPayment(sessionHeader, priceUsd, options, req);
-      } else if (widgetHeader) {
-        result = await verifyWidgetPayment(widgetHeader, priceUsd, options, req);
-      } else if (x402Header) {
-        result = await verifyX402PaymentUnified(x402Header, priceUsd, options, res);
-      } else {
-        return returnPaymentRequired(priceUsd, options, res);
-      }
-      if (!result.valid) {
-        return res.status(402).json({
-          error: "Invalid payment",
-          reason: result.error,
-          method: result.method
-        });
-      }
-      req.mixrPayment = result;
-      if (result.method === "x402" && result.x402Result) {
-        req.x402Payment = result.x402Result;
-      }
-      if (result.txHash) {
-        res.setHeader("X-Payment-TxHash", result.txHash);
-      }
-      if (result.chargeId) {
-        res.setHeader("X-Mixr-Charge-Id", result.chargeId);
-      }
-      if (result.amountUsd !== void 0) {
-        res.setHeader("X-Mixr-Charged", result.amountUsd.toString());
-      }
-      if (options.onPayment) {
-        await options.onPayment(result);
-      }
-      next();
-    } catch (error) {
-      console.error("[mixrpay] Middleware error:", error);
-      return res.status(500).json({
-        error: "Payment processing error",
-        message: error.message
-      });
-    }
-  };
-}
-async function verifySessionPayment(sessionId, priceUsd, options, req) {
-  const baseUrl = options.mixrpayApiUrl || process.env.MIXRPAY_API_URL || "https://mixrpay.com";
-  const secretKey = process.env.MIXRPAY_SECRET_KEY;
-  if (!secretKey) {
-    return {
-      valid: false,
-      method: "session",
-      error: "MIXRPAY_SECRET_KEY not configured"
-    };
-  }
-  try {
-    const response = await fetch(`${baseUrl}/api/v2/charge`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${secretKey}`
-      },
-      body: JSON.stringify({
-        sessionId,
-        amountUsd: priceUsd,
-        feature: options.feature || req.headers["x-mixr-feature"],
-        idempotencyKey: req.headers["x-idempotency-key"]
-      })
-    });
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      return {
-        valid: false,
-        method: "session",
-        error: errorData.message || errorData.error || `Charge failed: ${response.status}`,
-        sessionId
-      };
-    }
-    const data = await response.json();
-    return {
-      valid: true,
-      method: "session",
-      payer: data.payer || data.walletAddress,
-      amountUsd: data.amountUsd || priceUsd,
-      txHash: data.txHash,
-      chargeId: data.chargeId,
-      sessionId,
-      feature: options.feature,
-      settledAt: data.settledAt ? new Date(data.settledAt) : /* @__PURE__ */ new Date()
-    };
-  } catch (error) {
-    return {
-      valid: false,
-      method: "session",
-      error: `Session verification failed: ${error.message}`,
-      sessionId
-    };
-  }
-}
-async function verifyWidgetPayment(paymentJwt, priceUsd, options, req) {
-  const baseUrl = options.mixrpayApiUrl || process.env.MIXRPAY_API_URL || "https://mixrpay.com";
-  const secretKey = process.env.MIXRPAY_SECRET_KEY;
-  if (!secretKey) {
-    return {
-      valid: false,
-      method: "widget",
-      error: "MIXRPAY_SECRET_KEY not configured"
-    };
-  }
-  try {
-    const response = await fetch(`${baseUrl}/api/widget/verify`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${secretKey}`
-      },
-      body: JSON.stringify({
-        paymentJwt,
-        expectedAmountUsd: priceUsd,
-        feature: options.feature || req.headers["x-mixr-feature"]
-      })
-    });
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      return {
-        valid: false,
-        method: "widget",
-        error: errorData.message || errorData.error || `Widget verification failed: ${response.status}`
-      };
-    }
-    const data = await response.json();
-    return {
-      valid: true,
-      method: "widget",
-      payer: data.payer || data.walletAddress,
-      amountUsd: data.amountUsd || priceUsd,
-      txHash: data.txHash,
-      chargeId: data.chargeId,
-      feature: options.feature,
-      settledAt: data.settledAt ? new Date(data.settledAt) : /* @__PURE__ */ new Date()
-    };
-  } catch (error) {
-    return {
-      valid: false,
-      method: "widget",
-      error: `Widget verification failed: ${error.message}`
-    };
-  }
-}
-async function verifyX402PaymentUnified(paymentHeader, priceUsd, options, res) {
-  const recipient = options.recipient || process.env.MIXRPAY_MERCHANT_ADDRESS;
-  if (!recipient) {
-    return {
-      valid: false,
-      method: "x402",
-      error: "MIXRPAY_MERCHANT_ADDRESS not configured for x402 payments"
-    };
-  }
-  const priceMinor = usdToMinor(priceUsd);
-  const chainId = options.chainId || 8453;
-  const facilitator = options.facilitator || DEFAULT_FACILITATOR;
-  const x402Result = await verifyX402Payment(paymentHeader, {
-    expectedAmount: priceMinor,
-    expectedRecipient: recipient,
-    chainId,
-    facilitator,
-    skipSettlement: options.testMode
-  });
-  if (!x402Result.valid) {
-    return {
-      valid: false,
-      method: "x402",
-      error: x402Result.error,
-      x402Result
-    };
-  }
-  const receiptMode = options.receiptMode || "webhook";
-  if ((receiptMode === "jwt" || receiptMode === "both") && x402Result.txHash && x402Result.payer) {
-    try {
-      const receipt = await fetchPaymentReceipt({
-        txHash: x402Result.txHash,
-        payer: x402Result.payer,
-        recipient,
-        amount: priceMinor,
-        chainId,
-        apiUrl: options.mixrpayApiUrl
-      });
-      if (receipt) {
-        x402Result.receipt = receipt;
-        res.setHeader("X-Payment-Receipt", receipt);
-      }
-    } catch (receiptError) {
-      console.warn("[mixrpay] Failed to fetch JWT receipt:", receiptError);
-    }
-  }
-  return {
-    valid: true,
-    method: "x402",
-    payer: x402Result.payer,
-    amountUsd: x402Result.amount,
-    txHash: x402Result.txHash,
-    receipt: x402Result.receipt,
-    settledAt: x402Result.settledAt,
-    x402Result
-  };
-}
-function returnPaymentRequired(priceUsd, options, res) {
-  const priceMinor = usdToMinor(priceUsd);
-  const recipient = options.recipient || process.env.MIXRPAY_MERCHANT_ADDRESS;
-  const chainId = options.chainId || 8453;
-  const facilitator = options.facilitator || DEFAULT_FACILITATOR;
-  const nonce = generateNonce();
-  const expiresAt = Math.floor(Date.now() / 1e3) + 300;
-  const x402PaymentRequired = recipient ? {
-    recipient,
-    amount: priceMinor.toString(),
-    currency: "USDC",
-    chainId,
-    facilitator,
-    nonce,
-    expiresAt,
-    description: options.description
-  } : null;
-  if (x402PaymentRequired) {
-    res.setHeader("X-Payment-Required", JSON.stringify(x402PaymentRequired));
-    res.setHeader("WWW-Authenticate", `X-402 ${Buffer.from(JSON.stringify(x402PaymentRequired)).toString("base64")}`);
-  }
-  return res.status(402).json({
-    error: "Payment required",
-    priceUsd,
-    acceptedMethods: [
-      { method: "session", header: "X-Mixr-Session", description: "Session authorization ID" },
-      { method: "widget", header: "X-Mixr-Payment", description: "Widget payment JWT" },
-      ...recipient ? [{ method: "x402", header: "X-PAYMENT", description: "x402 protocol payment" }] : []
-    ],
-    x402: x402PaymentRequired,
-    description: options.description
-  });
-}
-
-// src/middleware/nextjs.ts
-import { NextResponse } from "next/server";
-function withX402(config, handler) {
-  return async (req) => {
-    try {
-      const recipient = config.recipient || process.env.MIXRPAY_MERCHANT_ADDRESS;
-      if (!recipient) {
-        console.error("[x402] No recipient address configured");
-        return NextResponse.json(
-          { error: "Payment configuration error" },
-          { status: 500 }
-        );
-      }
-      const price = config.getPrice ? await config.getPrice(req) : config.price;
-      const priceMinor = usdToMinor(price);
-      const chainId = config.chainId || 8453;
-      const facilitator = config.facilitator || DEFAULT_FACILITATOR;
-      const paymentHeader = req.headers.get("x-payment");
-      if (!paymentHeader) {
-        const nonce = generateNonce();
-        const expiresAt = Math.floor(Date.now() / 1e3) + 300;
-        const paymentRequired = {
-          recipient,
-          amount: priceMinor.toString(),
-          currency: "USDC",
-          chainId,
-          facilitator,
-          nonce,
-          expiresAt,
-          description: config.description
-        };
-        return NextResponse.json(
-          { error: "Payment required", payment: paymentRequired },
-          {
-            status: 402,
-            headers: {
-              "X-Payment-Required": JSON.stringify(paymentRequired),
-              "WWW-Authenticate": `X-402 ${Buffer.from(JSON.stringify(paymentRequired)).toString("base64")}`
-            }
-          }
-        );
-      }
-      const result = await verifyX402Payment(paymentHeader, {
-        expectedAmount: priceMinor,
-        expectedRecipient: recipient,
-        chainId,
-        facilitator,
-        skipSettlement: config.testMode
-      });
-      if (!result.valid) {
-        return NextResponse.json(
-          { error: "Invalid payment", reason: result.error },
-          { status: 402 }
-        );
-      }
-      const receiptMode = config.receiptMode || "webhook";
-      if ((receiptMode === "jwt" || receiptMode === "both") && result.txHash && result.payer) {
-        try {
-          const receipt = await fetchPaymentReceipt({
-            txHash: result.txHash,
-            payer: result.payer,
-            recipient,
-            amount: priceMinor,
-            chainId,
-            apiUrl: config.mixrpayApiUrl
-          });
-          if (receipt) {
-            result.receipt = receipt;
-          }
-        } catch (receiptError) {
-          console.warn("[x402] Failed to fetch JWT receipt:", receiptError);
-        }
-      }
-      if (config.onPayment) {
-        await config.onPayment(result, req);
-      }
-      const response = await handler(req, result);
-      if (result.txHash) {
-        response.headers.set("X-Payment-TxHash", result.txHash);
-      }
-      if (result.receipt) {
-        response.headers.set("X-Payment-Receipt", result.receipt);
-      }
-      return response;
-    } catch (error) {
-      console.error("[x402] Handler error:", error);
-      return NextResponse.json(
-        { error: "Payment processing error" },
-        { status: 500 }
-      );
-    }
-  };
-}
-function createPaymentRequired(options) {
-  const priceMinor = usdToMinor(options.amount);
-  const nonce = generateNonce();
-  const expiresAt = Math.floor(Date.now() / 1e3) + 300;
-  const paymentRequired = {
-    recipient: options.recipient,
-    amount: priceMinor.toString(),
-    currency: "USDC",
-    chainId: options.chainId || 8453,
-    facilitator: options.facilitator || DEFAULT_FACILITATOR,
-    nonce,
-    expiresAt,
-    description: options.description
-  };
-  return NextResponse.json(
-    { error: "Payment required", payment: paymentRequired },
-    {
-      status: 402,
-      headers: {
-        "X-Payment-Required": JSON.stringify(paymentRequired)
-      }
-    }
-  );
-}
-function withMixrPay(config, handler) {
-  return async (req) => {
-    try {
-      const priceUsd = config.getPrice ? await config.getPrice(req) : config.priceUsd;
-      const sessionHeader = req.headers.get("x-mixr-session");
-      const widgetHeader = req.headers.get("x-mixr-payment");
-      const x402Header = req.headers.get("x-payment");
-      let result;
-      if (sessionHeader) {
-        result = await verifySessionPaymentNext(sessionHeader, priceUsd, config, req);
-      } else if (widgetHeader) {
-        result = await verifyWidgetPaymentNext(widgetHeader, priceUsd, config, req);
-      } else if (x402Header) {
-        result = await verifyX402PaymentNext(x402Header, priceUsd, config);
-      } else {
-        return returnPaymentRequiredNext(priceUsd, config);
-      }
-      if (!result.valid) {
-        return NextResponse.json(
-          { error: "Invalid payment", reason: result.error, method: result.method },
-          { status: 402 }
-        );
-      }
-      if (config.onPayment) {
-        await config.onPayment(result, req);
-      }
-      const response = await handler(req, result);
-      if (result.txHash) {
-        response.headers.set("X-Payment-TxHash", result.txHash);
-      }
-      if (result.chargeId) {
-        response.headers.set("X-Mixr-Charge-Id", result.chargeId);
-      }
-      if (result.amountUsd !== void 0) {
-        response.headers.set("X-Mixr-Charged", result.amountUsd.toString());
-      }
-      return response;
-    } catch (error) {
-      console.error("[withMixrPay] Handler error:", error);
-      return NextResponse.json(
-        { error: "Payment processing error" },
-        { status: 500 }
-      );
-    }
-  };
-}
-async function verifySessionPaymentNext(sessionId, priceUsd, config, req) {
-  const baseUrl = config.mixrpayApiUrl || process.env.MIXRPAY_API_URL || "https://mixrpay.com";
-  const secretKey = process.env.MIXRPAY_SECRET_KEY;
-  if (!secretKey) {
-    return { valid: false, method: "session", error: "MIXRPAY_SECRET_KEY not configured" };
-  }
-  try {
-    const response = await fetch(`${baseUrl}/api/v2/charge`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${secretKey}`
-      },
-      body: JSON.stringify({
-        sessionId,
-        amountUsd: priceUsd,
-        feature: config.feature || req.headers.get("x-mixr-feature"),
-        idempotencyKey: req.headers.get("x-idempotency-key")
-      })
-    });
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      return {
-        valid: false,
-        method: "session",
-        error: errorData.message || errorData.error || `Charge failed: ${response.status}`,
-        sessionId
-      };
-    }
-    const data = await response.json();
-    return {
-      valid: true,
-      method: "session",
-      payer: data.payer || data.walletAddress,
-      amountUsd: data.amountUsd || priceUsd,
-      txHash: data.txHash,
-      chargeId: data.chargeId,
-      sessionId,
-      feature: config.feature,
-      settledAt: data.settledAt ? new Date(data.settledAt) : /* @__PURE__ */ new Date()
-    };
-  } catch (error) {
-    return {
-      valid: false,
-      method: "session",
-      error: `Session verification failed: ${error.message}`,
-      sessionId
-    };
-  }
-}
-async function verifyWidgetPaymentNext(paymentJwt, priceUsd, config, req) {
-  const baseUrl = config.mixrpayApiUrl || process.env.MIXRPAY_API_URL || "https://mixrpay.com";
-  const secretKey = process.env.MIXRPAY_SECRET_KEY;
-  if (!secretKey) {
-    return { valid: false, method: "widget", error: "MIXRPAY_SECRET_KEY not configured" };
-  }
-  try {
-    const response = await fetch(`${baseUrl}/api/widget/verify`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${secretKey}`
-      },
-      body: JSON.stringify({
-        paymentJwt,
-        expectedAmountUsd: priceUsd,
-        feature: config.feature || req.headers.get("x-mixr-feature")
-      })
-    });
-    if (!response.ok) {
-      const errorData = await response.json().catch(() => ({}));
-      return {
-        valid: false,
-        method: "widget",
-        error: errorData.message || errorData.error || `Widget verification failed: ${response.status}`
-      };
-    }
-    const data = await response.json();
-    return {
-      valid: true,
-      method: "widget",
-      payer: data.payer || data.walletAddress,
-      amountUsd: data.amountUsd || priceUsd,
-      txHash: data.txHash,
-      chargeId: data.chargeId,
-      feature: config.feature,
-      settledAt: data.settledAt ? new Date(data.settledAt) : /* @__PURE__ */ new Date()
-    };
-  } catch (error) {
-    return {
-      valid: false,
-      method: "widget",
-      error: `Widget verification failed: ${error.message}`
-    };
-  }
-}
-async function verifyX402PaymentNext(paymentHeader, priceUsd, config) {
-  const recipient = config.recipient || process.env.MIXRPAY_MERCHANT_ADDRESS;
-  if (!recipient) {
-    return {
-      valid: false,
-      method: "x402",
-      error: "MIXRPAY_MERCHANT_ADDRESS not configured for x402 payments"
-    };
-  }
-  const priceMinor = usdToMinor(priceUsd);
-  const chainId = config.chainId || 8453;
-  const facilitator = config.facilitator || DEFAULT_FACILITATOR;
-  const x402Result = await verifyX402Payment(paymentHeader, {
-    expectedAmount: priceMinor,
-    expectedRecipient: recipient,
-    chainId,
-    facilitator,
-    skipSettlement: config.testMode
-  });
-  if (!x402Result.valid) {
-    return {
-      valid: false,
-      method: "x402",
-      error: x402Result.error,
-      x402Result
-    };
-  }
-  const receiptMode = config.receiptMode || "webhook";
-  if ((receiptMode === "jwt" || receiptMode === "both") && x402Result.txHash && x402Result.payer) {
-    try {
-      const receipt = await fetchPaymentReceipt({
-        txHash: x402Result.txHash,
-        payer: x402Result.payer,
-        recipient,
-        amount: priceMinor,
-        chainId,
-        apiUrl: config.mixrpayApiUrl
-      });
-      if (receipt) {
-        x402Result.receipt = receipt;
-      }
-    } catch (receiptError) {
-      console.warn("[withMixrPay] Failed to fetch JWT receipt:", receiptError);
-    }
-  }
-  return {
-    valid: true,
-    method: "x402",
-    payer: x402Result.payer,
-    amountUsd: x402Result.amount,
-    txHash: x402Result.txHash,
-    receipt: x402Result.receipt,
-    settledAt: x402Result.settledAt,
-    x402Result
-  };
-}
-function returnPaymentRequiredNext(priceUsd, config) {
-  const priceMinor = usdToMinor(priceUsd);
-  const recipient = config.recipient || process.env.MIXRPAY_MERCHANT_ADDRESS;
-  const chainId = config.chainId || 8453;
-  const facilitator = config.facilitator || DEFAULT_FACILITATOR;
-  const nonce = generateNonce();
-  const expiresAt = Math.floor(Date.now() / 1e3) + 300;
-  const x402PaymentRequired = recipient ? {
-    recipient,
-    amount: priceMinor.toString(),
-    currency: "USDC",
-    chainId,
-    facilitator,
-    nonce,
-    expiresAt,
-    description: config.description
-  } : null;
-  const headers = {};
-  if (x402PaymentRequired) {
-    headers["X-Payment-Required"] = JSON.stringify(x402PaymentRequired);
-    headers["WWW-Authenticate"] = `X-402 ${Buffer.from(JSON.stringify(x402PaymentRequired)).toString("base64")}`;
-  }
-  return NextResponse.json(
-    {
-      error: "Payment required",
-      priceUsd,
-      acceptedMethods: [
-        { method: "session", header: "X-Mixr-Session", description: "Session authorization ID" },
-        { method: "widget", header: "X-Mixr-Payment", description: "Widget payment JWT" },
-        ...recipient ? [{ method: "x402", header: "X-PAYMENT", description: "x402 protocol payment" }] : []
-      ],
-      x402: x402PaymentRequired,
-      description: config.description
-    },
-    { status: 402, headers }
-  );
-}
-
-// src/middleware/fastify.ts
-var x402Plugin = (fastify, options, done) => {
-  fastify.decorateRequest("x402Payment", null);
-  fastify.decorate("x402Defaults", {
-    recipient: options.recipient || process.env.MIXRPAY_MERCHANT_ADDRESS,
-    chainId: options.chainId || 8453,
-    facilitator: options.facilitator || DEFAULT_FACILITATOR
-  });
-  done();
-};
-function x4022(options) {
-  return async (request, reply) => {
-    const context = {
-      path: request.url,
-      method: request.method,
-      headers: request.headers,
-      body: request.body
-    };
-    if (options.skip) {
-      const shouldSkip = await options.skip(context);
-      if (shouldSkip) {
-        return;
-      }
-    }
-    const defaults = request.server.x402Defaults || {};
-    const recipient = options.recipient || defaults.recipient || process.env.MIXRPAY_MERCHANT_ADDRESS;
-    if (!recipient) {
-      request.log.error("[x402] No recipient address configured");
-      return reply.status(500).send({
-        error: "Payment configuration error",
-        message: "Merchant wallet address not configured"
-      });
-    }
-    const price = options.getPrice ? await options.getPrice(context) : options.price;
-    const priceMinor = usdToMinor(price);
-    const chainId = options.chainId || defaults.chainId || 8453;
-    const facilitator = options.facilitator || defaults.facilitator || DEFAULT_FACILITATOR;
-    const paymentHeader = request.headers["x-payment"];
-    if (!paymentHeader) {
-      const nonce = generateNonce();
-      const expiresAt = Math.floor(Date.now() / 1e3) + 300;
-      const paymentRequired = {
-        recipient,
-        amount: priceMinor.toString(),
-        currency: "USDC",
-        chainId,
-        facilitator,
-        nonce,
-        expiresAt,
-        description: options.description
-      };
-      reply.header("X-Payment-Required", JSON.stringify(paymentRequired));
-      reply.header("WWW-Authenticate", `X-402 ${Buffer.from(JSON.stringify(paymentRequired)).toString("base64")}`);
-      return reply.status(402).send({
-        error: "Payment required",
-        payment: paymentRequired
-      });
-    }
-    const result = await verifyX402Payment(paymentHeader, {
-      expectedAmount: priceMinor,
-      expectedRecipient: recipient,
-      chainId,
-      facilitator,
-      skipSettlement: options.testMode
-    });
-    if (!result.valid) {
-      return reply.status(402).send({
-        error: "Invalid payment",
-        reason: result.error
-      });
-    }
-    request.x402Payment = result;
-    if (result.txHash) {
-      reply.header("X-Payment-TxHash", result.txHash);
-    }
-    const receiptMode = options.receiptMode || "webhook";
-    if ((receiptMode === "jwt" || receiptMode === "both") && result.txHash && result.payer) {
-      try {
-        const receipt = await fetchPaymentReceipt({
-          txHash: result.txHash,
-          payer: result.payer,
-          recipient,
-          amount: priceMinor,
-          chainId,
-          apiUrl: options.mixrpayApiUrl
-        });
-        if (receipt) {
-          result.receipt = receipt;
-          reply.header("X-Payment-Receipt", receipt);
-        }
-      } catch (receiptError) {
-        request.log.warn({ err: receiptError }, "[x402] Failed to fetch JWT receipt");
-      }
-    }
-    if (options.onPayment) {
-      await options.onPayment(result);
-    }
-  };
-}
 export {
-  ChargesClient,
-  DEFAULT_FACILITATOR,
-  USDC_CONTRACTS,
-  clearJWKSCache,
-  createPaymentRequired,
-  mixrpay as expressMixrPay,
-  x402 as expressX402,
-  x4022 as fastifyX402,
-  generateNonce,
-  getDefaultJWKSUrl,
-  isReceiptExpired,
-  isValidAddress,
-  minorToUsd,
-  normalizeAddress,
-  parsePaymentReceipt,
-  parseSessionGrant,
-  parseX402Payment,
-  usdToMinor,
   verifyPaymentReceipt,
-  verifySessionWebhook,
-  verifyX402Payment,
-  withMixrPay,
-  withX402,
-  x402Plugin
+  verifySessionWebhook
 };
 //# sourceMappingURL=index.mjs.map