add api test (aptos-labs#8948)

* add api test

* add gas fee payer to ts sdk and add test

* enable feature in genesis

* lint

* fmt

* fmt

Author: gerben-stavenga

api/src/tests/transactions_test.rs

@@ -250,7 +250,7 @@ async fn test_multi_agent_signed_transaction() {
         .post("/transactions", resp)
         .await;
 }
-/* works when feature is enabled
+
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_fee_payer_signed_transaction() {
     let mut context = new_test_context(current_function_name!());
@@ -266,7 +266,8 @@ async fn test_fee_payer_signed_transaction() {
 
     // Create a new account with a multi-agent signer
     let txn = root_account.sign_fee_payer_with_transaction_builder(
-        vec![], &secondary,
+        vec![],
+        &secondary,
         factory.create_user_account(account.public_key()),
     );
 
@@ -276,13 +277,13 @@ async fn test_fee_payer_signed_transaction() {
         .post_bcs_txn("/transactions", body)
         .await;
 
-    let (sender, secondary_signers,fee_payer_signer) = match txn.authenticator() {
+    let (sender, _, fee_payer_signer) = match txn.authenticator() {
         TransactionAuthenticator::FeePayer {
             sender,
             secondary_signer_addresses: _,
             secondary_signers,
             fee_payer_address: _,
-            fee_payer_signer
+            fee_payer_signer,
         } => (sender, secondary_signers, fee_payer_signer),
         _ => panic!(
             "expecting TransactionAuthenticator::MultiAgent, but got: {:?}",
@@ -317,7 +318,7 @@ async fn test_fee_payer_signed_transaction() {
         .post("/transactions", resp)
         .await;
 }
-*/
+
 #[ignore]
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn test_multi_ed25519_signed_transaction() {

aptos-move/e2e-move-tests/src/tests/fee_payer.rs

@@ -164,7 +164,7 @@ fn test_two_to_two_transfer_fee_payer_is_sender() {
 
 #[test]
 fn test_two_to_two_transfer_fee_payer_without_feature() {
-    let mut h = MoveHarness::new();
+    let mut h = MoveHarness::new_with_features(vec![], vec![FeatureFlag::GAS_PAYER_ENABLED]);
 
     let alice = h.new_account_at(AccountAddress::from_hex_literal("0xa11ce").unwrap());
     let bob = h.new_account_at(AccountAddress::from_hex_literal("0xb0b").unwrap());

aptos-move/vm-genesis/src/lib.rs

@@ -411,6 +411,7 @@ pub fn default_features() -> Vec<FeatureFlag> {
         FeatureFlag::BLS12_381_STRUCTURES,
         FeatureFlag::CHARGE_INVARIANT_VIOLATION,
         FeatureFlag::APTOS_UNIQUE_IDENTIFIERS,
+        FeatureFlag::GAS_PAYER_ENABLED,
     ]
 }
 

ecosystem/typescript/sdk/src/aptos_types/authenticator.ts

@@ -19,6 +19,8 @@ export abstract class TransactionAuthenticator {
         return TransactionAuthenticatorMultiEd25519.load(deserializer);
       case 2:
         return TransactionAuthenticatorMultiAgent.load(deserializer);
+      case 3:
+        return TransactionAuthenticatorFeePayer.load(deserializer);
       default:
         throw new Error(`Unknown variant index for TransactionAuthenticator: ${index}`);
     }
@@ -100,6 +102,36 @@ export class TransactionAuthenticatorMultiAgent extends TransactionAuthenticator
   }
 }
 
+export class TransactionAuthenticatorFeePayer extends TransactionAuthenticator {
+  constructor(
+    public readonly sender: AccountAuthenticator,
+    public readonly secondary_signer_addresses: Seq<AccountAddress>,
+    public readonly secondary_signers: Seq<AccountAuthenticator>,
+    public readonly fee_payer: { address: AccountAddress; authenticator: AccountAuthenticator },
+  ) {
+    super();
+  }
+
+  serialize(serializer: Serializer): void {
+    serializer.serializeU32AsUleb128(3);
+    this.sender.serialize(serializer);
+    serializeVector<AccountAddress>(this.secondary_signer_addresses, serializer);
+    serializeVector<AccountAuthenticator>(this.secondary_signers, serializer);
+    this.fee_payer.address.serialize(serializer);
+    this.fee_payer.authenticator.serialize(serializer);
+  }
+
+  static load(deserializer: Deserializer): TransactionAuthenticatorMultiAgent {
+    const sender = AccountAuthenticator.deserialize(deserializer);
+    const secondary_signer_addresses = deserializeVector(deserializer, AccountAddress);
+    const secondary_signers = deserializeVector(deserializer, AccountAuthenticator);
+    const address = AccountAddress.deserialize(deserializer);
+    const authenticator = AccountAuthenticator.deserialize(deserializer);
+    const fee_payer = { address, authenticator };
+    return new TransactionAuthenticatorFeePayer(sender, secondary_signer_addresses, secondary_signers, fee_payer);
+  }
+}
+
 export abstract class AccountAuthenticator {
   abstract serialize(serializer: Serializer): void;
 

ecosystem/typescript/sdk/src/aptos_types/transaction.ts

@@ -21,7 +21,7 @@ import {
   Uint16,
   Uint256,
 } from "../bcs";
-import { TransactionAuthenticator } from "./authenticator";
+import { AccountAuthenticator, TransactionAuthenticator, TransactionAuthenticatorMultiAgent } from "./authenticator";
 import { Identifier } from "./identifier";
 import { TypeTag } from "./type_tag";
 import { AccountAddress } from "./account_address";
@@ -371,6 +371,8 @@ export abstract class RawTransactionWithData {
     switch (index) {
       case 0:
         return MultiAgentRawTransaction.load(deserializer);
+      case 1:
+        return FeePayerRawTransaction.load(deserializer);
       default:
         throw new Error(`Unknown variant index for RawTransactionWithData: ${index}`);
     }
@@ -400,6 +402,32 @@ export class MultiAgentRawTransaction extends RawTransactionWithData {
   }
 }
 
+export class FeePayerRawTransaction extends RawTransactionWithData {
+  constructor(
+    public readonly raw_txn: RawTransaction,
+    public readonly secondary_signer_addresses: Seq<AccountAddress>,
+    public readonly fee_payer_address: AccountAddress,
+  ) {
+    super();
+  }
+
+  serialize(serializer: Serializer): void {
+    // enum variant index
+    serializer.serializeU32AsUleb128(1);
+    this.raw_txn.serialize(serializer);
+    serializeVector<TransactionArgument>(this.secondary_signer_addresses, serializer);
+    this.fee_payer_address.serialize(serializer);
+  }
+
+  static load(deserializer: Deserializer): FeePayerRawTransaction {
+    const rawTxn = RawTransaction.deserialize(deserializer);
+    const secondarySignerAddresses = deserializeVector(deserializer, AccountAddress);
+    const feePayerAddress = AccountAddress.deserialize(deserializer);
+
+    return new FeePayerRawTransaction(rawTxn, secondarySignerAddresses, feePayerAddress);
+  }
+}
+
 export abstract class TransactionPayload {
   abstract serialize(serializer: Serializer): void;
 

ecosystem/typescript/sdk/src/plugins/token_client.ts

@@ -291,12 +291,12 @@ export class TokenClient {
    * Directly transfer the specified amount of tokens from account to receiver
    * using a single multi signature transaction.
    *
-   * @param sender AptosAccount where token from which tokens will be transfered
-   * @param receiver Hex-encoded 32 byte Aptos account address to which tokens will be transfered
+   * @param sender AptosAccount where token from which tokens will be transferred
+   * @param receiver Hex-encoded 32 byte Aptos account address to which tokens will be transferred
    * @param creator Hex-encoded 32 byte Aptos account address to which created tokens
    * @param collectionName Name of collection where token is stored
    * @param name Token name
-   * @param amount Amount of tokens which will be transfered
+   * @param amount Amount of tokens which will be transferred
    * @param property_version the version of token PropertyMap with a default value 0.
    * @returns The hash of the transaction submitted to the API
    */
@@ -352,6 +352,85 @@ export class TokenClient {
     return transactionRes.hash;
   }
 
+  /**
+   * Directly transfer the specified amount of tokens from account to receiver
+   * using a single multi signature transaction.
+   *
+   * @param sender AptosAccount where token from which tokens will be transferred
+   * @param receiver Hex-encoded 32 byte Aptos account address to which tokens will be transferred
+   * @param creator Hex-encoded 32 byte Aptos account address to which created tokens
+   * @param collectionName Name of collection where token is stored
+   * @param name Token name
+   * @param amount Amount of tokens which will be transferred
+   * @param fee_payer AptosAccount which will pay fee for transaction
+   * @param property_version the version of token PropertyMap with a default value 0.
+   * @returns The hash of the transaction submitted to the API
+   */
+  async directTransferTokenWithFeePayer(
+    sender: AptosAccount,
+    receiver: AptosAccount,
+    creator: MaybeHexString,
+    collectionName: string,
+    name: string,
+    amount: AnyNumber,
+    fee_payer: AptosAccount,
+    propertyVersion: AnyNumber = 0,
+    extraArgs?: OptionalTransactionArgs,
+  ): Promise<string> {
+    const builder = new TransactionBuilderRemoteABI(this.aptosClient, { sender: sender.address(), ...extraArgs });
+    const rawTxn = await builder.build(
+      "0x3::token::direct_transfer_script",
+      [],
+      [creator, collectionName, name, propertyVersion, amount],
+    );
+
+    const feePayerTxn = new TxnBuilderTypes.FeePayerRawTransaction(
+      rawTxn,
+      [TxnBuilderTypes.AccountAddress.fromHex(receiver.address())],
+      TxnBuilderTypes.AccountAddress.fromHex(fee_payer.address()),
+    );
+
+    const senderSignature = new TxnBuilderTypes.Ed25519Signature(
+      sender.signBuffer(TransactionBuilder.getSigningMessage(feePayerTxn)).toUint8Array(),
+    );
+
+    const senderAuthenticator = new TxnBuilderTypes.AccountAuthenticatorEd25519(
+      new TxnBuilderTypes.Ed25519PublicKey(sender.signingKey.publicKey),
+      senderSignature,
+    );
+
+    const receiverSignature = new TxnBuilderTypes.Ed25519Signature(
+      receiver.signBuffer(TransactionBuilder.getSigningMessage(feePayerTxn)).toUint8Array(),
+    );
+
+    const receiverAuthenticator = new TxnBuilderTypes.AccountAuthenticatorEd25519(
+      new TxnBuilderTypes.Ed25519PublicKey(receiver.signingKey.publicKey),
+      receiverSignature,
+    );
+
+    const feePayerSignature = new TxnBuilderTypes.Ed25519Signature(
+      fee_payer.signBuffer(TransactionBuilder.getSigningMessage(feePayerTxn)).toUint8Array(),
+    );
+
+    const feePayerAuthenticator = new TxnBuilderTypes.AccountAuthenticatorEd25519(
+      new TxnBuilderTypes.Ed25519PublicKey(fee_payer.signingKey.publicKey),
+      feePayerSignature,
+    );
+
+    const txAuthenticatorFeePayer = new TxnBuilderTypes.TransactionAuthenticatorFeePayer(
+      senderAuthenticator,
+      [TxnBuilderTypes.AccountAddress.fromHex(receiver.address())],
+      [receiverAuthenticator],
+      { address: TxnBuilderTypes.AccountAddress.fromHex(fee_payer.address()), authenticator: feePayerAuthenticator },
+    );
+
+    const bcsTxn = bcsToBytes(new TxnBuilderTypes.SignedTransaction(rawTxn, txAuthenticatorFeePayer));
+
+    const transactionRes = await this.aptosClient.submitSignedBCSTransaction(bcsTxn);
+
+    return transactionRes.hash;
+  }
+
   /**
    * User opt-in or out direct transfer through a boolean flag
    *

ecosystem/typescript/sdk/src/tests/e2e/aptos_client.test.ts

@@ -462,6 +462,103 @@ test(
   longTestTimeout,
 );
 
+test(
+  "submits multiagent transaction with fee payer",
+  async () => {
+    const client = new AptosClient(NODE_URL);
+    const faucetClient = getFaucetClient();
+    const tokenClient = new TokenClient(client);
+
+    const alice = new AptosAccount();
+    const bob = new AptosAccount();
+
+    // Fund both Alice's and Bob's Account
+    await faucetClient.fundAccount(alice.address(), 100000000);
+    await faucetClient.fundAccount(bob.address(), 100000000);
+
+    const collectionName = "AliceCollection";
+    const tokenName = "Alice Token";
+
+    async function ensureTxnSuccess(txnHashPromise: Promise<string>) {
+      const txnHash = await txnHashPromise;
+      const txn = await client.waitForTransactionWithResult(txnHash);
+      expect((txn as any)?.success).toBe(true);
+    }
+
+    // Create collection and token on Alice's account
+    await ensureTxnSuccess(
+      tokenClient.createCollection(alice, collectionName, "Alice's simple collection", "https://aptos.dev"),
+    );
+
+    await ensureTxnSuccess(
+      tokenClient.createToken(
+        alice,
+        collectionName,
+        tokenName,
+        "Alice's simple token",
+        1,
+        "https://aptos.dev/img/nyan.jpeg",
+        1000,
+        alice.address(),
+        0,
+        0,
+        ["key"],
+        ["2"],
+        ["u64"],
+      ),
+    );
+
+    const propertyVersion = 0;
+    const tokenId = {
+      token_data_id: {
+        creator: alice.address().hex(),
+        collection: collectionName,
+        name: tokenName,
+      },
+      property_version: `${propertyVersion}`,
+    };
+
+    // Transfer Token from Alice's Account to Bob's Account with bob paying the fee
+    await tokenClient.getCollectionData(alice.address().hex(), collectionName);
+    let aliceBalance = await tokenClient.getTokenForAccount(alice.address().hex(), tokenId);
+    expect(aliceBalance.amount).toBe("1");
+
+    const getBalance = async (account: AptosAccount) => {
+      const resources = await client.getAccountResources(account.address().hex());
+      let accountResource = resources.find((r) => r.type === aptosCoin);
+      return BigInt((accountResource!.data as any).coin.value);
+    };
+
+    const aliceBefore = await getBalance(alice);
+    const bobBefore = await getBalance(bob);
+
+    const txnHash = await tokenClient.directTransferTokenWithFeePayer(
+      alice,
+      bob,
+      alice.address(),
+      collectionName,
+      tokenName,
+      1,
+      bob,
+      propertyVersion,
+      undefined,
+    );
+
+    await client.waitForTransaction(txnHash, { checkSuccess: true });
+
+    aliceBalance = await tokenClient.getTokenForAccount(alice.address().hex(), tokenId);
+    expect(aliceBalance.amount).toBe("0");
+
+    const bobBalance = await tokenClient.getTokenForAccount(bob.address().hex(), tokenId);
+    expect(bobBalance.amount).toBe("1");
+
+    // Check that Alice did not pay the fee
+    expect(await getBalance(alice)).toBe(aliceBefore);
+    // Check that Bob paid the fee
+    expect(await getBalance(bob)).toBeLessThan(bobBefore);
+  },
+  longTestTimeout,
+);
 test(
   "publishes a package",
   async () => {

ecosystem/typescript/sdk/src/transaction_builder/builder.ts

@@ -13,6 +13,7 @@ import {
   TransactionAuthenticatorMultiEd25519,
   SigningMessage,
   MultiAgentRawTransaction,
+  FeePayerRawTransaction,
   AccountAddress,
   EntryFunction,
   Identifier,
@@ -42,7 +43,7 @@ export { TypeTagParser } from "../aptos_types";
 const RAW_TRANSACTION_SALT = "APTOS::RawTransaction";
 const RAW_TRANSACTION_WITH_DATA_SALT = "APTOS::RawTransactionWithData";
 
-type AnyRawTransaction = RawTransaction | MultiAgentRawTransaction;
+type AnyRawTransaction = RawTransaction | MultiAgentRawTransaction | FeePayerRawTransaction;
 
 /**
  * Function that takes in a Signing Message (serialized raw transaction)
@@ -78,6 +79,8 @@ export class TransactionBuilder<F extends SigningFn> {
       hash.update(RAW_TRANSACTION_SALT);
     } else if (rawTxn instanceof MultiAgentRawTransaction) {
       hash.update(RAW_TRANSACTION_WITH_DATA_SALT);
+    } else if (rawTxn instanceof FeePayerRawTransaction) {
+      hash.update(RAW_TRANSACTION_WITH_DATA_SALT);
     } else {
       throw new Error("Unknown transaction type.");
     }