uvd-x402-sdk 2.10.0 → 2.11.1

package/dist/providers/algorand/index.mjs

@@ -470,6 +470,22 @@ var SUPPORTED_CHAINS = {
       name: "USD Coin",
       version: "1"
     },
+    tokens: {
+      usdc: {
+        address: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+        // USDC SPL token mint
+        decimals: 6,
+        name: "USD Coin",
+        version: "1"
+      },
+      ausd: {
+        address: "AUSD1jCcCyPLybk1YnvPWsHQSrZ46dxwoMniN4N2UEB9",
+        // AUSD Token2022 mint
+        decimals: 6,
+        name: "Agora Dollar",
+        version: "1"
+      }
+    },
     x402: {
       facilitatorUrl: DEFAULT_FACILITATOR_URL,
       enabled: true
@@ -668,36 +684,113 @@ function uint8ArrayToBase64(bytes) {
 }
 var algosdk = null;
 var PeraWalletConnect = null;
+var LuteConnect = null;
 async function loadAlgorandDeps() {
   if (!algosdk) {
     algosdk = await import('algosdk');
   }
+}
+async function loadPeraWallet() {
   if (!PeraWalletConnect) {
     const peraModule = await import('@perawallet/connect');
     PeraWalletConnect = peraModule.PeraWalletConnect;
   }
 }
+async function loadLuteWallet() {
+  if (!LuteConnect) {
+    try {
+      const luteModule = await import('lute-connect');
+      LuteConnect = luteModule.default;
+    } catch {
+      LuteConnect = null;
+    }
+  }
+}
+function isLuteAvailable() {
+  if (typeof window === "undefined") return false;
+  const win = window;
+  return !!(win.algorand || win.lute);
+}
 var AlgorandProvider = class {
-  id = "pera";
-  name = "Pera Wallet";
+  id = "algorand";
+  name = "Algorand Wallet";
   networkType = "algorand";
+  // Active wallet type
+  walletType = null;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  luteWallet = null;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   peraWallet = null;
   address = null;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   algodClients = /* @__PURE__ */ new Map();
   /**
-   * Check if Pera Wallet is available
-   * Note: Pera works as a WalletConnect modal, so it's always "available"
+   * Check if any Algorand wallet is available
+   * Returns true if Lute extension is installed OR we can use Pera (always available via WalletConnect)
    */
   isAvailable() {
     return typeof window !== "undefined";
   }
   /**
-   * Connect to Pera Wallet
+   * Get the name of the currently connected wallet
+   */
+  getWalletName() {
+    if (this.walletType === "lute") return "Lute Wallet";
+    if (this.walletType === "pera") return "Pera Wallet";
+    return "Algorand Wallet";
+  }
+  /**
+   * Connect to Algorand wallet
+   * Priority: Lute (desktop extension) > Pera (mobile via WalletConnect)
    */
   async connect(_chainName) {
     await loadAlgorandDeps();
+    if (isLuteAvailable()) {
+      try {
+        return await this.connectLute();
+      } catch (error) {
+        console.warn("Lute connection failed, falling back to Pera:", error);
+      }
+    }
+    return await this.connectPera();
+  }
+  /**
+   * Connect to Lute Wallet (desktop browser extension)
+   */
+  async connectLute() {
+    await loadLuteWallet();
+    if (!LuteConnect) {
+      throw new X402Error("Lute Wallet SDK not available", "WALLET_NOT_FOUND");
+    }
+    try {
+      this.luteWallet = new LuteConnect("402milly");
+      const genesisId = "mainnet-v1.0";
+      const accounts = await this.luteWallet.connect(genesisId);
+      if (!accounts || accounts.length === 0) {
+        throw new X402Error("No accounts returned from Lute Wallet", "WALLET_CONNECTION_REJECTED");
+      }
+      this.address = accounts[0];
+      this.walletType = "lute";
+      return accounts[0];
+    } catch (error) {
+      if (error instanceof X402Error) throw error;
+      if (error instanceof Error) {
+        if (error.message.includes("rejected") || error.message.includes("cancelled")) {
+          throw new X402Error("Connection rejected by user", "WALLET_CONNECTION_REJECTED");
+        }
+      }
+      throw new X402Error(
+        `Failed to connect Lute Wallet: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "UNKNOWN_ERROR",
+        error
+      );
+    }
+  }
+  /**
+   * Connect to Pera Wallet (mobile via WalletConnect)
+   */
+  async connectPera() {
+    await loadPeraWallet();
     if (!PeraWalletConnect) {
       throw new X402Error("Failed to load Pera Wallet SDK", "WALLET_NOT_FOUND");
     }
@@ -706,6 +799,7 @@ var AlgorandProvider = class {
       const accounts = await this.peraWallet.reconnectSession();
       if (accounts.length > 0) {
         this.address = accounts[0];
+        this.walletType = "pera";
         return accounts[0];
       }
       const newAccounts = await this.peraWallet.connect();
@@ -713,8 +807,10 @@ var AlgorandProvider = class {
         throw new X402Error("No accounts returned from Pera Wallet", "WALLET_CONNECTION_REJECTED");
       }
       this.address = newAccounts[0];
+      this.walletType = "pera";
       this.peraWallet.connector?.on("disconnect", () => {
         this.address = null;
+        this.walletType = null;
       });
       return newAccounts[0];
     } catch (error) {
@@ -731,17 +827,21 @@ var AlgorandProvider = class {
     }
   }
   /**
-   * Disconnect from Pera Wallet
+   * Disconnect from wallet
    */
   async disconnect() {
-    if (this.peraWallet) {
+    if (this.walletType === "lute" && this.luteWallet) {
+      this.luteWallet = null;
+    }
+    if (this.walletType === "pera" && this.peraWallet) {
       try {
         await this.peraWallet.disconnect();
       } catch {
       }
+      this.peraWallet = null;
     }
-    this.peraWallet = null;
     this.address = null;
+    this.walletType = null;
     this.algodClients.clear();
   }
   /**
@@ -785,7 +885,7 @@ var AlgorandProvider = class {
    */
   async signPayment(paymentInfo, chainConfig) {
     await loadAlgorandDeps();
-    if (!this.peraWallet || !this.address) {
+    if (!this.address || !this.walletType) {
       throw new X402Error("Wallet not connected", "WALLET_NOT_CONNECTED");
     }
     if (!algosdk) {
@@ -805,11 +905,23 @@ var AlgorandProvider = class {
         suggestedParams,
         note: new TextEncoder().encode("x402 payment via uvd-x402-sdk")
       });
-      const signedTxns = await this.peraWallet.signTransaction([[{ txn }]]);
-      if (!signedTxns || signedTxns.length === 0) {
-        throw new X402Error("No signed transaction returned", "SIGNATURE_REJECTED");
+      let signedTxn;
+      if (this.walletType === "lute" && this.luteWallet) {
+        const txnBase64 = uint8ArrayToBase64(txn.toByte());
+        const signedTxns = await this.luteWallet.signTxns([{ txn: txnBase64 }]);
+        if (!signedTxns || signedTxns.length === 0 || !signedTxns[0]) {
+          throw new X402Error("No signed transaction returned", "SIGNATURE_REJECTED");
+        }
+        signedTxn = Uint8Array.from(atob(signedTxns[0]), (c) => c.charCodeAt(0));
+      } else if (this.walletType === "pera" && this.peraWallet) {
+        const signedTxns = await this.peraWallet.signTransaction([[{ txn }]]);
+        if (!signedTxns || signedTxns.length === 0) {
+          throw new X402Error("No signed transaction returned", "SIGNATURE_REJECTED");
+        }
+        signedTxn = signedTxns[0];
+      } else {
+        throw new X402Error("No wallet available for signing", "WALLET_NOT_CONNECTED");
       }
-      const signedTxn = signedTxns[0];
       const payload = {
         from: this.address,
         to: recipient,