uvd-x402-sdk 2.10.1 → 2.12.0

package/dist/providers/algorand/index.mjs

@@ -684,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");
     }
@@ -722,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();
@@ -729,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) {
@@ -747,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();
   }
   /**
@@ -793,15 +877,17 @@ var AlgorandProvider = class {
     }
   }
   /**
-   * Create Algorand ASA transfer payment
+   * Create Algorand atomic group payment (GoPlausible x402-avm spec)
+   *
+   * Transaction structure (atomic group):
+   * - Transaction 0: Fee payment (UNSIGNED) - facilitator -> facilitator, covers all fees
+   * - Transaction 1: ASA transfer (SIGNED) - client -> merchant
    *
-   * Transaction structure:
-   * 1. ASA Transfer from user to recipient
-   * 2. Facilitator pays transaction fees
+   * The facilitator signs transaction 0 and submits the complete atomic group.
    */
   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) {
@@ -810,28 +896,85 @@ var AlgorandProvider = class {
     const algodClient = await this.getAlgodClient(chainConfig);
     const recipient = paymentInfo.recipients?.algorand || paymentInfo.recipient;
     const assetId = parseInt(chainConfig.usdc.address, 10);
+    const facilitatorAddress = paymentInfo.facilitator;
+    if (!facilitatorAddress) {
+      throw new X402Error(
+        "Facilitator address required for Algorand payments. Set paymentInfo.facilitator",
+        "PAYMENT_FAILED"
+      );
+    }
     const amount = Math.floor(parseFloat(paymentInfo.amount) * 1e6);
     try {
       const suggestedParams = await algodClient.getTransactionParams().do();
-      const txn = algosdk.makeAssetTransferTxnWithSuggestedParamsFromObject({
+      const feeTxn = algosdk.makePaymentTxnWithSuggestedParamsFromObject({
+        sender: facilitatorAddress,
+        receiver: facilitatorAddress,
+        // self-transfer
+        amount: 0,
+        suggestedParams: {
+          ...suggestedParams,
+          fee: 2e3,
+          // Covers both transactions (1000 each)
+          flatFee: true
+        }
+      });
+      const paymentTxn = algosdk.makeAssetTransferTxnWithSuggestedParamsFromObject({
         sender: this.address,
         receiver: recipient,
         amount: BigInt(amount),
         assetIndex: assetId,
-        suggestedParams,
+        suggestedParams: {
+          ...suggestedParams,
+          fee: 0,
+          // Fee paid by transaction 0
+          flatFee: true
+        },
         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");
+      const txnGroup = algosdk.assignGroupID([feeTxn, paymentTxn]);
+      const unsignedFeeTxnBytes = algosdk.encodeUnsignedTransaction(txnGroup[0]);
+      const unsignedFeeTxnBase64 = uint8ArrayToBase64(unsignedFeeTxnBytes);
+      let signedPaymentTxnBytes;
+      if (this.walletType === "lute" && this.luteWallet) {
+        const feeTxnBase64 = uint8ArrayToBase64(txnGroup[0].toByte());
+        const paymentTxnBase64 = uint8ArrayToBase64(txnGroup[1].toByte());
+        const signedTxns = await this.luteWallet.signTxns([
+          { txn: feeTxnBase64, signers: [] },
+          // Don't sign - facilitator will
+          { txn: paymentTxnBase64 }
+          // Sign this one
+        ]);
+        if (!signedTxns || signedTxns.length < 2 || !signedTxns[1]) {
+          throw new X402Error("No signed transaction returned", "SIGNATURE_REJECTED");
+        }
+        const signedResult = signedTxns[1];
+        signedPaymentTxnBytes = this.decodeSignedTxn(signedResult);
+      } else if (this.walletType === "pera" && this.peraWallet) {
+        const signedTxns = await this.peraWallet.signTransaction([
+          [
+            { txn: txnGroup[0], signers: [] },
+            // Don't sign - facilitator will
+            { txn: txnGroup[1] }
+            // Sign this one
+          ]
+        ]);
+        if (!signedTxns || signedTxns.length < 2 || !signedTxns[1]) {
+          throw new X402Error("No signed transaction returned", "SIGNATURE_REJECTED");
+        }
+        signedPaymentTxnBytes = signedTxns[1];
+      } else {
+        throw new X402Error("No wallet available for signing", "WALLET_NOT_CONNECTED");
       }
-      const signedTxn = signedTxns[0];
+      const signedPaymentTxnBase64 = uint8ArrayToBase64(signedPaymentTxnBytes);
       const payload = {
-        from: this.address,
-        to: recipient,
-        amount: amount.toString(),
-        assetId,
-        signedTxn: uint8ArrayToBase64(signedTxn)
+        paymentIndex: 1,
+        // Index of the payment transaction in the group
+        paymentGroup: [
+          unsignedFeeTxnBase64,
+          // Transaction 0: unsigned fee tx
+          signedPaymentTxnBase64
+          // Transaction 1: signed payment tx
+        ]
       };
       return JSON.stringify(payload);
     } catch (error) {
@@ -850,6 +993,29 @@ var AlgorandProvider = class {
       );
     }
   }
+  /**
+   * Decode signed transaction from wallet response (handles various formats)
+   */
+  decodeSignedTxn(signedResult) {
+    if (signedResult instanceof Uint8Array) {
+      return signedResult;
+    } else if (typeof signedResult === "string") {
+      try {
+        return Uint8Array.from(atob(signedResult), (c) => c.charCodeAt(0));
+      } catch {
+        const standardBase64 = signedResult.replace(/-/g, "+").replace(/_/g, "/");
+        return Uint8Array.from(atob(standardBase64), (c) => c.charCodeAt(0));
+      }
+    } else if (ArrayBuffer.isView(signedResult)) {
+      return new Uint8Array(
+        signedResult.buffer,
+        signedResult.byteOffset,
+        signedResult.byteLength
+      );
+    } else {
+      throw new X402Error("Unexpected signed transaction format", "PAYMENT_FAILED");
+    }
+  }
   /**
    * Encode Algorand payment as X-PAYMENT header
    *
@@ -860,14 +1026,15 @@ var AlgorandProvider = class {
    */
   encodePaymentHeader(paymentPayload, chainConfig, version = 1) {
     const payload = JSON.parse(paymentPayload);
-    const networkName = chainConfig?.name || "algorand";
+    let networkName;
+    if (chainConfig?.name === "algorand-testnet") {
+      networkName = "algorand-testnet";
+    } else {
+      networkName = "algorand-mainnet";
+    }
     const payloadData = {
-      from: payload.from,
-      to: payload.to,
-      amount: payload.amount,
-      assetId: payload.assetId,
-      signedTxn: payload.signedTxn,
-      ...payload.note && { note: payload.note }
+      paymentIndex: payload.paymentIndex,
+      paymentGroup: payload.paymentGroup
     };
     const x402Payload = version === 2 ? {
       x402Version: 2,
@@ -879,7 +1046,6 @@ var AlgorandProvider = class {
       x402Version: 1,
       scheme: "exact",
       network: networkName,
-      // Plain chain name for v1
       payload: payloadData
     };
     return btoa(JSON.stringify(x402Payload));