coinley-checkout 0.8.1 → 0.8.3

package/dist/coinley-checkout.es.js

@@ -18329,7 +18329,11 @@ const WALLET_TYPES = {
   METAMASK: "metamask",
   TRONLINK: "tronlink",
   TRUST_WALLET: "trustwallet",
-  LUTE: "lute"
+  LUTE: "lute",
+  PERA: "pera",
+  ALGOSIGNER: "algosigner",
+  DEFLY: "defly",
+  EXODUS: "exodus"
 };
 const NETWORK_TYPES = {
   ETHEREUM: "ethereum",
@@ -18447,59 +18451,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.LUTE]
+  [NETWORK_TYPES.ALGORAND]: [WALLET_TYPES.PERA, WALLET_TYPES.ALGOSIGNER, WALLET_TYPES.DEFLY, WALLET_TYPES.LUTE, WALLET_TYPES.EXODUS]
 };
 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.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/"
   };
   return urls[walletType] || "";
 };
-const detectLuteWallet = () => {
+const detectAlgorandWallets = () => {
+  var _a2, _b, _c, _d, _e, _f;
   if (typeof window === "undefined")
-    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;
-    }
-  });
+    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;
 };
 const detectWallets = () => {
-  const availableWallets = {
+  const algorandWallets = detectAlgorandWallets();
+  const availableWallets = __spreadValues({
     [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,
-    [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 ===");
-  }
+    [WALLET_TYPES.TRUST_WALLET]: typeof window !== "undefined" && window.ethereum !== void 0 && window.ethereum.isTrust === true
+  }, algorandWallets);
   return availableWallets;
 };
 const detectWalletsWithRetry = (maxRetries = 5, delay = 1e3) => __async(void 0, null, function* () {
@@ -18508,6 +18512,7 @@ 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;
     }
@@ -18516,16 +18521,19 @@ const detectWalletsWithRetry = (maxRetries = 5, delay = 1e3) => __async(void 0,
     yield new Promise((resolve) => setTimeout(resolve, delay));
     retries++;
   }
-  if (!wallets[WALLET_TYPES.LUTE]) {
-    console.log("Performing extended Lute wallet detection...");
+  if (!Object.values(wallets).some((v) => v === true)) {
+    console.log("Performing extended Algorand wallet detection...");
     if (typeof window !== "undefined") {
       try {
-        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();
+        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();
       } catch (error) {
-        console.warn("Extended Lute detection failed:", error);
+        console.warn("Extended Algorand detection failed:", error);
       }
     }
   }
@@ -18533,13 +18541,17 @@ const detectWalletsWithRetry = (maxRetries = 5, delay = 1e3) => __async(void 0,
   return wallets;
 });
 const debugWalletEnvironment = () => {
-  var _a2;
+  var _a2, _b;
   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,
@@ -18550,14 +18562,14 @@ const debugWalletEnvironment = () => {
   if (typeof window !== "undefined" && window.tronWeb) {
     console.log("tronWeb details:", {
       ready: window.tronWeb.ready,
-      fullNode: (_a2 = window.tronWeb.fullNode) == null ? void 0 : _a2.host,
+      fullNode: (_b = window.tronWeb.fullNode) == null ? void 0 : _b.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("wallet")
+      (key) => key.toLowerCase().includes("lute") || key.toLowerCase().includes("algo") || key.toLowerCase().includes("pera") || key.toLowerCase().includes("defly") || key.toLowerCase().includes("wallet")
     );
     console.log("Potential wallet properties:", walletProps);
   }
@@ -18683,58 +18695,117 @@ const connectTronlinkWallet = () => __async(void 0, null, function* () {
     throw error;
   }
 });
-const connectLuteWallet = () => __async(void 0, null, function* () {
-  var _a2;
-  console.log("Connecting to Lute wallet...");
+const connectAlgorandWallet = (walletType) => __async(void 0, null, function* () {
+  var _a2, _b, _c, _d, _e;
+  console.log(`Connecting to ${walletType} wallet...`);
   let walletProvider = null;
   let walletName = "";
-  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";
+  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 (!walletProvider) {
-    console.error("No Algorand wallet detected.");
+    console.error(`${walletType} wallet not detected.`);
     console.log("Available window properties:", Object.keys(window).filter(
-      (key) => key.toLowerCase().includes("lute") || key.toLowerCase().includes("algo") || key.toLowerCase().includes("wallet")
+      (key) => key.toLowerCase().includes("pera") || key.toLowerCase().includes("algo") || key.toLowerCase().includes("defly") || key.toLowerCase().includes("lute") || key.toLowerCase().includes("exodus")
     ));
-    throw new Error("Lute wallet not detected. Please install Lute extension or another Algorand wallet.");
+    throw new Error(`${walletType} wallet not detected. Please install ${walletName || walletType} or try another Algorand wallet.`);
   }
   console.log(`Found ${walletName} wallet provider:`, walletProvider);
   try {
     let address = null;
-    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...");
+    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) {
       yield walletProvider.connect();
       const accounts = yield walletProvider.accounts({ ledger: "MainNet" });
-      address = (_a2 = accounts[0]) == null ? void 0 : _a2.address;
+      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];
+      }
     }
     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: WALLET_TYPES.LUTE,
+      walletType,
       address,
       provider: walletProvider,
       network: NETWORK_TYPES.ALGORAND,
@@ -18761,8 +18832,12 @@ 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:
-      return connectLuteWallet();
+    case WALLET_TYPES.EXODUS:
+      return connectAlgorandWallet(walletType);
     default:
       throw new Error(`Unsupported wallet type: ${walletType}`);
   }
@@ -18900,7 +18975,11 @@ 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);
@@ -20557,7 +20636,20 @@ const QRCode = ({
       let paymentData;
       switch (network) {
         case "algorand":
-          paymentData = generateAlgorandQR2(walletAddress, amount, currency);
+          const merchantAddress = "5OY4UMMWLFQWB7SZZ4YZCANFSESHAURQGEJWJFV2SRLGUDSSBOWXJOEPDM";
+          const amountFloat = parseFloat(amount);
+          if (currency === "ALGO") {
+            const microAlgos = Math.floor(amountFloat * 1e6);
+            paymentData = `algorand://${merchantAddress}?amount=${microAlgos}`;
+          } else {
+            const tokenConfig = getTokenConfigForCurrency2(currency, "algorand");
+            if (tokenConfig && tokenConfig.assetId) {
+              const assetAmount = Math.floor(amountFloat * Math.pow(10, tokenConfig.decimals));
+              paymentData = `algorand://${merchantAddress}?amount=${assetAmount}&asset=${tokenConfig.assetId}`;
+            } else {
+              paymentData = `algorand://${merchantAddress}`;
+            }
+          }
           break;
         case "tron":
           if (currency === "TRX") {
@@ -20607,27 +20699,6 @@ const QRCode = ({
       setQrError("Error generating payment QR code");
     }
   }, [walletAddress, amount, currency, network]);
-  const generateAlgorandQR2 = (address, amount2, currency2) => {
-    try {
-      const demoAddress = "5OY4UMMWLFQWB7SZZ4YZCANFSESHAURQGEJWJFV2SRLGUDSSBOWXJOEPDM";
-      const amountFloat = parseFloat(amount2);
-      if (currency2 === "ALGO") {
-        const microAlgos = Math.floor(amountFloat * 1e6);
-        return `https://perawallet.app/qr-code-generator/?receiver=${demoAddress}&amount=${microAlgos}&note=Demo%20Payment`;
-      } else {
-        const tokenConfig = getTokenConfigForCurrency2(currency2, "algorand");
-        if (tokenConfig && tokenConfig.assetId) {
-          const assetAmount = Math.floor(amountFloat * Math.pow(10, tokenConfig.decimals));
-          return `https://perawallet.app/qr-code-generator/?receiver=${demoAddress}&amount=${assetAmount}&asset=${tokenConfig.assetId}&note=${currency2}%20Demo%20Payment`;
-        } else {
-          return demoAddress;
-        }
-      }
-    } catch (error) {
-      console.error("Error generating demo Algorand QR:", error);
-      return "5OY4UMMWLFQWB7SZZ4YZCANFSESHAURQGEJWJFV2SRLGUDSSBOWXJOEPDM";
-    }
-  };
   const getTokenConfigForCurrency2 = (currency2, network2) => {
     var _a2;
     const tokenConfigs = {