@circle-fin/x402-batching 2.0.3

package/dist/server/index.mjs

@@ -0,0 +1,668 @@
+// src/server/BatchFacilitatorClient.ts
+var BatchFacilitatorClient = class {
+  url;
+  _createAuthHeaders;
+  /**
+   * Creates a new BatchFacilitatorClient.
+   *
+   * @param config - Configuration including Gateway URL and optional auth headers
+   */
+  constructor(config = {}) {
+    this.url = (config.url ?? "https://gateway-api-testnet.circle.com").replace(
+      /\/$/,
+      ""
+    );
+    this._createAuthHeaders = config.createAuthHeaders;
+  }
+  /**
+   * Verify a payment with Circle Gateway.
+   *
+   * @param paymentPayload - The payment payload to verify
+   * @param paymentRequirements - The payment requirements
+   * @returns Verification response
+   */
+  async verify(paymentPayload, paymentRequirements) {
+    let headers = {
+      "Content-Type": "application/json"
+    };
+    if (this._createAuthHeaders) {
+      const authHeaders = await this._createAuthHeaders();
+      headers = { ...headers, ...authHeaders.verify };
+    }
+    const response = await fetch(`${this.url}/v1/x402/verify`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        paymentPayload: this.toJsonSafe(paymentPayload),
+        paymentRequirements: this.toJsonSafe(paymentRequirements)
+      })
+    });
+    const data = await response.json();
+    if (typeof data === "object" && data !== null && "isValid" in data) {
+      return data;
+    }
+    throw new Error(
+      `Circle Gateway verify failed (${response.status}): ${JSON.stringify(data)}`
+    );
+  }
+  /**
+   * Settle a payment with Circle Gateway.
+   *
+   * @param paymentPayload - The payment payload to settle
+   * @param paymentRequirements - The payment requirements
+   * @returns Settlement response
+   */
+  async settle(paymentPayload, paymentRequirements) {
+    let headers = {
+      "Content-Type": "application/json"
+    };
+    if (this._createAuthHeaders) {
+      const authHeaders = await this._createAuthHeaders();
+      headers = { ...headers, ...authHeaders.settle };
+    }
+    const response = await fetch(`${this.url}/v1/x402/settle`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        paymentPayload: this.toJsonSafe(paymentPayload),
+        paymentRequirements: this.toJsonSafe(paymentRequirements)
+      })
+    });
+    const text = await response.text();
+    if (!text) {
+      throw new Error(
+        `Circle Gateway settle returned empty response (${response.status})`
+      );
+    }
+    const data = JSON.parse(text);
+    if (typeof data === "object" && data !== null && "success" in data) {
+      return data;
+    }
+    throw new Error(`Circle Gateway settle failed (${response.status}): ${text}`);
+  }
+  /**
+   * Get supported payment kinds from Circle Gateway.
+   *
+   * This fetches the supported networks and their GatewayWallet contract addresses.
+   * The response includes `extra.verifyingContract` for each supported network.
+   *
+   * @returns Supported payment kinds and extensions
+   */
+  async getSupported() {
+    let headers = {
+      "Content-Type": "application/json"
+    };
+    if (this._createAuthHeaders) {
+      const authHeaders = await this._createAuthHeaders();
+      headers = { ...headers, ...authHeaders.supported };
+    }
+    const response = await fetch(`${this.url}/v1/x402/supported`, {
+      method: "GET",
+      headers
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => response.statusText);
+      throw new Error(
+        `Circle Gateway getSupported failed (${response.status}): ${errorText}`
+      );
+    }
+    return await response.json();
+  }
+  /**
+   * Helper to convert objects to JSON-safe format.
+   * Handles BigInt and other non-JSON types.
+   */
+  toJsonSafe(obj) {
+    return JSON.parse(
+      JSON.stringify(
+        obj,
+        (_, value) => typeof value === "bigint" ? value.toString() : value
+      )
+    );
+  }
+};
+
+// src/server/GatewayEvmScheme.ts
+import { ExactEvmScheme } from "@x402/evm/exact/server";
+
+// src/client/GatewayClient.ts
+import {
+  createPublicClient,
+  createWalletClient,
+  http,
+  parseUnits,
+  formatUnits,
+  pad,
+  zeroAddress,
+  maxUint256,
+  defineChain,
+  erc20Abi
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import * as chains from "viem/chains";
+var sonicTestnet = defineChain({
+  id: 14601,
+  name: "Sonic Testnet",
+  nativeCurrency: { decimals: 18, name: "Sonic", symbol: "S" },
+  rpcUrls: {
+    default: { http: ["https://rpc.testnet.soniclabs.com"] }
+  },
+  blockExplorers: {
+    default: { name: "Sonic Testnet Explorer", url: "https://testnet.soniclabs.com/" }
+  },
+  testnet: true
+});
+var GATEWAY_DOMAINS = {
+  // Testnet
+  arbitrumSepolia: 3,
+  arcTestnet: 26,
+  avalancheFuji: 1,
+  baseSepolia: 6,
+  sepolia: 0,
+  hyperEvmTestnet: 19,
+  optimismSepolia: 2,
+  polygonAmoy: 7,
+  seiAtlantic: 16,
+  sonicTestnet: 13,
+  unichainSepolia: 10,
+  worldChainSepolia: 14,
+  // Mainnet
+  arbitrum: 3,
+  avalanche: 1,
+  base: 6,
+  mainnet: 0,
+  hyperEvm: 19,
+  optimism: 2,
+  polygon: 7,
+  sei: 16,
+  sonic: 13,
+  unichain: 10,
+  worldChain: 14
+};
+var TESTNET_GATEWAY_WALLET = "0x0077777d7EBA4688BDeF3E311b846F25870A19B9";
+var TESTNET_GATEWAY_MINTER = "0x0022222ABE238Cc2C7Bb1f21003F0a260052475B";
+var MAINNET_GATEWAY_WALLET = "0x77777777Dcc4d5A8B6E418Fd04D8997ef11000eE";
+var MAINNET_GATEWAY_MINTER = "0x2222222d7164433c4C09B0b0D809a9b52C04C205";
+var CHAIN_CONFIGS = {
+  // Testnet chains
+  arbitrumSepolia: {
+    chain: chains.arbitrumSepolia,
+    domain: GATEWAY_DOMAINS.arbitrumSepolia,
+    usdc: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER
+  },
+  arcTestnet: {
+    chain: chains.arcTestnet,
+    domain: GATEWAY_DOMAINS.arcTestnet,
+    usdc: "0x3600000000000000000000000000000000000000",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER,
+    rpcUrl: "https://rpc.testnet.arc.network"
+  },
+  avalancheFuji: {
+    chain: chains.avalancheFuji,
+    domain: GATEWAY_DOMAINS.avalancheFuji,
+    usdc: "0x5425890298aed601595a70AB815c96711a31Bc65",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER
+  },
+  baseSepolia: {
+    chain: chains.baseSepolia,
+    domain: GATEWAY_DOMAINS.baseSepolia,
+    usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER,
+    rpcUrl: "https://sepolia-preconf.base.org"
+  },
+  sepolia: {
+    chain: chains.sepolia,
+    domain: GATEWAY_DOMAINS.sepolia,
+    usdc: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER
+  },
+  hyperEvmTestnet: {
+    chain: chains.hyperliquidEvmTestnet,
+    domain: GATEWAY_DOMAINS.hyperEvmTestnet,
+    usdc: "0x2B3370eE501B4a559b57D449569354196457D8Ab",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER
+  },
+  optimismSepolia: {
+    chain: chains.optimismSepolia,
+    domain: GATEWAY_DOMAINS.optimismSepolia,
+    usdc: "0x5fd84259d66Cd46123540766Be93DFE6D43130D7",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER
+  },
+  polygonAmoy: {
+    chain: chains.polygonAmoy,
+    domain: GATEWAY_DOMAINS.polygonAmoy,
+    usdc: "0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER
+  },
+  seiAtlantic: {
+    chain: chains.seiTestnet,
+    domain: GATEWAY_DOMAINS.seiAtlantic,
+    usdc: "0x4fCF1784B31630811181f670Aea7A7bEF803eaED",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER
+  },
+  sonicTestnet: {
+    chain: sonicTestnet,
+    domain: GATEWAY_DOMAINS.sonicTestnet,
+    usdc: "0x0BA304580ee7c9a980CF72e55f5Ed2E9fd30Bc51",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER
+  },
+  unichainSepolia: {
+    chain: chains.unichainSepolia,
+    domain: GATEWAY_DOMAINS.unichainSepolia,
+    usdc: "0x31d0220469e10c4E71834a79b1f276d740d3768F",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER
+  },
+  worldChainSepolia: {
+    chain: chains.worldchainSepolia,
+    domain: GATEWAY_DOMAINS.worldChainSepolia,
+    usdc: "0x66145f38cBAC35Ca6F1Dfb4914dF98F1614aeA88",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER
+  },
+  // Mainnet chains
+  arbitrum: {
+    chain: chains.arbitrum,
+    domain: GATEWAY_DOMAINS.arbitrum,
+    usdc: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  },
+  avalanche: {
+    chain: chains.avalanche,
+    domain: GATEWAY_DOMAINS.avalanche,
+    usdc: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  },
+  base: {
+    chain: chains.base,
+    domain: GATEWAY_DOMAINS.base,
+    usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  },
+  mainnet: {
+    chain: chains.mainnet,
+    domain: GATEWAY_DOMAINS.mainnet,
+    usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  },
+  hyperEvm: {
+    chain: chains.hyperEvm,
+    domain: GATEWAY_DOMAINS.hyperEvm,
+    usdc: "0xb88339CB7199b77E23DB6E890353E22632Ba630f",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  },
+  optimism: {
+    chain: chains.optimism,
+    domain: GATEWAY_DOMAINS.optimism,
+    usdc: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  },
+  polygon: {
+    chain: chains.polygon,
+    domain: GATEWAY_DOMAINS.polygon,
+    usdc: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  },
+  sei: {
+    chain: chains.sei,
+    domain: GATEWAY_DOMAINS.sei,
+    usdc: "0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  },
+  sonic: {
+    chain: chains.sonic,
+    domain: GATEWAY_DOMAINS.sonic,
+    usdc: "0x29219dd400f2Bf60E5a23d13Be72B486D4038894",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  },
+  unichain: {
+    chain: chains.unichain,
+    domain: GATEWAY_DOMAINS.unichain,
+    usdc: "0x078D782b760474a361dDA0AF3839290b0EF57AD6",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  },
+  worldChain: {
+    chain: chains.worldchain,
+    domain: GATEWAY_DOMAINS.worldChain,
+    usdc: "0x79A02482A880bCe3F13E09da970dC34dB4cD24D1",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  }
+};
+
+// src/server/GatewayEvmScheme.ts
+var GatewayEvmScheme = class extends ExactEvmScheme {
+  constructor() {
+    super();
+    this.registerGatewayMoneyParsers();
+  }
+  /**
+   * Enhances payment requirements by merging the facilitator's extra data.
+   *
+   * The base `ExactEvmScheme.enhancePaymentRequirements` returns requirements
+   * unchanged, dropping `supportedKind.extra`. Gateway payments require
+   * `extra.verifyingContract` (and other fields like `name`, `version`) to
+   * be present for clients to construct the correct signing domain.
+   */
+  async enhancePaymentRequirements(paymentRequirements, supportedKind, extensionKeys) {
+    void extensionKeys;
+    return {
+      ...paymentRequirements,
+      maxTimeoutSeconds: 345600,
+      // 4 days — Gateway batches settlements asynchronously
+      extra: {
+        ...paymentRequirements.extra,
+        ...supportedKind.extra
+      }
+    };
+  }
+  /**
+   * Registers money parsers for all Gateway-supported networks.
+   *
+   * Builds a `network → USDC address` lookup from `CHAIN_CONFIGS` and
+   * registers a single parser that converts dollar amounts to USDC atomic
+   * units (6 decimals) for any Gateway-supported chain.
+   *
+   * Returns `null` for unknown networks so `ExactEvmScheme`'s built-in
+   * parser handles them.
+   */
+  registerGatewayMoneyParsers() {
+    const networkUsdcMap = /* @__PURE__ */ new Map();
+    for (const config of Object.values(CHAIN_CONFIGS)) {
+      const network = `eip155:${config.chain.id}`;
+      networkUsdcMap.set(network, config.usdc);
+    }
+    this.registerMoneyParser(async (amount, network) => {
+      const usdcAddress = networkUsdcMap.get(network);
+      if (!usdcAddress) {
+        return null;
+      }
+      return {
+        amount: Math.round(amount * 1e6).toString(),
+        asset: usdcAddress
+      };
+    });
+  }
+};
+
+// src/constants.ts
+var CIRCLE_BATCHING_NAME = "GatewayWalletBatched";
+var CIRCLE_BATCHING_VERSION = "1";
+var CIRCLE_BATCHING_SCHEME = "exact";
+
+// src/detection.ts
+function supportsBatching(requirements) {
+  const extra = requirements.extra;
+  if (!extra) {
+    return false;
+  }
+  return extra.name === CIRCLE_BATCHING_NAME && extra.version === CIRCLE_BATCHING_VERSION;
+}
+var isBatchPayment = supportsBatching;
+
+// src/server/middleware.ts
+function getUsdcAddress(kind) {
+  const assets = kind.extra?.assets;
+  if (!assets || assets.length === 0) return null;
+  const usdc = assets.find((a) => a.symbol === "USDC");
+  return usdc?.address ?? null;
+}
+function parsePrice(price) {
+  const numericPrice = price.replace(/[$]/g, "");
+  const amount = parseFloat(numericPrice);
+  if (isNaN(amount) || amount <= 0) {
+    throw new Error(`Invalid price: ${price}`);
+  }
+  return Math.round(amount * 1e6).toString();
+}
+function createGatewayMiddleware(config) {
+  const facilitator = new BatchFacilitatorClient({
+    url: config.facilitatorUrl
+  });
+  const configuredNetworks = config.networks ? Array.isArray(config.networks) ? config.networks : [config.networks] : null;
+  let cachedSupportedKinds = null;
+  async function getSupportedKinds() {
+    if (cachedSupportedKinds) {
+      return cachedSupportedKinds;
+    }
+    const supported = await facilitator.getSupported();
+    cachedSupportedKinds = supported.kinds;
+    return cachedSupportedKinds;
+  }
+  async function getAcceptedNetworks() {
+    const allKinds = await getSupportedKinds();
+    if (configuredNetworks) {
+      return allKinds.filter(
+        (k) => configuredNetworks.includes(k.network) && k.extra?.verifyingContract
+      );
+    }
+    return allKinds.filter((k) => k.extra?.verifyingContract);
+  }
+  async function createAllPaymentRequirements(price) {
+    const networks = await getAcceptedNetworks();
+    const amount = parsePrice(price);
+    return networks.filter((kind) => getUsdcAddress(kind)).map((kind) => ({
+      scheme: CIRCLE_BATCHING_SCHEME,
+      // Must be 'exact' for Gateway API
+      network: kind.network,
+      asset: getUsdcAddress(kind),
+      // Use actual USDC address
+      amount,
+      payTo: config.sellerAddress,
+      maxTimeoutSeconds: 345600,
+      // 4 days (same as digital-dungeon)
+      extra: {
+        name: CIRCLE_BATCHING_NAME,
+        version: CIRCLE_BATCHING_VERSION,
+        verifyingContract: kind.extra.verifyingContract
+      }
+    }));
+  }
+  async function createPaymentRequirements(price, network) {
+    const networks = await getAcceptedNetworks();
+    const kind = networks.find((k) => k.network === network);
+    if (!kind || !kind.extra?.verifyingContract) {
+      return null;
+    }
+    const usdcAddress = getUsdcAddress(kind);
+    if (!usdcAddress) {
+      return null;
+    }
+    return {
+      scheme: CIRCLE_BATCHING_SCHEME,
+      // Must be 'exact' for Gateway API
+      network: kind.network,
+      asset: usdcAddress,
+      // Use actual USDC address
+      amount: parsePrice(price),
+      payTo: config.sellerAddress,
+      maxTimeoutSeconds: 345600,
+      // 4 days
+      extra: {
+        name: CIRCLE_BATCHING_NAME,
+        version: CIRCLE_BATCHING_VERSION,
+        verifyingContract: kind.extra.verifyingContract
+      }
+    };
+  }
+  return {
+    require: (price) => {
+      return async (req, res, next) => {
+        try {
+          const paymentHeader = req.headers["payment-signature"];
+          if (!paymentHeader) {
+            const allRequirements = await createAllPaymentRequirements(price);
+            const url = req.url ?? "/";
+            const description = config.description ?? "Paid resource";
+            if (allRequirements.length === 0) {
+              res.statusCode = 503;
+              res.setHeader("Content-Type", "application/json");
+              res.end(JSON.stringify({ error: "No payment networks available" }));
+              return;
+            }
+            const paymentRequired = {
+              x402Version: 2,
+              // Version 2 required by Gateway API
+              resource: {
+                url,
+                description,
+                mimeType: "application/json"
+              },
+              accepts: allRequirements
+            };
+            const paymentRequiredHeader = Buffer.from(
+              JSON.stringify(paymentRequired)
+            ).toString("base64");
+            res.statusCode = 402;
+            res.setHeader("PAYMENT-REQUIRED", paymentRequiredHeader);
+            res.setHeader("Content-Type", "application/json");
+            res.end(JSON.stringify({}));
+            return;
+          }
+          const paymentPayload = JSON.parse(
+            Buffer.from(paymentHeader, "base64").toString("utf-8")
+          );
+          const acceptedRequirements = paymentPayload.accepted;
+          if (!acceptedRequirements?.network) {
+            res.statusCode = 400;
+            res.setHeader("Content-Type", "application/json");
+            res.end(
+              JSON.stringify({ error: "Missing accepted requirements in payment" })
+            );
+            return;
+          }
+          const requirements = await createPaymentRequirements(
+            price,
+            acceptedRequirements.network
+          );
+          if (!requirements) {
+            res.statusCode = 400;
+            res.setHeader("Content-Type", "application/json");
+            res.end(
+              JSON.stringify({
+                error: `Network ${acceptedRequirements.network} not accepted`
+              })
+            );
+            return;
+          }
+          const verifyResult = await facilitator.verify(paymentPayload, requirements);
+          if (!verifyResult.isValid) {
+            res.statusCode = 402;
+            res.setHeader("Content-Type", "application/json");
+            res.end(
+              JSON.stringify({
+                error: "Payment verification failed",
+                reason: verifyResult.invalidReason
+              })
+            );
+            return;
+          }
+          const settleResult = await facilitator.settle(paymentPayload, requirements);
+          if (!settleResult.success) {
+            res.statusCode = 402;
+            res.setHeader("Content-Type", "application/json");
+            res.end(
+              JSON.stringify({
+                error: "Payment settlement failed",
+                reason: settleResult.errorReason
+              })
+            );
+            return;
+          }
+          req.payment = {
+            verified: true,
+            payer: settleResult.payer ?? verifyResult.payer ?? "",
+            amount: parsePrice(price),
+            network: requirements.network,
+            transaction: settleResult.transaction
+          };
+          const settleResponseHeader = Buffer.from(
+            JSON.stringify({
+              success: true,
+              transaction: settleResult.transaction,
+              network: requirements.network,
+              payer: settleResult.payer ?? verifyResult.payer ?? ""
+            })
+          ).toString("base64");
+          res.setHeader("PAYMENT-RESPONSE", settleResponseHeader);
+          next();
+        } catch (error) {
+          res.statusCode = 500;
+          res.setHeader("Content-Type", "application/json");
+          res.end(
+            JSON.stringify({
+              error: "Payment processing error",
+              message: error.message
+            })
+          );
+        }
+      };
+    },
+    verify: async (payment) => {
+      try {
+        const paymentPayload = payment;
+        const result = await facilitator.verify(
+          paymentPayload.paymentPayload,
+          paymentPayload.paymentRequirements
+        );
+        return {
+          valid: result.isValid,
+          payer: result.payer,
+          error: result.invalidReason
+        };
+      } catch (error) {
+        return {
+          valid: false,
+          error: error.message
+        };
+      }
+    },
+    settle: async (payment) => {
+      try {
+        const paymentPayload = payment;
+        const result = await facilitator.settle(
+          paymentPayload.paymentPayload,
+          paymentPayload.paymentRequirements
+        );
+        return {
+          success: result.success,
+          transaction: result.transaction,
+          error: result.errorReason
+        };
+      } catch (error) {
+        return {
+          success: false,
+          error: error.message
+        };
+      }
+    }
+  };
+}
+export {
+  BatchFacilitatorClient,
+  GatewayEvmScheme,
+  createGatewayMiddleware,
+  isBatchPayment
+};
+//# sourceMappingURL=index.mjs.map