coinley-checkout 0.8.3 → 0.8.4

package/dist/coinley-checkout.es.js

@@ -18329,11 +18329,7 @@ const WALLET_TYPES = {
   METAMASK: "metamask",
   TRONLINK: "tronlink",
   TRUST_WALLET: "trustwallet",
-  LUTE: "lute",
-  PERA: "pera",
-  ALGOSIGNER: "algosigner",
-  DEFLY: "defly",
-  EXODUS: "exodus"
+  LUTE: "lute"
 };
 const NETWORK_TYPES = {
   ETHEREUM: "ethereum",
@@ -18451,59 +18447,59 @@ const NETWORK_WALLET_MAP = {
   [NETWORK_TYPES.ETHEREUM]: [WALLET_TYPES.METAMASK, WALLET_TYPES.TRUST_WALLET],
   [NETWORK_TYPES.BSC]: [WALLET_TYPES.METAMASK, WALLET_TYPES.TRUST_WALLET],
   [NETWORK_TYPES.TRON]: [WALLET_TYPES.TRONLINK],
-  [NETWORK_TYPES.ALGORAND]: [WALLET_TYPES.PERA, WALLET_TYPES.ALGOSIGNER, WALLET_TYPES.DEFLY, WALLET_TYPES.LUTE, WALLET_TYPES.EXODUS]
+  [NETWORK_TYPES.ALGORAND]: [WALLET_TYPES.LUTE]
 };
 const getWalletInstallUrl = (walletType) => {
   const urls = {
     [WALLET_TYPES.METAMASK]: "https://metamask.io/download/",
     [WALLET_TYPES.TRONLINK]: "https://www.tronlink.org/download/",
     [WALLET_TYPES.TRUST_WALLET]: "https://trustwallet.com/download/",
-    [WALLET_TYPES.LUTE]: "https://lute.app/download/",
-    [WALLET_TYPES.PERA]: "https://perawallet.app/",
-    [WALLET_TYPES.ALGOSIGNER]: "https://chrome.google.com/webstore/detail/algosigner/kmmolakhbgdlpkjkcjkebenjheonagdm",
-    [WALLET_TYPES.DEFLY]: "https://defly.app/",
-    [WALLET_TYPES.EXODUS]: "https://www.exodus.com/download/"
+    [WALLET_TYPES.LUTE]: "https://lute.app/download/"
   };
   return urls[walletType] || "";
 };
-const detectAlgorandWallets = () => {
-  var _a2, _b, _c, _d, _e, _f;
+const detectLuteWallet = () => {
   if (typeof window === "undefined")
-    return {};
-  const algorandWallets = {};
-  algorandWallets[WALLET_TYPES.PERA] = Boolean(
-    window.PeraWallet || ((_a2 = window.algorand) == null ? void 0 : _a2.pera) || window.pera || document.querySelector('[data-wallet="pera"]')
-  );
-  algorandWallets[WALLET_TYPES.ALGOSIGNER] = Boolean(window.AlgoSigner);
-  algorandWallets[WALLET_TYPES.DEFLY] = Boolean(
-    window.DeflyWallet || window.defly || ((_b = window.algorand) == null ? void 0 : _b.defly)
-  );
-  algorandWallets[WALLET_TYPES.LUTE] = Boolean(
-    window.lute || window.luteWallet || ((_c = window.algorand) == null ? void 0 : _c.lute)
-  );
-  algorandWallets[WALLET_TYPES.EXODUS] = Boolean(
-    ((_d = window.exodus) == null ? void 0 : _d.algorand) || window.exodus && window.exodus.algorand
-  );
-  console.log("=== ALGORAND WALLETS DETECTION ===");
-  console.log("Pera (PeraWallet):", Boolean(window.PeraWallet));
-  console.log("Pera (algorand.pera):", Boolean((_e = window.algorand) == null ? void 0 : _e.pera));
-  console.log("Pera (window.pera):", Boolean(window.pera));
-  console.log("AlgoSigner:", Boolean(window.AlgoSigner));
-  console.log("Defly (DeflyWallet):", Boolean(window.DeflyWallet));
-  console.log("Defly (window.defly):", Boolean(window.defly));
-  console.log("Lute (window.lute):", Boolean(window.lute));
-  console.log("Exodus Algorand:", Boolean((_f = window.exodus) == null ? void 0 : _f.algorand));
-  console.log("Final detection results:", algorandWallets);
-  console.log("=== END ALGORAND DETECTION ===");
-  return algorandWallets;
+    return false;
+  const luteDetectionMethods = [
+    // Check for window.lute
+    () => window.lute !== void 0,
+    // Check for window.algorand (some Algorand wallets use this)
+    () => window.algorand !== void 0,
+    // Check for AlgoSigner (alternative Algorand wallet)
+    () => window.AlgoSigner !== void 0,
+    // Check for specific Lute wallet identifiers
+    () => window.luteWallet !== void 0,
+    // Check for wallet extension in DOM
+    () => document.querySelector('[data-wallet="lute"]') !== null,
+    // Check if Lute is injected via content script
+    () => window.postMessage && document.documentElement.getAttribute("data-lute-extension") === "true"
+  ];
+  return luteDetectionMethods.some((method) => {
+    try {
+      return method();
+    } catch (error) {
+      console.warn("Lute detection method failed:", error);
+      return false;
+    }
+  });
 };
 const detectWallets = () => {
-  const algorandWallets = detectAlgorandWallets();
-  const availableWallets = __spreadValues({
+  const availableWallets = {
     [WALLET_TYPES.METAMASK]: typeof window !== "undefined" && window.ethereum !== void 0 && window.ethereum.isMetaMask,
     [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
-  }, algorandWallets);
+    [WALLET_TYPES.TRUST_WALLET]: typeof window !== "undefined" && window.ethereum !== void 0 && window.ethereum.isTrust === true,
+    [WALLET_TYPES.LUTE]: detectLuteWallet()
+  };
+  if (typeof window !== "undefined") {
+    console.log("=== LUTE WALLET DETECTION DEBUG ===");
+    console.log("window.lute:", Boolean(window.lute));
+    console.log("window.algorand:", Boolean(window.algorand));
+    console.log("window.AlgoSigner:", Boolean(window.AlgoSigner));
+    console.log("window.luteWallet:", Boolean(window.luteWallet));
+    console.log("Lute detected overall:", availableWallets[WALLET_TYPES.LUTE]);
+    console.log("=== END LUTE DETECTION DEBUG ===");
+  }
   return availableWallets;
 };
 const detectWalletsWithRetry = (maxRetries = 5, delay = 1e3) => __async(void 0, null, function* () {
@@ -18512,7 +18508,6 @@ const detectWalletsWithRetry = (maxRetries = 5, delay = 1e3) => __async(void 0,
   while (retries < maxRetries) {
     wallets = detectWallets();
     const hasAnyWallet = Object.values(wallets).some((v) => v === true);
-    [WALLET_TYPES.PERA, WALLET_TYPES.ALGOSIGNER, WALLET_TYPES.DEFLY, WALLET_TYPES.LUTE, WALLET_TYPES.EXODUS].some((wallet) => wallets[wallet]);
     if (hasAnyWallet || retries >= maxRetries - 1) {
       break;
     }
@@ -18521,19 +18516,16 @@ const detectWalletsWithRetry = (maxRetries = 5, delay = 1e3) => __async(void 0,
     yield new Promise((resolve) => setTimeout(resolve, delay));
     retries++;
   }
-  if (!Object.values(wallets).some((v) => v === true)) {
-    console.log("Performing extended Algorand wallet detection...");
+  if (!wallets[WALLET_TYPES.LUTE]) {
+    console.log("Performing extended Lute wallet detection...");
     if (typeof window !== "undefined") {
       try {
-        const events = ["algorand-wallet-detect", "pera-wallet-detect", "defly-wallet-detect"];
-        events.forEach((eventName) => {
-          const event = new CustomEvent(eventName, { detail: { source: "coinley-sdk" } });
-          window.dispatchEvent(event);
-        });
-        yield new Promise((resolve) => setTimeout(resolve, 1e3));
-        wallets = detectWallets();
+        const event = new CustomEvent("lute-wallet-detect", { detail: { source: "coinley-sdk" } });
+        window.dispatchEvent(event);
+        yield new Promise((resolve) => setTimeout(resolve, 500));
+        wallets[WALLET_TYPES.LUTE] = detectLuteWallet();
       } catch (error) {
-        console.warn("Extended Algorand detection failed:", error);
+        console.warn("Extended Lute detection failed:", error);
       }
     }
   }
@@ -18541,17 +18533,13 @@ const detectWalletsWithRetry = (maxRetries = 5, delay = 1e3) => __async(void 0,
   return wallets;
 });
 const debugWalletEnvironment = () => {
-  var _a2, _b;
+  var _a2;
   console.log("=== WALLET ENVIRONMENT DEBUG ===");
   console.log("ethereum:", typeof window !== "undefined" ? Boolean(window.ethereum) : "Not in browser");
   console.log("tronWeb:", typeof window !== "undefined" ? Boolean(window.tronWeb) : "Not in browser");
-  console.log("=== ALGORAND WALLETS ===");
-  console.log("PeraWallet:", typeof window !== "undefined" ? Boolean(window.PeraWallet) : "Not in browser");
-  console.log("AlgoSigner:", typeof window !== "undefined" ? Boolean(window.AlgoSigner) : "Not in browser");
-  console.log("DeflyWallet:", typeof window !== "undefined" ? Boolean(window.DeflyWallet) : "Not in browser");
   console.log("lute:", typeof window !== "undefined" ? Boolean(window.lute) : "Not in browser");
-  console.log("exodus.algorand:", typeof window !== "undefined" ? Boolean((_a2 = window.exodus) == null ? void 0 : _a2.algorand) : "Not in browser");
   console.log("algorand:", typeof window !== "undefined" ? Boolean(window.algorand) : "Not in browser");
+  console.log("AlgoSigner:", typeof window !== "undefined" ? Boolean(window.AlgoSigner) : "Not in browser");
   if (typeof window !== "undefined" && window.ethereum) {
     console.log("ethereum details:", {
       isTrust: window.ethereum.isTrust,
@@ -18562,14 +18550,14 @@ const debugWalletEnvironment = () => {
   if (typeof window !== "undefined" && window.tronWeb) {
     console.log("tronWeb details:", {
       ready: window.tronWeb.ready,
-      fullNode: (_b = window.tronWeb.fullNode) == null ? void 0 : _b.host,
+      fullNode: (_a2 = window.tronWeb.fullNode) == null ? void 0 : _a2.host,
       defaultAddress: window.tronWeb.defaultAddress
     });
   }
   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("pera") || key.toLowerCase().includes("defly") || key.toLowerCase().includes("wallet")
+      (key) => key.toLowerCase().includes("lute") || key.toLowerCase().includes("algo") || key.toLowerCase().includes("wallet")
     );
     console.log("Potential wallet properties:", walletProps);
   }
@@ -18695,117 +18683,58 @@ const connectTronlinkWallet = () => __async(void 0, null, function* () {
     throw error;
   }
 });
-const connectAlgorandWallet = (walletType) => __async(void 0, null, function* () {
-  var _a2, _b, _c, _d, _e;
-  console.log(`Connecting to ${walletType} wallet...`);
+const connectLuteWallet = () => __async(void 0, null, function* () {
+  var _a2;
+  console.log("Connecting to Lute wallet...");
   let walletProvider = null;
   let walletName = "";
-  switch (walletType) {
-    case WALLET_TYPES.PERA:
-      if (window.PeraWallet) {
-        walletProvider = window.PeraWallet;
-        walletName = "Pera Wallet";
-      } else if ((_a2 = window.algorand) == null ? void 0 : _a2.pera) {
-        walletProvider = window.algorand.pera;
-        walletName = "Pera Wallet (algorand.pera)";
-      } else if (window.pera) {
-        walletProvider = window.pera;
-        walletName = "Pera Wallet (window.pera)";
-      }
-      break;
-    case WALLET_TYPES.ALGOSIGNER:
-      if (window.AlgoSigner) {
-        walletProvider = window.AlgoSigner;
-        walletName = "AlgoSigner";
-      }
-      break;
-    case WALLET_TYPES.DEFLY:
-      if (window.DeflyWallet) {
-        walletProvider = window.DeflyWallet;
-        walletName = "Defly Wallet";
-      } else if (window.defly) {
-        walletProvider = window.defly;
-        walletName = "Defly Wallet (window.defly)";
-      } else if ((_b = window.algorand) == null ? void 0 : _b.defly) {
-        walletProvider = window.algorand.defly;
-        walletName = "Defly Wallet (algorand.defly)";
-      }
-      break;
-    case WALLET_TYPES.LUTE:
-      if (window.lute) {
-        walletProvider = window.lute;
-        walletName = "Lute Wallet";
-      } else if (window.luteWallet) {
-        walletProvider = window.luteWallet;
-        walletName = "Lute Wallet (luteWallet)";
-      } else if ((_c = window.algorand) == null ? void 0 : _c.lute) {
-        walletProvider = window.algorand.lute;
-        walletName = "Lute Wallet (algorand.lute)";
-      }
-      break;
-    case WALLET_TYPES.EXODUS:
-      if ((_d = window.exodus) == null ? void 0 : _d.algorand) {
-        walletProvider = window.exodus.algorand;
-        walletName = "Exodus Wallet";
-      }
-      break;
+  if (window.lute) {
+    walletProvider = window.lute;
+    walletName = "Lute";
+  } else if (window.algorand) {
+    walletProvider = window.algorand;
+    walletName = "Algorand Provider";
+  } else if (window.AlgoSigner) {
+    walletProvider = window.AlgoSigner;
+    walletName = "AlgoSigner";
+  } else if (window.luteWallet) {
+    walletProvider = window.luteWallet;
+    walletName = "Lute Wallet";
   }
   if (!walletProvider) {
-    console.error(`${walletType} wallet not detected.`);
+    console.error("No Algorand wallet detected.");
     console.log("Available window properties:", Object.keys(window).filter(
-      (key) => key.toLowerCase().includes("pera") || key.toLowerCase().includes("algo") || key.toLowerCase().includes("defly") || key.toLowerCase().includes("lute") || key.toLowerCase().includes("exodus")
+      (key) => key.toLowerCase().includes("lute") || key.toLowerCase().includes("algo") || key.toLowerCase().includes("wallet")
     ));
-    throw new Error(`${walletType} wallet not detected. Please install ${walletName || walletType} or try another Algorand wallet.`);
+    throw new Error("Lute wallet not detected. Please install Lute extension or another Algorand wallet.");
   }
   console.log(`Found ${walletName} wallet provider:`, walletProvider);
   try {
     let address = null;
-    if (walletType === WALLET_TYPES.PERA) {
-      if (walletProvider.connect) {
-        const result = yield walletProvider.connect();
-        address = result.address || result[0] || result;
-      } else if (walletProvider.enable) {
-        const accounts = yield walletProvider.enable();
-        address = accounts[0] || accounts;
-      }
-    } else if (walletType === WALLET_TYPES.ALGOSIGNER) {
+    if (walletProvider.connect) {
+      console.log("Using connect() method...");
+      const result = yield walletProvider.connect();
+      address = result.address || result;
+    } else if (walletProvider.enable) {
+      console.log("Using enable() method...");
+      const accounts = yield walletProvider.enable();
+      address = accounts[0] || accounts;
+    } else if (walletProvider.requestAccounts) {
+      console.log("Using requestAccounts() method...");
+      const accounts = yield walletProvider.requestAccounts();
+      address = accounts[0];
+    } else if (walletProvider.connect && walletName === "AlgoSigner") {
+      console.log("Using AlgoSigner connect...");
       yield walletProvider.connect();
       const accounts = yield walletProvider.accounts({ ledger: "MainNet" });
-      address = (_e = accounts[0]) == null ? void 0 : _e.address;
-    } else if (walletType === WALLET_TYPES.DEFLY) {
-      if (walletProvider.connect) {
-        const result = yield walletProvider.connect();
-        address = result.address || result[0] || result;
-      } else if (walletProvider.enable) {
-        const accounts = yield walletProvider.enable();
-        address = accounts[0] || accounts;
-      }
-    } else if (walletType === WALLET_TYPES.EXODUS) {
-      if (walletProvider.connect) {
-        const result = yield walletProvider.connect();
-        address = result.address || result[0] || result;
-      } else if (walletProvider.enable) {
-        const accounts = yield walletProvider.enable();
-        address = accounts[0] || accounts;
-      }
-    } else {
-      if (walletProvider.connect) {
-        const result = yield walletProvider.connect();
-        address = result.address || result[0] || result;
-      } else if (walletProvider.enable) {
-        const accounts = yield walletProvider.enable();
-        address = accounts[0] || accounts;
-      } else if (walletProvider.requestAccounts) {
-        const accounts = yield walletProvider.requestAccounts();
-        address = accounts[0];
-      }
+      address = (_a2 = accounts[0]) == null ? void 0 : _a2.address;
     }
     if (!address) {
       throw new Error(`No address returned from ${walletName}. Please unlock your wallet and try again.`);
     }
     console.log(`Connected to ${walletName} wallet:`, address);
     return {
-      walletType,
+      walletType: WALLET_TYPES.LUTE,
       address,
       provider: walletProvider,
       network: NETWORK_TYPES.ALGORAND,
@@ -18832,12 +18761,8 @@ const connectWallet = (walletType) => __async(void 0, null, function* () {
       return connectTronlinkWallet();
     case WALLET_TYPES.TRUST_WALLET:
       return connectTrustWallet();
-    case WALLET_TYPES.PERA:
-    case WALLET_TYPES.ALGOSIGNER:
-    case WALLET_TYPES.DEFLY:
     case WALLET_TYPES.LUTE:
-    case WALLET_TYPES.EXODUS:
-      return connectAlgorandWallet(walletType);
+      return connectLuteWallet();
     default:
       throw new Error(`Unsupported wallet type: ${walletType}`);
   }
@@ -18975,11 +18900,7 @@ const sendTokenTransaction = (walletConnection, tokenConfig, toAddress, amount)
   switch (walletConnection.walletType) {
     case WALLET_TYPES.TRONLINK:
       return sendTRC20Transaction(walletConnection, tokenConfig, toAddress, amount);
-    case WALLET_TYPES.PERA:
-    case WALLET_TYPES.ALGOSIGNER:
-    case WALLET_TYPES.DEFLY:
     case WALLET_TYPES.LUTE:
-    case WALLET_TYPES.EXODUS:
       return sendAlgorandAssetTransaction(walletConnection, tokenConfig, toAddress, amount);
     default:
       return sendERC20Transaction(walletConnection, tokenConfig, toAddress, amount);
@@ -21830,65 +21751,46 @@ const CoinleyCheckout = forwardRef(({
       }
     };
   }, [checkingInterval]);
-  useEffect(() => {
-    if (transactionHash && pendingBackendConfirmation && paymentStatus === "loading") {
-      const interval = setInterval(() => __async(void 0, null, function* () {
-        try {
-          log("Checking payment status with backend...");
-          const processResponse = yield processPayment({
-            paymentId: payment.id,
-            transactionHash,
-            network: selectedPaymentMethod.network,
-            currency: selectedPaymentMethod.currency,
-            senderAddress: walletConnection == null ? void 0 : walletConnection.address,
-            confirmations,
-            check: true
-            // Just check status, don't process again
-          });
-          if (processResponse.status === "success") {
-            log("Payment confirmed by backend!");
-            clearInterval(interval);
-            setCheckingInterval(null);
-            setPendingBackendConfirmation(false);
-            setPaymentStatus("success");
-          }
-        } catch (err) {
-          log("Error checking payment status:", err);
-        }
-      }), 1e4);
-      setCheckingInterval(interval);
-      return () => {
-        clearInterval(interval);
-      };
-    }
-  }, [transactionHash, pendingBackendConfirmation, paymentStatus, payment, selectedPaymentMethod, walletConnection, confirmations]);
   const processBackendConfirmation = () => __async(void 0, null, function* () {
     if (!payment || !selectedPaymentMethod || !transactionHash) {
+      log("Missing required data for backend confirmation:", {
+        hasPayment: !!payment,
+        hasPaymentMethod: !!selectedPaymentMethod,
+        hasTransactionHash: !!transactionHash
+      });
       return;
     }
     try {
-      log("Processing payment with backend...");
+      log("Processing payment with backend...", {
+        paymentId: payment.id,
+        transactionHash,
+        network: selectedPaymentMethod.network,
+        currency: selectedPaymentMethod.currency
+      });
       const processResponse = yield processPayment({
         paymentId: payment.id,
         transactionHash,
         network: selectedPaymentMethod.network,
-        currency: selectedPaymentMethod.currency,
-        senderAddress: walletConnection == null ? void 0 : walletConnection.address,
-        confirmations
+        senderAddress: walletConnection == null ? void 0 : walletConnection.address
       });
-      log("Payment processed successfully:", processResponse);
+      log("Payment processed successfully with backend:", processResponse);
       setPendingBackendConfirmation(false);
+      setPaymentStatus("success");
       if (onSuccess) {
         log("Calling onSuccess callback...");
         onSuccess(payment.id, transactionHash, {
           network: selectedPaymentMethod.network,
           currency: selectedPaymentMethod.currency,
-          amount: payment.totalAmount || payment.amount
+          amount: payment.totalAmount || payment.amount,
+          processResponse
         });
       }
     } catch (processError) {
-      log("Payment processing initial attempt failed, will retry in background:", processError);
+      log("Payment processing failed:", processError);
       setPendingBackendConfirmation(true);
+      setTimeout(() => {
+        processBackendConfirmation();
+      }, 1e4);
     }
   });
   useImperativeHandle(ref, () => ({
@@ -22054,6 +21956,7 @@ const CoinleyCheckout = forwardRef(({
       log("Transaction hash obtained:", txHash);
       setTransactionHash(txHash);
       setStep("success");
+      setPaymentStatus("success");
       processBackendConfirmation();
     } catch (err) {
       log("Payment error:", err);