uvd-x402-sdk 2.11.1 → 2.13.0

package/dist/providers/algorand/index.mjs

@@ -674,6 +674,50 @@ function chainToCAIP2(chainName) {
   return chainName;
 }
 
+// src/facilitator.ts
+var FACILITATOR_ADDRESSES = {
+  /**
+   * Solana facilitator address (fee payer)
+   * Used for: Paying transaction fees on Solana
+   */
+  solana: "F742C4VfFLQ9zRQyithoj5229ZgtX2WqKCSFKgH2EThq",
+  /**
+   * Algorand facilitator address (fee payer)
+   * Used for: Signing Transaction 0 (fee tx) in atomic groups
+   * Note: This is derived from the facilitator's Algorand mnemonic
+   */
+  algorand: "SXHRBXS22SKKXHXK44DTQMWN2SXK3SFJWBDAQZGF4DRPW7PNFAUM2GYFAQ",
+  /**
+   * Algorand testnet facilitator address
+   */
+  "algorand-testnet": "SXHRBXS22SKKXHXK44DTQMWN2SXK3SFJWBDAQZGF4DRPW7PNFAUM2GYFAQ",
+  /**
+   * EVM facilitator address
+   * Used for: Submitting EIP-3009 transferWithAuthorization transactions
+   * Note: Same address across all EVM chains
+   */
+  evm: "0x7c5F3AdB0C7775968Bc7e7cF61b27fECf2e2b500",
+  /**
+   * Stellar facilitator address
+   * Used for: Signing soroban authorization entries
+   */
+  stellar: "GDUTDNV53WQPOB2JUZPO6SXH4LVT7CJSLCMLFQ7W4CNAXGIX7XYMCNP2",
+  /**
+   * NEAR facilitator address
+   * Used for: Relaying meta-transactions
+   */
+  near: "uvd-facilitator.near"
+};
+function getFacilitatorAddress(chainName, networkType) {
+  const exactMatch = FACILITATOR_ADDRESSES[chainName];
+  if (exactMatch) {
+    return exactMatch;
+  }
+  {
+    return FACILITATOR_ADDRESSES.algorand;
+  }
+}
+
 // src/providers/algorand/index.ts
 function uint8ArrayToBase64(bytes) {
   let binary = "";
@@ -877,11 +921,13 @@ 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();
@@ -894,40 +940,86 @@ var AlgorandProvider = class {
     const algodClient = await this.getAlgodClient(chainConfig);
     const recipient = paymentInfo.recipients?.algorand || paymentInfo.recipient;
     const assetId = parseInt(chainConfig.usdc.address, 10);
+    const chainName = chainConfig?.name || "algorand";
+    const facilitatorAddress = paymentInfo.facilitator || getFacilitatorAddress(chainName);
+    if (!facilitatorAddress) {
+      throw new X402Error(
+        "Facilitator address not configured for Algorand",
+        "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")
       });
-      let signedTxn;
+      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 txnBase64 = uint8ArrayToBase64(txn.toByte());
-        const signedTxns = await this.luteWallet.signTxns([{ txn: txnBase64 }]);
-        if (!signedTxns || signedTxns.length === 0 || !signedTxns[0]) {
+        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");
         }
-        signedTxn = Uint8Array.from(atob(signedTxns[0]), (c) => c.charCodeAt(0));
+        const signedResult = signedTxns[1];
+        signedPaymentTxnBytes = this.decodeSignedTxn(signedResult);
       } else if (this.walletType === "pera" && this.peraWallet) {
-        const signedTxns = await this.peraWallet.signTransaction([[{ txn }]]);
-        if (!signedTxns || signedTxns.length === 0) {
+        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");
         }
-        signedTxn = signedTxns[0];
+        signedPaymentTxnBytes = signedTxns[1];
       } else {
         throw new X402Error("No wallet available for signing", "WALLET_NOT_CONNECTED");
       }
+      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) {
@@ -946,6 +1038,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
    *
@@ -956,14 +1071,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,
@@ -975,7 +1091,6 @@ var AlgorandProvider = class {
       x402Version: 1,
       scheme: "exact",
       network: networkName,
-      // Plain chain name for v1
       payload: payloadData
     };
     return btoa(JSON.stringify(x402Payload));