uvd-x402-sdk 2.10.1 → 2.12.0

package/dist/providers/algorand/index.d.mts

@@ -1,11 +1,16 @@
-import { c as WalletAdapter, C as ChainConfig, P as PaymentInfo, l as X402Version } from '../../index-D-dO_FoP.mjs';
+import { c as WalletAdapter, C as ChainConfig, P as PaymentInfo, l as X402Version } from '../../index-fIhvHqCQ.mjs';
 
 /**
  * uvd-x402-sdk - Algorand Provider
  *
- * Provides wallet connection and payment creation for Algorand via Pera Wallet.
+ * Provides wallet connection and payment creation for Algorand.
+ * Supports both Lute Wallet (desktop browser extension) and Pera Wallet (mobile).
  * Uses ASA (Algorand Standard Assets) transfers for USDC payments.
  *
+ * Wallet Priority:
+ * 1. Lute Wallet - Desktop browser extension (preferred for desktop)
+ * 2. Pera Wallet - Mobile via WalletConnect (fallback/mobile)
+ *
  * USDC ASA IDs:
  * - Mainnet: 31566704
  * - Testnet: 10458941
@@ -17,7 +22,7 @@ import { c as WalletAdapter, C as ChainConfig, P as PaymentInfo, l as X402Versio
  *
  * const algorand = new AlgorandProvider();
  *
- * // Connect to Pera Wallet
+ * // Connect to Lute (desktop) or Pera (mobile) automatically
  * const address = await algorand.connect();
  *
  * // Create Algorand payment
@@ -28,28 +33,44 @@ import { c as WalletAdapter, C as ChainConfig, P as PaymentInfo, l as X402Versio
  */
 
 /**
- * AlgorandProvider - Wallet adapter for Algorand via Pera Wallet
+ * AlgorandProvider - Wallet adapter for Algorand
  *
- * Supports both mainnet and testnet through chain configuration.
+ * Supports Lute Wallet (desktop) and Pera Wallet (mobile).
+ * Automatically detects and uses the best available wallet.
  */
 declare class AlgorandProvider implements WalletAdapter {
-    readonly id = "pera";
-    readonly name = "Pera Wallet";
+    readonly id = "algorand";
+    readonly name = "Algorand Wallet";
     readonly networkType: "algorand";
+    private walletType;
+    private luteWallet;
     private peraWallet;
     private address;
     private algodClients;
     /**
-     * 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(): boolean;
     /**
-     * Connect to Pera Wallet
+     * Get the name of the currently connected wallet
+     */
+    getWalletName(): string;
+    /**
+     * Connect to Algorand wallet
+     * Priority: Lute (desktop extension) > Pera (mobile via WalletConnect)
      */
     connect(_chainName?: string): Promise<string>;
     /**
-     * Disconnect from Pera Wallet
+     * Connect to Lute Wallet (desktop browser extension)
+     */
+    private connectLute;
+    /**
+     * Connect to Pera Wallet (mobile via WalletConnect)
+     */
+    private connectPera;
+    /**
+     * Disconnect from wallet
      */
     disconnect(): Promise<void>;
     /**
@@ -61,13 +82,19 @@ declare class AlgorandProvider implements WalletAdapter {
      */
     getBalance(chainConfig: ChainConfig): Promise<string>;
     /**
-     * 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.
      */
     signPayment(paymentInfo: PaymentInfo, chainConfig: ChainConfig): Promise<string>;
+    /**
+     * Decode signed transaction from wallet response (handles various formats)
+     */
+    private decodeSignedTxn;
     /**
      * Encode Algorand payment as X-PAYMENT header
      *

package/dist/providers/algorand/index.d.ts

@@ -1,11 +1,16 @@
-import { c as WalletAdapter, C as ChainConfig, P as PaymentInfo, l as X402Version } from '../../index-D-dO_FoP.js';
+import { c as WalletAdapter, C as ChainConfig, P as PaymentInfo, l as X402Version } from '../../index-fIhvHqCQ.js';
 
 /**
  * uvd-x402-sdk - Algorand Provider
  *
- * Provides wallet connection and payment creation for Algorand via Pera Wallet.
+ * Provides wallet connection and payment creation for Algorand.
+ * Supports both Lute Wallet (desktop browser extension) and Pera Wallet (mobile).
  * Uses ASA (Algorand Standard Assets) transfers for USDC payments.
  *
+ * Wallet Priority:
+ * 1. Lute Wallet - Desktop browser extension (preferred for desktop)
+ * 2. Pera Wallet - Mobile via WalletConnect (fallback/mobile)
+ *
  * USDC ASA IDs:
  * - Mainnet: 31566704
  * - Testnet: 10458941
@@ -17,7 +22,7 @@ import { c as WalletAdapter, C as ChainConfig, P as PaymentInfo, l as X402Versio
  *
  * const algorand = new AlgorandProvider();
  *
- * // Connect to Pera Wallet
+ * // Connect to Lute (desktop) or Pera (mobile) automatically
  * const address = await algorand.connect();
  *
  * // Create Algorand payment
@@ -28,28 +33,44 @@ import { c as WalletAdapter, C as ChainConfig, P as PaymentInfo, l as X402Versio
  */
 
 /**
- * AlgorandProvider - Wallet adapter for Algorand via Pera Wallet
+ * AlgorandProvider - Wallet adapter for Algorand
  *
- * Supports both mainnet and testnet through chain configuration.
+ * Supports Lute Wallet (desktop) and Pera Wallet (mobile).
+ * Automatically detects and uses the best available wallet.
  */
 declare class AlgorandProvider implements WalletAdapter {
-    readonly id = "pera";
-    readonly name = "Pera Wallet";
+    readonly id = "algorand";
+    readonly name = "Algorand Wallet";
     readonly networkType: "algorand";
+    private walletType;
+    private luteWallet;
     private peraWallet;
     private address;
     private algodClients;
     /**
-     * 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(): boolean;
     /**
-     * Connect to Pera Wallet
+     * Get the name of the currently connected wallet
+     */
+    getWalletName(): string;
+    /**
+     * Connect to Algorand wallet
+     * Priority: Lute (desktop extension) > Pera (mobile via WalletConnect)
      */
     connect(_chainName?: string): Promise<string>;
     /**
-     * Disconnect from Pera Wallet
+     * Connect to Lute Wallet (desktop browser extension)
+     */
+    private connectLute;
+    /**
+     * Connect to Pera Wallet (mobile via WalletConnect)
+     */
+    private connectPera;
+    /**
+     * Disconnect from wallet
      */
     disconnect(): Promise<void>;
     /**
@@ -61,13 +82,19 @@ declare class AlgorandProvider implements WalletAdapter {
      */
     getBalance(chainConfig: ChainConfig): Promise<string>;
     /**
-     * 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.
      */
     signPayment(paymentInfo: PaymentInfo, chainConfig: ChainConfig): Promise<string>;
+    /**
+     * Decode signed transaction from wallet response (handles various formats)
+     */
+    private decodeSignedTxn;
     /**
      * Encode Algorand payment as X-PAYMENT header
      *

package/dist/providers/algorand/index.js

@@ -688,36 +688,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");
     }
@@ -726,6 +803,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();
@@ -733,8 +811,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) {
@@ -751,17 +831,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();
   }
   /**
@@ -797,15 +881,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) {
@@ -814,28 +900,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) {
@@ -854,6 +997,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
    *
@@ -864,14 +1030,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,
@@ -883,7 +1050,6 @@ var AlgorandProvider = class {
       x402Version: 1,
       scheme: "exact",
       network: networkName,
-      // Plain chain name for v1
       payload: payloadData
     };
     return btoa(JSON.stringify(x402Payload));