@w3payments/common 1.1.0

package/dist/index.mjs

@@ -0,0 +1,630 @@
+class PaymentMethodService {
+  static instance;
+  paymentMethods = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  static getInstance() {
+    if (!PaymentMethodService.instance) {
+      PaymentMethodService.instance = new PaymentMethodService();
+    }
+    return PaymentMethodService.instance;
+  }
+  /**
+   * Register a new payment method
+   */
+  register(method) {
+    this.paymentMethods.set(method.id, method);
+  }
+  /**
+   * Register multiple payment methods
+   */
+  registerMany(methods) {
+    methods.forEach((method) => this.register(method));
+  }
+  /**
+   * Get payment method by ID
+   */
+  getPaymentMethod(id) {
+    return this.paymentMethods.get(id);
+  }
+  /**
+   * Get all registered payment methods
+   */
+  getAllPaymentMethods() {
+    return Array.from(this.paymentMethods.values());
+  }
+  /**
+   * Check if payment method exists
+   */
+  hasPaymentMethod(id) {
+    return this.paymentMethods.has(id);
+  }
+  /**
+   * Get payment methods by vendor
+   */
+  getByVendor(vendorId) {
+    return this.getAllPaymentMethods().filter(
+      (method) => method.vendorId === vendorId
+    );
+  }
+  /**
+   * Get payment methods by method type (ach, wallet, exchange)
+   */
+  getByMethod(methodType) {
+    return this.getAllPaymentMethods().filter(
+      (method) => method.method === methodType
+    );
+  }
+  /**
+   * Get payment methods by type (fiat or crypto)
+   */
+  getByType(type) {
+    return this.getAllPaymentMethods().filter((method) => method.type === type);
+  }
+  /**
+   * Get fiat payment methods only
+   */
+  getFiatPaymentMethods() {
+    return this.getAllPaymentMethods().filter(
+      (method) => method.type === "fiat"
+    );
+  }
+  /**
+   * Get crypto payment methods only
+   */
+  getCryptoPaymentMethods() {
+    return this.getAllPaymentMethods().filter(
+      (method) => method.type === "crypto"
+    );
+  }
+  /**
+   * Get payment methods by currency
+   */
+  getByCurrency(currencyCode) {
+    return this.getAllPaymentMethods().filter(
+      (method) => method.supportedCurrencies.includes(currencyCode)
+    );
+  }
+  /**
+   * Get crypto payment methods by network
+   */
+  getByNetwork(networkId) {
+    return this.getCryptoPaymentMethods().filter(
+      (method) => method.network === networkId
+    );
+  }
+  /**
+   * Get crypto payment methods by network and currency combination
+   */
+  getByNetworkAndCurrency(networkId, currencyCode) {
+    return this.getCryptoPaymentMethods().filter(
+      (method) => method.network === networkId && method.currency === currencyCode
+    );
+  }
+  /**
+   * Get payment methods by region
+   */
+  getByRegion(region) {
+    return this.getAllPaymentMethods().filter(
+      (method) => !method.regions || method.regions.length === 0 || method.regions.includes(region)
+    );
+  }
+  /**
+   * Get active payment methods only
+   */
+  getActive() {
+    return this.getAllPaymentMethods().filter((method) => method.isActive);
+  }
+  /**
+   * Get available payment methods for currency and region
+   */
+  getAvailableFor(currencyCode, region) {
+    const methods = this.getByCurrency(currencyCode).filter(
+      (method) => method.isActive
+    );
+    if (region) {
+      return methods.filter(
+        (method) => !method.regions || method.regions.length === 0 || method.regions.includes(region)
+      );
+    }
+    return methods;
+  }
+  /**
+   * Search payment methods by name or description
+   */
+  searchPaymentMethods(query) {
+    const lowerQuery = query.toLowerCase();
+    return this.getAllPaymentMethods().filter(
+      (method) => method.name.toLowerCase().includes(lowerQuery) || method.description?.toLowerCase().includes(lowerQuery)
+    );
+  }
+  /**
+   * Get wallet payment methods with optional currency and target filters
+   */
+  getWalletMethods(filters) {
+    const walletMethods = this.getCryptoPaymentMethods().filter(
+      (method) => method.method === "wallet"
+    );
+    console.log("getWalletMethods: All wallet methods:", walletMethods.length);
+    console.log("getWalletMethods: Filters:", filters);
+    if (!filters) return walletMethods;
+    const filtered = walletMethods.filter((method) => {
+      const currencyMatches = !filters.currencies?.length || filters.currencies.some(
+        (curr) => method.currency.toLowerCase() === curr.toLowerCase()
+      );
+      const targetMatches = (!filters.targetCurrency || method.currency.toLowerCase() === filters.targetCurrency.toLowerCase()) && (!filters.targetNetwork || method.network.toLowerCase() === filters.targetNetwork.toLowerCase());
+      const matches = currencyMatches && targetMatches;
+      console.log(
+        `getWalletMethods: Method ${method.currency}/${method.network} - currencyMatches: ${currencyMatches}, targetMatches: ${targetMatches}, overall: ${matches}`
+      );
+      return matches;
+    });
+    console.log("getWalletMethods: Filtered result:", filtered.length);
+    return filtered;
+  }
+  /**
+   * Get exchange payment methods with optional exchange and target filters
+   */
+  getExchangeMethods(filters) {
+    const exchangeMethods = this.getCryptoPaymentMethods().filter(
+      (method) => method.method === "exchange"
+    );
+    if (!filters) return exchangeMethods;
+    return exchangeMethods.filter((method) => {
+      const exchangeMatches = !filters.exchanges?.length || filters.exchanges.some(
+        (exchange) => method.name.toLowerCase().includes(exchange.toLowerCase())
+      );
+      const targetMatches = !filters.targetCurrency || method.currency.toLowerCase() === filters.targetCurrency.toLowerCase();
+      return exchangeMatches && targetMatches;
+    });
+  }
+  /**
+   * Get fiat payment methods with optional method type filter
+   */
+  getFiatMethods(filters) {
+    const fiatMethods = this.getFiatPaymentMethods();
+    if (!filters?.methods?.length) return fiatMethods;
+    return fiatMethods.filter(
+      (method) => filters.methods.some(
+        (fiat) => method.method.toLowerCase() === fiat.toLowerCase()
+      )
+    );
+  }
+  /**
+   * Get simple display options from filter values
+   */
+  getDisplayOptions(filters) {
+    const result = [];
+    console.log(
+      "getDisplayOptions: Processing walletFilter:",
+      filters?.walletFilter
+    );
+    filters?.walletFilter?.forEach((currency) => {
+      console.log(`getDisplayOptions: Processing wallet currency: ${currency}`);
+      const walletMethods = this.getWalletMethods({
+        currencies: [currency],
+        targetCurrency: filters.targetCurrency,
+        targetNetwork: filters.targetNetwork
+      });
+      console.log(
+        `getDisplayOptions: Found ${walletMethods.length} wallet methods for ${currency}`
+      );
+      if (walletMethods.length > 0) {
+        result.push({
+          id: `wallet-${currency.toLowerCase()}`,
+          displayName: currency,
+          method: "wallet"
+        });
+        console.log(`getDisplayOptions: Added wallet option for ${currency}`);
+      }
+    });
+    filters?.exchangeFilter?.forEach((exchange) => {
+      const exchangeMethods = this.getExchangeMethods({
+        exchanges: [exchange],
+        targetCurrency: filters.targetCurrency
+      });
+      if (exchangeMethods.length > 0) {
+        result.push({
+          id: `exchange-${exchange.toLowerCase()}`,
+          displayName: exchange,
+          method: "exchange"
+        });
+      }
+    });
+    filters?.fiatFilter?.forEach((fiatMethod) => {
+      const fiatMethods = this.getFiatMethods({
+        methods: [fiatMethod]
+      });
+      if (fiatMethods.length > 0) {
+        result.push({
+          id: `fiat-${fiatMethod.toLowerCase()}`,
+          displayName: fiatMethod,
+          method: "fiat"
+        });
+      }
+    });
+    return result;
+  }
+  /**
+   * Clear all payment methods (useful for testing)
+   */
+  clear() {
+    this.paymentMethods.clear();
+  }
+}
+const paymentMethodService = PaymentMethodService.getInstance();
+class CurrencyService {
+  static instance;
+  currencies = /* @__PURE__ */ new Map();
+  supportedCurrencies = {
+    sandbox: /* @__PURE__ */ new Set(),
+    production: /* @__PURE__ */ new Set()
+  };
+  constructor() {
+  }
+  static getInstance() {
+    if (!CurrencyService.instance) {
+      CurrencyService.instance = new CurrencyService();
+    }
+    return CurrencyService.instance;
+  }
+  /**
+   * Register a new currency
+   */
+  register(currency) {
+    this.currencies.set(currency.code, currency);
+  }
+  /**
+   * Register multiple currencies
+   */
+  registerMany(currencies) {
+    currencies.forEach((currency) => this.register(currency));
+  }
+  /**
+   * Get currency by code
+   */
+  getCurrency(code) {
+    return this.currencies.get(code);
+  }
+  /**
+   * Get all registered currencies
+   */
+  getAllCurrencies() {
+    return Array.from(this.currencies.values());
+  }
+  /**
+   * Check if currency exists
+   */
+  hasCurrency(code) {
+    return this.currencies.has(code);
+  }
+  /**
+   * Get currency icon URL
+   */
+  getCurrencyIcon(code) {
+    const currency = this.getCurrency(code);
+    return currency?.iconUrl || "";
+  }
+  /**
+   * Get cryptocurrencies only
+   */
+  getCryptoCurrencies() {
+    return this.getAllCurrencies().filter(
+      (currency) => currency.type === "crypto"
+    );
+  }
+  /**
+   * Get fiat currencies only
+   */
+  getFiatCurrencies() {
+    return this.getAllCurrencies().filter(
+      (currency) => currency.type === "fiat"
+    );
+  }
+  /**
+   * Get stablecoins only
+   */
+  getStablecoins() {
+    return this.getCryptoCurrencies().filter((currency) => currency.isStablecoin);
+  }
+  /**
+   * Get currencies by network
+   */
+  getCurrenciesByNetwork(networkId) {
+    return this.getCryptoCurrencies().filter(
+      (currency) => currency.network === networkId
+    );
+  }
+  /**
+   * Search currencies by code or name
+   */
+  searchCurrencies(query) {
+    const lowerQuery = query.toLowerCase();
+    return this.getAllCurrencies().filter(
+      (currency) => currency.code.toLowerCase().includes(lowerQuery) || currency.name.toLowerCase().includes(lowerQuery)
+    );
+  }
+  /**
+   * Add currency to supported list for environment
+   */
+  addSupportedCurrency(code, environment) {
+    this.supportedCurrencies[environment].add(code);
+  }
+  /**
+   * Get supported currencies for environment
+   */
+  getSupportedCurrencies(environment) {
+    return Array.from(this.supportedCurrencies[environment]);
+  }
+  /**
+   * Check if currency is supported in environment
+   */
+  isCurrencySupported(code, environment) {
+    return this.supportedCurrencies[environment].has(code);
+  }
+  /**
+   * Clear all currencies (useful for testing)
+   */
+  clear() {
+    this.currencies.clear();
+    this.supportedCurrencies.sandbox.clear();
+    this.supportedCurrencies.production.clear();
+  }
+}
+const currencyService = CurrencyService.getInstance();
+class NetworkService {
+  static instance;
+  networks = /* @__PURE__ */ new Map();
+  constructor() {
+  }
+  static getInstance() {
+    if (!NetworkService.instance) {
+      NetworkService.instance = new NetworkService();
+    }
+    return NetworkService.instance;
+  }
+  /**
+   * Register a new network
+   */
+  register(network) {
+    this.networks.set(network.id, network);
+  }
+  /**
+   * Register multiple networks
+   */
+  registerMany(networks) {
+    networks.forEach((network) => this.register(network));
+  }
+  /**
+   * Get network by ID
+   */
+  getNetwork(id) {
+    return this.networks.get(id);
+  }
+  /**
+   * Get all registered networks
+   */
+  getAllNetworks() {
+    return Array.from(this.networks.values());
+  }
+  /**
+   * Check if network exists
+   */
+  hasNetwork(id) {
+    return this.networks.has(id);
+  }
+  /**
+   * Get mainnet networks only
+   */
+  getMainnetNetworks() {
+    return this.getAllNetworks().filter((network) => !network.isTestnet);
+  }
+  /**
+   * Get testnet networks only
+   */
+  getTestnetNetworks() {
+    return this.getAllNetworks().filter((network) => network.isTestnet);
+  }
+  /**
+   * Clear all networks (useful for testing)
+   */
+  clear() {
+    this.networks.clear();
+  }
+}
+const networkService = NetworkService.getInstance();
+function camelToKebab(str) {
+  return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+}
+function getDefaultVariables() {
+  return {
+    colorPrimary: "#6366f1",
+    colorPrimaryHover: "#4f46e5",
+    colorPrimaryLight: "#e0e7ff",
+    colorBackground: "#ffffff",
+    colorText: "#1f2937",
+    colorTextMuted: "#6b7280",
+    colorBorder: "#e5e7eb",
+    colorBorderLight: "#f3f4f6",
+    colorDanger: "#ef4444",
+    colorSuccess: "#10b981",
+    fontFamily: "system-ui, -apple-system, sans-serif",
+    fontSize: "1rem",
+    borderRadius: "0.5rem",
+    spacing: "1rem"
+  };
+}
+function getThemePreset(themeName) {
+  const defaults = getDefaultVariables();
+  switch (themeName) {
+    case "dark":
+      return {
+        ...defaults,
+        colorPrimary: "#6366f1",
+        colorPrimaryHover: "#7c3aed",
+        colorPrimaryLight: "#1e1b4b",
+        colorBackground: "#111827",
+        colorText: "#f9fafb",
+        colorTextMuted: "#9ca3af",
+        colorBorder: "#374151",
+        colorBorderLight: "#4b5563"
+      };
+    case "light":
+    default:
+      return defaults;
+  }
+}
+function applyTheme(themeInput, container) {
+  const theme = typeof themeInput === "string" ? { theme: themeInput } : themeInput;
+  const baseVariables = getThemePreset(theme.theme ?? "light");
+  const finalVariables = { ...baseVariables, ...theme.variables };
+  Object.entries(finalVariables).forEach(([key, value]) => {
+    if (value !== void 0) {
+      const cssVar = `--${camelToKebab(key)}`;
+      container.style.setProperty(cssVar, value);
+    }
+  });
+  if (theme.theme) {
+    container.setAttribute("data-theme", theme.theme);
+  }
+  if (theme.rules) {
+    applyComponentRules(theme.rules);
+  }
+}
+function applyComponentRules(rules) {
+  const styleId = "w3-theme-rules";
+  let styleElement = document.getElementById(styleId);
+  if (!styleElement) {
+    styleElement = document.createElement("style");
+    styleElement.id = styleId;
+    document.head.appendChild(styleElement);
+  }
+  const css = Object.entries(rules).map(([selector, styles]) => {
+    const cssProperties = Object.entries(styles).map(([prop, value]) => `${camelToKebab(prop)}: ${value};`).join(" ");
+    return `.w3-widget ${selector} { ${cssProperties} }`;
+  }).join("\n");
+  styleElement.textContent = css;
+}
+const CURRENCIES = {
+  USD: {
+    code: "USD",
+    name: "US Dollar",
+    symbol: "$",
+    decimals: 2,
+    type: "fiat",
+    countryCode: "US",
+    iconUrl: "https://cdn.jsdelivr.net/gh/atomiclabs/cryptocurrency-icons@1a63530be6e374711a8554f31b17e4cb92c25fa5/svg/icon/usd.svg"
+  },
+  BTC: {
+    code: "BTC",
+    name: "Bitcoin",
+    symbol: "₿",
+    decimals: 8,
+    type: "crypto",
+    network: "bitcoin",
+    isStablecoin: false,
+    iconUrl: "https://cdn.jsdelivr.net/gh/atomiclabs/cryptocurrency-icons@1a63530be6e374711a8554f31b17e4cb92c25fa5/svg/icon/btc.svg"
+  },
+  ETH: {
+    code: "ETH",
+    name: "Ethereum",
+    symbol: "Ξ",
+    decimals: 18,
+    type: "crypto",
+    network: "ethereum",
+    isStablecoin: false,
+    iconUrl: "https://cdn.jsdelivr.net/gh/atomiclabs/cryptocurrency-icons@1a63530be6e374711a8554f31b17e4cb92c25fa5/svg/icon/eth.svg"
+  }
+};
+const NETWORKS = {
+  bitcoin: {
+    id: "bitcoin",
+    name: "Bitcoin",
+    symbol: "BTC"
+  },
+  ethereum: {
+    id: "ethereum",
+    name: "Ethereum",
+    symbol: "ETH",
+    chainId: 1
+  }
+};
+const currencyIcons = {
+  // Major Cryptocurrencies
+  BTC: "https://cryptologos.cc/logos/bitcoin-btc-logo.svg",
+  ETH: "https://cryptologos.cc/logos/ethereum-eth-logo.svg",
+  USDC: "https://cryptologos.cc/logos/usd-coin-usdc-logo.svg",
+  USDT: "https://cryptologos.cc/logos/tether-usdt-logo.svg",
+  DAI: "https://cryptologos.cc/logos/multi-collateral-dai-dai-logo.svg",
+  // Layer 1 Networks
+  SOL: "https://cryptologos.cc/logos/solana-sol-logo.svg",
+  AVAX: "https://cryptologos.cc/logos/avalanche-avax-logo.svg",
+  MATIC: "https://cryptologos.cc/logos/polygon-matic-logo.svg",
+  BNB: "https://cryptologos.cc/logos/bnb-bnb-logo.svg",
+  // DeFi Tokens
+  UNI: "https://cryptologos.cc/logos/uniswap-uni-logo.svg",
+  LINK: "https://cryptologos.cc/logos/chainlink-link-logo.svg",
+  AAVE: "https://cryptologos.cc/logos/aave-aave-logo.svg",
+  // Layer 2
+  ARB: "https://cryptologos.cc/logos/arbitrum-arb-logo.svg",
+  OP: "https://cryptologos.cc/logos/optimism-ethereum-op-logo.svg",
+  // Other Popular
+  DOGE: "https://cryptologos.cc/logos/dogecoin-doge-logo.svg",
+  XRP: "https://cryptologos.cc/logos/xrp-xrp-logo.svg",
+  ADA: "https://cryptologos.cc/logos/cardano-ada-logo.svg",
+  DOT: "https://cryptologos.cc/logos/polkadot-new-dot-logo.svg"
+};
+function getCurrencyIcon(code) {
+  return currencyIcons[code.toUpperCase()];
+}
+const exchangeIcons = {
+  // Major Exchanges
+  coinbase: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPGNpcmNsZSBjeD0iMTIiIGN5PSIxMiIgcj0iMTAiIGZpbGw9IiMwMDUyRkYiLz4KPHJlY3QgeD0iOSIgeT0iOSIgd2lkdGg9IjYiIGhlaWdodD0iNiIgcng9IjEiIGZpbGw9IndoaXRlIi8+Cjwvc3ZnPg==",
+  kraken: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPGNpcmNsZSBjeD0iMTIiIGN5PSIxMiIgcj0iMTAiIGZpbGw9IiM1NzQxOUEiLz4KPHBhdGggZD0iTTggN0wxNiA5VjE3TDggMTVWN1oiIGZpbGw9IndoaXRlIi8+Cjwvc3ZnPg==",
+  binance: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPGNpcmNsZSBjeD0iMTIiIGN5PSIxMiIgcj0iMTAiIGZpbGw9IiNGM0JBMkYiLz4KPHBhdGggZD0iTTEyIDZMMTUgOVYxNUwxMiAxOEw5IDE1VjlMMTIgNloiIGZpbGw9IndoaXRlIi8+Cjwvc3ZnPg==",
+  // Other Exchanges
+  gemini: "https://assets.coincap.io/assets/icons/256/gemini.png",
+  kucoin: "https://assets.coincap.io/assets/icons/256/kucoin.png",
+  huobi: "https://assets.coincap.io/assets/icons/256/huobi.png",
+  okx: "https://assets.coincap.io/assets/icons/256/okx.png",
+  gate: "https://assets.coincap.io/assets/icons/256/gate.png",
+  bitfinex: "https://assets.coincap.io/assets/icons/256/bitfinex.png",
+  // Alternative sources if needed
+  "coinbase-pro": "https://assets.coincap.io/assets/icons/256/coinbase.png",
+  "binance-us": "https://assets.coincap.io/assets/icons/256/binance.png"
+};
+function getExchangeIcon(exchange) {
+  return exchangeIcons[exchange.toLowerCase()];
+}
+const fiatIcons = {
+  // Bank Transfer Methods
+  ach: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTMgN1YxN0gyMVY3SDNaTTQgOEgyMFYxNkg0VjhaTTYgMTBWMTRIOVYxMEg2Wk0xMCAxMFYxMUgxOFYxMEgxMFpNMTAgMTJWMTNIMTVWMTJIMTBaIiBmaWxsPSJjdXJyZW50Q29sb3IiLz4KPC9zdmc+",
+  wire: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTEyIDJMMTMuMDkgOC4yNkwyMCA5TDEzLjA5IDE1Ljc0TDEyIDIyTDEwLjkxIDE1Ljc0TDQgOUwxMC45MSA4LjI2TDEyIDJaIiBmaWxsPSJjdXJyZW50Q29sb3IiLz4KPC9zdmc+",
+  sepa: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTIwIDRIOEE0IDQgMCAwIDAgNCA4VjE2QTQgNCAwIDAgMCA4IDIwSDE2QTggOCAwIDAgMCAyMCA0Wk04IDZIMTZBMiAyIDAgMCAxIDE4IDhWMTZBNiA2IDAgMCAxIDYgMTBWOEEyIDIgMCAwIDEgOCA2WiIgZmlsbD0iY3VycmVudENvbG9yIi8+Cjwvc3ZnPg==",
+  // Cards
+  credit: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTIwIDRINEMyLjg5IDQgMiA0Ljg5IDIgNlYxOEMyIDE5LjExIDIuODkgMjAgNCAyMEgyMEMyMS4xMSAyMCAyMiAxOS4xMSAyMiAxOFY2QzIyIDQuODkgMjEuMTEgNCAyMCA0Wk0yMCA2VjhINFY2SDIwWk0yMCAxOEg0VjEwSDIwVjE4WiIgZmlsbD0iY3VycmVudENvbG9yIi8+Cjwvc3ZnPg==",
+  debit: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTIwIDRINEMyLjg5IDQgMiA0Ljg5IDIgNlYxOEMyIDE5LjExIDIuODkgMjAgNCAyMEgyMEMyMS4xMSAyMCAyMiAxOS4xMSAyMiAxOFY2QzIyIDQuODkgMjEuMTEgNCAyMCA0Wk0yMCA2VjhINFY2SDIwWk0yMCAxOEg0VjEwSDIwVjE4WiIgZmlsbD0iY3VycmVudENvbG9yIi8+Cjwvc3ZnPg==",
+  // Digital Wallets
+  paypal: "https://cdn.jsdelivr.net/gh/devicons/devicon/icons/paypal/paypal-original.svg",
+  applepay: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTE4Ljc0IDguNDNDMTguNzQgMTEuNTQgMTUuNzQgMTMgMTIuNzQgMTNIMTBWMjBINlYzSDEyLjc0QzE1Ljc0IDMgMTguNzQgNC40NiAxOC43NCA4LjQzWk0xNC41IDguNDNDMTQuNSA2LjY3IDEzLjU5IDUuNzUgMTEuOTggNS43NUgxMFYxMS4yNUgxMS45OEMxMy41OSAxMS4yNSAxNC41IDEwLjMzIDE0LjUgOC40M1oiIGZpbGw9ImN1cnJlbnRDb2xvciIvPgo8L3N2Zz4K",
+  googlepay: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTEyIDJDNi40OCAyIDIgNi40OCAyIDEyUzYuNDggMjIgMTIgMjJTMjIgMTcuNTIgMjIgMTJTMTcuNTIgMiAxMiAyWk0xMyAxN0g5VjE1SDE1VjE3SDE3VjE5SDE1VjIxSDEzVjE5SDlWMTVIMTNWMTdaIiBmaWxsPSJjdXJyZW50Q29sb3IiLz4KPC9zdmc+",
+  // Others/Fallback
+  bank: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTMgN1YxN0gyMVY3SDNaTTQgOEgyMFYxNkg0VjhaTTYgMTBWMTRIOVYxMEg2Wk0xMCAxMFYxMUgxOFYxMEgxMFpNMTAgMTJWMTNIMTVWMTJIMTBaIiBmaWxsPSJjdXJyZW50Q29sb3IiLz4KPC9zdmc+",
+  other: "data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggZD0iTTEyIDhDMTMuMSA4IDE0IDcuMSAxNCA2UzEzLjEgNCAxMiA0IDEwIDQuOSAxMCA2UzEwLjkgOCAxMiA4Wk0xMiAxMEMxMC45IDEwIDEwIDEwLjkgMTAgMTJTMTAuOSAxNCAxMiAxNFMxNCAxMy4xIDE0IDEyUzEzLjEgMTAgMTIgMTBaTTEyIDE2QzEwLjkgMTYgMTAgMTYuOSAxMCAxOFMxMC45IDIwIDEyIDIwUzE0IDE5LjEgMTQgMThTMTMuMSAxNiAxMiAxNloiIGZpbGw9ImN1cnJlbnRDb2xvciIvPgo8L3N2Zz4K"
+};
+function getFiatIcon(method) {
+  return fiatIcons[method.toLowerCase()];
+}
+export {
+  CURRENCIES,
+  NETWORKS,
+  PaymentMethodService,
+  applyTheme,
+  currencyService,
+  getCurrencyIcon,
+  getExchangeIcon,
+  getFiatIcon,
+  networkService,
+  paymentMethodService
+};
+//# sourceMappingURL=index.mjs.map