coinley-checkout 0.4.5 → 0.4.8

package/dist/coinley-checkout.es.js

@@ -1206,9 +1206,6 @@ function parseUnits(value, unit) {
   }
   return FixedNumber.fromString(value, { decimals, width: 512 }).value;
 }
-function parseEther(ether) {
-  return parseUnits(ether, 18);
-}
 const WordSize = 32;
 const Padding = new Uint8Array(WordSize);
 const passProperties$1 = ["then"];
@@ -7780,46 +7777,6 @@ const TOKEN_CONFIG = {
       symbol: "ALGO",
       isNative: true
     }
-  },
-  DAI: {
-    ethereum: {
-      contractAddress: "0x6B175474E89094C44Da98b954EedeAC495271d0F",
-      decimals: 18,
-      symbol: "DAI"
-    }
-  },
-  FRAX: {
-    ethereum: {
-      contractAddress: "0x853d955aCEf822Db058eb8505911ED77F175b99e",
-      decimals: 18,
-      symbol: "FRAX"
-    },
-    bsc: {
-      contractAddress: "0x90C97F71E18723b0Cf0dfa30ee176Ab653E89F40",
-      decimals: 18,
-      symbol: "FRAX"
-    }
-  },
-  PYUSD: {
-    ethereum: {
-      contractAddress: "0x6c3ea9036406852006290770BEdFcAbA0e23A0e8",
-      decimals: 6,
-      symbol: "PYUSD"
-    }
-  },
-  BUSD: {
-    bsc: {
-      contractAddress: "0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56",
-      decimals: 18,
-      symbol: "BUSD"
-    }
-  },
-  USDJ: {
-    tron: {
-      contractAddress: "TMwFHYXLJaRUPeW6421aqXL4ZEzPRFGkGT",
-      decimals: 18,
-      symbol: "USDJ"
-    }
   }
 };
 const NETWORK_WALLET_MAP = {
@@ -7839,7 +7796,7 @@ const getWalletInstallUrl = (walletType) => {
 };
 const detectWallets = () => {
   const availableWallets = {
-    [WALLET_TYPES.METAMASK]: typeof window !== "undefined" && window.ethereum !== void 0 && window.ethereum.isMetaMask === true,
+    [WALLET_TYPES.METAMASK]: typeof window !== "undefined" && window.ethereum !== void 0,
     [WALLET_TYPES.TRONLINK]: typeof window !== "undefined" && window.tronWeb !== void 0,
     [WALLET_TYPES.TRUST_WALLET]: typeof window !== "undefined" && window.ethereum !== void 0 && window.ethereum.isTrust === true,
     [WALLET_TYPES.LUTE]: typeof window !== "undefined" && window.lute !== void 0
@@ -7881,17 +7838,27 @@ const debugWalletEnvironment = () => {
   const wallets = detectWallets();
   console.log("Detected wallets:", wallets);
 };
+const createEthersValue = (amount, decimals) => {
+  try {
+    return parseUnits(amount.toString(), decimals);
+  } catch (error) {
+    const value = parseFloat(amount) * Math.pow(10, decimals);
+    return {
+      toString: () => value.toLocaleString("fullwide", { useGrouping: false }),
+      toBigInt: () => BigInt(Math.floor(value))
+    };
+  }
+};
 const connectMetamaskWallet = () => __async(void 0, null, function* () {
   console.log("Connecting to MetaMask wallet...");
   if (!window.ethereum || !window.ethereum.isMetaMask) {
+    console.error("MetaMask not found.");
     throw new Error("MetaMask not detected. Please install MetaMask extension.");
   }
   try {
-    const accounts = yield window.ethereum.request({
-      method: "eth_requestAccounts"
-    });
+    const accounts = yield window.ethereum.request({ method: "eth_requestAccounts" });
     if (!accounts || accounts.length === 0) {
-      throw new Error("No accounts found. Please unlock MetaMask.");
+      throw new Error("No accounts found");
     }
     const address = accounts[0];
     const chainIdHex = yield window.ethereum.request({ method: "eth_chainId" });
@@ -7907,8 +7874,7 @@ const connectMetamaskWallet = () => __async(void 0, null, function* () {
       default:
         networkType = `unknown-${chainId}`;
     }
-    const providerWrapper = {
-      request: (params) => window.ethereum.request(params),
+    const simpleProvider = {
       getSigner: () => ({
         getAddress: () => __async(void 0, null, function* () {
           return address;
@@ -7919,9 +7885,9 @@ const connectMetamaskWallet = () => __async(void 0, null, function* () {
             params: [{
               from: address,
               to: tx.to,
-              value: tx.value ? typeof tx.value === "string" ? tx.value : tx.value.toString() : "0x0",
-              gasLimit: tx.gasLimit ? typeof tx.gasLimit === "string" ? tx.gasLimit : tx.gasLimit.toString() : void 0,
-              data: tx.data || "0x"
+              value: tx.value ? tx.value.toString() : "0x0",
+              gasLimit: tx.gasLimit ? tx.gasLimit.toString() : void 0,
+              data: tx.data
             }]
           });
           return { hash: txHash };
@@ -7933,82 +7899,43 @@ const connectMetamaskWallet = () => __async(void 0, null, function* () {
           params: [{
             from: address,
             to: tx.to,
-            value: tx.value ? typeof tx.value === "string" ? tx.value : tx.value.toString() : "0x0",
-            data: tx.data || "0x"
+            value: tx.value ? tx.value.toString() : "0x0"
           }]
         });
-        const gasLimit = parseInt(gasHex, 16);
+        const gasValue = parseInt(gasHex, 16);
         return {
-          toString: () => gasLimit.toString(),
+          toString: () => gasValue.toString(),
           mul: (n2) => ({
             div: (d) => ({
-              toString: () => Math.floor(gasLimit * n2 / d).toString()
+              toString: () => Math.floor(gasValue * n2 / d).toString()
             })
           })
         };
       })
     };
-    console.log("MetaMask connected successfully:", { address, chainId, networkType });
     return {
       walletType: WALLET_TYPES.METAMASK,
       address,
-      provider: providerWrapper,
+      provider: simpleProvider,
       network: networkType,
       isConnected: true,
       chainId
     };
   } catch (error) {
-    console.error("MetaMask connection error:", error);
-    throw error;
-  }
-});
-const connectTronlinkWallet = () => __async(void 0, null, function* () {
-  console.log("Connecting to TronLink wallet...");
-  if (!window.tronWeb) {
-    throw new Error("TronLink not detected. Please install TronLink extension.");
-  }
-  const waitForTronWeb = (maxAttempts = 10, interval = 500) => __async(void 0, null, function* () {
-    for (let attempt = 0; attempt < maxAttempts; attempt++) {
-      if (window.tronWeb && window.tronWeb.ready) {
-        return window.tronWeb;
-      }
-      console.log(`Waiting for TronWeb to be ready... Attempt ${attempt + 1}/${maxAttempts}`);
-      yield new Promise((resolve) => setTimeout(resolve, interval));
-    }
-    throw new Error("TronWeb took too long to be ready");
-  });
-  try {
-    const tronWeb = yield waitForTronWeb();
-    if (!tronWeb.defaultAddress || !tronWeb.defaultAddress.base58) {
-      try {
-        yield window.tronWeb.request({ method: "tron_requestAccounts" });
-      } catch (permissionError) {
-        throw new Error("Please unlock TronLink and approve connection");
-      }
-    }
-    const address = tronWeb.defaultAddress.base58;
-    console.log("TronLink connected successfully:", address);
-    return {
-      walletType: WALLET_TYPES.TRONLINK,
-      address,
-      provider: tronWeb,
-      network: NETWORK_TYPES.TRON,
-      isConnected: true
-    };
-  } catch (error) {
-    console.error("TronLink connection error:", error);
+    console.error("Error connecting to MetaMask:", error);
     throw error;
   }
 });
 const connectTrustWallet = () => __async(void 0, null, function* () {
   console.log("Connecting to Trust Wallet...");
   if (!window.ethereum || !window.ethereum.isTrust) {
+    console.error("Trust Wallet not found.");
     throw new Error("Trust Wallet not detected. Please install Trust Wallet.");
   }
   try {
     const accounts = yield window.ethereum.request({ method: "eth_requestAccounts" });
     if (!accounts || accounts.length === 0) {
-      throw new Error("No accounts found. Please unlock Trust Wallet.");
+      throw new Error("No accounts found");
     }
     const address = accounts[0];
     const chainIdHex = yield window.ethereum.request({ method: "eth_chainId" });
@@ -8024,8 +7951,7 @@ const connectTrustWallet = () => __async(void 0, null, function* () {
       default:
         networkType = `unknown-${chainId}`;
     }
-    const providerWrapper = {
-      request: (params) => window.ethereum.request(params),
+    const simpleProvider = {
       getSigner: () => ({
         getAddress: () => __async(void 0, null, function* () {
           return address;
@@ -8036,9 +7962,9 @@ const connectTrustWallet = () => __async(void 0, null, function* () {
             params: [{
               from: address,
               to: tx.to,
-              value: tx.value ? typeof tx.value === "string" ? tx.value : tx.value.toString() : "0x0",
-              gasLimit: tx.gasLimit ? typeof tx.gasLimit === "string" ? tx.gasLimit : tx.gasLimit.toString() : void 0,
-              data: tx.data || "0x"
+              value: tx.value ? tx.value.toString() : "0x0",
+              gasLimit: tx.gasLimit ? tx.gasLimit.toString() : void 0,
+              data: tx.data
             }]
           });
           return { hash: txHash };
@@ -8050,16 +7976,15 @@ const connectTrustWallet = () => __async(void 0, null, function* () {
           params: [{
             from: address,
             to: tx.to,
-            value: tx.value ? typeof tx.value === "string" ? tx.value : tx.value.toString() : "0x0",
-            data: tx.data || "0x"
+            value: tx.value ? tx.value.toString() : "0x0"
           }]
         });
-        const gasLimit = parseInt(gasHex, 16);
+        const gasValue = parseInt(gasHex, 16);
         return {
-          toString: () => gasLimit.toString(),
+          toString: () => gasValue.toString(),
           mul: (n2) => ({
             div: (d) => ({
-              toString: () => Math.floor(gasLimit * n2 / d).toString()
+              toString: () => Math.floor(gasValue * n2 / d).toString()
             })
           })
         };
@@ -8068,19 +7993,60 @@ const connectTrustWallet = () => __async(void 0, null, function* () {
     return {
       walletType: WALLET_TYPES.TRUST_WALLET,
       address,
-      provider: providerWrapper,
+      provider: simpleProvider,
       network: networkType,
       isConnected: true,
       chainId
     };
   } catch (error) {
-    console.error("Trust Wallet connection error:", error);
+    console.error("Error connecting to Trust Wallet:", error);
+    throw error;
+  }
+});
+const connectTronlinkWallet = () => __async(void 0, null, function* () {
+  console.log("Connecting to TronLink wallet...");
+  if (!window.tronWeb) {
+    console.error("TronWeb not found. Is TronLink installed?");
+    throw new Error("TronLink not detected. Please install TronLink extension.");
+  }
+  const waitForTronWeb = (maxAttempts = 10, interval = 500) => __async(void 0, null, function* () {
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      if (window.tronWeb && window.tronWeb.ready) {
+        return window.tronWeb;
+      }
+      console.log(`Waiting for TronWeb to be ready... Attempt ${attempt + 1}/${maxAttempts}`);
+      yield new Promise((resolve) => setTimeout(resolve, interval));
+    }
+    throw new Error("TronWeb took too long to be ready");
+  });
+  try {
+    const tronWeb = yield waitForTronWeb();
+    if (!tronWeb.defaultAddress || !tronWeb.defaultAddress.base58) {
+      try {
+        yield window.tronWeb.request({ method: "tron_requestAccounts" });
+      } catch (permissionError) {
+        console.error("Failed to get permission from TronLink:", permissionError);
+        throw new Error("Please unlock TronLink and approve connection");
+      }
+    }
+    const address = tronWeb.defaultAddress.base58;
+    console.log("Connected to TronLink wallet:", address);
+    return {
+      walletType: WALLET_TYPES.TRONLINK,
+      address,
+      provider: tronWeb,
+      network: NETWORK_TYPES.TRON,
+      isConnected: true
+    };
+  } catch (error) {
+    console.error("Error connecting to TronLink:", error);
     throw error;
   }
 });
 const connectLuteWallet = () => __async(void 0, null, function* () {
   console.log("Connecting to Lute wallet...");
   if (!window.lute) {
+    console.error("Lute not found.");
     throw new Error("Lute not detected. Please install Lute extension.");
   }
   try {
@@ -8088,7 +8054,7 @@ const connectLuteWallet = () => __async(void 0, null, function* () {
     if (!address) {
       throw new Error("No address returned. Please unlock Lute wallet.");
     }
-    console.log("Lute wallet connected successfully:", address);
+    console.log("Connected to Lute wallet:", address);
     return {
       walletType: WALLET_TYPES.LUTE,
       address,
@@ -8097,66 +8063,39 @@ const connectLuteWallet = () => __async(void 0, null, function* () {
       isConnected: true
     };
   } catch (error) {
-    console.error("Lute wallet connection error:", error);
+    console.error("Error connecting to Lute wallet:", error);
     throw error;
   }
 });
-const connectWallet = (walletType, network, retries = 1) => __async(void 0, null, function* () {
-  console.log("Connecting to wallet:", { walletType, network });
-  for (let attempt = 0; attempt < retries; attempt++) {
-    try {
-      switch (walletType) {
-        case WALLET_TYPES.METAMASK:
-          return yield connectMetamaskWallet();
-        case WALLET_TYPES.TRONLINK:
-          return yield connectTronlinkWallet();
-        case WALLET_TYPES.TRUST_WALLET:
-          return yield connectTrustWallet();
-        case WALLET_TYPES.LUTE:
-          return yield connectLuteWallet();
-        default:
-          throw new Error(`Unsupported wallet type: ${walletType}`);
-      }
-    } catch (error) {
-      console.log(`Wallet connection attempt ${attempt + 1} failed:`, error.message);
-      if (attempt === retries - 1) {
-        throw error;
-      }
-      yield new Promise((resolve) => setTimeout(resolve, 1e3));
-    }
+const connectWallet = (walletType) => __async(void 0, null, function* () {
+  console.log("Connecting to wallet:", walletType);
+  switch (walletType) {
+    case WALLET_TYPES.METAMASK:
+      return connectMetamaskWallet();
+    case WALLET_TYPES.TRONLINK:
+      return connectTronlinkWallet();
+    case WALLET_TYPES.TRUST_WALLET:
+      return connectTrustWallet();
+    case WALLET_TYPES.LUTE:
+      return connectLuteWallet();
+    default:
+      throw new Error(`Unsupported wallet type: ${walletType}`);
   }
 });
 const getSupportedWalletsForNetwork = (network) => {
   return NETWORK_WALLET_MAP[network] || [];
 };
-const sendTransaction = (walletConnection, transactionParams) => __async(void 0, null, function* () {
-  console.log("Sending transaction:", { walletConnection, transactionParams });
-  if (!walletConnection) {
+const sendNativeTransaction = (walletConnection, toAddress, amount) => __async(void 0, null, function* () {
+  console.log("Sending native transaction:", { toAddress, amount });
+  if (!walletConnection || !walletConnection.provider) {
     throw new Error("Wallet not connected");
   }
-  const { to, amount, tokenAddress, tokenDecimals, currency, network, tokenConfig } = transactionParams;
-  if (!to) {
+  if (!toAddress) {
     throw new Error("Recipient address not provided");
   }
   if (!amount || isNaN(parseFloat(amount)) || parseFloat(amount) <= 0) {
     throw new Error("Invalid amount");
   }
-  const isNativeToken = !tokenAddress || tokenAddress === null;
-  if (isNativeToken) {
-    return sendNativeTransaction(walletConnection, to, amount);
-  } else {
-    return sendTokenTransaction(walletConnection, {
-      contractAddress: tokenAddress,
-      decimals: tokenDecimals,
-      symbol: currency
-    }, to, amount);
-  }
-});
-const sendNativeTransaction = (walletConnection, toAddress, amount) => __async(void 0, null, function* () {
-  console.log("Sending native transaction:", { toAddress, amount });
-  if (!walletConnection || !walletConnection.provider) {
-    throw new Error("Wallet not connected");
-  }
   try {
     let transaction;
     switch (walletConnection.walletType) {
@@ -8164,12 +8103,21 @@ const sendNativeTransaction = (walletConnection, toAddress, amount) => __async(v
       case WALLET_TYPES.TRUST_WALLET:
         const provider = walletConnection.provider;
         const signer = provider.getSigner();
-        const amountWei = parseEther ? parseEther(amount.toString()) : (void 0).parseEther(amount.toString());
+        const amountInEther = amount.toString();
+        const amountWei = createEthersValue(amountInEther, 18);
+        console.log("Sending ETH/BNB:", {
+          to: toAddress,
+          value: amountWei.toString()
+        });
         const gasEstimate = yield provider.estimateGas({
           to: toAddress,
           value: amountWei
         });
-        const gasLimit = typeof gasEstimate.mul === "function" ? gasEstimate.mul(110).div(100) : { toString: () => Math.floor(parseInt(gasEstimate.toString()) * 1.1).toString() };
+        console.log("Gas estimate:", gasEstimate.toString());
+        const gasLimit = {
+          toString: () => Math.floor(parseInt(gasEstimate.toString()) * 1.1).toString()
+        };
+        console.log("Using gas limit:", gasLimit.toString());
         transaction = yield signer.sendTransaction({
           to: toAddress,
           value: amountWei,
@@ -8182,11 +8130,22 @@ const sendNativeTransaction = (walletConnection, toAddress, amount) => __async(v
           throw new Error("TronWeb not initialized");
         }
         const amountSun = tronWeb.toSun(amount.toString());
-        transaction = yield tronWeb.trx.sendTransaction(toAddress, amountSun);
+        console.log("Sending TRX:", {
+          to: toAddress,
+          value: amountSun
+        });
+        transaction = yield tronWeb.trx.sendTransaction(
+          toAddress,
+          amountSun
+        );
         break;
       case WALLET_TYPES.LUTE:
         const lute = walletConnection.provider;
         const microAlgos = Math.floor(parseFloat(amount) * 1e6);
+        console.log("Sending Algos:", {
+          to: toAddress,
+          amount: microAlgos
+        });
         transaction = yield lute.sendPayment({
           recipient: toAddress,
           amount: microAlgos
@@ -8195,22 +8154,50 @@ const sendNativeTransaction = (walletConnection, toAddress, amount) => __async(v
       default:
         throw new Error(`Unsupported wallet type: ${walletConnection.walletType}`);
     }
+    console.log("Transaction sent:", transaction);
     const hash = transaction.hash || transaction.txID || transaction.txId || transaction;
-    console.log("Native transaction sent:", hash);
+    console.log("Transaction hash:", hash);
     return hash;
   } catch (error) {
     console.error("Native transaction error:", error);
     throw error;
   }
 });
+const sendTransaction = (walletConnection, transactionDetails) => __async(void 0, null, function* () {
+  var _a2;
+  console.log("Sending transaction with:", transactionDetails);
+  if (!walletConnection) {
+    throw new Error("Wallet not connected");
+  }
+  const { to, amount, tokenAddress, currency, network } = transactionDetails;
+  if (!to) {
+    throw new Error("Recipient address not provided");
+  }
+  const tokenConfig = (_a2 = TOKEN_CONFIG[currency]) == null ? void 0 : _a2[network];
+  if (tokenConfig && tokenConfig.isNative) {
+    return sendNativeTransaction(walletConnection, to, amount);
+  } else if (tokenConfig) {
+    return sendTokenTransaction(walletConnection, tokenConfig, to, amount);
+  } else {
+    return sendNativeTransaction(walletConnection, to, amount);
+  }
+});
 const sendTokenTransaction = (walletConnection, tokenConfig, toAddress, amount) => __async(void 0, null, function* () {
-  console.log("Sending token transaction:", { tokenConfig, toAddress, amount });
+  console.log("Sending token transaction with:", { tokenConfig, toAddress, amount });
   if (!walletConnection || !walletConnection.provider) {
     throw new Error("Wallet not connected");
   }
-  if (!tokenConfig || !tokenConfig.contractAddress) {
-    throw new Error("Token configuration missing");
+  if (!tokenConfig) {
+    throw new Error("Token configuration not provided");
   }
+  if (!toAddress) {
+    throw new Error("Recipient address not provided");
+  }
+  if (!amount || isNaN(parseFloat(amount)) || parseFloat(amount) <= 0) {
+    throw new Error("Invalid amount");
+  }
+  const { contractAddress, decimals, symbol } = tokenConfig;
+  console.log(`Token: ${symbol}, Decimals: ${decimals}, Contract: ${contractAddress}`);
   switch (walletConnection.walletType) {
     case WALLET_TYPES.TRONLINK:
       return sendTRC20Transaction(walletConnection, tokenConfig, toAddress, amount);
@@ -8221,21 +8208,16 @@ const sendTokenTransaction = (walletConnection, tokenConfig, toAddress, amount)
   }
 });
 const sendERC20Transaction = (walletConnection, tokenConfig, toAddress, amount) => __async(void 0, null, function* () {
-  console.log("Sending ERC20/BEP20 transaction:", { tokenConfig, toAddress, amount });
+  console.log("Sending ERC20/BEP20 transaction with:", { tokenConfig, toAddress, amount });
+  if (!walletConnection || !walletConnection.provider) {
+    throw new Error("Wallet not connected");
+  }
   const provider = walletConnection.provider;
   const signer = provider.getSigner();
   const { contractAddress, decimals, symbol } = tokenConfig;
   const tokenAmount = parseFloat(amount);
   const tokenDecimals = parseInt(decimals);
-  let tokenUnits;
-  try {
-    tokenUnits = parseUnits ? parseUnits(tokenAmount.toString(), tokenDecimals) : (void 0).parseUnits(tokenAmount.toString(), tokenDecimals);
-  } catch (err) {
-    const value = tokenAmount * Math.pow(10, tokenDecimals);
-    tokenUnits = {
-      toString: () => value.toLocaleString("fullwide", { useGrouping: false })
-    };
-  }
+  const tokenUnits = createEthersValue(tokenAmount.toString(), tokenDecimals);
   console.log(`Sending ${tokenAmount} ${symbol} (${tokenUnits.toString()} base units) to ${toAddress}`);
   try {
     const tokenContract = new Contract(
@@ -8243,13 +8225,28 @@ const sendERC20Transaction = (walletConnection, tokenConfig, toAddress, amount)
       ["function transfer(address to, uint256 amount) returns (bool)"],
       signer
     );
-    const gasMultiplier = symbol === "USDC" ? 1.5 : 1.2;
-    const transaction = yield tokenContract.transfer(toAddress, tokenUnits, {
-      gasLimit: Math.floor(2e5 * gasMultiplier)
-      // Fixed gas limit with multiplier
-    });
-    console.log("ERC20 transaction sent:", transaction);
-    return transaction.hash;
+    try {
+      const gasEstimate = yield tokenContract.transfer.estimateGas(toAddress, tokenUnits);
+      console.log("Gas estimate:", gasEstimate.toString());
+      const gasLimit = symbol === "USDC" ? Math.floor(parseInt(gasEstimate.toString()) * 1.2).toString() : Math.floor(parseInt(gasEstimate.toString()) * 1.1).toString();
+      console.log("Using gas limit:", gasLimit);
+      const transaction = yield tokenContract.transfer(toAddress, tokenUnits, {
+        gasLimit
+      });
+      console.log("Transaction sent:", transaction);
+      return transaction.hash;
+    } catch (gasError) {
+      console.error("Gas estimation failed:", gasError);
+      if (symbol === "USDC") {
+        console.log("Trying USDC transaction with fixed gas limit");
+        const transaction = yield tokenContract.transfer(toAddress, tokenUnits, {
+          gasLimit: 15e4
+        });
+        console.log("Transaction sent with fixed gas limit:", transaction);
+        return transaction.hash;
+      }
+      throw new Error(`Transaction would likely fail: ${gasError.message}`);
+    }
   } catch (error) {
     console.error("ERC20 transaction error:", error);
     if (error.message && error.message.includes("user rejected")) {
@@ -8262,16 +8259,23 @@ const sendERC20Transaction = (walletConnection, tokenConfig, toAddress, amount)
   }
 });
 const sendTRC20Transaction = (walletConnection, tokenConfig, toAddress, amount) => __async(void 0, null, function* () {
-  console.log("Sending TRC20 transaction:", { tokenConfig, toAddress, amount });
+  console.log("Sending TRC20 transaction with:", { tokenConfig, toAddress, amount });
+  if (!walletConnection || !walletConnection.provider) {
+    throw new Error("Tron wallet not connected");
+  }
   const tronWeb = walletConnection.provider;
   if (!tronWeb || !tronWeb.ready) {
     throw new Error("TronWeb not initialized");
   }
+  if (!tokenConfig || !tokenConfig.contractAddress) {
+    throw new Error("Invalid token configuration");
+  }
   const { contractAddress, decimals, symbol } = tokenConfig;
   const tokenAmount = parseFloat(amount);
   const tokenDecimals = parseInt(decimals);
-  const amountWithDecimals = Math.floor(tokenAmount * Math.pow(10, tokenDecimals));
-  console.log(`Sending ${tokenAmount} ${symbol} (${amountWithDecimals} base units) to ${toAddress}`);
+  const amountWithDecimals = tokenAmount * Math.pow(10, tokenDecimals);
+  const amountString = amountWithDecimals.toString();
+  console.log(`Sending ${tokenAmount} ${symbol} (${amountString} base units) to ${toAddress}`);
   try {
     const contract = yield tronWeb.contract().at(contractAddress);
     if (!contract.transfer) {
@@ -8279,10 +8283,9 @@ const sendTRC20Transaction = (walletConnection, tokenConfig, toAddress, amount)
     }
     const transaction = yield contract.transfer(
       toAddress,
-      amountWithDecimals.toString()
+      amountString
     ).send({
       feeLimit: 1e8,
-      // 100 TRX fee limit
       callValue: 0,
       shouldPollResponse: false
     });
@@ -8294,14 +8297,22 @@ const sendTRC20Transaction = (walletConnection, tokenConfig, toAddress, amount)
       throw new Error("Transaction rejected by user");
     } else if (error.message && error.message.includes("bandwidth")) {
       throw new Error("Insufficient energy or bandwidth. Make sure you have enough TRX for fees.");
+    } else if (error.message && error.message.includes("balance")) {
+      throw new Error("Insufficient token balance for transfer");
     } else {
       throw new Error(`Transaction failed: ${error.message || "Unknown error"}`);
     }
   }
 });
 const sendAlgorandAssetTransaction = (walletConnection, tokenConfig, toAddress, amount) => __async(void 0, null, function* () {
-  console.log("Sending Algorand asset transaction:", { tokenConfig, toAddress, amount });
+  console.log("Sending Algorand asset transaction with:", { tokenConfig, toAddress, amount });
+  if (!walletConnection || !walletConnection.provider) {
+    throw new Error("Algorand wallet not connected");
+  }
   const lute = walletConnection.provider;
+  if (!tokenConfig || !tokenConfig.assetId) {
+    throw new Error("Invalid token configuration - missing assetId");
+  }
   const { assetId, decimals, symbol } = tokenConfig;
   const tokenAmount = parseFloat(amount);
   const tokenDecimals = parseInt(decimals);
@@ -8319,6 +8330,8 @@ const sendAlgorandAssetTransaction = (walletConnection, tokenConfig, toAddress,
     console.error("Algorand asset transaction error:", error);
     if (error.message && error.message.includes("rejected")) {
       throw new Error("Transaction rejected by user");
+    } else if (error.message && error.message.includes("balance")) {
+      throw new Error("Insufficient asset balance");
     } else {
       throw error;
     }
@@ -8328,78 +8341,87 @@ let apiConfig = {
   apiKey: null,
   apiSecret: null,
   apiUrl: "https://coinleyserver-production.up.railway.app",
-  merchantWalletAddresses: {}
+  merchantWalletAddresses: {},
+  authToken: null
 };
-const initializeApi = (config) => {
+const initializeApi = (config) => __async(void 0, null, function* () {
   apiConfig = __spreadValues(__spreadValues({}, apiConfig), config);
   console.log("API initialized with:", {
     apiUrl: apiConfig.apiUrl,
     apiKey: apiConfig.apiKey ? `${apiConfig.apiKey.substring(0, 6)}...` : null,
     hasWalletAddresses: Object.keys(apiConfig.merchantWalletAddresses || {}).length > 0
   });
-  if (apiConfig.apiKey && apiConfig.apiSecret) {
-    fetchMerchantWalletAddresses().then((wallets) => {
-      if (wallets) {
-        apiConfig.merchantWalletAddresses = __spreadValues(__spreadValues({}, apiConfig.merchantWalletAddresses), wallets);
-        console.log("Auto-fetched merchant wallet addresses:", wallets);
-      }
-    }).catch((err) => {
-      console.warn("Could not auto-fetch merchant wallet addresses:", err.message);
-    });
+  try {
+    yield authenticateAndFetchWallets();
+  } catch (error) {
+    console.error("Failed to fetch merchant wallets during initialization:", error);
   }
-};
-const getHeaders = () => {
-  return {
-    "Content-Type": "application/json",
-    "x-api-key": apiConfig.apiKey,
-    "x-api-secret": apiConfig.apiSecret
-  };
-};
-const fetchMerchantWalletAddresses = () => __async(void 0, null, function* () {
+});
+const authenticateAndFetchWallets = () => __async(void 0, null, function* () {
   try {
-    const response = yield fetch(`${apiConfig.apiUrl}/api/merchants/wallets`, {
+    console.log("Authenticating and fetching merchant wallets...");
+    const tempToken = btoa(`${apiConfig.apiKey}:${apiConfig.apiSecret}`);
+    const response = yield fetch(`${apiConfig.apiUrl}/api/merchants/dashboard`, {
       method: "GET",
-      headers: getHeaders()
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${tempToken}`,
+        "x-api-key": apiConfig.apiKey,
+        "x-api-secret": apiConfig.apiSecret
+      }
     });
-    if (!response.ok) {
-      throw new Error(`Failed to fetch wallet addresses: ${response.status}`);
-    }
-    const data = yield response.json();
-    const walletAddresses = {};
-    if (data.success && data.wallets) {
-      data.wallets.forEach((wallet) => {
-        if (wallet.walletAddress && wallet.networkShortName) {
-          walletAddresses[wallet.networkShortName] = wallet.walletAddress;
+    if (response.ok) {
+      const data = yield response.json();
+      console.log("Merchant dashboard data received:", data);
+      if (data.merchant) {
+        const walletAddresses = {};
+        if (data.merchant.walletAddress) {
+          walletAddresses.ethereum = data.merchant.walletAddress;
         }
-      });
+        if (data.merchant.solWalletAddress) {
+          walletAddresses.solana = data.merchant.solWalletAddress;
+        }
+        if (data.merchant.merchantWallets) {
+          Object.assign(walletAddresses, data.merchant.merchantWallets);
+        }
+        apiConfig.merchantWalletAddresses = walletAddresses;
+        console.log("Merchant wallet addresses retrieved:", walletAddresses);
+        return walletAddresses;
+      }
+    } else {
+      console.error("Failed to fetch merchant dashboard:", response.status);
     }
-    return walletAddresses;
   } catch (error) {
-    console.error("Error fetching merchant wallet addresses:", error);
-    throw error;
+    console.error("Error fetching merchant wallets:", error);
+  }
+  return {};
+});
+const getMerchantWallets = () => __async(void 0, null, function* () {
+  if (Object.keys(apiConfig.merchantWalletAddresses).length === 0) {
+    yield authenticateAndFetchWallets();
   }
+  return apiConfig.merchantWalletAddresses;
 });
+const getHeaders = () => {
+  return {
+    "Content-Type": "application/json",
+    "x-api-key": apiConfig.apiKey,
+    "x-api-secret": apiConfig.apiSecret,
+    "Authorization": apiConfig.authToken ? `Bearer ${apiConfig.authToken}` : void 0
+  };
+};
 const createPayment = (paymentData) => __async(void 0, null, function* () {
   try {
     console.log("Creating payment with data:", paymentData);
     if (!paymentData.amount) {
       throw new Error("Payment amount is required");
     }
-    let merchantWallets = apiConfig.merchantWalletAddresses || {};
-    if (Object.keys(merchantWallets).length === 0) {
-      try {
-        merchantWallets = yield fetchMerchantWalletAddresses();
-        apiConfig.merchantWalletAddresses = merchantWallets;
-      } catch (fetchError) {
-        console.warn("Could not fetch merchant wallet addresses:", fetchError.message);
-      }
-    }
+    const merchantWallets = yield getMerchantWallets();
+    console.log("Using merchant wallets:", merchantWallets);
     const enhancedPaymentData = __spreadProps(__spreadValues({}, paymentData), {
       merchantWalletAddresses: __spreadValues(__spreadValues({}, merchantWallets), paymentData.merchantWalletAddresses)
     });
-    console.log("Enhanced payment data:", __spreadProps(__spreadValues({}, enhancedPaymentData), {
-      merchantWalletAddresses: enhancedPaymentData.merchantWalletAddresses
-    }));
+    console.log("Enhanced payment data:", enhancedPaymentData);
     const response = yield fetch(`${apiConfig.apiUrl}/api/payments/create`, {
       method: "POST",
       headers: getHeaders(),
@@ -8417,10 +8439,7 @@ const createPayment = (paymentData) => __async(void 0, null, function* () {
       throw new Error(errorData.error || `Failed to create payment: ${response.status}`);
     }
     const data = yield response.json();
-    console.log("Create payment response data:", data);
-    if (data.merchantConfig && data.merchantConfig.walletAddresses) {
-      apiConfig.merchantWalletAddresses = __spreadValues(__spreadValues({}, apiConfig.merchantWalletAddresses), data.merchantConfig.walletAddresses);
-    }
+    console.log("Payment created successfully:", data);
     return data;
   } catch (error) {
     console.error("Create payment error:", error);
@@ -8449,9 +8468,6 @@ const getPayment = (paymentId) => __async(void 0, null, function* () {
     }
     const data = yield response.json();
     console.log("Get payment response:", data);
-    if (data.payment && data.payment.merchantWallets) {
-      apiConfig.merchantWalletAddresses = __spreadValues(__spreadValues({}, apiConfig.merchantWalletAddresses), data.payment.merchantWallets);
-    }
     return data;
   } catch (error) {
     console.error("Get payment error:", error);
@@ -8513,41 +8529,6 @@ const getSupportedNetworks = () => __async(void 0, null, function* () {
     throw error;
   }
 });
-const getMerchantProfile = () => __async(void 0, null, function* () {
-  try {
-    const response = yield fetch(`${apiConfig.apiUrl}/api/merchants/dashboard`, {
-      method: "GET",
-      headers: getHeaders()
-    });
-    if (!response.ok) {
-      let errorData;
-      try {
-        errorData = yield response.json();
-      } catch (e) {
-        throw new Error(`Failed to get merchant profile: ${response.status} ${response.statusText}`);
-      }
-      throw new Error(errorData.error || `Failed to get merchant profile: ${response.status}`);
-    }
-    const data = yield response.json();
-    if (data.merchant) {
-      const walletAddresses = {};
-      if (data.merchant.walletAddress) {
-        walletAddresses.ethereum = data.merchant.walletAddress;
-      }
-      if (data.merchant.solWalletAddress) {
-        walletAddresses.solana = data.merchant.solWalletAddress;
-      }
-      if (data.merchant.merchantWallets) {
-        Object.assign(walletAddresses, data.merchant.merchantWallets);
-      }
-      apiConfig.merchantWalletAddresses = __spreadValues(__spreadValues({}, apiConfig.merchantWalletAddresses), walletAddresses);
-    }
-    return data;
-  } catch (error) {
-    console.error("Get merchant profile error:", error);
-    throw error;
-  }
-});
 const validateWalletAddress = (address, network) => __async(void 0, null, function* () {
   try {
     const response = yield fetch(`${apiConfig.apiUrl}/api/wallets/validate`, {
@@ -8571,12 +8552,6 @@ const validateWalletAddress = (address, network) => __async(void 0, null, functi
     throw error;
   }
 });
-const getApiConfig = () => {
-  return __spreadProps(__spreadValues({}, apiConfig), {
-    // Return a copy to prevent external modification
-    merchantWalletAddresses: __spreadValues({}, apiConfig.merchantWalletAddresses)
-  });
-};
 const generateMockTransactionHash = (network = "ethereum") => {
   const prefixes = {
     ethereum: "0x",
@@ -8639,45 +8614,55 @@ const CoinleyProvider = ({
   apiSecret,
   apiUrl = "https://coinleyserver-production.up.railway.app",
   merchantWalletAddress = null,
-  // New prop for merchant wallet address
+  // Legacy prop for backward compatibility
   merchantSolWalletAddress = null,
-  // New prop for Solana wallet address
+  // Legacy prop for backward compatibility
   debug = false,
   children
 }) => {
   const [isInitialized, setIsInitialized] = useState(false);
   const [error, setError] = useState(null);
   const [paymentData, setPaymentData] = useState(null);
+  const [merchantWallets, setMerchantWallets] = useState({});
   useEffect(() => {
     if (!apiKey || !apiSecret) {
       setError("API key and secret are required");
       return;
     }
-    try {
-      initializeApi({
-        apiKey,
-        apiSecret,
-        apiUrl,
-        merchantWalletAddress,
-        // Pass wallet address to API service
-        merchantSolWalletAddress
-      });
-      setIsInitialized(true);
-      if (debug) {
-        console.log("Coinley SDK initialized with:", {
+    const initializeSDK = () => __async(void 0, null, function* () {
+      try {
+        yield initializeApi({
           apiKey,
+          apiSecret,
           apiUrl,
-          merchantWalletAddress: merchantWalletAddress ? `${merchantWalletAddress.substring(0, 6)}...${merchantWalletAddress.substring(merchantWalletAddress.length - 4)}` : "Not provided",
-          merchantSolWalletAddress: merchantSolWalletAddress ? `${merchantSolWalletAddress.substring(0, 6)}...${merchantSolWalletAddress.substring(merchantSolWalletAddress.length - 4)}` : "Not provided"
+          debug
         });
+        const wallets = yield getMerchantWallets();
+        const allWallets = __spreadValues(__spreadValues(__spreadValues({}, wallets), merchantWalletAddress && { ethereum: merchantWalletAddress }), merchantSolWalletAddress && { solana: merchantSolWalletAddress });
+        setMerchantWallets(allWallets);
+        setIsInitialized(true);
+        if (debug) {
+          console.log("Coinley SDK initialized successfully with wallets:", allWallets);
+        }
+      } catch (err) {
+        setError(err.message);
+        if (debug) {
+          console.error("Coinley SDK initialization error:", err);
+        }
       }
+    });
+    initializeSDK();
+  }, [apiKey, apiSecret, apiUrl, merchantWalletAddress, merchantSolWalletAddress, debug]);
+  const refreshMerchantWallets = () => __async(void 0, null, function* () {
+    try {
+      const wallets = yield getMerchantWallets();
+      setMerchantWallets(wallets);
+      return wallets;
     } catch (err) {
-      setError(err.message);
-      if (debug) {
-        console.error("Coinley SDK initialization error:", err);
-      }
+      console.error("Failed to refresh merchant wallets:", err);
+      return merchantWallets;
     }
-  }, [apiKey, apiSecret, apiUrl, merchantWalletAddress, merchantSolWalletAddress, debug]);
+  });
   const storePaymentData = (data) => {
     setPaymentData(data);
     return data;
@@ -8687,12 +8672,17 @@ const CoinleyProvider = ({
     apiSecret,
     apiUrl,
     merchantWalletAddress,
+    // Legacy
     merchantSolWalletAddress,
+    // Legacy
+    merchantWallets,
+    // New: All merchant wallets
     isInitialized,
     error,
     debug,
     paymentData,
-    storePaymentData
+    storePaymentData,
+    refreshMerchantWallets
   };
   return /* @__PURE__ */ jsxRuntimeExports.jsx(CoinleyContext.Provider, { value, children });
 };
@@ -10734,6 +10724,7 @@ const CoinleyCheckout = forwardRef(({
   customerEmail,
   merchantName = "Merchant",
   merchantWalletAddresses = {},
+  // This will be overridden by backend data
   onSuccess,
   onError,
   onClose,
@@ -10756,31 +10747,34 @@ const CoinleyCheckout = forwardRef(({
   const [walletConnection, setWalletConnection] = useState(null);
   const [availableWallets, setAvailableWallets] = useState({});
   const [step, setStep] = useState("select-currency");
-  const [merchantWallets, setMerchantWallets] = useState({});
-  const [isLoadingWallets, setIsLoadingWallets] = useState(false);
+  const [actualMerchantWallets, setActualMerchantWallets] = useState({});
   const effectiveApiKey = apiKey || (coinleyContext == null ? void 0 : coinleyContext.apiKey);
   const effectiveApiSecret = apiSecret || (coinleyContext == null ? void 0 : coinleyContext.apiSecret);
   apiUrl || (coinleyContext == null ? void 0 : coinleyContext.apiUrl);
   const effectiveTheme = theme || contextTheme;
   const effectiveDebug = debug || (coinleyContext == null ? void 0 : coinleyContext.debug);
   const effectiveSupportedNetworks = supportedNetworks.length > 0 ? supportedNetworks : [NETWORK_TYPES.ETHEREUM, NETWORK_TYPES.BSC, NETWORK_TYPES.TRON, NETWORK_TYPES.ALGORAND];
-  useImperativeHandle(ref, () => ({
-    open: (paymentDetails) => {
-      handleOpen(paymentDetails);
-    },
-    close: () => {
-      handleClose();
-    },
-    getPayment: () => payment,
-    getWalletConnection: () => walletConnection,
-    getMerchantWallets: () => merchantWallets,
-    debugWallets: () => debugWalletEnvironment()
-  }));
   const log = (message, data) => {
     if (effectiveDebug) {
       console.log(`[Coinley SDK] ${message}`, data);
     }
   };
+  useEffect(() => {
+    const fetchMerchantWallets = () => __async(void 0, null, function* () {
+      try {
+        log("Fetching merchant wallet addresses from backend...");
+        const wallets = yield getMerchantWallets();
+        setActualMerchantWallets(wallets);
+        log("Merchant wallets fetched successfully:", wallets);
+      } catch (error2) {
+        console.error("Failed to fetch merchant wallets:", error2);
+        setActualMerchantWallets(merchantWalletAddresses);
+      }
+    });
+    if (effectiveApiKey && effectiveApiSecret) {
+      fetchMerchantWallets();
+    }
+  }, [effectiveApiKey, effectiveApiSecret, merchantWalletAddresses]);
   useEffect(() => {
     if (typeof window !== "undefined") {
       const detectWalletsAsync = () => __async(void 0, null, function* () {
@@ -10791,44 +10785,18 @@ const CoinleyCheckout = forwardRef(({
       detectWalletsAsync();
     }
   }, [effectiveDebug]);
-  useEffect(() => {
-    const loadMerchantWallets = () => __async(void 0, null, function* () {
-      if (!effectiveApiKey || !effectiveApiSecret) {
-        log("No API credentials available for wallet address fetching");
-        return;
-      }
-      setIsLoadingWallets(true);
-      try {
-        const apiConfig2 = getApiConfig();
-        if (apiConfig2.merchantWalletAddresses && Object.keys(apiConfig2.merchantWalletAddresses).length > 0) {
-          setMerchantWallets(apiConfig2.merchantWalletAddresses);
-          log("Loaded wallet addresses from API config:", apiConfig2.merchantWalletAddresses);
-        } else {
-          const walletAddresses = yield fetchMerchantWalletAddresses();
-          if (walletAddresses && Object.keys(walletAddresses).length > 0) {
-            setMerchantWallets(walletAddresses);
-            log("Fetched wallet addresses from API:", walletAddresses);
-          } else {
-            log("No wallet addresses found in API response");
-          }
-        }
-        if (merchantWalletAddresses && Object.keys(merchantWalletAddresses).length > 0) {
-          setMerchantWallets((prev) => __spreadValues(__spreadValues({}, prev), merchantWalletAddresses));
-          log("Added manual wallet addresses:", merchantWalletAddresses);
-        }
-      } catch (error2) {
-        log("Error loading merchant wallet addresses:", error2);
-        console.warn("Could not load merchant wallet addresses:", error2.message);
-        if (merchantWalletAddresses && Object.keys(merchantWalletAddresses).length > 0) {
-          setMerchantWallets(merchantWalletAddresses);
-          log("Using fallback manual wallet addresses:", merchantWalletAddresses);
-        }
-      } finally {
-        setIsLoadingWallets(false);
-      }
-    });
-    loadMerchantWallets();
-  }, [effectiveApiKey, effectiveApiSecret, merchantWalletAddresses, effectiveDebug]);
+  useImperativeHandle(ref, () => ({
+    open: (paymentDetails) => {
+      handleOpen(paymentDetails);
+    },
+    close: () => {
+      handleClose();
+    },
+    getPayment: () => payment,
+    getWalletConnection: () => walletConnection,
+    debugWallets: () => debugWalletEnvironment(),
+    getMerchantWallets: () => actualMerchantWallets
+  }));
   const handleOpen = (paymentDetails) => __async(void 0, null, function* () {
     if (!paymentDetails || !paymentDetails.amount) {
       setError("Payment amount is required");
@@ -10841,26 +10809,13 @@ const CoinleyCheckout = forwardRef(({
     setStep("select-currency");
     try {
       log("Creating payment with details:", paymentDetails);
-      let finalWalletAddresses = __spreadValues({}, merchantWallets);
-      if (Object.keys(finalWalletAddresses).length === 0) {
-        log("No wallet addresses available, attempting to fetch...");
-        try {
-          const fetchedWallets = yield fetchMerchantWalletAddresses();
-          if (fetchedWallets) {
-            finalWalletAddresses = fetchedWallets;
-            setMerchantWallets(fetchedWallets);
-          }
-        } catch (fetchError) {
-          log("Failed to fetch wallet addresses:", fetchError);
-        }
-      }
-      if (paymentDetails.merchantWalletAddresses) {
-        finalWalletAddresses = __spreadValues(__spreadValues({}, finalWalletAddresses), paymentDetails.merchantWalletAddresses);
-      }
-      if (merchantWalletAddresses) {
-        finalWalletAddresses = __spreadValues(__spreadValues({}, finalWalletAddresses), merchantWalletAddresses);
+      let walletAddresses = actualMerchantWallets;
+      if (Object.keys(walletAddresses).length === 0) {
+        log("No wallet addresses found, fetching from backend...");
+        walletAddresses = yield getMerchantWallets();
+        setActualMerchantWallets(walletAddresses);
       }
-      log("Final wallet addresses for payment:", finalWalletAddresses);
+      log("Using wallet addresses:", walletAddresses);
       const paymentResponse = yield createPayment({
         amount: paymentDetails.amount,
         currency: paymentDetails.currency || "USDT",
@@ -10868,24 +10823,15 @@ const CoinleyCheckout = forwardRef(({
         customerEmail: paymentDetails.customerEmail || customerEmail,
         callbackUrl: paymentDetails.callbackUrl,
         metadata: __spreadProps(__spreadValues({}, paymentDetails.metadata), {
-          sdkVersion: "1.0.0",
-          merchantWallets: finalWalletAddresses
+          merchantWalletAddresses: walletAddresses
         }),
-        merchantWalletAddresses: finalWalletAddresses
+        merchantWalletAddresses: walletAddresses
       });
       log("Payment created:", paymentResponse);
-      if (paymentResponse.payment) {
-        setPayment(paymentResponse.payment);
-        if (paymentResponse.merchantConfig && paymentResponse.merchantConfig.walletAddresses) {
-          setMerchantWallets((prev) => __spreadValues(__spreadValues({}, prev), paymentResponse.merchantConfig.walletAddresses));
-          log("Updated wallet addresses from payment response:", paymentResponse.merchantConfig.walletAddresses);
-        }
-        setPaymentStatus("idle");
-        setError(null);
-      } else {
-        throw new Error("Invalid payment response structure");
-      }
-      log("Payment created and state updated successfully");
+      setPayment(paymentResponse.payment);
+      setPaymentStatus("idle");
+      setError(null);
+      log("Payment created and state updated");
     } catch (err) {
       log("Error creating payment:", err);
       setError(err.message || "Failed to create payment");
@@ -10900,67 +10846,60 @@ const CoinleyCheckout = forwardRef(({
     setWalletConnection(null);
     setSelectedPaymentMethod(null);
     setStep("select-currency");
-    setError(null);
     if (onClose)
       onClose();
   };
   const handlePaymentMethodSelect = (paymentMethod) => {
+    console.log("=== PAYMENT METHOD SELECTION DEBUG ===");
+    console.log("1. Payment method selected:", paymentMethod);
+    console.log("2. Current step before:", step);
     log("Payment method selected:", paymentMethod);
     setSelectedPaymentMethod(paymentMethod);
     setStep("confirm");
+    console.log("3. Step should now be: confirm");
+    console.log("=== END PAYMENT METHOD SELECTION DEBUG ===");
   };
   const handleBack = () => {
     if (step === "confirm") {
       setStep("select-currency");
       setWalletConnection(null);
-      setError(null);
     } else if (step === "error") {
       setStep("confirm");
-      setError(null);
     }
   };
   const handleConnectWallet = (walletType) => __async(void 0, null, function* () {
+    console.log("=== WALLET CONNECTION DEBUG ===");
+    console.log("1. Wallet type requested:", walletType);
+    console.log("2. Selected payment method:", selectedPaymentMethod);
+    console.log("3. Available wallets:", availableWallets);
+    console.log("4. Current step:", step);
     if (!selectedPaymentMethod) {
+      console.error("No payment method selected");
       setError("Please select a payment method first");
       return;
     }
     try {
+      console.log("5. Attempting to connect wallet...");
       setError(null);
       log("Connecting wallet:", { walletType, network: selectedPaymentMethod.network });
       const connection = yield connectWallet(walletType, selectedPaymentMethod.network, 2);
       setWalletConnection(connection);
       setError(null);
+      console.log("6. Connection successful:", connection);
       log("Wallet connected successfully:", connection);
     } catch (err) {
+      console.error("7. Connection failed:", err);
       log("Wallet connection error:", err);
       setError(err.message || "Failed to connect wallet");
     }
+    console.log("=== END WALLET CONNECTION DEBUG ===");
   });
-  const getRecipientAddress = () => {
-    if (!selectedPaymentMethod)
-      return null;
-    const network = selectedPaymentMethod.network;
-    if (payment && payment.recipientWallet) {
-      return payment.recipientWallet;
-    }
-    if (merchantWallets[network]) {
-      return merchantWallets[network];
-    }
-    if (merchantWalletAddresses[network]) {
-      return merchantWalletAddresses[network];
-    }
-    return null;
-  };
   const handlePayment = () => __async(void 0, null, function* () {
+    var _a2, _b;
     if (!payment || !selectedPaymentMethod) {
       setError("Missing payment information");
       return;
     }
-    const recipientAddress = getRecipientAddress();
-    if (!recipientAddress && !testMode) {
-      setError(`No recipient wallet address configured for ${selectedPaymentMethod.network} network`);
-      return;
-    }
     if (!walletConnection && !testMode) {
       setError("Please connect your wallet first");
       return;
@@ -10975,20 +10914,23 @@ const CoinleyCheckout = forwardRef(({
         log("Test mode: Generating mock transaction...");
         txHash = `test_${Date.now().toString(16)}_${Math.random().toString(16).substring(2, 10)}`;
       } else {
-        log("Sending transaction through wallet...", {
-          recipientAddress,
-          amount: payment.totalAmount || payment.amount,
-          network: selectedPaymentMethod.network
-        });
-        const tokenConfig = payment.token || selectedPaymentMethod.tokenConfig;
+        let merchantAddress;
+        if (payment.recipientWallet) {
+          merchantAddress = payment.recipientWallet;
+        } else if (actualMerchantWallets[selectedPaymentMethod.network]) {
+          merchantAddress = actualMerchantWallets[selectedPaymentMethod.network];
+        } else {
+          throw new Error(`No merchant wallet address found for ${selectedPaymentMethod.network} network`);
+        }
+        log("Using merchant address for payment:", merchantAddress);
+        log("Sending transaction through wallet...");
         txHash = yield sendTransaction(walletConnection, {
-          to: recipientAddress,
+          to: merchantAddress,
           amount: payment.totalAmount || payment.amount,
-          tokenAddress: tokenConfig == null ? void 0 : tokenConfig.contractAddress,
-          tokenDecimals: tokenConfig == null ? void 0 : tokenConfig.decimals,
+          tokenAddress: (_a2 = selectedPaymentMethod.tokenConfig) == null ? void 0 : _a2.address,
+          tokenDecimals: (_b = selectedPaymentMethod.tokenConfig) == null ? void 0 : _b.decimals,
           currency: selectedPaymentMethod.currency,
-          network: selectedPaymentMethod.network,
-          tokenConfig
+          network: selectedPaymentMethod.network
         });
       }
       log("Transaction hash:", txHash);
@@ -11009,27 +10951,16 @@ const CoinleyCheckout = forwardRef(({
         onSuccess(payment.id, txHash, {
           network: selectedPaymentMethod.network,
           currency: selectedPaymentMethod.currency,
-          amount: payment.totalAmount || payment.amount,
-          recipientAddress
+          amount: payment.totalAmount || payment.amount
         });
       }
     } catch (err) {
       log("Payment error:", err);
-      let errorMessage = err.message || "Failed to process payment";
-      if (errorMessage.includes("User rejected") || errorMessage.includes("user rejected")) {
-        errorMessage = "Transaction was rejected by user";
-      } else if (errorMessage.includes("insufficient funds")) {
-        errorMessage = "Insufficient funds in wallet";
-      } else if (errorMessage.includes("network")) {
-        errorMessage = "Network error. Please check your connection and try again";
-      } else if (errorMessage.includes("recipient") || errorMessage.includes("address")) {
-        errorMessage = "Invalid recipient address. Please contact support";
-      }
-      setError(errorMessage);
+      setError(err.message || "Failed to process payment");
       setPaymentStatus("error");
       setStep("error");
       if (onError)
-        onError(new Error(errorMessage));
+        onError(err);
     }
   });
   const getSupportedWallets = () => {
@@ -11037,12 +10968,6 @@ const CoinleyCheckout = forwardRef(({
       return [];
     return getSupportedWalletsForNetwork(selectedPaymentMethod.network);
   };
-  if (isLoadingWallets) {
-    return /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "fixed inset-0 z-50 flex items-center justify-center bg-black/50", children: /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "bg-white p-6 rounded-lg shadow-xl", children: /* @__PURE__ */ jsxRuntimeExports.jsxs("div", { className: "flex items-center space-x-3", children: [
-      /* @__PURE__ */ jsxRuntimeExports.jsx("div", { className: "animate-spin rounded-full h-6 w-6 border-2 border-blue-500 border-t-transparent" }),
-      /* @__PURE__ */ jsxRuntimeExports.jsx("span", { className: "text-gray-700", children: "Loading payment gateway..." })
-    ] }) }) });
-  }
   return /* @__PURE__ */ jsxRuntimeExports.jsx(jsxRuntimeExports.Fragment, { children: isOpen && /* @__PURE__ */ jsxRuntimeExports.jsx(
     CoinleyModal,
     {
@@ -11065,8 +10990,7 @@ const CoinleyCheckout = forwardRef(({
       availableWallets,
       supportedWallets: getSupportedWallets(),
       step,
-      merchantWalletAddresses: merchantWallets,
-      recipientAddress: getRecipientAddress(),
+      merchantWalletAddresses: actualMerchantWallets,
       debug: effectiveDebug
     }
   ) });
@@ -11096,7 +11020,7 @@ export {
   createPayment,
   detectWallets,
   generateMockTransactionHash,
-  getMerchantProfile,
+  getMerchantWallets,
   getPayment,
   getSupportedNetworks,
   getSupportedWalletsForNetwork,