@dj-test/payment-sdk 1.0.0

package/dist/index.mjs

@@ -0,0 +1,3789 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/core/constants.ts
+var SDK_VERSION = "1.0.0";
+var API_ENDPOINTS = {
+  ORDERS: "/payments",
+  PRODUCTS: "/products"
+};
+var ENVIRONMENT_URLS = {
+  production: "https://pay.com",
+  sandbox: "http://localhost:8080"
+};
+var PAYMENT_DOMAINS = {
+  production: "https://pay-home.com",
+  sandbox: "http://localhost:3000"
+};
+var DEFAULT_TIMEOUT = 3e4;
+var ORDER_EXPIRY_MINUTES = 30;
+var MIN_WITHDRAWAL_AMOUNT = 0.01;
+var SUPPORTED_CHAINS = {
+  ETHEREUM: "1",
+  SEPOLIA: "11155111",
+  POLYGON: "137"
+};
+var ERROR_CODES = {
+  INVALID_API_KEY: "INVALID_API_KEY",
+  INVALID_PRODUCT: "INVALID_PRODUCT",
+  ORDER_NOT_FOUND: "ORDER_NOT_FOUND",
+  ORDER_EXPIRED: "ORDER_EXPIRED",
+  INSUFFICIENT_BALANCE: "INSUFFICIENT_BALANCE",
+  SELF_TRANSFER: "SELF_TRANSFER",
+  INVALID_ADDRESS: "INVALID_ADDRESS",
+  NETWORK_ERROR: "NETWORK_ERROR"
+};
+
+// src/core/config.ts
+var Config = class _Config {
+  constructor() {
+    this.config = null;
+  }
+  static getInstance() {
+    if (!_Config.instance) {
+      _Config.instance = new _Config();
+    }
+    return _Config.instance;
+  }
+  initialize(config2) {
+    if (!config2.baseUrl && config2.environment) {
+      config2.baseUrl = ENVIRONMENT_URLS[config2.environment];
+    }
+    if (!config2.timeout) {
+      config2.timeout = DEFAULT_TIMEOUT;
+    }
+    this.config = config2;
+  }
+  getConfig() {
+    if (!this.config) {
+      return {
+        environment: "sandbox",
+        baseUrl: ENVIRONMENT_URLS.sandbox,
+        timeout: DEFAULT_TIMEOUT
+      };
+    }
+    return this.config;
+  }
+  isInitialized() {
+    return this.config !== null;
+  }
+  reset() {
+    this.config = null;
+  }
+};
+var config = Config.getInstance();
+
+// src/core/wagmi-config.ts
+import { http, createConfig } from "wagmi";
+import {
+  mainnet,
+  sepolia,
+  polygon,
+  polygonAmoy,
+  base,
+  baseSepolia
+} from "wagmi/chains";
+import { injected, walletConnect } from "@wagmi/connectors";
+var supportedEvmChains = [
+  mainnet,
+  sepolia,
+  polygon,
+  polygonAmoy,
+  base,
+  baseSepolia
+];
+var supportedChains = supportedEvmChains;
+var createWagmiConfig = (projectId) => {
+  const connectors = [injected()];
+  if (projectId) {
+    const sdkConfig = config.getConfig();
+    const environment = sdkConfig.environment || "sandbox";
+    const paymentDomain = PAYMENT_DOMAINS[environment];
+    connectors.push(
+      walletConnect({
+        projectId,
+        metadata: {
+          name: "Payment SDK",
+          description: "Multi-chain Payment SDK",
+          url: paymentDomain,
+          icons: [`${paymentDomain}/icon.png`]
+        },
+        showQrModal: true
+      })
+    );
+  }
+  return createConfig({
+    chains: [mainnet, sepolia, polygon, polygonAmoy, base, baseSepolia],
+    connectors,
+    transports: {
+      [mainnet.id]: http(),
+      [sepolia.id]: http(),
+      [polygon.id]: http(),
+      [polygonAmoy.id]: http(),
+      [base.id]: http(),
+      [baseSepolia.id]: http()
+    },
+    ssr: true
+  });
+};
+var getEvmChainById = (chainId) => {
+  return supportedEvmChains.find((chain) => chain.id === chainId);
+};
+var getChainById = getEvmChainById;
+
+// src/core/WalletContext.tsx
+import { createContext, useContext } from "react";
+import { jsx } from "react/jsx-runtime";
+var WalletContext = createContext(null);
+var useWalletContext = () => {
+  const context = useContext(WalletContext);
+  if (!context) {
+    throw new Error("useWalletContext must be used within WalletProvider");
+  }
+  return context;
+};
+var WalletContextProvider = ({ factory, children }) => {
+  return /* @__PURE__ */ jsx(WalletContext.Provider, { value: { factory }, children });
+};
+
+// src/components/PaymentProvider.tsx
+import { createContext as createContext2, useEffect } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+var PaymentContext = createContext2(null);
+var isValidUrl = (url) => {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+};
+var PaymentProvider = ({
+  baseUrl,
+  paymentDomain,
+  redirectUrl,
+  webhookUrl,
+  environment = "sandbox",
+  timeout,
+  children
+}) => {
+  useEffect(() => {
+    if (redirectUrl && !isValidUrl(redirectUrl)) {
+      console.error("Invalid redirectUrl");
+    }
+    if (webhookUrl && !isValidUrl(webhookUrl)) {
+      console.error("Invalid webhookUrl");
+    }
+    if (paymentDomain && !isValidUrl(paymentDomain)) {
+      console.error("Invalid paymentDomain");
+    }
+    const sdkConfig = {
+      environment,
+      baseUrl,
+      paymentDomain,
+      redirectUrl,
+      webhookUrl,
+      timeout
+    };
+    config.initialize(sdkConfig);
+  }, [environment, baseUrl, paymentDomain, redirectUrl, webhookUrl, timeout]);
+  const contextValue = {
+    config: {
+      environment,
+      baseUrl,
+      paymentDomain,
+      redirectUrl,
+      webhookUrl,
+      timeout
+    },
+    isInitialized: config.isInitialized()
+  };
+  return /* @__PURE__ */ jsx2(PaymentContext.Provider, { value: contextValue, children });
+};
+
+// src/components/PaymentButton.tsx
+import { useState as useState8, useContext as useContext3 } from "react";
+
+// src/hooks/usePayment.ts
+import { useState, useCallback, useContext as useContext2 } from "react";
+
+// src/api/orders.ts
+var orders_exports = {};
+__export(orders_exports, {
+  createOrder: () => createOrder,
+  getOrder: () => getOrder,
+  getOrders: () => getOrders
+});
+
+// src/api/client.ts
+import axios from "axios";
+
+// src/types/sdk.ts
+var SDKError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "SDKError";
+  }
+};
+var APIError = class extends SDKError {
+  constructor(message, statusCode, details) {
+    super(message, "API_ERROR", details);
+    this.statusCode = statusCode;
+    this.name = "APIError";
+  }
+};
+
+// src/api/client.ts
+var APIClient = class {
+  constructor() {
+    this.instance = null;
+  }
+  getClient() {
+    if (!this.instance) {
+      const sdkConfig = config.getConfig();
+      this.instance = axios.create({
+        baseURL: sdkConfig.baseUrl,
+        timeout: sdkConfig.timeout,
+        headers: {
+          "Content-Type": "application/json"
+        },
+        withCredentials: true
+        // 기존 프로젝트 패턴과 일치
+      });
+      this.instance.interceptors.request.use(
+        (requestConfig) => {
+          return requestConfig;
+        },
+        (error) => Promise.reject(error)
+      );
+      this.instance.interceptors.response.use(
+        (response) => response,
+        (error) => {
+          const status = error.response?.status;
+          const data = error.response?.data;
+          const message = data?.message || error.message;
+          const details = error.response?.data;
+          throw new APIError(message, status, details);
+        }
+      );
+    }
+    return this.instance;
+  }
+  reset() {
+    this.instance = null;
+  }
+};
+var apiClient = new APIClient();
+
+// src/api/orders.ts
+var createOrder = async (productId, redirectUrl, webhookUrl) => {
+  const request = {
+    productId,
+    redirectUrl,
+    webhookUrl
+  };
+  const response = await apiClient.getClient().post(API_ENDPOINTS.ORDERS, request);
+  const order = response.data.output;
+  return {
+    orderId: order.uuid,
+    publicOrderId: order.uuid,
+    paymentUrl: "",
+    // 사용 안 함
+    amount: 0,
+    // 주문 생성 시점에는 없음
+    coinId: "",
+    // 주문 생성 시점에는 없음
+    chainId: "",
+    // 주문 생성 시점에는 없음
+    status: order.status,
+    expiresAt: "",
+    // 주문 생성 시점에는 없음
+    redirectUrl: order.redirectUrl || null
+    // 서버 응답의 redirectUrl
+  };
+};
+var getOrder = async (publicOrderId) => {
+  const response = await apiClient.getClient().get(`${API_ENDPOINTS.ORDERS}/${publicOrderId}`);
+  const orderData = response.data.output;
+  if (!orderData || typeof orderData !== "object") {
+    throw new Error("Order data is null or invalid");
+  }
+  if (!orderData.orderId || orderData.orderStat === void 0 || orderData.orderStat === null) {
+    throw new Error("Order data is incomplete - missing required fields");
+  }
+  return orderData;
+};
+var getOrders = async () => {
+  const response = await apiClient.getClient().get(API_ENDPOINTS.ORDERS);
+  return response.data.output;
+};
+
+// src/utils/errors.ts
+import { AxiosError as AxiosError2 } from "axios";
+var handleAPIError = (error) => {
+  if (error instanceof SDKError) {
+    return error;
+  }
+  if (error instanceof AxiosError2) {
+    const status = error.response?.status;
+    const message = error.response?.data?.message || error.message;
+    const details = error.response?.data;
+    return new APIError(message, status, details);
+  }
+  if (error instanceof Error) {
+    return new SDKError(error.message);
+  }
+  return new SDKError("Unknown error occurred");
+};
+var getErrorMessage = (error) => {
+  const sdkError = handleAPIError(error);
+  if (sdkError instanceof APIError) {
+    switch (sdkError.statusCode) {
+      case 401:
+        return "\uC778\uC99D\uC5D0 \uC2E4\uD328\uD588\uC2B5\uB2C8\uB2E4. API \uD0A4\uB97C \uD655\uC778\uD574\uC8FC\uC138\uC694.";
+      case 403:
+        return "\uC811\uADFC \uAD8C\uD55C\uC774 \uC5C6\uC2B5\uB2C8\uB2E4.";
+      case 404:
+        return "\uC694\uCCAD\uD55C \uB9AC\uC18C\uC2A4\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4.";
+      case 429:
+        return "\uC694\uCCAD \uD55C\uB3C4\uB97C \uCD08\uACFC\uD588\uC2B5\uB2C8\uB2E4. \uC7A0\uC2DC \uD6C4 \uB2E4\uC2DC \uC2DC\uB3C4\uD574\uC8FC\uC138\uC694.";
+      case 500:
+        return "\uC11C\uBC84 \uC624\uB958\uAC00 \uBC1C\uC0DD\uD588\uC2B5\uB2C8\uB2E4. \uC7A0\uC2DC \uD6C4 \uB2E4\uC2DC \uC2DC\uB3C4\uD574\uC8FC\uC138\uC694.";
+      default:
+        return sdkError.message;
+    }
+  }
+  return sdkError.message;
+};
+
+// src/utils/validation.ts
+var validation_exports = {};
+__export(validation_exports, {
+  validateProductId: () => validateProductId,
+  validateWithdrawalAddress: () => validateWithdrawalAddress
+});
+
+// src/utils/address.ts
+function isEvmAddress(address) {
+  return /^0x[a-fA-F0-9]{40}$/.test(address);
+}
+function isTronAddress(address) {
+  return /^T[A-Za-z0-9]{33}$/.test(address);
+}
+function detectChainType(address) {
+  if (isEvmAddress(address)) {
+    return "evm";
+  }
+  if (isTronAddress(address)) {
+    return "tron";
+  }
+  return null;
+}
+function isValidAddress(address) {
+  return isEvmAddress(address) || isTronAddress(address);
+}
+
+// src/utils/validation.ts
+var validateWithdrawalAddress = (fromAddress, toAddress) => {
+  const normalizedFrom = fromAddress.trim();
+  const normalizedTo = toAddress.trim();
+  if (isEvmAddress(normalizedFrom) && isEvmAddress(normalizedTo)) {
+    if (normalizedFrom.toLowerCase() === normalizedTo.toLowerCase()) {
+      return {
+        valid: false,
+        error: "Cannot send to your own wallet address"
+      };
+    }
+  } else if (isTronAddress(normalizedFrom) && isTronAddress(normalizedTo)) {
+    if (normalizedFrom === normalizedTo) {
+      return {
+        valid: false,
+        error: "Cannot send to your own wallet address"
+      };
+    }
+  }
+  if (!isValidAddress(toAddress)) {
+    return {
+      valid: false,
+      error: "Invalid wallet address format"
+    };
+  }
+  return { valid: true };
+};
+var validateProductId = (productId) => {
+  if (!productId || productId.trim().length === 0) {
+    return {
+      valid: false,
+      error: "Product ID is required"
+    };
+  }
+  return { valid: true };
+};
+
+// src/hooks/usePayment.ts
+var usePayment = () => {
+  const context = useContext2(PaymentContext);
+  if (!context) {
+    throw new Error("usePayment must be used within PaymentProvider");
+  }
+  const { config: config2 } = context;
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [order, setOrder] = useState(null);
+  const create = useCallback(
+    async (params) => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        const validation = validateProductId(params.productId);
+        if (!validation.valid) {
+          throw new Error(validation.error);
+        }
+        const orderResponse = await createOrder(
+          params.productId,
+          config2.redirectUrl || "",
+          config2.webhookUrl || ""
+        );
+        setOrder(orderResponse);
+        return orderResponse;
+      } catch (err) {
+        const sdkError = handleAPIError(err);
+        setError(sdkError);
+        throw sdkError;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [config2.redirectUrl, config2.webhookUrl]
+  );
+  return {
+    createOrder: create,
+    isLoading,
+    error,
+    order,
+    errorMessage: error ? getErrorMessage(error) : null
+  };
+};
+
+// src/components/PaymentModal.tsx
+import { useEffect as useEffect8 } from "react";
+
+// src/components/OrderPayment.tsx
+import { useEffect as useEffect7, useState as useState7 } from "react";
+
+// src/hooks/useOrder.ts
+import { useState as useState2, useEffect as useEffect2, useRef } from "react";
+
+// src/utils/orderStatus.ts
+var isOrderSuccess = (status) => {
+  return status === "S" || status === "1";
+};
+var isOrderFailed = (status) => {
+  return status === "F" || status === "4";
+};
+var isOrderRefundInsufficient = (status) => {
+  return status === "R1" || status === "2";
+};
+var isOrderRefundExcess = (status) => {
+  return status === "R2" || status === "3";
+};
+var isOrderFinalState = (status) => {
+  return isOrderSuccess(status) || isOrderFailed(status) || isOrderRefundInsufficient(status) || isOrderRefundExcess(status);
+};
+var getOrderState = (status) => {
+  if (isOrderSuccess(status)) return "success" /* SUCCESS */;
+  if (isOrderFailed(status)) return "failed" /* FAILED */;
+  if (isOrderRefundInsufficient(status)) return "refund_insufficient" /* REFUND_INSUFFICIENT */;
+  if (isOrderRefundExcess(status)) return "refund_excess" /* REFUND_EXCESS */;
+  return "waiting" /* WAITING */;
+};
+var getOrderStatusMessage = (status) => {
+  const state = getOrderState(status);
+  switch (state) {
+    case "success" /* SUCCESS */:
+      return "Payment successful";
+    case "failed" /* FAILED */:
+      return "Payment failed";
+    case "refund_insufficient" /* REFUND_INSUFFICIENT */:
+      return "Payment refunded - Insufficient amount";
+    case "refund_excess" /* REFUND_EXCESS */:
+      return "Payment refunded - Excess amount";
+    case "waiting" /* WAITING */:
+    default:
+      return "Waiting for payment";
+  }
+};
+
+// src/hooks/useOrder.ts
+var useOrder = (publicOrderId, options) => {
+  const [order, setOrder] = useState2(null);
+  const [isLoading, setIsLoading] = useState2(true);
+  const [error, setError] = useState2(null);
+  const pollingInterval = options?.pollingInterval || 5e3;
+  const enablePolling = options?.enablePolling ?? true;
+  const intervalRef = useRef(null);
+  const isInitialFetch = useRef(true);
+  useEffect2(() => {
+    if (!publicOrderId) return;
+    let retryCount = 0;
+    const maxRetries = 5;
+    const fetchOrder = async (isInitial = false) => {
+      if (isInitial) {
+        setIsLoading(true);
+      }
+      setError(null);
+      try {
+        const orderData = await getOrder(publicOrderId);
+        setOrder(orderData);
+        retryCount = 0;
+        if (enablePolling && isOrderFinalState(orderData.orderStat)) {
+          if (intervalRef.current) {
+            clearInterval(intervalRef.current);
+            intervalRef.current = null;
+          }
+        }
+      } catch (err) {
+        const sdkError = handleAPIError(err);
+        if (isInitial && retryCount < maxRetries && (sdkError.message.includes("incomplete") || sdkError.message.includes("null or invalid"))) {
+          retryCount++;
+          console.log(`[useOrder] Retrying order fetch (${retryCount}/${maxRetries})...`);
+          setTimeout(() => fetchOrder(true), 500);
+          return;
+        }
+        setError(sdkError);
+      } finally {
+        if (isInitial && retryCount === 0) {
+          setIsLoading(false);
+        }
+      }
+    };
+    fetchOrder(true);
+    isInitialFetch.current = false;
+    if (enablePolling) {
+      intervalRef.current = setInterval(() => fetchOrder(false), pollingInterval);
+    }
+    return () => {
+      if (intervalRef.current) {
+        clearInterval(intervalRef.current);
+        intervalRef.current = null;
+      }
+    };
+  }, [publicOrderId, pollingInterval, enablePolling]);
+  const refetch = async () => {
+    if (!publicOrderId) return;
+    setIsLoading(true);
+    try {
+      const orderData = await getOrder(publicOrderId);
+      setOrder(orderData);
+    } catch (err) {
+      const sdkError = handleAPIError(err);
+      setError(sdkError);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+  return {
+    order,
+    isLoading,
+    error,
+    refetch
+  };
+};
+
+// src/components/PaymentFlow.tsx
+import { useState as useState6, useEffect as useEffect6 } from "react";
+
+// src/components/PayWithWallet.tsx
+import { useState as useState4, useEffect as useEffect4, useMemo } from "react";
+import { parseUnits } from "viem";
+
+// src/hooks/useWalletAdapter.ts
+import { useState as useState3, useEffect as useEffect3 } from "react";
+import { watchChainId } from "@wagmi/core";
+
+// src/adapters/EvmWalletAdapter.ts
+import {
+  getAccount,
+  getBalance,
+  getChainId,
+  connect,
+  disconnect,
+  switchChain,
+  sendTransaction,
+  writeContract,
+  getConnections,
+  getConnectors
+} from "@wagmi/core";
+var ERC20_ABI = [
+  {
+    name: "transfer",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    outputs: [{ name: "", type: "bool" }]
+  }
+];
+var EvmWalletAdapter = class {
+  constructor(config2) {
+    this.type = "evm";
+    this.chainType = "evm";
+    this.config = config2;
+  }
+  // 연결 상태
+  isConnected() {
+    const account = getAccount(this.config);
+    return account.isConnected;
+  }
+  getAddress() {
+    const account = getAccount(this.config);
+    return account.address || null;
+  }
+  getChainId() {
+    try {
+      return getChainId(this.config);
+    } catch {
+      return null;
+    }
+  }
+  async getBalance() {
+    const account = getAccount(this.config);
+    if (!account.address) return null;
+    try {
+      const balance = await getBalance(this.config, {
+        address: account.address
+      });
+      return {
+        value: balance.value,
+        decimals: balance.decimals,
+        symbol: balance.symbol,
+        formatted: balance.formatted
+      };
+    } catch (error) {
+      console.error("[EvmWalletAdapter] Failed to get balance:", error);
+      return null;
+    }
+  }
+  getConnectionInfo() {
+    const account = getAccount(this.config);
+    if (!account.isConnected || !account.address) {
+      return null;
+    }
+    const currentChainId = this.getChainId();
+    console.log("[EvmWalletAdapter] getConnectionInfo:", {
+      isConnected: account.isConnected,
+      address: account.address,
+      accountChainId: account.chainId,
+      currentChainId,
+      status: account.status
+    });
+    if (!currentChainId) {
+      return null;
+    }
+    return {
+      address: account.address,
+      chainId: currentChainId,
+      // 실제 현재 체인 ID 사용
+      chainType: this.chainType,
+      isConnected: account.isConnected,
+      connector: account.connector ? {
+        id: account.connector.id,
+        name: account.connector.name,
+        icon: account.connector.icon
+      } : void 0
+    };
+  }
+  // 연결 관리
+  async connect(connectorId) {
+    try {
+      const connectors = getConnectors(this.config);
+      const connector = connectorId ? connectors.find((c) => c.id === connectorId) : connectors[0];
+      if (!connector) {
+        throw new Error(
+          connectorId ? `Connector ${connectorId} not found` : "No connectors available"
+        );
+      }
+      await connect(this.config, { connector });
+    } catch (error) {
+      console.error("[EvmWalletAdapter] Connection failed:", error);
+      throw error;
+    }
+  }
+  async disconnect() {
+    try {
+      const connections = getConnections(this.config);
+      if (connections.length > 0) {
+        await disconnect(this.config, {
+          connector: connections[0].connector
+        });
+      }
+    } catch (error) {
+      console.error("[EvmWalletAdapter] Disconnect failed:", error);
+      throw error;
+    }
+  }
+  async switchChain(chainId) {
+    if (typeof chainId === "string") {
+      throw new Error("EVM adapter expects numeric chainId");
+    }
+    const currentChainId = getAccount(this.config).chainId;
+    console.log(`[EvmWalletAdapter] Switching chain from ${currentChainId} to ${chainId}`);
+    try {
+      await switchChain(this.config, { chainId });
+      console.log(`[EvmWalletAdapter] Switch chain completed for chainId: ${chainId}`);
+    } catch (error) {
+      console.error("[EvmWalletAdapter] Switch chain failed:", error);
+      console.error("[EvmWalletAdapter] Error details:", {
+        message: error.message,
+        code: error.code,
+        name: error.name
+      });
+      throw error;
+    }
+  }
+  // 트랜잭션
+  async sendPayment(tx) {
+    try {
+      const account = getAccount(this.config);
+      if (!account.isConnected || !account.address) {
+        throw new Error("Wallet not connected");
+      }
+      if (typeof tx.chainId === "string") {
+        throw new Error("EVM adapter expects numeric chainId");
+      }
+      const currentChainId = getChainId(this.config);
+      console.log("[EvmWalletAdapter] sendPayment - Current chain check:", {
+        currentChainId,
+        accountChainId: account.chainId,
+        requestedChainId: tx.chainId
+      });
+      if (currentChainId !== tx.chainId) {
+        console.log(`[EvmWalletAdapter] Chain mismatch! Switching from ${currentChainId} to ${tx.chainId}`);
+        await this.switchChain(tx.chainId);
+        const chainIdAfterSwitch = getChainId(this.config);
+        console.log("[EvmWalletAdapter] After switch:", {
+          chainId: chainIdAfterSwitch,
+          expected: tx.chainId
+        });
+        if (chainIdAfterSwitch !== tx.chainId) {
+          throw new Error(`Failed to switch to chain ${tx.chainId}. Current chain: ${chainIdAfterSwitch}`);
+        }
+      }
+      let hash;
+      const chain = this.config.chains.find((c) => c.id === tx.chainId);
+      if (!chain) {
+        throw new Error(`Chain ${tx.chainId} not found in wagmi config`);
+      }
+      if (tx.tokenAddress && tx.decimals !== void 0) {
+        console.log("[EvmWalletAdapter] ERC20 Transfer:", {
+          token: tx.tokenAddress,
+          to: tx.to,
+          value: tx.value.toString(),
+          decimals: tx.decimals,
+          chainId: tx.chainId,
+          chainName: chain.name
+        });
+        hash = await writeContract(this.config, {
+          address: tx.tokenAddress,
+          abi: ERC20_ABI,
+          functionName: "transfer",
+          args: [tx.to, tx.value],
+          chain
+        });
+        console.log("[EvmWalletAdapter] ERC20 Transfer hash:", hash);
+      } else {
+        console.log("[EvmWalletAdapter] Native Transfer:", {
+          to: tx.to,
+          value: tx.value.toString(),
+          chainId: tx.chainId,
+          chainName: chain.name
+        });
+        hash = await sendTransaction(this.config, {
+          to: tx.to,
+          value: tx.value,
+          chainId: tx.chainId
+        });
+        console.log("[EvmWalletAdapter] Native Transfer hash:", hash);
+      }
+      return { success: true, hash };
+    } catch (error) {
+      console.error("[EvmWalletAdapter] Payment failed:", error);
+      return {
+        success: false,
+        hash: "0x",
+        error: error?.message ?? "Transaction failed"
+      };
+    }
+  }
+  // 지원 여부 확인
+  isChainSupported(chainId) {
+    if (typeof chainId === "string") return false;
+    return this.config.chains.some((chain) => chain.id === chainId);
+  }
+  getChainType(_chainId) {
+    return this.chainType;
+  }
+  // 커넥터 정보
+  getConnectors() {
+    const connectors = getConnectors(this.config);
+    return connectors.map((c) => ({
+      id: c.id,
+      name: c.name,
+      icon: c.icon
+    }));
+  }
+  checkWalletInstalled(connectorId) {
+    const connectors = getConnectors(this.config);
+    return connectors.some((c) => c.id === connectorId);
+  }
+};
+
+// src/hooks/useWalletAdapter.ts
+var useWalletAdapter = (options) => {
+  const { factory } = useWalletContext();
+  const { chainId, depositAddress } = typeof options === "object" && options !== null ? options : { chainId: options, depositAddress: void 0 };
+  const [activeAdapter, setActiveAdapter] = useState3(
+    null
+  );
+  const [connectionInfo, setConnectionInfo] = useState3(null);
+  const [balance, setBalance] = useState3(null);
+  const [isSending, setIsSending] = useState3(false);
+  const [txHash, setTxHash] = useState3(null);
+  useEffect3(() => {
+    if (depositAddress) {
+      const adapter = factory.getAdapterByAddress(depositAddress);
+      setActiveAdapter(adapter);
+      return;
+    }
+    if (chainId) {
+      const adapter = factory.getAdapterForChain(chainId);
+      setActiveAdapter(adapter);
+      return;
+    }
+    const connected = factory.getConnectedAdapter();
+    setActiveAdapter(connected);
+  }, [chainId, depositAddress, factory]);
+  useEffect3(() => {
+    if (!activeAdapter) return;
+    const updateConnectionInfo = () => {
+      const info = activeAdapter.getConnectionInfo();
+      setConnectionInfo(info);
+      if (info?.isConnected) {
+        activeAdapter.getBalance().then(setBalance);
+      }
+    };
+    updateConnectionInfo();
+    if (activeAdapter.type === "evm" && activeAdapter instanceof EvmWalletAdapter) {
+      const unwatch = watchChainId(activeAdapter.config, {
+        onChange: (chainId2) => {
+          console.log("[useWalletAdapter] Chain changed to:", chainId2);
+          updateConnectionInfo();
+        }
+      });
+      return unwatch;
+    }
+  }, [activeAdapter]);
+  const connect2 = async (walletType, connectorId) => {
+    try {
+      const adapter = factory.getAdapter(walletType);
+      if (!adapter) {
+        throw new Error(`Adapter for ${walletType} not found`);
+      }
+      await adapter.connect(connectorId);
+      setActiveAdapter(adapter);
+      const info = adapter.getConnectionInfo();
+      setConnectionInfo(info);
+      if (info?.isConnected) {
+        const bal = await adapter.getBalance();
+        setBalance(bal);
+      }
+    } catch (error) {
+      console.error("[useWalletAdapter] Connection failed:", error);
+      throw error;
+    }
+  };
+  const disconnect2 = async () => {
+    if (!activeAdapter) return;
+    try {
+      await activeAdapter.disconnect();
+      setConnectionInfo(null);
+      setBalance(null);
+      if (!depositAddress && !chainId) {
+        setActiveAdapter(null);
+      }
+    } catch (error) {
+      console.error("[useWalletAdapter] Disconnect failed:", error);
+      throw error;
+    }
+  };
+  const switchChain2 = async (targetChainId) => {
+    if (!activeAdapter) {
+      throw new Error("No active adapter");
+    }
+    try {
+      await activeAdapter.switchChain(targetChainId);
+      const info = activeAdapter.getConnectionInfo();
+      setConnectionInfo(info);
+    } catch (error) {
+      console.error("[useWalletAdapter] Switch chain failed:", error);
+      throw error;
+    }
+  };
+  const sendPayment = async (tx) => {
+    if (!activeAdapter) {
+      throw new Error("No active adapter");
+    }
+    setIsSending(true);
+    setTxHash(null);
+    try {
+      const result = await activeAdapter.sendPayment(tx);
+      if (result.success) {
+        setTxHash(result.hash);
+      }
+      return result;
+    } catch (error) {
+      console.error("[useWalletAdapter] Payment failed:", error);
+      return {
+        success: false,
+        hash: "",
+        error: error?.message || "Payment failed"
+      };
+    } finally {
+      setIsSending(false);
+    }
+  };
+  const getAllConnectors = () => {
+    const adapters = factory.getAllAdapters();
+    const connectors = [];
+    adapters.forEach((adapter) => {
+      const adapterConnectors = adapter.getConnectors();
+      adapterConnectors.forEach((conn) => {
+        connectors.push({
+          ...conn,
+          walletType: adapter.type
+        });
+      });
+    });
+    return connectors;
+  };
+  const getConnectors2 = (walletType) => {
+    if (walletType) {
+      const adapter = factory.getAdapter(walletType);
+      return adapter?.getConnectors() || [];
+    }
+    if (activeAdapter) {
+      return activeAdapter.getConnectors();
+    }
+    return [];
+  };
+  const checkWalletInstalled = (walletType, connectorId) => {
+    const adapter = factory.getAdapter(walletType);
+    return adapter?.checkWalletInstalled(connectorId) || false;
+  };
+  const getChainType = (chainId2) => {
+    try {
+      return factory.getChainType(chainId2);
+    } catch {
+      return null;
+    }
+  };
+  const getWallet = () => {
+    if (!activeAdapter) return null;
+    return activeAdapter.getConnectionInfo();
+  };
+  return {
+    // 연결 정보
+    wallet: connectionInfo,
+    address: connectionInfo?.address || null,
+    chainId: connectionInfo?.chainId || null,
+    chainType: connectionInfo?.chainType || null,
+    isConnected: connectionInfo?.isConnected || false,
+    balance,
+    // 어댑터 정보
+    activeAdapter,
+    adapterType: activeAdapter?.type || null,
+    // 연결 관리
+    connect: connect2,
+    disconnect: disconnect2,
+    switchChain: switchChain2,
+    // 커넥터
+    connectors: getConnectors2(),
+    allConnectors: getAllConnectors(),
+    checkWalletInstalled,
+    // 트랜잭션
+    sendPayment,
+    isSending,
+    txHash,
+    // 유틸리티
+    getChainType,
+    getWallet,
+    factory
+  };
+};
+
+// src/utils/format.ts
+var truncateAddress = (address, startChars = 6, endChars = 6) => {
+  if (!address) return "";
+  if (address.length <= startChars + endChars) return address;
+  return `${address.slice(0, startChars)}...${address.slice(-endChars)}`;
+};
+var truncateHash = (hash) => {
+  return truncateAddress(hash, 10, 8);
+};
+var truncateOrderId = (orderId) => {
+  return truncateAddress(orderId, 6, 6);
+};
+var shortenErrorMessage = (error) => {
+  const message = typeof error === "string" ? error : error.message;
+  const patterns = [
+    {
+      pattern: /User rejected the request|User denied transaction signature/i,
+      replacement: "Transaction cancelled"
+    },
+    {
+      pattern: /insufficient funds|Insufficient balance/i,
+      replacement: "Insufficient balance"
+    },
+    {
+      pattern: /Failed to fetch|Network request failed/i,
+      replacement: "Network error"
+    },
+    {
+      pattern: /Cannot read properties of null/i,
+      replacement: "Data not ready"
+    },
+    {
+      pattern: /Order data is incomplete - missing required fields/i,
+      replacement: "Payment details loading..."
+    }
+  ];
+  for (const { pattern, replacement } of patterns) {
+    if (pattern.test(message)) {
+      return replacement;
+    }
+  }
+  if (message.length > 100) {
+    return message.slice(0, 97) + "...";
+  }
+  return message;
+};
+
+// src/components/PayWithWallet.tsx
+import { Fragment, jsx as jsx3, jsxs } from "react/jsx-runtime";
+var PayWithWallet = ({
+  toAddress,
+  amount,
+  coinId,
+  chainId,
+  chainInfo,
+  tokenAddress,
+  decimals,
+  publicOrderId,
+  onSuccess,
+  onError,
+  className = "",
+  children
+}) => {
+  const adapter = useWalletAdapter({ depositAddress: toAddress });
+  const {
+    wallet,
+    connect: connect2,
+    disconnect: disconnect2,
+    connectors,
+    sendPayment,
+    txHash,
+    checkWalletInstalled,
+    switchChain: switchChain2,
+    adapterType,
+    getWallet
+  } = adapter;
+  const [showWalletSelector, setShowWalletSelector] = useState4(false);
+  const [error, setError] = useState4(null);
+  const [hasNotified] = useState4(false);
+  const [isProcessing, setIsProcessing] = useState4(false);
+  const [isConnecting, setIsConnecting] = useState4(false);
+  const installedWallets = useMemo(() => {
+    if (!adapterType) return [];
+    console.log("[PayWithWallet] Checking installed wallets...", {
+      adapterType,
+      connectors: connectors.map((c) => c.id)
+    });
+    const installed = connectors.filter((c) => {
+      const isInstalled = checkWalletInstalled(adapterType, c.id);
+      console.log(
+        `[PayWithWallet] Connector ${c.id}: ${isInstalled ? "INSTALLED" : "NOT INSTALLED"}`
+      );
+      return isInstalled;
+    });
+    console.log(
+      "[PayWithWallet] Installed wallets:",
+      installed.map((w) => w.id)
+    );
+    return installed;
+  }, [adapterType, connectors, checkWalletInstalled]);
+  console.log("[PayWithWallet] Render state:", {
+    depositAddress: toAddress,
+    adapterType,
+    connectors: connectors.map((c) => c.id),
+    installedWallets: installedWallets.map((w) => w.id),
+    hasInstalledWallets: installedWallets.length > 0
+  });
+  useEffect4(() => {
+    if (txHash) {
+      setIsProcessing(false);
+    }
+  }, [txHash]);
+  useEffect4(() => {
+  }, [txHash, publicOrderId, hasNotified, onSuccess]);
+  const handleConnect = async (connectorId) => {
+    if (!adapterType) {
+      setError("Wallet adapter not initialized");
+      return;
+    }
+    try {
+      setError(null);
+      setIsConnecting(true);
+      await connect2(adapterType, connectorId);
+      setShowWalletSelector(false);
+    } catch (err) {
+      const errorMsg = shortenErrorMessage(
+        err instanceof Error ? err : "Failed to connect wallet"
+      );
+      setError(errorMsg);
+    } finally {
+      setIsConnecting(false);
+    }
+  };
+  const handlePay = async () => {
+    if (!wallet) {
+      setError("Please connect your wallet first");
+      return;
+    }
+    try {
+      setError(null);
+      setIsProcessing(true);
+      const validation = validateWithdrawalAddress(wallet.address, toAddress);
+      if (!validation.valid) {
+        setError("Invalid wallet address");
+        setIsProcessing(false);
+        return;
+      }
+      if (wallet.chainId !== chainId) {
+        if (adapterType === "tron") {
+          const networkNames = {
+            728126428: "Mainnet",
+            2494104990: "Shasta",
+            3448148188: "Nile"
+          };
+          const requiredNetwork = networkNames[chainId] || chainId;
+          setError(`Switch to ${requiredNetwork} network`);
+          setIsProcessing(false);
+          return;
+        }
+        console.log(`[PayWithWallet] Switching chain from ${wallet.chainId} to ${chainId}`);
+        await switchChain2(chainId);
+        let attempts = 0;
+        let switched = false;
+        while (attempts < 30) {
+          await new Promise((resolve) => setTimeout(resolve, 100));
+          const currentWallet = getWallet();
+          console.log(`[PayWithWallet] Attempt ${attempts}: current chainId = ${currentWallet?.chainId}, target = ${chainId}`);
+          if (currentWallet && currentWallet.chainId === chainId) {
+            console.log(`[PayWithWallet] Chain switched successfully to ${chainId}`);
+            switched = true;
+            break;
+          }
+          attempts++;
+        }
+        if (!switched) {
+          setError(`Please switch to ${chainInfo.name} network in your wallet`);
+          setIsProcessing(false);
+          return;
+        }
+      }
+      const finalCheck = getWallet();
+      if (!finalCheck || finalCheck.chainId !== chainId) {
+        console.error(`[PayWithWallet] Chain mismatch before sending! Current: ${finalCheck?.chainId}, Required: ${chainId}`);
+        setError(`Wrong network. Please switch to ${chainInfo.name} in MetaMask`);
+        setIsProcessing(false);
+        return;
+      }
+      console.log(`[PayWithWallet] Chain verified: ${chainId}, proceeding with payment`);
+      let value;
+      if (tokenAddress && decimals !== void 0) {
+        value = parseUnits(amount, decimals);
+      } else {
+        value = parseUnits(amount, chainInfo.coinDigit);
+      }
+      const result = await sendPayment({
+        to: toAddress,
+        value,
+        chainId,
+        coinId,
+        tokenAddress,
+        decimals
+      });
+      if (!result.success) {
+        const errorMsg = shortenErrorMessage(
+          result.error || "Transaction failed"
+        );
+        setError(errorMsg);
+        onError?.(errorMsg);
+        setIsProcessing(false);
+      }
+    } catch (err) {
+      const errorMsg = shortenErrorMessage(
+        err instanceof Error ? err : "Payment failed"
+      );
+      setError(errorMsg);
+      onError?.(errorMsg);
+      setIsProcessing(false);
+    }
+  };
+  return /* @__PURE__ */ jsxs("div", { className: `payment-with-wallet ${className}`, children: [
+    children ? children : /* @__PURE__ */ jsxs("div", { className: "payment-container", children: [
+      /* @__PURE__ */ jsx3("h3", { children: "Payment Details" }),
+      /* @__PURE__ */ jsxs("div", { className: "payment-info", children: [
+        /* @__PURE__ */ jsxs("div", { className: "info-row", children: [
+          /* @__PURE__ */ jsx3("span", { className: "label", children: "Amount" }),
+          /* @__PURE__ */ jsxs("span", { className: "value amount-value", children: [
+            amount,
+            " ",
+            coinId
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "info-row", children: [
+          /* @__PURE__ */ jsx3("span", { className: "label", children: "Network" }),
+          /* @__PURE__ */ jsx3("span", { className: "value", children: chainInfo.name })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "info-row", children: [
+          /* @__PURE__ */ jsx3("span", { className: "label", children: "To" }),
+          /* @__PURE__ */ jsx3("span", { className: "value address", children: truncateAddress(toAddress) })
+        ] })
+      ] }),
+      isProcessing && !txHash ? /* @__PURE__ */ jsxs("div", { className: "waiting-verification", children: [
+        /* @__PURE__ */ jsx3("div", { className: "waiting-icon", children: /* @__PURE__ */ jsx3("div", { className: "waiting-spinner-large" }) }),
+        /* @__PURE__ */ jsx3("h3", { children: "Waiting for Approval" }),
+        /* @__PURE__ */ jsxs("p", { className: "waiting-message", children: [
+          "Please approve the transaction in your wallet",
+          /* @__PURE__ */ jsx3("br", {}),
+          "Check your wallet extension to continue"
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "verification-notice", children: [
+          /* @__PURE__ */ jsx3(
+            "svg",
+            {
+              width: "16",
+              height: "16",
+              viewBox: "0 0 16 16",
+              fill: "currentColor",
+              children: /* @__PURE__ */ jsx3("path", { d: "M8 1a7 7 0 100 14A7 7 0 008 1zm0 12.5a.75.75 0 110-1.5.75.75 0 010 1.5zM8 11a.75.75 0 01-.75-.75v-4.5a.75.75 0 011.5 0v4.5A.75.75 0 018 11z" })
+            }
+          ),
+          /* @__PURE__ */ jsx3("span", { children: "Do not close this window" })
+        ] })
+      ] }) : txHash ? /* @__PURE__ */ jsxs("div", { className: "waiting-verification", children: [
+        /* @__PURE__ */ jsx3("div", { className: "waiting-icon", children: /* @__PURE__ */ jsx3("div", { className: "waiting-spinner-large" }) }),
+        /* @__PURE__ */ jsx3("h3", { children: "Processing Payment" }),
+        /* @__PURE__ */ jsxs("p", { className: "waiting-message", children: [
+          "Your transaction is being processed",
+          /* @__PURE__ */ jsx3("br", {}),
+          "Please wait for confirmation"
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "tx-info", children: [
+          /* @__PURE__ */ jsx3("span", { className: "tx-label", children: "Transaction Hash" }),
+          /* @__PURE__ */ jsx3("code", { className: "tx-hash-code", children: truncateHash(txHash) })
+        ] }),
+        /* @__PURE__ */ jsxs("div", { className: "verification-notice", children: [
+          /* @__PURE__ */ jsx3(
+            "svg",
+            {
+              width: "16",
+              height: "16",
+              viewBox: "0 0 16 16",
+              fill: "currentColor",
+              children: /* @__PURE__ */ jsx3("path", { d: "M8 1a7 7 0 100 14A7 7 0 008 1zm0 12.5a.75.75 0 110-1.5.75.75 0 010 1.5zM8 11a.75.75 0 01-.75-.75v-4.5a.75.75 0 011.5 0v4.5A.75.75 0 018 11z" })
+            }
+          ),
+          /* @__PURE__ */ jsx3("span", { children: "This may take a few moments" })
+        ] })
+      ] }) : !wallet?.isConnected ? /* @__PURE__ */ jsxs("div", { className: "wallet-connection", children: [
+        /* @__PURE__ */ jsx3("p", { children: "Connect your wallet to continue" }),
+        installedWallets.length > 0 ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          /* @__PURE__ */ jsx3(
+            "button",
+            {
+              onClick: () => setShowWalletSelector(!showWalletSelector),
+              className: "btn-primary",
+              disabled: isConnecting,
+              children: isConnecting ? "Connecting..." : "Select Wallet"
+            }
+          ),
+          showWalletSelector && /* @__PURE__ */ jsx3("div", { className: "wallet-selector", children: installedWallets.map((connector) => /* @__PURE__ */ jsxs(
+            "button",
+            {
+              onClick: () => handleConnect(connector.id),
+              className: "wallet-option",
+              children: [
+                connector.icon && /* @__PURE__ */ jsx3("img", { src: connector.icon, alt: connector.name }),
+                /* @__PURE__ */ jsx3("span", { children: connector.name })
+              ]
+            },
+            connector.id
+          )) })
+        ] }) : /* @__PURE__ */ jsxs("div", { className: "no-wallets", children: [
+          /* @__PURE__ */ jsx3("p", { children: "No compatible wallet detected" }),
+          /* @__PURE__ */ jsx3("p", { className: "wallet-hint", children: adapterType === "tron" ? "Please install TronLink extension to continue" : "Please install MetaMask, Trust Wallet, or WalletConnect to continue" })
+        ] })
+      ] }) : /* @__PURE__ */ jsxs("div", { className: "wallet-connected", children: [
+        /* @__PURE__ */ jsxs("div", { className: "connected-info", children: [
+          /* @__PURE__ */ jsx3("p", { className: "connected-address", children: truncateAddress(wallet.address, 6, 4) }),
+          /* @__PURE__ */ jsx3("button", { onClick: () => disconnect2(), className: "btn-disconnect", children: "Disconnect" })
+        ] }),
+        /* @__PURE__ */ jsx3(
+          "button",
+          {
+            onClick: handlePay,
+            className: "btn-primary",
+            disabled: isProcessing,
+            children: isProcessing ? "Sending..." : `Pay ${amount} ${coinId}`
+          }
+        )
+      ] }),
+      error && /* @__PURE__ */ jsx3("div", { className: "error-message", children: error })
+    ] }),
+    /* @__PURE__ */ jsx3("style", { children: `
+        .payment-with-wallet {
+          padding: 1.5rem;
+        }
+
+        .payment-container {
+          max-width: 500px;
+          margin: 0 auto;
+        }
+
+        h3 {
+          font-size: 1.25rem;
+          font-weight: 600;
+          margin-bottom: 1.5rem;
+          color: hsl(222.2 47.4% 11.2%);
+        }
+
+        .payment-info {
+          background: hsl(0 0% 100%);
+          border: 1px solid hsl(214.3 31.8% 91.4%);
+          padding: 1.25rem;
+          border-radius: 0.75rem;
+          margin-bottom: 1.5rem;
+        }
+
+        .info-row {
+          display: flex;
+          justify-content: space-between;
+          align-items: center;
+          padding: 0.625rem 0;
+          border-bottom: 1px solid hsl(214.3 31.8% 91.4%);
+        }
+
+        .info-row:last-child {
+          border-bottom: none;
+          padding-bottom: 0;
+        }
+
+        .info-row:first-child {
+          padding-top: 0;
+        }
+
+        .label {
+          font-size: 0.875rem;
+          color: hsl(215.4 16.3% 46.9%);
+          font-weight: 500;
+        }
+
+        .value {
+          font-size: 0.875rem;
+          color: hsl(222.2 47.4% 11.2%);
+          font-weight: 500;
+        }
+
+        .amount-value {
+          font-size: 1.125rem;
+          font-weight: 600;
+          color: hsl(222.2 47.4% 11.2%);
+        }
+
+        .address {
+          font-family: 'SF Mono', 'Monaco', 'Inconsolata', 'Roboto Mono', monospace;
+          font-size: 0.8125rem;
+          color: hsl(215.4 16.3% 46.9%);
+        }
+
+        .waiting-verification {
+          text-align: center;
+          padding: 2.5rem 1.5rem;
+          background: hsl(0 0% 100%);
+          border: 1px solid hsl(214.3 31.8% 91.4%);
+          border-radius: 0.75rem;
+        }
+
+        .waiting-icon {
+          margin: 0 auto 1.5rem;
+          display: flex;
+          justify-content: center;
+        }
+
+        .waiting-spinner-large {
+          width: 48px;
+          height: 48px;
+          border: 3px solid hsl(214.3 31.8% 91.4%);
+          border-top-color: hsl(222.2 47.4% 11.2%);
+          border-radius: 50%;
+          animation: spin 0.8s linear infinite;
+        }
+
+        .waiting-verification h3 {
+          font-size: 1.125rem;
+          font-weight: 600;
+          color: hsl(222.2 47.4% 11.2%);
+          margin-bottom: 0.75rem;
+        }
+
+        .waiting-message {
+          color: hsl(215.4 16.3% 46.9%);
+          line-height: 1.6;
+          margin-bottom: 1.5rem;
+          font-size: 0.875rem;
+        }
+
+        .tx-info {
+          background: hsl(210 40% 98%);
+          border: 1px solid hsl(214.3 31.8% 91.4%);
+          padding: 1rem;
+          border-radius: 0.5rem;
+          margin-bottom: 1.5rem;
+        }
+
+        .tx-label {
+          display: block;
+          font-size: 0.8125rem;
+          color: hsl(215.4 16.3% 46.9%);
+          margin-bottom: 0.5rem;
+          font-weight: 500;
+        }
+
+        .tx-hash-code {
+          display: block;
+          font-family: 'SF Mono', 'Monaco', 'Inconsolata', 'Roboto Mono', monospace;
+          font-size: 0.8125rem;
+          color: hsl(222.2 47.4% 11.2%);
+          word-break: break-all;
+        }
+
+        .verification-notice {
+          display: flex;
+          align-items: flex-start;
+          gap: 0.75rem;
+          padding: 0.875rem 1rem;
+          background: hsl(210 40% 98%);
+          border: 1px solid hsl(214.3 31.8% 91.4%);
+          border-radius: 0.5rem;
+          text-align: left;
+        }
+
+        .verification-notice svg {
+          flex-shrink: 0;
+          color: hsl(215.4 16.3% 46.9%);
+          margin-top: 1px;
+        }
+
+        .verification-notice span {
+          font-size: 0.8125rem;
+          color: hsl(215.4 16.3% 46.9%);
+          line-height: 1.5;
+        }
+
+        .wallet-connection,
+        .wallet-connected {
+          margin-top: 1.5rem;
+        }
+
+        .wallet-selector {
+          margin-top: 1rem;
+          display: flex;
+          flex-direction: column;
+          gap: 0.625rem;
+        }
+
+        .wallet-option {
+          display: flex;
+          align-items: center;
+          gap: 0.75rem;
+          padding: 0.875rem 1rem;
+          border: 1px solid hsl(214.3 31.8% 91.4%);
+          border-radius: 0.5rem;
+          background: hsl(0 0% 100%);
+          cursor: pointer;
+          transition: all 0.15s;
+          font-weight: 500;
+          font-size: 0.875rem;
+        }
+
+        .wallet-option:hover {
+          background: hsl(210 40% 98%);
+          border-color: hsl(217.2 32.6% 17.5%);
+        }
+
+        .wallet-option img {
+          width: 20px;
+          height: 20px;
+        }
+
+        .connected-info {
+          display: flex;
+          justify-content: space-between;
+          align-items: center;
+          margin-bottom: 1rem;
+          padding: 0.875rem 1rem;
+          background: hsl(142.1 76.2% 97.3%);
+          border: 1px solid hsl(142.1 76.2% 90%);
+          border-radius: 0.5rem;
+        }
+
+        .connected-address {
+          font-family: 'SF Mono', 'Monaco', 'Inconsolata', 'Roboto Mono', monospace;
+          font-size: 0.8125rem;
+          color: hsl(142.1 70.6% 45.3%);
+          font-weight: 500;
+          margin: 0;
+        }
+
+        .btn-primary,
+        .btn-disconnect {
+          border: none;
+          border-radius: 0.5rem;
+          font-weight: 600;
+          cursor: pointer;
+          transition: all 0.15s;
+          font-size: 0.875rem;
+          display: inline-flex;
+          align-items: center;
+          justify-content: center;
+        }
+
+        .btn-primary {
+          padding: 0.625rem 1.25rem;
+          background: hsl(222.2 47.4% 11.2%);
+          color: hsl(210 40% 98%);
+          width: 100%;
+          height: 2.5rem;
+        }
+
+        .btn-primary:hover:not(:disabled) {
+          background: hsl(222.2 47.4% 8%);
+        }
+
+        .btn-primary:disabled {
+          background: hsl(215.4 16.3% 46.9%);
+          cursor: not-allowed;
+          opacity: 0.5;
+        }
+
+        .btn-disconnect {
+          background: transparent;
+          color: hsl(215.4 16.3% 46.9%);
+          width: auto;
+          padding: 0.375rem 0.875rem;
+          font-size: 0.8125rem;
+          font-weight: 500;
+        }
+
+        .btn-disconnect:hover {
+          background: hsl(210 40% 96.1%);
+          color: hsl(222.2 47.4% 11.2%);
+        }
+
+        .no-wallets {
+          padding: 1.25rem;
+          background: hsl(47.9 95.8% 96.1%);
+          border: 1px solid hsl(47.9 95.8% 82%);
+          border-radius: 0.5rem;
+          text-align: center;
+        }
+
+        .no-wallets p {
+          color: hsl(25 95.8% 25%);
+          font-size: 0.875rem;
+          margin: 0;
+          font-weight: 600;
+        }
+
+        .wallet-hint {
+          margin-top: 0.5rem !important;
+          font-weight: 400 !important;
+          color: hsl(25 95.8% 35%) !important;
+        }
+
+        @keyframes spin {
+          to { transform: rotate(360deg); }
+        }
+
+        .error-message {
+          margin-top: 1rem;
+          padding: 0.875rem 1rem;
+          background: hsl(0 84.2% 97.3%);
+          border: 1px solid hsl(0 84.2% 92%);
+          border-radius: 0.5rem;
+          color: hsl(0 74.3% 42%);
+          font-size: 0.875rem;
+          line-height: 1.5;
+        }
+      ` })
+  ] });
+};
+
+// src/components/PayWithAddress.tsx
+import { useState as useState5, useEffect as useEffect5 } from "react";
+import { QRCodeSVG } from "qrcode.react";
+import { jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+var PayWithAddress = ({
+  walletAddress,
+  amount,
+  coinId,
+  chainId: _chainId,
+  chainInfo,
+  publicOrderId,
+  expiresAt,
+  onCopy,
+  className = "",
+  children
+}) => {
+  const [copied, setCopied] = useState5(false);
+  const [showQR, setShowQR] = useState5(true);
+  const [currentTime, setCurrentTime] = useState5(Date.now());
+  useEffect5(() => {
+    if (!expiresAt) return;
+    const interval = setInterval(() => {
+      setCurrentTime(Date.now());
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, [expiresAt]);
+  const handleCopy = async () => {
+    try {
+      await navigator.clipboard.writeText(walletAddress);
+      setCopied(true);
+      onCopy?.();
+      setTimeout(() => setCopied(false), 2e3);
+    } catch (err) {
+      console.error("Failed to copy:", err);
+    }
+  };
+  const formatExpiryTime = (expiryString) => {
+    if (!expiryString) return null;
+    const expiry = new Date(expiryString);
+    const diff = expiry.getTime() - currentTime;
+    if (diff <= 0) return "Expired";
+    const minutes = Math.floor(diff / 1e3 / 60);
+    const seconds = Math.floor(diff / 1e3 % 60);
+    return `${minutes}:${seconds.toString().padStart(2, "0")}`;
+  };
+  return /* @__PURE__ */ jsxs2("div", { className: `payment-with-address ${className}`, children: [
+    children ? children : /* @__PURE__ */ jsxs2("div", { className: "payment-container", children: [
+      /* @__PURE__ */ jsx4("h3", { children: "Payment Address" }),
+      /* @__PURE__ */ jsxs2("div", { className: "payment-info", children: [
+        /* @__PURE__ */ jsxs2("div", { className: "info-row", children: [
+          /* @__PURE__ */ jsx4("span", { className: "label", children: "Amount" }),
+          /* @__PURE__ */ jsxs2("span", { className: "value amount-value", children: [
+            amount,
+            " ",
+            coinId
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs2("div", { className: "info-row", children: [
+          /* @__PURE__ */ jsx4("span", { className: "label", children: "Network" }),
+          /* @__PURE__ */ jsx4("span", { className: "value", children: chainInfo.name })
+        ] }),
+        publicOrderId && /* @__PURE__ */ jsxs2("div", { className: "info-row", children: [
+          /* @__PURE__ */ jsx4("span", { className: "label", children: "Order ID" }),
+          /* @__PURE__ */ jsx4("span", { className: "value order-id", children: truncateOrderId(publicOrderId) })
+        ] }),
+        expiresAt && /* @__PURE__ */ jsxs2("div", { className: "info-row expiry", children: [
+          /* @__PURE__ */ jsx4("span", { className: "label", children: "Time Remaining" }),
+          /* @__PURE__ */ jsx4("span", { className: "value time", children: formatExpiryTime(expiresAt) })
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs2("div", { className: "payment-methods", children: [
+        /* @__PURE__ */ jsxs2("div", { className: "method-toggle", children: [
+          /* @__PURE__ */ jsx4(
+            "button",
+            {
+              onClick: () => setShowQR(true),
+              className: showQR ? "active" : "",
+              children: "QR Code"
+            }
+          ),
+          /* @__PURE__ */ jsx4(
+            "button",
+            {
+              onClick: () => setShowQR(false),
+              className: !showQR ? "active" : "",
+              children: "Address"
+            }
+          )
+        ] }),
+        showQR ? /* @__PURE__ */ jsxs2("div", { className: "qr-section", children: [
+          /* @__PURE__ */ jsx4("div", { className: "qr-code", children: /* @__PURE__ */ jsx4(
+            QRCodeSVG,
+            {
+              value: walletAddress,
+              size: 200,
+              level: "H",
+              includeMargin: true
+            }
+          ) }),
+          /* @__PURE__ */ jsx4("p", { className: "qr-instruction", children: "Scan QR code with your wallet app" })
+        ] }) : /* @__PURE__ */ jsxs2("div", { className: "address-section", children: [
+          /* @__PURE__ */ jsx4("div", { className: "address-display", children: /* @__PURE__ */ jsx4("code", { children: walletAddress }) }),
+          /* @__PURE__ */ jsx4(
+            "button",
+            {
+              onClick: handleCopy,
+              className: "copy-button",
+              children: copied ? "Copied!" : "Copy Address"
+            }
+          )
+        ] })
+      ] }),
+      /* @__PURE__ */ jsxs2("div", { className: "payment-status", children: [
+        /* @__PURE__ */ jsxs2("div", { className: "status-badge waiting", children: [
+          /* @__PURE__ */ jsx4("div", { className: "status-spinner" }),
+          /* @__PURE__ */ jsx4("span", { children: "Waiting for Payment" })
+        ] }),
+        /* @__PURE__ */ jsx4("p", { className: "status-text", children: "We're checking for your payment on the blockchain" })
+      ] }),
+      /* @__PURE__ */ jsxs2("div", { className: "warning", children: [
+        /* @__PURE__ */ jsx4("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "currentColor", children: /* @__PURE__ */ jsx4("path", { d: "M8 1a7 7 0 100 14A7 7 0 008 1zm0 12.5a.75.75 0 110-1.5.75.75 0 010 1.5zM8 11a.75.75 0 01-.75-.75v-4.5a.75.75 0 011.5 0v4.5A.75.75 0 018 11z" }) }),
+        /* @__PURE__ */ jsx4("span", { children: "Send only to this address. Sending to wrong address may result in loss of funds." })
+      ] })
+    ] }),
+    /* @__PURE__ */ jsx4("style", { children: `
+        .payment-with-address {
+          padding: 1.5rem;
+        }
+
+        .payment-container {
+          max-width: 500px;
+          margin: 0 auto;
+        }
+
+        h3 {
+          font-size: 1.25rem;
+          font-weight: 600;
+          margin-bottom: 1.5rem;
+          color: hsl(222.2 47.4% 11.2%);
+        }
+
+        .payment-info {
+          background: hsl(0 0% 100%);
+          border: 1px solid hsl(214.3 31.8% 91.4%);
+          padding: 1.25rem;
+          border-radius: 0.75rem;
+          margin-bottom: 1.5rem;
+        }
+
+        .info-row {
+          display: flex;
+          justify-content: space-between;
+          align-items: center;
+          padding: 0.625rem 0;
+          border-bottom: 1px solid hsl(214.3 31.8% 91.4%);
+        }
+
+        .info-row:last-child {
+          border-bottom: none;
+          padding-bottom: 0;
+        }
+
+        .info-row:first-child {
+          padding-top: 0;
+        }
+
+        .label {
+          font-size: 0.875rem;
+          color: hsl(215.4 16.3% 46.9%);
+          font-weight: 500;
+        }
+
+        .value {
+          font-size: 0.875rem;
+          color: hsl(222.2 47.4% 11.2%);
+          font-weight: 500;
+        }
+
+        .amount-value {
+          font-size: 1.125rem;
+          font-weight: 600;
+          color: hsl(222.2 47.4% 11.2%);
+        }
+
+        .order-id {
+          font-family: 'SF Mono', 'Monaco', 'Inconsolata', 'Roboto Mono', monospace;
+          font-size: 0.8125rem;
+          color: hsl(215.4 16.3% 46.9%);
+        }
+
+        .expiry {
+          border-top: 2px solid hsl(214.3 31.8% 91.4%);
+          padding-top: 0.75rem;
+          margin-top: 0.5rem;
+        }
+
+        .time {
+          font-weight: 600;
+          font-size: 0.9375rem;
+          color: hsl(0 74.3% 42%);
+        }
+
+        .payment-methods {
+          margin: 1.5rem 0;
+        }
+
+        .method-toggle {
+          display: flex;
+          gap: 0.5rem;
+          padding: 0.25rem;
+          background: hsl(210 40% 98%);
+          border-radius: 0.5rem;
+          margin-bottom: 1.5rem;
+        }
+
+        .method-toggle button {
+          flex: 1;
+          padding: 0.5rem 1rem;
+          border: none;
+          border-radius: 0.375rem;
+          background: transparent;
+          cursor: pointer;
+          transition: all 0.15s;
+          font-weight: 500;
+          font-size: 0.875rem;
+          color: hsl(215.4 16.3% 46.9%);
+        }
+
+        .method-toggle button.active {
+          background: hsl(0 0% 100%);
+          color: hsl(222.2 47.4% 11.2%);
+          box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
+        }
+
+        .method-toggle button:hover:not(.active) {
+          color: hsl(222.2 47.4% 11.2%);
+        }
+
+        .qr-section {
+          display: flex;
+          flex-direction: column;
+          align-items: center;
+          padding: 1.5rem;
+          background: hsl(0 0% 100%);
+          border: 1px solid hsl(214.3 31.8% 91.4%);
+          border-radius: 0.75rem;
+        }
+
+        .qr-code {
+          padding: 1rem;
+          background: hsl(0 0% 100%);
+          border-radius: 0.5rem;
+        }
+
+        .qr-instruction {
+          margin-top: 1rem;
+          color: hsl(215.4 16.3% 46.9%);
+          text-align: center;
+          font-size: 0.875rem;
+        }
+
+        .address-section {
+          display: flex;
+          flex-direction: column;
+          gap: 1rem;
+        }
+
+        .address-display {
+          padding: 1rem;
+          background: hsl(210 40% 98%);
+          border: 1px solid hsl(214.3 31.8% 91.4%);
+          border-radius: 0.5rem;
+          overflow: auto;
+        }
+
+        .address-display code {
+          font-family: 'SF Mono', 'Monaco', 'Inconsolata', 'Roboto Mono', monospace;
+          font-size: 0.8125rem;
+          word-break: break-all;
+          color: hsl(222.2 47.4% 11.2%);
+        }
+
+        .copy-button {
+          padding: 0.625rem 1.25rem;
+          background: hsl(222.2 47.4% 11.2%);
+          color: hsl(210 40% 98%);
+          border: none;
+          border-radius: 0.5rem;
+          font-weight: 600;
+          cursor: pointer;
+          transition: all 0.15s;
+          font-size: 0.875rem;
+          height: 2.5rem;
+        }
+
+        .copy-button:hover {
+          background: hsl(222.2 47.4% 8%);
+        }
+
+        .payment-status {
+          margin: 1.5rem 0;
+          padding: 1rem 1.25rem;
+          background: hsl(47.9 95.8% 96.1%);
+          border-radius: 0.5rem;
+          border: 1px solid hsl(47.9 95.8% 82%);
+        }
+
+        .status-badge {
+          display: flex;
+          align-items: center;
+          gap: 0.625rem;
+          margin-bottom: 0.5rem;
+        }
+
+        .status-badge.waiting {
+          color: hsl(25 95.8% 25%);
+          font-weight: 600;
+          font-size: 0.875rem;
+        }
+
+        .status-spinner {
+          width: 14px;
+          height: 14px;
+          border: 2px solid hsl(25 95.8% 55%);
+          border-top-color: transparent;
+          border-radius: 50%;
+          animation: spin 0.8s linear infinite;
+        }
+
+        @keyframes spin {
+          to { transform: rotate(360deg); }
+        }
+
+        .status-text {
+          color: hsl(25 95.8% 35%);
+          font-size: 0.8125rem;
+          margin: 0;
+          line-height: 1.5;
+        }
+
+        .warning {
+          display: flex;
+          gap: 0.75rem;
+          padding: 0.875rem 1rem;
+          background: hsl(47.9 95.8% 96.1%);
+          border-radius: 0.5rem;
+          border: 1px solid hsl(47.9 95.8% 82%);
+          color: hsl(25 95.8% 25%);
+          font-size: 0.8125rem;
+          line-height: 1.5;
+        }
+
+        .warning svg {
+          flex-shrink: 0;
+          margin-top: 1px;
+          color: hsl(25 95.8% 45%);
+        }
+      ` })
+  ] });
+};
+
+// src/api/coins.ts
+var coins_exports = {};
+__export(coins_exports, {
+  findChainByCoinAndChainId: () => findChainByCoinAndChainId,
+  getCoinChains: () => getCoinChains
+});
+async function getCoinChains(coinId) {
+  try {
+    const response = await apiClient.getClient().get(
+      `/coins/${coinId}`
+    );
+    if (!response.data.isSuccess) {
+      throw new Error(response.data.message || "Failed to fetch coin chains");
+    }
+    return response.data.output.chains;
+  } catch (error) {
+    if (error.response?.data?.message) {
+      throw new Error(error.response.data.message);
+    }
+    throw new Error("Failed to fetch coin chains");
+  }
+}
+async function findChainByCoinAndChainId(coinId, chainId) {
+  const chains = await getCoinChains(coinId);
+  return chains.find((chain) => chain.chainId === chainId) || null;
+}
+
+// src/components/PaymentFlow.tsx
+import { jsx as jsx5, jsxs as jsxs3 } from "react/jsx-runtime";
+var PaymentFlow = ({
+  toAddress,
+  amount,
+  coinId,
+  chainId,
+  tokenAddress,
+  decimals,
+  publicOrderId,
+  expiresAt,
+  defaultMethod = "wallet",
+  allowMethodSwitch = true,
+  onSuccess,
+  onError,
+  onMethodChange,
+  className = "",
+  children
+}) => {
+  const [selectedMethod, setSelectedMethod] = useState6(defaultMethod);
+  const [chainInfo, setChainInfo] = useState6(null);
+  const [isLoadingChain, setIsLoadingChain] = useState6(true);
+  const [chainError, setChainError] = useState6(null);
+  useEffect6(() => {
+    const fetchChainInfo = async () => {
+      try {
+        setIsLoadingChain(true);
+        setChainError(null);
+        console.log("[PaymentFlow] Fetching chain info:", {
+          coinId,
+          requestedChainId: chainId,
+          requestedChainIdType: typeof chainId
+        });
+        const chains = await getCoinChains(coinId);
+        console.log("[PaymentFlow] Available chains:", chains.map((c) => ({
+          chainId: c.chainId,
+          name: c.name
+        })));
+        const matchingChain = chains.find(
+          (chain) => chain.chainId === chainId.toString()
+        );
+        if (!matchingChain) {
+          console.error("[PaymentFlow] No matching chain found!", {
+            requestedChainId: chainId.toString(),
+            availableChainIds: chains.map((c) => c.chainId)
+          });
+          setChainError(`Chain ${chainId} not supported for ${coinId}`);
+        } else {
+          console.log("[PaymentFlow] Matching chain found:", {
+            chainId: matchingChain.chainId,
+            name: matchingChain.name
+          });
+          setChainInfo(matchingChain);
+        }
+      } catch (error) {
+        console.error("[PaymentFlow] Failed to fetch chain info:", error);
+        setChainError(error.message || "Failed to load chain information");
+      } finally {
+        setIsLoadingChain(false);
+      }
+    };
+    fetchChainInfo();
+  }, [coinId, chainId]);
+  const handleMethodChange = (method) => {
+    setSelectedMethod(method);
+    onMethodChange?.(method);
+  };
+  const handleWalletSuccess = (txHash) => {
+    onSuccess?.({ txHash, publicOrderId });
+  };
+  if (children) {
+    return /* @__PURE__ */ jsx5("div", { className, children });
+  }
+  if (isLoadingChain) {
+    return /* @__PURE__ */ jsx5("div", { className: `payment-flow loading ${className}`, children: /* @__PURE__ */ jsxs3("div", { className: "loading-spinner", children: [
+      /* @__PURE__ */ jsx5("div", { className: "spinner" }),
+      /* @__PURE__ */ jsx5("p", { children: "Loading chain information..." })
+    ] }) });
+  }
+  if (chainError || !chainInfo) {
+    return /* @__PURE__ */ jsx5("div", { className: `payment-flow error ${className}`, children: /* @__PURE__ */ jsx5("div", { className: "error-message", children: /* @__PURE__ */ jsxs3("p", { children: [
+      "\u26A0\uFE0F ",
+      chainError || "Chain information not available"
+    ] }) }) });
+  }
+  return /* @__PURE__ */ jsxs3("div", { className: `payment-flow ${className}`, children: [
+    allowMethodSwitch && /* @__PURE__ */ jsxs3("div", { className: "payment-method-selector", children: [
+      /* @__PURE__ */ jsxs3(
+        "button",
+        {
+          onClick: () => handleMethodChange("wallet"),
+          className: `method-button ${selectedMethod === "wallet" ? "active" : ""}`,
+          children: [
+            /* @__PURE__ */ jsxs3("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", children: [
+              /* @__PURE__ */ jsx5("path", { d: "M21 12a9 9 0 11-18 0 9 9 0 0118 0z", strokeWidth: "2", strokeLinecap: "round" }),
+              /* @__PURE__ */ jsx5("path", { d: "M9 12l2 2 4-4", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" })
+            ] }),
+            /* @__PURE__ */ jsx5("span", { children: "Connect Wallet" })
+          ]
+        }
+      ),
+      /* @__PURE__ */ jsxs3(
+        "button",
+        {
+          onClick: () => handleMethodChange("address"),
+          className: `method-button ${selectedMethod === "address" ? "active" : ""}`,
+          children: [
+            /* @__PURE__ */ jsxs3("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", children: [
+              /* @__PURE__ */ jsx5("rect", { x: "3", y: "11", width: "18", height: "10", rx: "2", strokeWidth: "2" }),
+              /* @__PURE__ */ jsx5("path", { d: "M7 11V7a5 5 0 0110 0v4", strokeWidth: "2", strokeLinecap: "round" })
+            ] }),
+            /* @__PURE__ */ jsx5("span", { children: "QR / Address" })
+          ]
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx5("div", { className: "payment-content", children: selectedMethod === "wallet" ? /* @__PURE__ */ jsx5(
+      PayWithWallet,
+      {
+        toAddress,
+        amount,
+        coinId,
+        chainId: parseInt(chainInfo.chainId),
+        chainInfo,
+        tokenAddress,
+        decimals,
+        publicOrderId,
+        onSuccess: handleWalletSuccess,
+        onError
+      }
+    ) : /* @__PURE__ */ jsx5(
+      PayWithAddress,
+      {
+        walletAddress: toAddress,
+        amount,
+        coinId,
+        chainId: parseInt(chainInfo.chainId),
+        chainInfo,
+        publicOrderId,
+        expiresAt,
+        onCopy: () => console.log("Address copied")
+      }
+    ) }),
+    /* @__PURE__ */ jsx5("style", { children: `
+        .payment-flow {
+          width: 100%;
+          max-width: 600px;
+          margin: 0 auto;
+        }
+
+        .payment-method-selector {
+          display: flex;
+          gap: 0.5rem;
+          margin-bottom: 1.5rem;
+          padding: 0.25rem;
+          background: hsl(210 40% 98%);
+          border-radius: 0.5rem;
+        }
+
+        .method-button {
+          flex: 1;
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          gap: 0.5rem;
+          padding: 0.625rem 1rem;
+          border: none;
+          border-radius: 0.375rem;
+          background: transparent;
+          cursor: pointer;
+          transition: all 0.15s;
+          font-weight: 500;
+          font-size: 0.875rem;
+          color: hsl(215.4 16.3% 46.9%);
+        }
+
+        .method-button:hover:not(.active) {
+          color: hsl(222.2 47.4% 11.2%);
+        }
+
+        .method-button.active {
+          background: hsl(0 0% 100%);
+          color: hsl(222.2 47.4% 11.2%);
+          box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
+        }
+
+        .method-button svg {
+          width: 18px;
+          height: 18px;
+        }
+
+        .payment-content {
+          background: hsl(0 0% 100%);
+          border: 1px solid hsl(214.3 31.8% 91.4%);
+          border-radius: 0.75rem;
+          padding: 0;
+          box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.05);
+        }
+      ` })
+  ] });
+};
+
+// src/components/OrderStatusScreen.tsx
+import { jsx as jsx6, jsxs as jsxs4 } from "react/jsx-runtime";
+var OrderStatusScreen = ({
+  state,
+  publicOrderId,
+  amount,
+  coinId,
+  onRetry
+}) => {
+  const getContent = () => {
+    switch (state) {
+      case "success" /* SUCCESS */:
+        return {
+          icon: /* @__PURE__ */ jsxs4("svg", { width: "64", height: "64", viewBox: "0 0 24 24", fill: "none", children: [
+            /* @__PURE__ */ jsx6("circle", { cx: "12", cy: "12", r: "10", fill: "#10b981" }),
+            /* @__PURE__ */ jsx6(
+              "path",
+              {
+                d: "M8 12l2 2 6-6",
+                stroke: "white",
+                strokeWidth: "2",
+                strokeLinecap: "round",
+                strokeLinejoin: "round"
+              }
+            )
+          ] }),
+          title: "Payment Successful!",
+          message: "Your payment has been processed successfully.",
+          color: "#10b981"
+        };
+      case "failed" /* FAILED */:
+        return {
+          icon: /* @__PURE__ */ jsxs4("svg", { width: "64", height: "64", viewBox: "0 0 24 24", fill: "none", children: [
+            /* @__PURE__ */ jsx6("circle", { cx: "12", cy: "12", r: "10", fill: "#ef4444" }),
+            /* @__PURE__ */ jsx6(
+              "path",
+              {
+                d: "M8 8l8 8M16 8l-8 8",
+                stroke: "white",
+                strokeWidth: "2",
+                strokeLinecap: "round"
+              }
+            )
+          ] }),
+          title: "Payment Failed",
+          message: "The payment transaction could not be completed.",
+          color: "#ef4444",
+          showRetry: true
+        };
+      case "refund_insufficient" /* REFUND_INSUFFICIENT */:
+        return {
+          icon: /* @__PURE__ */ jsxs4("svg", { width: "64", height: "64", viewBox: "0 0 24 24", fill: "none", children: [
+            /* @__PURE__ */ jsx6("circle", { cx: "12", cy: "12", r: "10", fill: "#f59e0b" }),
+            /* @__PURE__ */ jsx6(
+              "path",
+              {
+                d: "M12 8v4M12 16h.01",
+                stroke: "white",
+                strokeWidth: "2",
+                strokeLinecap: "round"
+              }
+            )
+          ] }),
+          title: "Insufficient Amount - Refund Issued",
+          message: "The payment amount was less than required. A refund has been initiated.",
+          color: "#f59e0b",
+          showRetry: true
+        };
+      case "refund_excess" /* REFUND_EXCESS */:
+        return {
+          icon: /* @__PURE__ */ jsxs4("svg", { width: "64", height: "64", viewBox: "0 0 24 24", fill: "none", children: [
+            /* @__PURE__ */ jsx6("circle", { cx: "12", cy: "12", r: "10", fill: "#f59e0b" }),
+            /* @__PURE__ */ jsx6(
+              "path",
+              {
+                d: "M12 8v4M12 16h.01",
+                stroke: "white",
+                strokeWidth: "2",
+                strokeLinecap: "round"
+              }
+            )
+          ] }),
+          title: "Excess Amount - Partial Refund Issued",
+          message: "The payment amount exceeded the required amount. The excess has been refunded.",
+          color: "#f59e0b",
+          showRetry: true
+        };
+      default:
+        return null;
+    }
+  };
+  const content = getContent();
+  if (!content) return null;
+  return /* @__PURE__ */ jsxs4("div", { className: "order-status-screen", children: [
+    /* @__PURE__ */ jsxs4("div", { className: "status-container", children: [
+      /* @__PURE__ */ jsx6("div", { className: "status-icon", children: content.icon }),
+      /* @__PURE__ */ jsx6("h3", { style: { color: content.color }, children: content.title }),
+      /* @__PURE__ */ jsx6("p", { children: content.message }),
+      /* @__PURE__ */ jsxs4("div", { className: "order-details", children: [
+        amount && coinId && /* @__PURE__ */ jsxs4("div", { className: "detail-row", children: [
+          /* @__PURE__ */ jsx6("span", { children: "Amount:" }),
+          /* @__PURE__ */ jsxs4("span", { className: "detail-value", children: [
+            amount,
+            " ",
+            coinId
+          ] })
+        ] }),
+        /* @__PURE__ */ jsxs4("div", { className: "detail-row", children: [
+          /* @__PURE__ */ jsx6("span", { children: "Order ID:" }),
+          /* @__PURE__ */ jsxs4("span", { className: "detail-value", children: [
+            publicOrderId.slice(0, 8),
+            "..."
+          ] })
+        ] })
+      ] }),
+      content.showRetry && onRetry && /* @__PURE__ */ jsx6("button", { onClick: onRetry, className: "retry-button", children: "Try Again" })
+    ] }),
+    /* @__PURE__ */ jsx6("style", { children: `
+        .order-status-screen {
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          min-height: 400px;
+        }
+
+        .status-container {
+          text-align: center;
+          max-width: 400px;
+        }
+
+        .status-icon {
+          margin: 0 auto 1.5rem;
+        }
+
+        .status-container h3 {
+          font-size: 1.5rem;
+          font-weight: 600;
+          margin-bottom: 0.5rem;
+        }
+
+        .status-container p {
+          color: #6b7280;
+          margin-bottom: 1.5rem;
+        }
+
+        .order-details {
+          background: #f9fafb;
+          padding: 1rem;
+          border-radius: 8px;
+          margin-bottom: 1.5rem;
+        }
+
+        .detail-row {
+          display: flex;
+          justify-content: space-between;
+          margin-bottom: 0.5rem;
+        }
+
+        .detail-row:last-child {
+          margin-bottom: 0;
+        }
+
+        .detail-value {
+          font-weight: 600;
+          color: #2563eb;
+        }
+
+        .retry-button {
+          padding: 0.75rem 1.5rem;
+          background: #2563eb;
+          color: white;
+          border: none;
+          border-radius: 8px;
+          font-weight: 600;
+          cursor: pointer;
+          transition: background 0.2s;
+        }
+
+        .retry-button:hover {
+          background: #1d4ed8;
+        }
+      ` })
+  ] });
+};
+
+// src/components/OrderPayment.tsx
+import { jsx as jsx7, jsxs as jsxs5 } from "react/jsx-runtime";
+var OrderPayment = ({
+  publicOrderId,
+  onSuccess,
+  onError,
+  className = ""
+}) => {
+  const { order, isLoading, error } = useOrder(publicOrderId, {
+    pollingInterval: 5e3,
+    enablePolling: true
+  });
+  const [hasNotifiedSuccess, setHasNotifiedSuccess] = useState7(false);
+  useEffect7(() => {
+    if (error) {
+      onError?.(error.message);
+    }
+  }, [error, onError]);
+  useEffect7(() => {
+    if (!order || !order.orderStat) return;
+    const state = getOrderState(order.orderStat);
+    if (state === "success" /* SUCCESS */ && !hasNotifiedSuccess) {
+      setHasNotifiedSuccess(true);
+      onSuccess?.({ publicOrderId });
+    }
+    if (state === "failed" /* FAILED */ || state === "refund_insufficient" /* REFUND_INSUFFICIENT */ || state === "refund_excess" /* REFUND_EXCESS */) {
+      const errorMessage = getOrderStatusMessage(order.orderStat);
+      onError?.(errorMessage);
+    }
+  }, [order, hasNotifiedSuccess, onSuccess, onError, publicOrderId]);
+  const handleWalletPaymentSuccess = (result) => {
+    console.log("[OrderPayment] Wallet payment success, txHash:", result.txHash);
+  };
+  const handleRetry = () => {
+    window.location.reload();
+  };
+  if (isLoading) {
+    return /* @__PURE__ */ jsxs5("div", { className: `order-payment loading ${className}`, children: [
+      /* @__PURE__ */ jsxs5("div", { className: "loading-spinner", children: [
+        /* @__PURE__ */ jsx7("div", { className: "spinner" }),
+        /* @__PURE__ */ jsx7("p", { children: "Loading payment details..." })
+      ] }),
+      /* @__PURE__ */ jsx7("style", { children: `
+          .order-payment.loading {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            min-height: 400px;
+          }
+
+          .loading-spinner {
+            text-align: center;
+          }
+
+          .spinner {
+            width: 48px;
+            height: 48px;
+            border: 4px solid #e5e7eb;
+            border-top-color: #2563eb;
+            border-radius: 50%;
+            animation: spin 0.8s linear infinite;
+            margin: 0 auto 1rem;
+          }
+
+          @keyframes spin {
+            to { transform: rotate(360deg); }
+          }
+
+          .loading-spinner p {
+            color: #6b7280;
+            font-size: 0.875rem;
+          }
+        ` })
+    ] });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsxs5("div", { className: `order-payment error ${className}`, children: [
+      /* @__PURE__ */ jsxs5("div", { className: "error-container", children: [
+        /* @__PURE__ */ jsxs5("svg", { width: "64", height: "64", viewBox: "0 0 24 24", fill: "none", stroke: "#ef4444", children: [
+          /* @__PURE__ */ jsx7("circle", { cx: "12", cy: "12", r: "10", strokeWidth: "2" }),
+          /* @__PURE__ */ jsx7("path", { d: "M12 8v4M12 16h.01", strokeWidth: "2", strokeLinecap: "round" })
+        ] }),
+        /* @__PURE__ */ jsx7("h3", { children: "Payment Error" }),
+        /* @__PURE__ */ jsx7("p", { children: error.message }),
+        /* @__PURE__ */ jsx7("button", { onClick: () => window.location.reload(), className: "retry-button", children: "Try Again" })
+      ] }),
+      /* @__PURE__ */ jsx7("style", { children: `
+          .order-payment.error {
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            min-height: 400px;
+          }
+
+          .error-container {
+            text-align: center;
+            max-width: 400px;
+          }
+
+          .error-container svg {
+            margin: 0 auto 1rem;
+          }
+
+          .error-container h3 {
+            font-size: 1.25rem;
+            font-weight: 600;
+            color: #ef4444;
+            margin-bottom: 0.5rem;
+          }
+
+          .error-container p {
+            color: #6b7280;
+            margin-bottom: 1.5rem;
+          }
+
+          .retry-button {
+            padding: 0.75rem 1.5rem;
+            background: #2563eb;
+            color: white;
+            border: none;
+            border-radius: 8px;
+            font-weight: 600;
+            cursor: pointer;
+            transition: background 0.2s;
+          }
+
+          .retry-button:hover {
+            background: #1d4ed8;
+          }
+        ` })
+    ] });
+  }
+  if (!order || !order.orderStat) {
+    return null;
+  }
+  const orderState = getOrderState(order.orderStat);
+  const isExpired = new Date(order.expireDt) < /* @__PURE__ */ new Date();
+  if (orderState !== "waiting" /* WAITING */ || isExpired) {
+    return /* @__PURE__ */ jsx7("div", { className, children: /* @__PURE__ */ jsx7(
+      OrderStatusScreen,
+      {
+        state: isExpired ? "failed" /* FAILED */ : orderState,
+        publicOrderId,
+        amount: order.price,
+        coinId: order.coin,
+        onRetry: handleRetry
+      }
+    ) });
+  }
+  const walletInfo = order.walletInfo?.[0];
+  if (!walletInfo?.address) {
+    return /* @__PURE__ */ jsx7(
+      OrderStatusScreen,
+      {
+        state: "failed" /* FAILED */,
+        publicOrderId,
+        onRetry: handleRetry
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx7("div", { className, children: /* @__PURE__ */ jsx7(
+    PaymentFlow,
+    {
+      toAddress: walletInfo.address,
+      amount: order.price.toString(),
+      coinId: order.coin,
+      chainId: parseInt(order.chain),
+      tokenAddress: walletInfo.contractAddr,
+      decimals: walletInfo.digit,
+      publicOrderId,
+      expiresAt: order.expireDt,
+      onSuccess: handleWalletPaymentSuccess,
+      onError,
+      allowMethodSwitch: true,
+      defaultMethod: "wallet"
+    }
+  ) });
+};
+
+// src/components/PaymentModal.tsx
+import { jsx as jsx8, jsxs as jsxs6 } from "react/jsx-runtime";
+var PaymentModal = ({
+  publicOrderId,
+  isOpen,
+  onClose,
+  onSuccess,
+  onError
+}) => {
+  useEffect8(() => {
+    const handleEscape = (e) => {
+      if (e.key === "Escape" && isOpen) {
+        onClose();
+      }
+    };
+    document.addEventListener("keydown", handleEscape);
+    return () => document.removeEventListener("keydown", handleEscape);
+  }, [isOpen, onClose]);
+  useEffect8(() => {
+    if (isOpen) {
+      document.body.style.overflow = "hidden";
+    } else {
+      document.body.style.overflow = "unset";
+    }
+    return () => {
+      document.body.style.overflow = "unset";
+    };
+  }, [isOpen]);
+  if (!isOpen) return null;
+  return /* @__PURE__ */ jsxs6("div", { className: "payment-modal-overlay", onClick: onClose, children: [
+    /* @__PURE__ */ jsxs6("div", { className: "payment-modal-content", onClick: (e) => e.stopPropagation(), children: [
+      /* @__PURE__ */ jsx8("button", { className: "payment-modal-close", onClick: onClose, type: "button", children: /* @__PURE__ */ jsx8("svg", { width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", stroke: "currentColor", children: /* @__PURE__ */ jsx8("path", { d: "M18 6L6 18M6 6l12 12", strokeWidth: "2", strokeLinecap: "round" }) }) }),
+      /* @__PURE__ */ jsx8(
+        OrderPayment,
+        {
+          publicOrderId,
+          onSuccess: (result) => {
+            onSuccess?.(result);
+            onClose();
+          },
+          onError
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx8("style", { children: `
+        .payment-modal-overlay {
+          position: fixed;
+          top: 0;
+          left: 0;
+          right: 0;
+          bottom: 0;
+          background: rgba(0, 0, 0, 0.5);
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          z-index: 9999;
+          padding: 1rem;
+          animation: fadeIn 0.2s ease-out;
+        }
+
+        @keyframes fadeIn {
+          from {
+            opacity: 0;
+          }
+          to {
+            opacity: 1;
+          }
+        }
+
+        .payment-modal-content {
+          position: relative;
+          background: white;
+          border-radius: 16px;
+          max-width: 640px;
+          width: 100%;
+          max-height: 90vh;
+          overflow-y: auto;
+          box-shadow: 0 20px 25px -5px rgba(0, 0, 0, 0.1), 0 10px 10px -5px rgba(0, 0, 0, 0.04);
+          animation: slideUp 0.3s ease-out;
+        }
+
+        @keyframes slideUp {
+          from {
+            transform: translateY(20px);
+            opacity: 0;
+          }
+          to {
+            transform: translateY(0);
+            opacity: 1;
+          }
+        }
+
+        .payment-modal-close {
+          position: absolute;
+          top: 1rem;
+          right: 1rem;
+          width: 40px;
+          height: 40px;
+          border: none;
+          background: rgba(0, 0, 0, 0.05);
+          border-radius: 50%;
+          cursor: pointer;
+          display: flex;
+          align-items: center;
+          justify-content: center;
+          transition: all 0.2s;
+          z-index: 1;
+        }
+
+        .payment-modal-close:hover {
+          background: rgba(0, 0, 0, 0.1);
+        }
+
+        .payment-modal-close svg {
+          width: 20px;
+          height: 20px;
+          color: #6b7280;
+        }
+
+        /* \uBAA8\uBC14\uC77C \uB300\uC751 */
+        @media (max-width: 640px) {
+          .payment-modal-overlay {
+            padding: 0;
+          }
+
+          .payment-modal-content {
+            max-width: 100%;
+            max-height: 100vh;
+            border-radius: 0;
+          }
+        }
+      ` })
+  ] });
+};
+
+// src/components/PaymentButton.tsx
+import { Fragment as Fragment2, jsx as jsx9, jsxs as jsxs7 } from "react/jsx-runtime";
+var PaymentButton = ({
+  productId,
+  metadata,
+  onSuccess,
+  onError,
+  className = "",
+  disabled = false,
+  children
+}) => {
+  const context = useContext3(PaymentContext);
+  const { createOrder: createOrder2, isLoading } = usePayment();
+  const [isModalOpen, setIsModalOpen] = useState8(false);
+  const [publicOrderId, setPublicOrderId] = useState8(null);
+  const [isCompleted, setIsCompleted] = useState8(false);
+  const [createdOrder, setCreatedOrder] = useState8(null);
+  const isOurDomain = (url) => {
+    const environment = context?.config?.environment || "sandbox";
+    const ourDomain = PAYMENT_DOMAINS[environment];
+    return url.startsWith(ourDomain);
+  };
+  const handleClick = async () => {
+    if (publicOrderId) {
+      setIsModalOpen(true);
+      return;
+    }
+    try {
+      const params = {
+        productId,
+        metadata
+      };
+      const order = await createOrder2(params);
+      if (order.redirectUrl && order.redirectUrl.trim() !== "") {
+        if (!isOurDomain(order.redirectUrl)) {
+          throw new Error("Invalid redirect URL. Only our domain is allowed.");
+        }
+        const separator = order.redirectUrl.endsWith("/") ? "" : "/";
+        window.location.href = `${order.redirectUrl}${separator}order/${order.publicOrderId}`;
+        return;
+      }
+      setPublicOrderId(order.publicOrderId);
+      setCreatedOrder(order);
+      setIsModalOpen(true);
+    } catch (err) {
+      if (onError && err instanceof Error) {
+        onError(err);
+      }
+    }
+  };
+  const handleModalSuccess = async (result) => {
+    setIsCompleted(true);
+    setIsModalOpen(false);
+    if (!onSuccess) return;
+    try {
+      let orderDetail = null;
+      let retryCount = 0;
+      const maxRetries = 5;
+      while (retryCount < maxRetries) {
+        try {
+          const detail = await getOrder(result.publicOrderId);
+          if (detail && detail.orderId && detail.orderStat !== void 0) {
+            orderDetail = detail;
+            break;
+          }
+          throw new Error("Incomplete order data");
+        } catch (err) {
+          retryCount++;
+          if (retryCount >= maxRetries) {
+            console.error(`[PaymentButton] Failed after ${maxRetries} retries:`, err);
+            throw err;
+          }
+          console.log(`[PaymentButton] Retry ${retryCount}/${maxRetries}...`);
+          await new Promise((resolve) => setTimeout(resolve, 500));
+        }
+      }
+      if (orderDetail) {
+        onSuccess({
+          orderId: orderDetail.orderId,
+          publicOrderId: result.publicOrderId,
+          paymentUrl: "",
+          amount: orderDetail.price || 0,
+          coinId: orderDetail.coin || "",
+          chainId: orderDetail.chain || "",
+          status: orderDetail.orderStat,
+          expiresAt: orderDetail.expireDt || "",
+          redirectUrl: orderDetail.redirectUrl || null
+        });
+      } else {
+        throw new Error("Order detail is null after retries");
+      }
+    } catch (err) {
+      console.error("[PaymentButton] Failed to get valid order details:", err);
+      if (createdOrder) {
+        console.log("[PaymentButton] Using created order info as fallback");
+        onSuccess({
+          ...createdOrder,
+          status: "completed"
+          // 결제 완료 상태로 업데이트
+        });
+      } else {
+        console.warn("[PaymentButton] No order info available, using minimal data");
+        onSuccess({
+          orderId: result.publicOrderId,
+          publicOrderId: result.publicOrderId,
+          paymentUrl: "",
+          amount: 0,
+          coinId: "",
+          chainId: "",
+          status: "completed",
+          expiresAt: "",
+          redirectUrl: null
+        });
+      }
+    }
+  };
+  const handleModalError = (error) => {
+    if (onError) {
+      onError(new Error(error));
+    }
+  };
+  return /* @__PURE__ */ jsxs7(Fragment2, { children: [
+    /* @__PURE__ */ jsx9(
+      "button",
+      {
+        onClick: handleClick,
+        disabled: disabled || isLoading || isCompleted,
+        className,
+        type: "button",
+        children: isLoading ? "Processing..." : isCompleted ? "Completed" : children || "Pay Now"
+      }
+    ),
+    publicOrderId && /* @__PURE__ */ jsx9(
+      PaymentModal,
+      {
+        publicOrderId,
+        isOpen: isModalOpen,
+        onClose: () => setIsModalOpen(false),
+        onSuccess: handleModalSuccess,
+        onError: handleModalError
+      }
+    )
+  ] });
+};
+
+// src/components/WalletProvider.tsx
+import { useMemo as useMemo2 } from "react";
+import { WagmiProvider } from "wagmi";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+
+// src/adapters/types.ts
+var WalletType = /* @__PURE__ */ ((WalletType2) => {
+  WalletType2["EVM"] = "evm";
+  WalletType2["TRON"] = "tron";
+  return WalletType2;
+})(WalletType || {});
+var ChainType = /* @__PURE__ */ ((ChainType2) => {
+  ChainType2["EVM"] = "evm";
+  ChainType2["TRON"] = "tron";
+  return ChainType2;
+})(ChainType || {});
+
+// src/adapters/TronWalletAdapter.ts
+var TRON_NETWORKS = {
+  mainnet: 728126428,
+  shasta: 2494104990,
+  // Testnet
+  nile: 3448148188
+  // Testnet
+};
+var TRON_NETWORK_NAMES = {
+  728126428: "mainnet",
+  2494104990: "shasta",
+  3448148188: "nile"
+};
+var TRC20_TRANSFER_ABI = {
+  type: "Function",
+  stateMutability: "Nonpayable",
+  name: "transfer",
+  inputs: [
+    { type: "address", name: "_to" },
+    { type: "uint256", name: "_value" }
+  ],
+  outputs: [{ type: "bool" }]
+};
+var TronWalletAdapter = class {
+  constructor() {
+    this.type = "tron";
+    this.chainType = "tron";
+    this.tronWeb = null;
+    this.currentAddress = null;
+    this.currentNetwork = null;
+    this.initialized = false;
+    this.eventListenerRegistered = false;
+    this.handleTronLinkMessage = (event) => {
+      if (event.data?.message && event.data.message.action === "setNode") {
+        if (this.isTronWalletAvailable()) {
+          this.initializeTronWeb();
+          if (this.initialized) {
+            this.removeEventListener();
+          }
+        }
+      }
+    };
+  }
+  /**
+   * Trust Wallet 설치 확인
+   */
+  hasTrustWallet() {
+    if (typeof window === "undefined") return false;
+    const windowAny = window;
+    return !!(windowAny.trustwallet || windowAny.trustWallet || windowAny.ethereum?.isTrust || windowAny.ethereum?.isTrustWallet);
+  }
+  /**
+   * TronLink 전용 감지 (Trust Wallet보다 우선)
+   * ⚠️ CRITICAL: 이 메서드는 connect() 시점에만 호출되어야 함
+   */
+  isTronLinkInstalled() {
+    if (typeof window === "undefined") return false;
+    return true;
+  }
+  /**
+   * Tron 지갑 사용 가능 여부 확인
+   * ⚠️ CRITICAL: 이 메서드는 connect() 시점에만 호출되어야 함
+   */
+  isTronWalletAvailable() {
+    if (typeof window === "undefined") return false;
+    return true;
+  }
+  /**
+   * 현재 사용 중인 wallet 타입 반환
+   */
+  getWalletType() {
+    if (this.isTronLinkInstalled()) return "TronLink";
+    if (this.hasTrustWallet()) return "Trust Wallet";
+    return "Unknown";
+  }
+  /**
+   * 이벤트 리스너 등록 (connect 호출 시에만)
+   */
+  registerEventListener() {
+    if (typeof window !== "undefined" && !this.eventListenerRegistered && !this.initialized) {
+      window.addEventListener("message", this.handleTronLinkMessage);
+      this.eventListenerRegistered = true;
+      console.log("[TronWalletAdapter] Message event listener registered");
+    }
+  }
+  /**
+   * 이벤트 리스너 제거
+   */
+  removeEventListener() {
+    if (typeof window !== "undefined" && this.eventListenerRegistered) {
+      window.removeEventListener("message", this.handleTronLinkMessage);
+      this.eventListenerRegistered = false;
+      console.log("[TronWalletAdapter] Message event listener removed");
+    }
+  }
+  // TronWeb에서 현재 네트워크 감지
+  detectNetwork(tronWeb) {
+    try {
+      let fullNodeHost = "";
+      if (tronWeb.fullNode?.host) {
+        fullNodeHost = tronWeb.fullNode.host;
+      } else if (tronWeb.fullHost) {
+        fullNodeHost = tronWeb.fullHost;
+      } else if (tronWeb.solidityNode?.host) {
+        fullNodeHost = tronWeb.solidityNode.host;
+      }
+      console.log("[TronWalletAdapter] Detecting network from host:", fullNodeHost);
+      const hostLower = fullNodeHost.toLowerCase();
+      if (hostLower.includes("shasta")) {
+        console.log("[TronWalletAdapter] Detected: Shasta Testnet");
+        return TRON_NETWORKS.shasta;
+      } else if (hostLower.includes("nile")) {
+        console.log("[TronWalletAdapter] Detected: Nile Testnet");
+        return TRON_NETWORKS.nile;
+      } else {
+        console.log("[TronWalletAdapter] Detected: Mainnet (default)");
+        return TRON_NETWORKS.mainnet;
+      }
+    } catch (error) {
+      console.warn("[TronWalletAdapter] Failed to detect network:", error);
+      return TRON_NETWORKS.mainnet;
+    }
+  }
+  initializeTronWeb() {
+    if (this.initialized) return;
+    if (typeof window === "undefined") return;
+    if (!this.isTronWalletAvailable()) {
+      return;
+    }
+    const windowAny = window;
+    if (windowAny.tronLink?.tronWeb) {
+      this.tronWeb = windowAny.tronLink.tronWeb;
+      this.initialized = true;
+      console.log(`[TronWalletAdapter] ${this.getWalletType()} initialized`);
+    } else if (windowAny.tronWeb) {
+      this.tronWeb = windowAny.tronWeb;
+      this.initialized = true;
+      console.log("[TronWalletAdapter] Using window.tronWeb");
+    }
+  }
+  // 연결 상태
+  isConnected() {
+    return !!this.currentAddress && !!this.tronWeb;
+  }
+  getAddress() {
+    return this.currentAddress;
+  }
+  getChainId() {
+    if (this.tronWeb) {
+      this.currentNetwork = this.detectNetwork(this.tronWeb);
+    }
+    return this.currentNetwork || TRON_NETWORKS.mainnet;
+  }
+  async getBalance() {
+    if (!this.tronWeb || !this.currentAddress) return null;
+    try {
+      const balance = await this.tronWeb.trx.getBalance(this.currentAddress);
+      return {
+        value: BigInt(balance),
+        decimals: 6,
+        symbol: "TRX",
+        formatted: (Number(balance) / 1e6).toFixed(6)
+      };
+    } catch (error) {
+      console.error("[TronWalletAdapter] Failed to get balance:", error);
+      return null;
+    }
+  }
+  getConnectionInfo() {
+    if (!this.isConnected() || !this.currentAddress) {
+      return null;
+    }
+    return {
+      address: this.currentAddress,
+      chainId: this.getChainId() || TRON_NETWORKS.mainnet,
+      chainType: this.chainType,
+      isConnected: true,
+      connector: {
+        id: "tronlink",
+        name: "TronLink",
+        icon: "https://www.tronlink.org/favicon.ico"
+      }
+    };
+  }
+  // 연결 관리
+  async connect(_connectorId) {
+    if (typeof window === "undefined") {
+      throw new Error("Window not available");
+    }
+    const windowAny = window;
+    if (!windowAny.tronLink || typeof windowAny.tronLink.request !== "function") {
+      throw new Error(
+        "Tron wallet not installed. Please install TronLink extension."
+      );
+    }
+    const isTronLinkProp = windowAny.tronLink?.isTronLink;
+    const hasTrustWallet = this.hasTrustWallet();
+    console.log("[TronWalletAdapter] Connecting with wallet:", {
+      hasTronLink: !!windowAny.tronLink,
+      isTronLinkProp,
+      hasTrustWallet,
+      walletType: isTronLinkProp === true ? "TronLink" : hasTrustWallet ? "Trust Wallet (Tron support)" : "Unknown"
+    });
+    if (!this.initialized) {
+      this.registerEventListener();
+    }
+    try {
+      console.log(`[TronWalletAdapter] Connecting to ${this.getWalletType()}...`);
+      const result = await windowAny.tronLink.request({
+        method: "tron_requestAccounts"
+      });
+      if (result.code === 200) {
+        this.initializeTronWeb();
+        if (!this.tronWeb) {
+          throw new Error("TronWeb not initialized after connection");
+        }
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        if (windowAny.tronLink?.tronWeb) {
+          this.tronWeb = windowAny.tronLink.tronWeb;
+          this.currentAddress = this.tronWeb.defaultAddress?.base58 || null;
+          this.currentNetwork = this.detectNetwork(this.tronWeb);
+        } else if (windowAny.tronWeb) {
+          this.tronWeb = windowAny.tronWeb;
+          this.currentAddress = this.tronWeb.defaultAddress?.base58 || null;
+          this.currentNetwork = this.detectNetwork(this.tronWeb);
+        }
+        if (!this.currentAddress) {
+          throw new Error("Failed to get wallet address after connection");
+        }
+        console.log(
+          "[TronWalletAdapter] Connected:",
+          this.currentAddress,
+          "Network:",
+          this.currentNetwork ? TRON_NETWORK_NAMES[this.currentNetwork] : "unknown"
+        );
+      } else {
+        throw new Error(result.message || "Connection rejected");
+      }
+    } catch (error) {
+      console.error("[TronWalletAdapter] Connection failed:", error);
+      throw error;
+    }
+  }
+  async disconnect() {
+    try {
+      if (typeof window !== "undefined") {
+        try {
+          const windowAny = window;
+          if (windowAny.tronLink?.request) {
+            await windowAny.tronLink.request({
+              method: "wallet_disconnect"
+            });
+            console.log("[TronWalletAdapter] TronLink disconnected via wallet_disconnect");
+          }
+        } catch (error) {
+          console.log("[TronWalletAdapter] wallet_disconnect not supported, clearing state only");
+        }
+      }
+    } catch (error) {
+      console.warn("[TronWalletAdapter] Disconnect request failed:", error);
+    }
+    this.removeEventListener();
+    this.currentAddress = null;
+    this.currentNetwork = null;
+    this.tronWeb = null;
+    this.initialized = false;
+    console.log("[TronWalletAdapter] Internal state cleared");
+  }
+  async switchChain(chainId) {
+    const networkId = typeof chainId === "number" ? chainId : parseInt(chainId);
+    const validNetworks = [TRON_NETWORKS.mainnet, TRON_NETWORKS.shasta, TRON_NETWORKS.nile];
+    if (!validNetworks.includes(networkId)) {
+      throw new Error(`Unsupported Tron network: ${chainId}`);
+    }
+    console.warn(
+      "[TronWalletAdapter] Network switching must be done manually in TronLink"
+    );
+    this.currentNetwork = networkId;
+  }
+  // 트랜잭션
+  async sendPayment(tx) {
+    try {
+      if (!this.tronWeb || !this.currentAddress) {
+        throw new Error("Wallet not connected");
+      }
+      let hash;
+      if (tx.tokenAddress) {
+        const contract = await this.tronWeb.contract(
+          [TRC20_TRANSFER_ABI],
+          tx.tokenAddress
+        );
+        const result = await contract.transfer(tx.to, tx.value.toString()).send({
+          from: this.currentAddress
+        });
+        hash = result;
+      } else {
+        const amountInSun = Number(tx.value);
+        const transaction = await this.tronWeb.transactionBuilder.sendTrx(
+          tx.to,
+          amountInSun,
+          this.currentAddress
+        );
+        const signedTx = await this.tronWeb.trx.sign(transaction);
+        const broadcast = await this.tronWeb.trx.sendRawTransaction(signedTx);
+        if (!broadcast.result) {
+          throw new Error(
+            broadcast.message || "Transaction broadcast failed"
+          );
+        }
+        hash = broadcast.txid || signedTx.txID;
+      }
+      return { success: true, hash };
+    } catch (error) {
+      console.error("[TronWalletAdapter] Payment failed:", error);
+      return {
+        success: false,
+        hash: "",
+        error: error?.message ?? "Transaction failed"
+      };
+    }
+  }
+  // 지원 여부 확인
+  isChainSupported(chainId) {
+    const networkId = typeof chainId === "number" ? chainId : parseInt(chainId);
+    const validNetworks = [TRON_NETWORKS.mainnet, TRON_NETWORKS.shasta, TRON_NETWORKS.nile];
+    return validNetworks.includes(networkId);
+  }
+  getChainType(_chainId) {
+    return this.chainType;
+  }
+  // 커넥터 정보
+  getConnectors() {
+    return [
+      {
+        id: "tronlink",
+        name: "TronLink",
+        icon: "https://www.tronlink.org/favicon.ico"
+      }
+    ];
+  }
+  checkWalletInstalled(connectorId) {
+    if (typeof window === "undefined") return false;
+    if (connectorId === "tronlink") {
+      const hasTronLinkAPI = !!window.tronLink;
+      const hasTronWeb = !!window.tronWeb;
+      const isTronLinkProp = window.tronLink?.isTronLink;
+      const hasTronLink = hasTronLinkAPI || hasTronWeb;
+      console.log("[TronWalletAdapter] TronLink detection:", {
+        hasTronLinkAPI,
+        hasTronWeb,
+        isTronLinkProp,
+        hasTrustWallet: this.hasTrustWallet(),
+        result: hasTronLink
+      });
+      return hasTronLink;
+    }
+    return false;
+  }
+};
+
+// src/adapters/WalletAdapterFactory.ts
+var WalletAdapterFactory = class {
+  constructor() {
+    this.evmAdapter = null;
+    this.tronAdapter = null;
+  }
+  // EVM 체인 ID 확인 (숫자 또는 0x로 시작하는 문자열)
+  isEvmChainId(chainId) {
+    if (chainId === "evm") return true;
+    if (typeof chainId === "number") return true;
+    if (typeof chainId === "string") {
+      if (chainId === "mainnet" || chainId === "shasta" || chainId === "nile" || chainId === "tron") {
+        return false;
+      }
+      const numericChainId = Number(chainId);
+      if (!isNaN(numericChainId) && numericChainId > 0) {
+        return true;
+      }
+    }
+    return false;
+  }
+  // Tron 네트워크 확인
+  isTronNetwork(chainId) {
+    if (chainId === "tron") return true;
+    const tronNetworkIds = [728126428, 2494104990, 3448148188];
+    const networkId = typeof chainId === "number" ? chainId : parseInt(chainId);
+    if (tronNetworkIds.includes(networkId)) {
+      return true;
+    }
+    return false;
+  }
+  // EVM 주소 형식 확인 (0x로 시작하는 42자)
+  isEvmAddress(address) {
+    return /^0x[a-fA-F0-9]{40}$/.test(address);
+  }
+  // Tron 주소 형식 확인 (T로 시작하는 34자 Base58)
+  isTronAddress(address) {
+    return /^T[A-Za-z0-9]{33}$/.test(address);
+  }
+  /**
+   * EVM 어댑터 초기화
+   */
+  initializeEvmAdapter(wagmiConfig) {
+    this.evmAdapter = new EvmWalletAdapter(wagmiConfig);
+  }
+  /**
+   * Tron 어댑터 초기화
+   */
+  initializeTronAdapter() {
+    this.tronAdapter = new TronWalletAdapter();
+  }
+  /**
+   * 어댑터 타입으로 어댑터 가져오기
+   */
+  getAdapter(type) {
+    switch (type) {
+      case "evm":
+        return this.evmAdapter;
+      case "tron":
+        return this.tronAdapter;
+      default:
+        return null;
+    }
+  }
+  /**
+   * 체인 ID로 적절한 어댑터 가져오기
+   */
+  getAdapterForChain(chainId) {
+    console.log("testtest get chainId", chainId);
+    if (this.isEvmChainId(chainId)) {
+      return this.evmAdapter;
+    }
+    if (this.isTronNetwork(chainId)) {
+      return this.tronAdapter;
+    }
+    return null;
+  }
+  /**
+   * 입금 주소 형식으로 적절한 어댑터 가져오기
+   * - 0x로 시작 → EVM adapter
+   * - T로 시작 → Tron adapter
+   */
+  getAdapterByAddress(address) {
+    if (this.isEvmAddress(address)) {
+      return this.evmAdapter;
+    }
+    if (this.isTronAddress(address)) {
+      return this.tronAdapter;
+    }
+    console.warn(`[WalletAdapterFactory] Unknown address format: ${address}`);
+    return null;
+  }
+  /**
+   * 주소로부터 체인 타입 결정
+   */
+  getChainTypeByAddress(address) {
+    if (this.isEvmAddress(address)) {
+      return "evm";
+    }
+    if (this.isTronAddress(address)) {
+      return "tron";
+    }
+    return null;
+  }
+  /**
+   * 체인 타입 결정
+   */
+  getChainType(chainId) {
+    if (this.isEvmChainId(chainId)) {
+      return "evm";
+    }
+    if (this.isTronNetwork(chainId)) {
+      return "tron";
+    }
+    throw new Error(`Unsupported chain ID: ${chainId}`);
+  }
+  /**
+   * 모든 어댑터 가져오기
+   */
+  getAllAdapters() {
+    const adapters = [];
+    if (this.evmAdapter) adapters.push(this.evmAdapter);
+    if (this.tronAdapter) adapters.push(this.tronAdapter);
+    return adapters;
+  }
+  /**
+   * 연결된 어댑터 가져오기
+   */
+  getConnectedAdapter() {
+    if (this.evmAdapter?.isConnected()) {
+      return this.evmAdapter;
+    }
+    if (this.tronAdapter?.isConnected()) {
+      return this.tronAdapter;
+    }
+    return null;
+  }
+};
+
+// src/components/WalletProvider.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+var defaultQueryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      refetchOnWindowFocus: false,
+      retry: 3,
+      staleTime: 1e3 * 60 * 5
+      // 5 minutes
+    }
+  }
+});
+var WalletProvider = ({
+  children,
+  projectId,
+  queryClient = defaultQueryClient
+}) => {
+  const wagmiConfig = useMemo2(
+    () => createWagmiConfig(projectId),
+    [projectId]
+  );
+  const adapterFactory = useMemo2(() => {
+    const factory = new WalletAdapterFactory();
+    factory.initializeEvmAdapter(wagmiConfig);
+    factory.initializeTronAdapter();
+    return factory;
+  }, [wagmiConfig]);
+  return /* @__PURE__ */ jsx10(WagmiProvider, { config: wagmiConfig, children: /* @__PURE__ */ jsx10(QueryClientProvider, { client: queryClient, children: /* @__PURE__ */ jsx10(WalletContextProvider, { factory: adapterFactory, children }) }) });
+};
+
+// src/components/PaymentQRCode.tsx
+import { useState as useState9 } from "react";
+import { QRCodeSVG as QRCodeSVG2 } from "qrcode.react";
+
+// src/utils/qrcode.ts
+function generatePaymentQRUrl(publicOrderId) {
+  const sdkConfig = config.getConfig();
+  const environment = sdkConfig.environment || "sandbox";
+  const paymentDomain = PAYMENT_DOMAINS[environment];
+  const domain = paymentDomain.endsWith("/") ? paymentDomain.slice(0, -1) : paymentDomain;
+  return `${domain}/order/${publicOrderId}`;
+}
+function getPaymentDomain() {
+  const sdkConfig = config.getConfig();
+  const environment = sdkConfig.environment || "sandbox";
+  return PAYMENT_DOMAINS[environment];
+}
+
+// src/components/PaymentQRCode.tsx
+import { jsx as jsx11, jsxs as jsxs8 } from "react/jsx-runtime";
+function PaymentQRCode({
+  publicOrderId,
+  size = 200,
+  level = "H",
+  includeMargin = true,
+  className = "",
+  showUrl = false,
+  enableCopy = false,
+  onCopy
+}) {
+  const [copied, setCopied] = useState9(false);
+  const paymentUrl = generatePaymentQRUrl(publicOrderId);
+  const handleCopy = async () => {
+    try {
+      await navigator.clipboard.writeText(paymentUrl);
+      setCopied(true);
+      onCopy?.();
+      setTimeout(() => setCopied(false), 2e3);
+    } catch (error) {
+      console.error("Failed to copy to clipboard:", error);
+    }
+  };
+  return /* @__PURE__ */ jsxs8("div", { className: `payment-qr-code ${className}`, children: [
+    /* @__PURE__ */ jsx11(
+      "div",
+      {
+        style: {
+          padding: "16px",
+          backgroundColor: "white",
+          borderRadius: "8px",
+          display: "inline-block"
+        },
+        children: /* @__PURE__ */ jsx11(
+          QRCodeSVG2,
+          {
+            value: paymentUrl,
+            size,
+            level,
+            includeMargin
+          }
+        )
+      }
+    ),
+    showUrl && /* @__PURE__ */ jsx11(
+      "div",
+      {
+        style: {
+          marginTop: "12px",
+          fontSize: "12px",
+          color: "#666",
+          wordBreak: "break-all"
+        },
+        children: paymentUrl
+      }
+    ),
+    enableCopy && /* @__PURE__ */ jsx11(
+      "button",
+      {
+        onClick: handleCopy,
+        style: {
+          marginTop: "12px",
+          padding: "8px 16px",
+          backgroundColor: copied ? "#22c55e" : "#3b82f6",
+          color: "white",
+          border: "none",
+          borderRadius: "6px",
+          cursor: "pointer",
+          fontSize: "14px",
+          fontWeight: "500"
+        },
+        children: copied ? "Copied!" : "Copy Link"
+      }
+    )
+  ] });
+}
+
+// src/components/PaymentQRModal.tsx
+import { useState as useState10, useEffect as useEffect9 } from "react";
+import { jsx as jsx12, jsxs as jsxs9 } from "react/jsx-runtime";
+function PaymentQRModal({
+  isOpen,
+  onClose,
+  productId,
+  productName,
+  qrSize = 200,
+  className = ""
+}) {
+  const { createOrder: createOrder2 } = usePayment();
+  const [publicOrderId, setPublicOrderId] = useState10(null);
+  const [isLoading, setIsLoading] = useState10(false);
+  const [error, setError] = useState10(null);
+  useEffect9(() => {
+    if (isOpen && !publicOrderId) {
+      const generateOrder = async () => {
+        try {
+          setIsLoading(true);
+          setError(null);
+          const order = await createOrder2({ productId });
+          setPublicOrderId(order.publicOrderId);
+        } catch (err) {
+          setError(err.message || "Failed to create order");
+        } finally {
+          setIsLoading(false);
+        }
+      };
+      generateOrder();
+    }
+  }, [isOpen, productId, publicOrderId, createOrder2]);
+  const handleClose = () => {
+    setPublicOrderId(null);
+    setError(null);
+    onClose();
+  };
+  if (!isOpen) return null;
+  return /* @__PURE__ */ jsx12(
+    "div",
+    {
+      style: {
+        position: "fixed",
+        inset: 0,
+        zIndex: 9999,
+        display: "flex",
+        alignItems: "center",
+        justifyContent: "center",
+        backgroundColor: "rgba(0, 0, 0, 0.5)",
+        padding: "16px"
+      },
+      onClick: onClose,
+      children: /* @__PURE__ */ jsxs9(
+        "div",
+        {
+          className: `payment-qr-modal ${className}`,
+          style: {
+            position: "relative",
+            backgroundColor: "white",
+            borderRadius: "12px",
+            padding: "24px",
+            maxWidth: "400px",
+            width: "100%",
+            boxShadow: "0 20px 25px -5px rgba(0, 0, 0, 0.1)"
+          },
+          onClick: (e) => e.stopPropagation(),
+          children: [
+            /* @__PURE__ */ jsx12(
+              "button",
+              {
+                onClick: handleClose,
+                style: {
+                  position: "absolute",
+                  right: "16px",
+                  top: "16px",
+                  background: "none",
+                  border: "none",
+                  fontSize: "24px",
+                  cursor: "pointer",
+                  color: "#666",
+                  lineHeight: 1,
+                  padding: 0
+                },
+                children: "\u2715"
+              }
+            ),
+            /* @__PURE__ */ jsx12(
+              "h2",
+              {
+                style: {
+                  fontSize: "20px",
+                  fontWeight: "bold",
+                  marginBottom: "8px",
+                  marginTop: 0
+                },
+                children: "Payment QR Code"
+              }
+            ),
+            /* @__PURE__ */ jsx12(
+              "p",
+              {
+                style: {
+                  fontSize: "14px",
+                  color: "#666",
+                  marginBottom: "24px",
+                  marginTop: 0
+                },
+                children: productName ? `Scan this QR code to pay for ${productName}` : "Scan this QR code to complete your payment"
+              }
+            ),
+            isLoading && /* @__PURE__ */ jsx12(
+              "div",
+              {
+                style: {
+                  display: "flex",
+                  justifyContent: "center",
+                  padding: "40px"
+                },
+                children: /* @__PURE__ */ jsx12("p", { style: { color: "#666" }, children: "Creating order..." })
+              }
+            ),
+            error && /* @__PURE__ */ jsx12(
+              "div",
+              {
+                style: {
+                  backgroundColor: "#fee",
+                  color: "#c33",
+                  padding: "12px",
+                  borderRadius: "6px",
+                  marginBottom: "16px"
+                },
+                children: error
+              }
+            ),
+            publicOrderId && !isLoading && !error && /* @__PURE__ */ jsx12("div", { style: { display: "flex", justifyContent: "center" }, children: /* @__PURE__ */ jsx12(
+              PaymentQRCode,
+              {
+                publicOrderId,
+                size: qrSize,
+                level: "H",
+                includeMargin: true,
+                showUrl: true,
+                enableCopy: true
+              }
+            ) })
+          ]
+        }
+      )
+    }
+  );
+}
+
+// src/hooks/useWallet.ts
+var useWallet = () => {
+  const adapter = useWalletAdapter();
+  const walletInfo = adapter.isConnected && adapter.address && typeof adapter.chainId === "number" ? {
+    address: adapter.address,
+    chainId: adapter.chainId,
+    isConnected: adapter.isConnected,
+    connector: adapter.wallet?.connector
+  } : null;
+  const sendPayment = async (tx) => {
+    const result = await adapter.sendPayment({
+      to: tx.to,
+      value: tx.value,
+      chainId: tx.chainId,
+      coinId: tx.coinId,
+      tokenAddress: tx.tokenAddress,
+      decimals: tx.decimals
+    });
+    return {
+      hash: result.hash,
+      success: result.success,
+      error: result.error
+    };
+  };
+  const connectWallet = async (connectorId) => {
+    if (adapter.isConnected) {
+      await adapter.disconnect();
+    }
+    await adapter.connect("evm" /* EVM */, connectorId);
+  };
+  const evmAdapter = adapter.factory.getAdapter("evm" /* EVM */);
+  const evmConnectors = evmAdapter?.getConnectors() || [];
+  return {
+    // Wallet info
+    wallet: walletInfo,
+    address: adapter.address,
+    chainId: typeof adapter.chainId === "number" ? adapter.chainId : null,
+    isConnected: adapter.isConnected,
+    balance: adapter.balance,
+    // Connection actions
+    connect: connectWallet,
+    disconnect: adapter.disconnect,
+    connectors: evmConnectors,
+    // EVM 커넥터만
+    isConnecting: false,
+    // TODO: track loading state
+    // Chain switching
+    switchChain: (chainId) => adapter.switchChain(chainId),
+    // Transaction
+    sendPayment,
+    isSending: adapter.isSending,
+    isConfirming: false,
+    // TODO: track confirmation
+    isConfirmed: false,
+    // TODO: track confirmation
+    txHash: adapter.txHash,
+    // Utilities
+    checkWalletInstalled: (connectorId) => adapter.checkWalletInstalled("evm" /* EVM */, connectorId)
+    // EVM만 체크
+  };
+};
+export {
+  API_ENDPOINTS,
+  ChainType as ChainTypes,
+  DEFAULT_TIMEOUT,
+  ENVIRONMENT_URLS,
+  ERROR_CODES,
+  EvmWalletAdapter,
+  MIN_WITHDRAWAL_AMOUNT,
+  ORDER_EXPIRY_MINUTES,
+  OrderPayment,
+  PAYMENT_DOMAINS,
+  PayWithAddress,
+  PayWithWallet,
+  PaymentButton,
+  PaymentContext,
+  PaymentFlow,
+  PaymentModal,
+  PaymentProvider,
+  PaymentQRCode,
+  PaymentQRModal,
+  SDK_VERSION,
+  SUPPORTED_CHAINS,
+  TRON_NETWORKS,
+  TronWalletAdapter,
+  WalletAdapterFactory,
+  WalletProvider,
+  WalletType as WalletTypes,
+  coins_exports as coinsAPI,
+  config,
+  createWagmiConfig,
+  detectChainType,
+  generatePaymentQRUrl,
+  getChainById,
+  getErrorMessage,
+  getEvmChainById,
+  getPaymentDomain,
+  handleAPIError,
+  isEvmAddress,
+  isTronAddress,
+  isValidAddress,
+  orders_exports as ordersAPI,
+  supportedChains,
+  supportedEvmChains,
+  useOrder,
+  usePayment,
+  useWallet,
+  useWalletAdapter,
+  useWalletContext,
+  validation_exports as validation
+};