coinley-checkout 1.2.9 → 1.3.1

package/dist/coinley-checkout.es.js

@@ -21673,36 +21673,110 @@ const createSolanaConnection = async () => {
 const detectTrustWallet = () => {
   if (typeof window === "undefined")
     return false;
+  console.log("=== TRUST WALLET DETECTION DEBUG ===");
+  if (window.ethereum) {
+    console.log("window.ethereum exists:", {
+      isMetaMask: window.ethereum.isMetaMask,
+      isTrust: window.ethereum.isTrust,
+      isTrustWallet: window.ethereum.isTrustWallet,
+      providers: window.ethereum.providers?.length || 0,
+      chainId: window.ethereum.chainId
+    });
+    if (window.ethereum.providers) {
+      console.log("Multiple providers detected:", window.ethereum.providers.map((p2) => ({
+        isMetaMask: p2.isMetaMask,
+        isTrust: p2.isTrust,
+        isTrustWallet: p2.isTrustWallet
+      })));
+    }
+  }
+  console.log("Trust Wallet globals:", {
+    trustwallet: Boolean(window.trustwallet),
+    trust: Boolean(window.trust),
+    isTrustWallet: Boolean(window.isTrustWallet)
+  });
   const trustDetectionMethods = [
-    // Method 1: Check for Trust Wallet specific identifier
-    () => window.ethereum && window.ethereum.isTrust === true,
-    // Method 2: Check for TrustWallet global object
-    () => window.trustwallet !== void 0,
-    // Method 3: Check for Trust Wallet mobile app interface
-    () => window.ethereum && window.ethereum.isTrustWallet === true,
-    // Method 4: Check for Trust Wallet via provider detection
-    () => window.ethereum && window.ethereum.providers && window.ethereum.providers.some((p2) => p2.isTrust || p2.isTrustWallet),
-    // Method 5: Check for Trust Wallet injected provider
-    () => window.ethereum && window.ethereum._metamask === void 0 && window.ethereum.isMetaMask === void 0 && window.ethereum.isTrust !== false,
-    // Method 6: Check for Trust Wallet specific methods
-    () => window.ethereum && typeof window.ethereum.isTrust === "boolean",
-    // Method 7: Check for Trust Wallet Solana support
-    () => window.solana && window.solana.isTrust === true,
-    // Method 8: Check for Trust Wallet Tron support  
-    () => window.tronWeb && window.tronWeb.isTrust === true,
-    // Method 9: Check user agent for Trust Wallet mobile app
-    () => /TrustWallet/i.test(navigator.userAgent),
-    // Method 10: Check for Trust Wallet extension in DOM
-    () => document.querySelector('[data-wallet="trustwallet"]') !== null
+    // Method 1: Direct Trust Wallet identifier
+    () => {
+      const result = window.ethereum && window.ethereum.isTrust === true;
+      console.log("Method 1 (ethereum.isTrust):", result);
+      return result;
+    },
+    // Method 2: TrustWallet global object
+    () => {
+      const result = window.trustwallet !== void 0;
+      console.log("Method 2 (window.trustwallet):", result);
+      return result;
+    },
+    // Method 3: Trust Wallet mobile/extension interface
+    () => {
+      const result = window.ethereum && window.ethereum.isTrustWallet === true;
+      console.log("Method 3 (ethereum.isTrustWallet):", result);
+      return result;
+    },
+    // Method 4: Provider array detection
+    () => {
+      const result = window.ethereum && window.ethereum.providers && window.ethereum.providers.some((p2) => p2.isTrust === true || p2.isTrustWallet === true);
+      console.log("Method 4 (providers array):", result);
+      return result;
+    },
+    // Method 5: Trust Wallet as primary provider when no MetaMask
+    () => {
+      const result = window.ethereum && !window.ethereum.isMetaMask && window.ethereum.request && window.ethereum.isTrust !== false;
+      console.log("Method 5 (primary provider, not MetaMask):", result);
+      return result;
+    },
+    // Method 6: Check for Trust Wallet specific methods/properties
+    () => {
+      const result = window.ethereum && (typeof window.ethereum.isTrust === "boolean" || window.ethereum._trustwallet || window.ethereum.trustWallet);
+      console.log("Method 6 (Trust Wallet specific properties):", result);
+      return result;
+    },
+    // Method 7: User agent detection (for mobile web)
+    () => {
+      const result = /TrustWallet/i.test(navigator.userAgent);
+      console.log("Method 7 (user agent):", result);
+      return result;
+    },
+    // Method 8: DOM element detection
+    () => {
+      const result = document.querySelector('[data-wallet="trustwallet"]') !== null || document.querySelector("#trustwallet-extension") !== null;
+      console.log("Method 8 (DOM elements):", result);
+      return result;
+    },
+    // Method 9: Check for Trust Wallet via window.trust
+    () => {
+      const result = window.trust !== void 0;
+      console.log("Method 9 (window.trust):", result);
+      return result;
+    },
+    // Method 10: Advanced provider detection
+    () => {
+      if (!window.ethereum)
+        return false;
+      const hasTrustFeatures = (
+        // Not MetaMask and not other known wallets
+        !window.ethereum.isMetaMask && !window.ethereum.isPhantom && !window.ethereum.isFrame && // Has ethereum methods but could be Trust Wallet
+        window.ethereum.request && window.ethereum.on && // Check for Trust Wallet specific patterns
+        (window.ethereum.chainId || window.ethereum.networkVersion)
+      );
+      console.log("Method 10 (advanced detection):", hasTrustFeatures);
+      return hasTrustFeatures;
+    }
   ];
-  return trustDetectionMethods.some((method) => {
+  const detectionResults = trustDetectionMethods.map((method, index) => {
     try {
       return method();
     } catch (error) {
-      console.warn("Trust Wallet detection method failed:", error);
+      console.warn(`Trust Wallet detection method ${index + 1} failed:`, error);
       return false;
     }
   });
+  const isDetected = detectionResults.some((result) => result === true);
+  console.log("Detection results:", detectionResults);
+  console.log("Final Trust Wallet detection result:", isDetected);
+  console.log("=== END TRUST WALLET DETECTION DEBUG ===");
+  return isDetected;
 };
 const detectLuteWallet = () => {
   if (typeof window === "undefined")
@@ -21825,14 +21899,27 @@ const debugWalletEnvironment = () => {
   console.log("solana:", typeof window !== "undefined" ? Boolean(window.solana) : "Not in browser");
   console.log("phantom:", typeof window !== "undefined" ? Boolean(window.phantom) : "Not in browser");
   console.log("trustwallet:", typeof window !== "undefined" ? Boolean(window.trustwallet) : "Not in browser");
+  console.log("trust:", typeof window !== "undefined" ? Boolean(window.trust) : "Not in browser");
   if (typeof window !== "undefined" && window.ethereum) {
     console.log("ethereum details:", {
       isMetaMask: window.ethereum.isMetaMask,
       isTrust: window.ethereum.isTrust,
       isTrustWallet: window.ethereum.isTrustWallet,
       chainId: window.ethereum.chainId,
-      providers: window.ethereum.providers?.length || 0
+      providers: window.ethereum.providers?.length || 0,
+      selectedAddress: window.ethereum.selectedAddress
     });
+    if (window.ethereum.providers && window.ethereum.providers.length > 0) {
+      console.log("All providers:");
+      window.ethereum.providers.forEach((provider, index) => {
+        console.log(`Provider ${index}:`, {
+          isMetaMask: provider.isMetaMask,
+          isTrust: provider.isTrust,
+          isTrustWallet: provider.isTrustWallet,
+          selectedAddress: provider.selectedAddress
+        });
+      });
+    }
   }
   if (typeof window !== "undefined" && window.tronWeb) {
     console.log("tronWeb details:", {
@@ -21853,13 +21940,26 @@ const debugWalletEnvironment = () => {
   if (typeof window !== "undefined") {
     console.log("All window wallet properties:");
     const walletProps = Object.keys(window).filter(
-      (key) => key.toLowerCase().includes("lute") || key.toLowerCase().includes("algo") || key.toLowerCase().includes("wallet") || key.toLowerCase().includes("phantom") || key.toLowerCase().includes("solana") || key.toLowerCase().includes("trust")
+      (key) => key.toLowerCase().includes("lute") || key.toLowerCase().includes("algo") || key.toLowerCase().includes("wallet") || key.toLowerCase().includes("phantom") || key.toLowerCase().includes("solana") || key.toLowerCase().includes("trust") || key.toLowerCase().includes("metamask")
     );
     console.log("Potential wallet properties:", walletProps);
+    console.log("Trust Wallet specific checks:", {
+      "window.trustwallet": Boolean(window.trustwallet),
+      "window.trust": Boolean(window.trust),
+      "window.isTrustWallet": Boolean(window.isTrustWallet),
+      "document trust elements": document.querySelectorAll('[id*="trust"], [class*="trust"]').length
+    });
   }
+  console.log("=== DETECTION RESULTS ===");
   const wallets = detectWallets();
-  console.log("Detected wallets:", wallets);
+  console.log("Final detection results:", wallets);
+  console.log("Trust Wallet specific detection result:", detectTrustWallet());
   console.log("=== END WALLET ENVIRONMENT DEBUG ===");
+  return {
+    wallets,
+    ethereum: typeof window !== "undefined" ? window.ethereum : null,
+    trustWalletDetected: typeof window !== "undefined" ? detectTrustWallet() : false
+  };
 };
 const connectMetamaskWallet = async () => {
   console.log("Connecting to MetaMask wallet...");
@@ -21901,32 +22001,110 @@ const connectMetamaskWallet = async () => {
   }
 };
 const connectTrustWallet = async (targetNetwork = null) => {
+  console.log("=== TRUST WALLET CONNECTION DEBUG ===");
   console.log("Connecting to Trust Wallet for network:", targetNetwork);
+  let trustProvider = null;
   let networkType = targetNetwork || NETWORK_TYPES.ETHEREUM;
+  if (window.ethereum) {
+    console.log("Available ethereum providers:", {
+      main: {
+        isMetaMask: window.ethereum.isMetaMask,
+        isTrust: window.ethereum.isTrust,
+        isTrustWallet: window.ethereum.isTrustWallet,
+        providers: window.ethereum.providers?.length || 0
+      }
+    });
+    if (window.ethereum.providers) {
+      window.ethereum.providers.forEach((provider, index) => {
+        console.log(`Provider ${index}:`, {
+          isMetaMask: provider.isMetaMask,
+          isTrust: provider.isTrust,
+          isTrustWallet: provider.isTrustWallet
+        });
+      });
+    }
+  }
   try {
     if (networkType === NETWORK_TYPES.ETHEREUM || networkType === NETWORK_TYPES.BSC) {
       if (!window.ethereum) {
-        throw new Error("Ethereum provider not found. Please install Trust Wallet.");
+        throw new Error("No Ethereum provider found. Please install Trust Wallet browser extension.");
       }
-      let trustProvider = null;
       if (window.ethereum.isTrust === true || window.ethereum.isTrustWallet === true) {
         trustProvider = window.ethereum;
-      } else if (window.ethereum.providers) {
-        trustProvider = window.ethereum.providers.find((p2) => p2.isTrust || p2.isTrustWallet);
-      } else if (window.trustwallet) {
-        trustProvider = window.trustwallet.ethereum || window.trustwallet;
+        console.log("✅ Found Trust Wallet via direct detection");
+      } else if (window.ethereum.providers && window.ethereum.providers.length > 0) {
+        trustProvider = window.ethereum.providers.find((p2) => p2.isTrust === true || p2.isTrustWallet === true);
+        if (trustProvider) {
+          console.log("✅ Found Trust Wallet in providers array");
+        } else {
+          const nonMetaMaskProvider = window.ethereum.providers.find((p2) => !p2.isMetaMask);
+          if (nonMetaMaskProvider) {
+            trustProvider = nonMetaMaskProvider;
+            console.log("✅ Found non-MetaMask provider, assuming it's Trust Wallet");
+          }
+        }
+      } else if (window.trustwallet && window.trustwallet.ethereum) {
+        trustProvider = window.trustwallet.ethereum;
+        console.log("✅ Found Trust Wallet via global trustwallet object");
+      } else if (window.ethereum && !window.ethereum.isMetaMask && !window.ethereum.isPhantom) {
+        console.log("🔍 Single provider detected, not MetaMask or Phantom - assuming Trust Wallet");
+        trustProvider = window.ethereum;
+      } else if (window.ethereum) {
+        console.log("🔍 Fallback strategy - testing main ethereum provider as Trust Wallet");
+        trustProvider = window.ethereum;
       }
       if (!trustProvider) {
-        throw new Error("Trust Wallet not detected. Please install Trust Wallet or switch to Trust Wallet if multiple wallets are installed.");
+        throw new Error(`Trust Wallet provider not found. Available providers: ${window.ethereum.providers?.length || 1}. Please ensure Trust Wallet is properly installed and enabled.`);
+      }
+      console.log("🚀 Attempting to connect with Trust Wallet provider...");
+      let accounts;
+      try {
+        accounts = await trustProvider.request({
+          method: "eth_requestAccounts"
+        });
+      } catch (requestError) {
+        console.log("❌ Connection attempt failed:", requestError);
+        if (window.ethereum.providers && window.ethereum.providers.length > 1) {
+          console.log("🔄 Trying alternative providers...");
+          for (let i = 0; i < window.ethereum.providers.length; i++) {
+            const altProvider = window.ethereum.providers[i];
+            if (altProvider !== trustProvider) {
+              try {
+                console.log(`🔍 Testing provider ${i}...`);
+                const altAccounts = await altProvider.request({ method: "eth_requestAccounts" });
+                if (altAccounts && altAccounts.length > 0) {
+                  trustProvider = altProvider;
+                  accounts = altAccounts;
+                  console.log(`✅ Alternative provider ${i} worked!`);
+                  break;
+                }
+              } catch (altError) {
+                console.log(`❌ Alternative provider ${i} failed:`, altError.message);
+                continue;
+              }
+            }
+          }
+        }
+        if (!accounts) {
+          if (requestError.code === 4001) {
+            throw new Error("Connection rejected by user. Please approve the connection in Trust Wallet.");
+          } else {
+            throw new Error(`Failed to connect to Trust Wallet: ${requestError.message}. Please make sure Trust Wallet is unlocked and try again.`);
+          }
+        }
       }
-      console.log("Found Trust Wallet Ethereum provider");
-      const accounts = await trustProvider.request({ method: "eth_requestAccounts" });
       if (!accounts || accounts.length === 0) {
-        throw new Error("No accounts found");
+        throw new Error("No accounts found in Trust Wallet. Please create an account or unlock your wallet.");
       }
       const address = accounts[0];
-      const chainIdHex = await trustProvider.request({ method: "eth_chainId" });
-      const chainId = parseInt(chainIdHex, 16);
+      let chainIdHex, chainId;
+      try {
+        chainIdHex = await trustProvider.request({ method: "eth_chainId" });
+        chainId = parseInt(chainIdHex, 16);
+      } catch (chainError) {
+        console.warn("Could not get chain ID:", chainError);
+        chainId = 1;
+      }
       switch (chainId) {
         case 1:
           networkType = NETWORK_TYPES.ETHEREUM;
@@ -21938,6 +22116,12 @@ const connectTrustWallet = async (targetNetwork = null) => {
           networkType = `unknown-${chainId}`;
       }
       const web3Provider = new BrowserProvider(trustProvider);
+      console.log("✅ Trust Wallet connected successfully:", {
+        address,
+        network: networkType,
+        chainId
+      });
+      console.log("=== END TRUST WALLET CONNECTION DEBUG ===");
       return {
         walletType: WALLET_TYPES.TRUST_WALLET,
         address,
@@ -21949,7 +22133,7 @@ const connectTrustWallet = async (targetNetwork = null) => {
       };
     } else if (networkType === NETWORK_TYPES.TRON) {
       if (!window.tronWeb) {
-        throw new Error("TronWeb not found. Please install Trust Wallet with TRON support.");
+        throw new Error("TronWeb not found. Please install Trust Wallet with TRON support or use Trust Wallet mobile app.");
       }
       if (window.tronWeb.isTrust !== true && !window.trustwallet) {
         console.warn("TronWeb detected but may not be from Trust Wallet");
@@ -21993,7 +22177,7 @@ const connectTrustWallet = async (targetNetwork = null) => {
         solanaProvider = window.solana;
       }
       if (!solanaProvider) {
-        throw new Error("Trust Wallet Solana provider not found. Please install Trust Wallet with Solana support.");
+        throw new Error("Trust Wallet Solana provider not found. Please install Trust Wallet with Solana support or use Trust Wallet mobile app.");
       }
       console.log("Found Trust Wallet Solana provider");
       const response = await solanaProvider.connect();
@@ -22015,13 +22199,17 @@ const connectTrustWallet = async (targetNetwork = null) => {
       throw new Error(`Trust Wallet does not support network: ${networkType}`);
     }
   } catch (error) {
-    console.error("Error connecting to Trust Wallet:", error);
+    console.error("=== TRUST WALLET CONNECTION ERROR ===");
+    console.error("Error details:", error);
+    console.log("=== END TRUST WALLET CONNECTION DEBUG ===");
     if (error.code === 4001 || error.message.includes("rejected")) {
       throw new Error("Connection rejected by user. Please approve the connection in Trust Wallet.");
     } else if (error.message.includes("locked")) {
       throw new Error("Trust Wallet is locked. Please unlock your wallet and try again.");
-    } else {
+    } else if (error.message.includes("install") || error.message.includes("not detected") || error.message.includes("not found")) {
       throw error;
+    } else {
+      throw new Error(`Failed to connect to Trust Wallet: ${error.message}`);
     }
   }
 };