Add transaction worker

Author: banool

Cargo.lock

@@ -2,10 +2,11 @@
 resolver = "2"
 
 members = [
-    "crates/aptos-rust-sdk",
-    "crates/aptos-rust-sdk-types",
     "crates/aptos-crypto",
     "crates/aptos-crypto-derive",
+    "crates/aptos-rust-sdk",
+    "crates/aptos-rust-sdk-types",
+    "crates/aptos-txn-worker",
     "crates/examples"
 ]
 
@@ -15,10 +16,11 @@ members = [
 #
 # For more, see the "Conditional compilation for tests" section in documentation/coding_guidelines.md.
 default-members = [
+    "crates/aptos-crypto",
+    "crates/aptos-crypto-derive",
     "crates/aptos-rust-sdk",
     "crates/aptos-rust-sdk-types",
-    "crates/aptos-crypto",
-    "crates/aptos-crypto-derive"
+    "crates/aptos-txn-worker",
 ]
 
 # All workspace members should inherit these keys
@@ -47,6 +49,7 @@ anyhow = "1.0.97"
 arbitrary = { version = "1.4.1", features = ["derive"] }
 ark-bn254 = "0.5.0"
 ark-ff = "0.5.0"
+async-trait = "0.1.88"
 base64 = "0.22.1"
 bcs = { git = "https://github.com/aptos-labs/bcs.git", rev = "d31fab9d81748e2594be5cd5cdf845786a30562d" }
 bitvec = "1.0.1"
@@ -93,8 +96,10 @@ static_assertions = "1.1.0"
 syn = { version = "1.0.109", features = ["derive", "extra-traits"] }
 thiserror = "2.0.12"
 tiny-keccak = { version = "2.0.2", features = ["keccak", "sha3"] }
+tracing = "0.1.41"
 trybuild = "1.0.104"
 tokio = { version = "1.44.1", features = ["full"] }
+tokio-util = { version = "0.7.9", features = ["rt"] }
 typenum = "1.18.0"
 url = { version = "2.5.4", features = ["serde"] }
 

Cargo.toml

@@ -1,5 +1,41 @@
+use super::transaction_authenticator::AuthenticationKey;
 use serde::{Deserialize, Serialize};
-use std::fmt::Debug;
+use std::{fmt::Debug, str::FromStr};
+
+#[derive(Debug)]
+pub struct Account {
+    pub sequence_number: u64,
+    pub authentication_key: AuthenticationKey,
+}
+
+impl<'de> Deserialize<'de> for Account {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        #[derive(Deserialize)]
+        struct RawAccount {
+            sequence_number: String,
+            authentication_key: String,
+        }
+
+        let raw = RawAccount::deserialize(deserializer)?;
+
+        let sequence_number = raw.sequence_number.parse::<u64>().map_err(|e| {
+            serde::de::Error::custom(format!("Failed to parse sequence_number: {}", e))
+        })?;
+
+        let authentication_key =
+            AuthenticationKey::from_str(&raw.authentication_key).map_err(|e| {
+                serde::de::Error::custom(format!("Failed to parse authentication_key: {}", e))
+            })?;
+
+        Ok(Account {
+            sequence_number,
+            authentication_key,
+        })
+    }
+}
 
 #[derive(Debug, Serialize, Deserialize)]
 pub struct AccountResource {

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

@@ -131,6 +131,36 @@ pub struct RawTransaction {
     chain_id: ChainId,
 }
 
+impl RawTransaction {
+    pub fn get_sender(&self) -> AccountAddress {
+        self.sender
+    }
+
+    pub fn get_sequence_number(&self) -> u64 {
+        self.sequence_number
+    }
+
+    pub fn get_payload(&self) -> &TransactionPayload {
+        &self.payload
+    }
+
+    pub fn get_max_gas_amount(&self) -> u64 {
+        self.max_gas_amount
+    }
+
+    pub fn get_gas_unit_price(&self) -> u64 {
+        self.gas_unit_price
+    }
+
+    pub fn get_expiration_timestamp_secs(&self) -> u64 {
+        self.expiration_timestamp_secs
+    }
+
+    pub fn get_chain_id(&self) -> ChainId {
+        self.chain_id
+    }
+}
+
 /// Different kinds of transactions.
 #[derive(Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
 pub enum TransactionPayload {
@@ -253,7 +283,7 @@ impl GenerateSigningMessage for RawTransactionWithData {
         message.extend(hash);
         message.extend(bytes);
         Ok(message)
-    }   
+    }
 }
 
 impl SignedTransaction {
@@ -319,7 +349,6 @@ impl GenerateSigningMessage for RawTransaction {
         message.extend(bytes);
         Ok(message)
     }
-    
 }
 
 impl EntryFunction {

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

@@ -56,14 +56,19 @@ pub enum TransactionAuthenticator {
         sender: AccountAuthenticator,
         secondary_signer_addresses: Vec<AccountAddress>,
         secondary_signers: Vec<AccountAuthenticator>,
-        fee_payer_address: AccountAddress,
-        fee_payer_signer: AccountAuthenticator,
+        fee_payer: FeePayerAuthenticator,
     },
     SingleSender {
         sender: AccountAuthenticator,
     },
 }
 
