feat: add multi-agent transaction support with fee payer functionality in RawTransactionWithData

Author: WGB5445

crates/aptos-rust-sdk-types/src/api_types/transaction.rs

@@ -211,6 +211,30 @@ pub enum RawTransactionWithData {
     },
 }
 
+impl RawTransactionWithData {
+    pub fn new_multi_agent(
+        raw_txn: RawTransaction,
+        secondary_signer_addresses: Vec<AccountAddress>,
+    ) -> Self {
+        Self::MultiAgent {
+            raw_txn,
+            secondary_signer_addresses,
+        }
+    }
+
+    pub fn new_multi_agent_with_fee_payer(
+        raw_txn: RawTransaction,
+        secondary_signer_addresses: Vec<AccountAddress>,
+        fee_payer_address: AccountAddress,
+    ) -> Self {
+        Self::MultiAgentWithFeePayer {
+            raw_txn,
+            secondary_signer_addresses,
+            fee_payer_address,
+        }
+    }
+}
+
 impl SignedTransaction {
     pub fn new(raw_txn: RawTransaction, authenticator: TransactionAuthenticator) -> Self {
         Self {

crates/examples/src/lib.rs

@@ -2,18 +2,20 @@
 mod tests {
     use aptos_crypto::compat::Sha3_256;
     use aptos_crypto::ed25519::{Ed25519PrivateKey, Ed25519PublicKey};
+    use aptos_crypto::Uniform;
     use aptos_rust_sdk::client::builder::AptosClientBuilder;
     use aptos_rust_sdk::client::config::AptosNetwork;
     use aptos_rust_sdk_types::api_types::address::AccountAddress;
     use aptos_rust_sdk_types::api_types::chain_id::ChainId;
     use aptos_rust_sdk_types::api_types::module_id::ModuleId;
     use aptos_rust_sdk_types::api_types::transaction::{
-        EntryFunction, RawTransaction, SignedTransaction, TransactionPayload
+        EntryFunction, RawTransaction, SignedTransaction, TransactionPayload,
     };
     use aptos_rust_sdk_types::api_types::transaction_authenticator::{
         AccountAuthenticator, AuthenticationKey, TransactionAuthenticator,
     };
     use ed25519_dalek::Digest;
+    use std::str::FromStr;
 
     #[tokio::test]
     async fn submit_transaction() {
@@ -81,25 +83,122 @@ mod tests {
         let signature = key.sign_message(&message);
 
         let simulate_transaction = client
-            .simulate_transaction(
-                SignedTransaction::new(
-                    raw_txn.clone(),
+            .simulate_transaction(SignedTransaction::new(
+                raw_txn.clone(),
                 TransactionAuthenticator::single_sender(AccountAuthenticator::no_authenticator()),
-                )
-            )
+            ))
             .await;
 
         println!("Simulate Transaction: {:?}", simulate_transaction);
 
         let transaction = client
-            .submit_transaction(
-                SignedTransaction::new(
-                    raw_txn.clone(),
-                    TransactionAuthenticator::ed25519(Ed25519PublicKey::from(&key), signature),
-                )
-            )
+            .submit_transaction(SignedTransaction::new(
+                raw_txn.clone(),
+                TransactionAuthenticator::ed25519(Ed25519PublicKey::from(&key), signature),
+            ))
             .await;
 
         println!("Transaction: {:?}", transaction);
     }
+
+    #[tokio::test]
+    async fn submit_feepayer_transaction() {
+        let builder = AptosClientBuilder::new(AptosNetwork::testnet());
+        let client = builder.build();
+
+        let state = client.get_state().await.unwrap();
+
+        let mut seed = [0u8; 32];
+        let seed_bytes =
+            hex::decode("4aeeeb3f286caa91984d4a16d424786c7aa26947050b00e84ab7033f2aab0c2d")
+                .unwrap(); // Remove the 0x prefix
+        seed[..seed_bytes.len()].copy_from_slice(&seed_bytes);
+
+        let fee_payer_key = Ed25519PrivateKey::try_from(seed_bytes.as_slice()).unwrap();
+        let fee_payer_address =
+            AuthenticationKey::ed25519(&Ed25519PublicKey::from(&fee_payer_key)).account_address();
+        println!("Feepayer Address: {:?}", fee_payer_address.to_string());
+
+        let txn_sender_key = Ed25519PrivateKey::generate(&mut rand::thread_rng());
+        let txn_sender_address =
+            AuthenticationKey::ed25519(&Ed25519PublicKey::from(&txn_sender_key)).account_address();
+
+        let payload = TransactionPayload::EntryFunction(EntryFunction::new(
+            ModuleId::new(
+                AccountAddress::from_str(
+                    "0x94bd6fa34dba07f935ea2288ba36d74aa5dda6ae541137844cc2f0af8b6b73f3",
+                )
+                .unwrap(),
+                "create_object".to_string(),
+            ),
+            "create".to_string(),
+            vec![],
+            vec![],
+        ));
+
+        let max_gas_amount = 1500;
+        let gas_unit_price = 100;
+        let expiration_timestamp_secs = state.timestamp_usecs / 1000 / 1000 + 60 * 10;
+        let chain_id = ChainId::Testnet;
+
+        let raw_txn = RawTransaction::new(
+            txn_sender_address,
+            0,
+            payload,
+            max_gas_amount,
+            gas_unit_price,
+            expiration_timestamp_secs,
+            chain_id,
+        );
+
+        let mut sha3 = Sha3_256::new();
+        sha3.update("APTOS::RawTransactionWithData".as_bytes());
+        let hash = sha3.finalize().to_vec();
+        let mut bytes = vec![];
+        bcs::serialize_into(&mut bytes, &raw_txn).unwrap();
+        let mut message = vec![];
+        message.extend(hash);
+        // FeePayerRawTransaction 1
+        message.extend(bcs::to_bytes(&1u8).unwrap());
+        message.extend(bytes);
+        message.extend(bcs::to_bytes::<Vec<AccountAddress>>(&vec![]).unwrap());
+        message.extend(bcs::to_bytes::<AccountAddress>(&fee_payer_address).unwrap());
+
+        let txn_sender_signature = txn_sender_key.sign_message(&message);
+
+        let fee_payer_signature = fee_payer_key.sign_message(&message);
+
+        let simulate_transaction = client
+            .simulate_transaction(SignedTransaction::new(
+                raw_txn.clone(),
+                TransactionAuthenticator::fee_payer(
+                    AccountAuthenticator::no_authenticator(),
+                    vec![],
+                    vec![],
+                    fee_payer_address,
+                    AccountAuthenticator::no_authenticator(),
+                ),
+            ))
+            .await;
+        println!("Simulate Transaction: {:?}", simulate_transaction);
+        let transaction = client
+            .submit_transaction(SignedTransaction::new(
+                raw_txn.clone(),
+                TransactionAuthenticator::fee_payer(
+                    AccountAuthenticator::ed25519(
+                        Ed25519PublicKey::from(&txn_sender_key),
+                        txn_sender_signature,
+                    ),
+                    vec![],
+                    vec![],
+                    fee_payer_address,
+                    AccountAuthenticator::ed25519(
+                        Ed25519PublicKey::from(&fee_payer_key),
+                        fee_payer_signature,
+                    ),
+                ),
+            ))
+            .await;
+        println!("Transaction: {:?}", transaction);
+    }
 }