[fee-payer] Add multi-agent / fee payer support

This adds 3 new APIs, prepRawTransaction, signRawTransaction, and
signAndSubmitRawTransaction.  Prep will create a multiagent or fee
payer transaction accordingly, unsigned with information from the
wallet on sequence number and chain id.  Then all parties can sign
the transaction with signRawTransaction, and the last party can
sign with signAndSubmitRawTransaction to sign and send it off as the
sender.

.changeset/polite-tigers-applaud.md

@@ -0,0 +1,7 @@
+---
+"@aptos-labs/wallet-adapter-nextjs-example": minor
+"@aptos-labs/wallet-adapter-core": minor
+"@aptos-labs/wallet-adapter-react": minor
+---
+
+Added support for Multiagent and fee payer transactions

apps/nextjs-example/pages/index.tsx

@@ -15,7 +15,11 @@ import dynamic from "next/dynamic";
 import Image from "next/image";
 import {useAutoConnect} from "../components/AutoConnectProvider";
 import {useAlert} from "../components/AlertProvider";
-import {AccountInfo, NetworkInfo, WalletInfo} from "@aptos-labs/wallet-adapter-core";
+import {
+    AccountInfo,
+    NetworkInfo,
+    WalletInfo
+} from "@aptos-labs/wallet-adapter-core";
 import {useState} from "react";
 
 const FEE_PAYER_ACCOUNT_KEY = "feePayerAccountPrivateKey";