+#[derive(Clone, Debug, Eq, PartialEq, Hash, Serialize, Deserialize)]
+pub struct FeePayerAuthenticator {
+    pub address: AccountAddress,
+    pub authenticator: AccountAuthenticator,
+}
+
 impl TransactionAuthenticator {
     /// Create a single-signature ed25519 authenticator
     pub fn ed25519(public_key: Ed25519PublicKey, signature: Ed25519Signature) -> Self {
@@ -72,21 +77,18 @@ impl TransactionAuthenticator {
             signature,
         }
     }
-
     /// Create a (optional) multi-agent fee payer authenticator
     pub fn fee_payer(
         sender: AccountAuthenticator,
         secondary_signer_addresses: Vec<AccountAddress>,
         secondary_signers: Vec<AccountAuthenticator>,
-        fee_payer_address: AccountAddress,
-        fee_payer_signer: AccountAuthenticator,
+        fee_payer: FeePayerAuthenticator,
     ) -> Self {
         Self::FeePayer {
             sender,
             secondary_signer_addresses,
             secondary_signers,
-            fee_payer_address,
-            fee_payer_signer,
+            fee_payer,
         }
     }
 
@@ -242,25 +244,9 @@ impl TransactionAuthenticator {
                 sender: _,
                 secondary_signer_addresses: _,
                 secondary_signers: _,
-                fee_payer_address,
+                fee_payer,
                 ..
-            } => Some(*fee_payer_address),
-        }
-    }
-
-    pub fn fee_payer_signer(&self) -> Option<AccountAuthenticator> {
-        match self {
-            Self::Ed25519 { .. }
-            | Self::MultiAgent { .. }
-            | Self::SingleSender { .. }
-            | Self::MultiEd25519 { .. } => None,
-            Self::FeePayer {
-                sender: _,
-                secondary_signer_addresses: _,
-                secondary_signers: _,
-                fee_payer_address: _,
-                fee_payer_signer,
-            } => Some(fee_payer_signer.clone()),
+            } => Some(fee_payer.address),
         }
     }
 
@@ -275,9 +261,6 @@ impl TransactionAuthenticator {
                 let mut account_authenticators: Vec<AccountAuthenticator> = vec![];
                 account_authenticators.push(self.sender());
                 account_authenticators.extend(self.secondary_signers());
-                if let Some(fee_payer) = self.fee_payer_signer() {
-                    account_authenticators.push(fee_payer);
-                }
                 account_authenticators
             }
         }
@@ -338,8 +321,7 @@ impl fmt::Display for TransactionAuthenticator {
                 sender,
                 secondary_signer_addresses,
                 secondary_signers,
-                fee_payer_address,
-                fee_payer_signer,
+                fee_payer,
             } => {
                 let mut sec_addrs: String = "".to_string();
                 for sec_addr in secondary_signer_addresses {
@@ -356,9 +338,8 @@ impl fmt::Display for TransactionAuthenticator {
                         \tsender: {}\n\
                         \tsecondary signer addresses: {}\n\
                         \tsecondary signers: {}\n\n
-                        \tfee payer address: {}\n\n
-                        \tfee payer signer: {}]",
-                    sender, sec_addrs, sec_signers, fee_payer_address, fee_payer_signer,
+                        \tfee payer address: {}]",
+                    sender, sec_addrs, sec_signers, fee_payer.address,
                 )
             }
             Self::MultiAgent {
@@ -615,7 +596,7 @@ impl fmt::Display for AccountAuthenticator {
             "AccountAuthenticator[scheme id: {:?}, public key: {}, signature: {}]",
             self.scheme(),
             hex::encode(self.public_key_bytes()),
-            hex::encode(self.signature_bytes())
+            hex::encode(self.signature_bytes()),
         )
     }
 }
@@ -645,6 +626,8 @@ impl FromStr for AuthenticationKey {
     type Err = anyhow::Error;
 
     fn from_str(s: &str) -> Result<Self, anyhow::Error> {
+        // Trim 0x from the start if present.
+        let s = if s.starts_with("0x") { &s[2..] } else { s };
         ensure!(
             !s.is_empty(),
             "authentication key string should not be empty.",