@@ -35,37 +39,62 @@ const WalletSelectorAntDesign = dynamic(
 );
 
 const aptosClient = (network?: string) => {
-    if (network === NetworkName.Devnet.toLowerCase()) {
+    if (isDevnet(network)) {
         return DEVNET_CLIENT;
-    } else if (network === NetworkName.Testnet.toLowerCase()) {
+    }else if (isTestnet(network)) {
         return TESTNET_CLIENT;
-    } else if (network === NetworkName.Mainnet.toLowerCase()) {
+    } else if (isLocal(network)) {
+        return LOCAL_CLIENT;
+    } else if (isMainnet(network)) {
         throw new Error("Please use devnet or testnet for testing");
     } else {
         throw new Error(`Unknown network: ${network}`);
     }
 }
 
 const faucet = (network?: string) => {
-    if (network === NetworkName.Devnet.toLowerCase()) {
+    if (isDevnet(network)) {
         return DEVNET_FAUCET;
-    } else if (network === NetworkName.Testnet.toLowerCase()) {
+    } else if (isTestnet(network)) {
         return TESTNET_FAUCET;
-    } else if (network === NetworkName.Mainnet.toLowerCase()) {
+    } else if (isMainnet(network)) {
         throw new Error("Please use devnet or testnet for testing");
+    } else if (isLocal(network)) {
+        return LOCAL_FAUCET;
     } else {
         throw new Error(`Unknown network: ${network}`);
     }
 }
 
 const DEVNET_CLIENT = new Provider(Network.DEVNET);
 const TESTNET_CLIENT = new Provider(Network.TESTNET);
+const LOCAL_CLIENT = new Provider(Network.LOCAL);
 const DEVNET_FAUCET = new FaucetClient("https://fullnode.devnet.aptoslabs.com", "https://faucet.devnet.aptoslabs.com");
 const TESTNET_FAUCET = new FaucetClient("https://fullnode.testnet.aptoslabs.com", "https://faucet.testnet.aptoslabs.com");
+const LOCAL_FAUCET = new FaucetClient("http://localhost:8080", "http://localhost:8081");
+
+const isDevnet = (network?: string): boolean => {
+    let net = network?.toLowerCase();
+    return net === Network.DEVNET.toLowerCase()
+}
+const isTestnet = (network?: string): boolean => {
+    let net = network?.toLowerCase();
+    return net === Network.TESTNET.toLowerCase()
+}
+const isMainnet = (network?: string): boolean => {
+    let net = network?.toLowerCase();
+    return net === Network.MAINNET.toLowerCase()
+}
+
+const isLocal = (network?: string): boolean => {
+    let net = network?.toLowerCase();
+    return net === "localhost" || net === "local"
+}
 
 const isSendableNetwork = (connected: boolean, network?: string): boolean => {
-    return connected && (network?.toLowerCase() === NetworkName.Devnet.toLowerCase()
-        || network?.toLowerCase() === NetworkName.Testnet.toLowerCase())
+    return connected && (isDevnet(network)
+        || isTestnet(network)
+        || isLocal(network))
 }
 
 export default function App() {
@@ -312,11 +341,12 @@ function OptionalFunctionality() {
         connected,
         account,
         network,
-        signAndSubmitTransaction,
         signAndSubmitBCSTransaction,
         signTransaction,
         signMessageAndVerify,
-        signMultiAgentTransaction,
+        prepRawTransaction,
+        signRawTransaction,
+        signAndSubmitRawTransaction,
     } = useWallet();
     let sendable = isSendableNetwork(connected, network?.name)
 
@@ -409,7 +439,56 @@ function OptionalFunctionality() {
         return feePayerAccount;
     }
 
-    const onSubmitFeePayer = async () => {
+    const signAndSubmitFeePayerTransaction = async () => {
+        if (!account) {
+            throw new Error("Not connected");
+        }
+
+        let provider = aptosClient(network?.name.toLowerCase());
+        // Generate an account and fund it
+        let feePayerAccount = await fundAndSetFeePayer(provider);
+
+        const payload: Types.TransactionPayload = {
+            type: "entry_function_payload",
+            function: "0x1::aptos_account::transfer",
+            type_arguments: [],
+            arguments: [account.address, 1], // 1 is in Octas
+        };
+
+        // Get the information about gas & expiration from the wallet
+        let rawTxn = await prepRawTransaction({
+            payload: payload,
+            feePayer: {
+                publicKey: feePayerAccount.pubKey().hex(),
+                address: feePayerAccount.address().hex()
+            },
+        });
+
+        if (!rawTxn) {
+            console.log("Failed to prep transaction");
+            return;
+        }
+
+        // Sign with fee payer
+        const feePayerAuthenticator = await provider.signMultiTransaction(feePayerAccount, (rawTxn as TxnBuilderTypes.FeePayerRawTransaction));
+
+        // Sign and submit with wallet
+        const response = await signAndSubmitRawTransaction({
+            rawTransaction: rawTxn,
+            feePayerAuthenticator: feePayerAuthenticator,
+        });
+        if (!response?.hash) {
+            throw new Error(`No response given ${response}`)
+        }
+        await aptosClient(network?.name.toLowerCase()).waitForTransaction(response.hash);
+        setSuccessAlertHash(response.hash, network?.name);
+
+        setSuccessAlertMessage(
+            JSON.stringify({signAndSubmitTransaction: response ?? "No response"})
+        );
+    };
+
+    const signFeePayerTransaction = async () => {
         if (!account) {
             throw new Error("Not connected");
         }
@@ -441,26 +520,25 @@ function OptionalFunctionality() {
         const feePayerAuthenticator = await provider.signMultiTransaction(feePayerAccount, rawTxn);
 
         // Sign with user
-        const userSignature  = await signMultiAgentTransaction(rawTxn);
-        // TODO: Why do we need to check this when the error should fail?
+        const userSignature = await signRawTransaction(rawTxn);
         if (!userSignature) {
             return;
         }
 
         // TODO: This extra code here needs to be put into the wallet adapter
         let userAuthenticator = new TxnBuilderTypes.AccountAuthenticatorEd25519(
-            new TxnBuilderTypes.Ed25519PublicKey(HexString.ensure(account.publicKey as string).toUint8Array()),
-            new TxnBuilderTypes.Ed25519Signature(HexString.ensure(userSignature as string).toUint8Array())
+            new TxnBuilderTypes.Ed25519PublicKey(HexString.ensure(userSignature.publicKey as string).toUint8Array()),
+            new TxnBuilderTypes.Ed25519Signature(HexString.ensure(userSignature.signature as string).toUint8Array())
         );
 
         // Submit it TODO: the wallet possibly should send it instead?
         let response: undefined | Types.PendingTransaction = undefined;
-            response = await provider.submitFeePayerTransaction(rawTxn, userAuthenticator, feePayerAuthenticator);
-            if (response?.hash === undefined) {
-                throw new Error(`No response given ${response}`)
-            }
-            await aptosClient(network?.name.toLowerCase()).waitForTransaction(response.hash);
-            setSuccessAlertHash(response.hash, network?.name);
+        response = await provider.submitFeePayerTransaction(rawTxn, userAuthenticator, feePayerAuthenticator);
+        if (response?.hash === undefined) {
+            throw new Error(`No response given ${response}`)
+        }
+        await aptosClient(network?.name.toLowerCase()).waitForTransaction(response.hash);
+        setSuccessAlertHash(response.hash, network?.name);
 
         setSuccessAlertMessage(
             JSON.stringify({signAndSubmitTransaction: response ?? "No response"})
@@ -477,8 +555,10 @@ function OptionalFunctionality() {
             <Button color={"blue"} onClick={onSignTransaction} disabled={!sendable} message={"Sign transaction"}/>
             <Button color={"blue"} onClick={onSignAndSubmitBCSTransaction} disabled={!sendable}
                     message={"Sign and submit BCS transaction"}/>
-            <Button color={"blue"} onClick={onSubmitFeePayer} disabled={!sendable}
-                    message={"Sign and submit fee payer"}/>
+            <Button color={"blue"} onClick={signFeePayerTransaction} disabled={!sendable}
+                    message={"Sign and submit fee payer by application"}/>
+            <Button color={"blue"} onClick={signAndSubmitFeePayerTransaction} disabled={!sendable}
+                    message={"Sign and submit fee payer by wallet"}/>
         </Col>
     </Row>;
 }

packages/wallet-adapter-core/src/WalletCore.ts

@@ -1,4 +1,11 @@
-import {HexString, TxnBuilderTypes, Types} from "aptos";
+import {
+  AnyRawTransaction,
+  HexString,
+  Network,
+  Provider,
+  TxnBuilderTypes,
+  Types
+} from "aptos";
 import EventEmitter from "eventemitter3";
 import nacl from "tweetnacl";
 import { Buffer } from "buffer";
@@ -29,7 +36,7 @@ import {
   Wallet,
   WalletInfo,
   WalletCoreEvents,
-  TransactionOptions,
+  TransactionOptions, RawTransactionRequest, RawTransactionPrepPayload, SignRawTransactionResponse,
 } from "./types";
 import {
   removeLocalStorage,
@@ -371,27 +378,6 @@ export class WalletCore extends EventEmitter<WalletCoreEvents> {
     }
   }
 
-  async signMultiAgentTransaction(
-    transaction: TxnBuilderTypes.MultiAgentRawTransaction | TxnBuilderTypes.FeePayerRawTransaction
-  ): Promise<string | null> {
-    if (this._wallet && !("signMultiAgentTransaction" in this._wallet)) {
-      throw new WalletNotSupportedMethod(
-          `Multi agent & Fee payer transactions are not supported by ${this.wallet?.name}`
-      ).message;
-    }
-    try {
-      this.doesWalletExist();
-      const response = await (this._wallet as any).signMultiAgentTransaction(
-          transaction
-      );
-      return response;
-    } catch (error: any) {
-      const errMsg =
-          typeof error == "object" && "message" in error ? error.message : error;
-      throw new WalletSignTransactionError(errMsg).message;
-    }
-  }
-
   /**
   Event for when account has changed on the wallet
   @return the new account info
@@ -501,4 +487,124 @@ export class WalletCore extends EventEmitter<WalletCoreEvents> {
       throw new WalletSignMessageAndVerifyError(errMsg).message;
     }
   }
+
+  /**
+   * Provides a raw transaction for wallets to sign.
+   *
+   * This includes building a transaction for multi-agent and fee payer transactions.  It pulls the address,
+   * sequence number, and chain id from the wallet directly.
+   *
+   * @param input Raw transaction arguments and fee payer / multiagent signers
+   */
+  async prepRawTransaction(input: RawTransactionPrepPayload): Promise<AnyRawTransaction> {
+    try {
+      this.doesWalletExist();
+    } catch (error: any) {
+      const errMsg =
+          typeof error == "object" && "message" in error ? error.message : error;
+      throw new WalletSignTransactionError(errMsg).message;
+    }
+    if (!this._account?.address) {
+      throw new WalletNotSupportedMethod(`Wallet not providing address of account`).message;
+    }
+
+    const provider = this.getClient();
+
+    // If there is a fee payer, then it's a fee payer transaction
+    // Default expiration time is 60 seconds because there are more actions
+    const expiration_timestamp_secs = Math.floor(Date.now() / 1000) + (input.options?.expiration_milliseconds ?? 60000);
+    const additional_signers = input.additionalSigners?.map((value) => {return value.address}) ?? [];
+
+    // TODO: Add simulation for gas estimation
+    if (!input.feePayer && !input.additionalSigners) {
+      return await provider.generateTransaction(HexString.ensure(this._account.address), input.payload)
+    } else if (input.feePayer) {
+      return await provider.generateFeePayerTransaction(this._account.address, input.payload, input.feePayer.address, additional_signers, {
+        max_gas_amount: input.options?.max_gas_amount?.toString(),
+        gas_unit_price: input.options?.gas_unit_price?.toString(),
+        expiration_timestamp_secs: expiration_timestamp_secs.toString()
+      })
+    } else {
+      // TODO: Support multiagent without fee payer
+      throw new WalletNotSupportedMethod(`Multiagent without fee payer is not supported yet`).message;
+    }
+  }
+
+  /**
+   * Signs a raw transaction of any type.
+   *
+   * This handles signing for single signer, fee payer, and multi-agent transactions.
+   * @param rawTransaction any raw transaction for signing
+   */
+  async signRawTransaction(
+      rawTransaction: AnyRawTransaction
+  ): Promise<SignRawTransactionResponse | null> {
+    if (this._wallet && !("signRawTransaction" in this._wallet)) {
+      throw new WalletNotSupportedMethod(
+          `SignRawTransaction is not supported by ${this.wallet?.name}`
+      ).message;
+    }
+    try {
+      this.doesWalletExist();
+      const response = await (this._wallet as any).signRawTransaction(
+          rawTransaction
+      );
+      return response;
+    } catch (error: any) {
+      const errMsg =
+          typeof error == "object" && "message" in error ? error.message : error;
+      throw new WalletSignTransactionError(errMsg).message;
+    }
+  }
+
+  /**
+   * Signs a raw transaction of any type and submits it to the blockchain.
+   *
+   * Similar to `signRawTransaction` but with submission to the blockchain.
+   * @param input The raw transaction to be submitted to the blockchain and associated options
+   */
+  async signAndSubmitRawTransaction(input: RawTransactionRequest): Promise<any> {
+    if (this._wallet && !("signAndSubmitRawTransaction" in this._wallet)) {
+      throw new WalletNotSupportedMethod(`signAndSubmitRawTransaction not supported by ${this.wallet?.name}`).message;
+    }
+    try {
+      this.doesWalletExist();
+      return await (this._wallet as any).signAndSubmitRawTransaction(input);
+    } catch (error: any) {
+      throw this.convertError(error);
+    }
+  }
+
+  private getClient(): Provider {
+    let network = this._network;
+    if (!network) {
+      throw new WalletNotSupportedMethod(`Function not supported by ${this.wallet?.name} due to network() not being supported`).message;
+    }
+
+    // TODO: All wallets need to support nodeUrl properly
+    // Now the fun about estimating a proper URL for the node
+    if (network.url) {
+      // We have a URL, let's use it
+      return new Provider({fullnodeUrl: network.url})
+    } else if (network.name) {
+      // We don't have a URL, let's use the default for the network
+      if (network.name.toLowerCase() === Network.MAINNET.toLowerCase()) {
+        return new Provider(Network.MAINNET);
+      } else if (network.name.toLowerCase() === Network.TESTNET.toLowerCase()) {
+        return new Provider(Network.TESTNET);
+      } else if (network.name.toLowerCase() === Network.DEVNET.toLowerCase()) {
+        return new Provider(Network.DEVNET);
+      } else {
+        throw new WalletNotSupportedMethod(`Invalid network ${network.name} without node URL for ${this.wallet?.name}`).message;
+      }
+    } else {
+      throw new WalletNotSupportedMethod(`Function not supported by ${this.wallet?.name} due to network() not being supported`).message;
+    }
+  }
+
+  private convertError(error: any) {
+      const errMsg =
+          typeof error == "object" && "message" in error ? error.message : error;
+      return new WalletSignTransactionError(errMsg).message;
+  }
 }