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 {
@@ -264,6 +294,46 @@ impl SignedTransaction {
         }
     }
 
+    /// Create a new signed transaction with a fee payer. Use this as the fee payer, if
+    /// you are just creating a transaction to be signed by a fee payer later, use
+    /// `new_for_future_fee_payer`.
+    pub fn new_as_fee_payer(
+        raw_txn: RawTransaction,
+        sender: AccountAuthenticator,
+        secondary_signer_addresses: Vec<AccountAddress>,
+        secondary_signers: Vec<AccountAuthenticator>,
+        fee_payer_address: AccountAddress,
+        fee_payer_authenticator: AccountAuthenticator,
+    ) -> Self {
+        let authenticator = TransactionAuthenticator::FeePayer {
+            sender,
+            secondary_signer_addresses,
+            secondary_signers,
+            fee_payer: FeePayerAuthenticator {
+                address: fee_payer_address,
+                // This gets ignored for the gas station use case.
+                authenticator: fee_payer_authenticator,
+            },
+        };
+        SignedTransaction::new(raw_txn, authenticator)
+    }
+
+    /// Create a new signed transaction, indicating that a fee payer will be set later.
+    /// If you want to actually sign as a fee payer, use `new_as_fee_payer`.
+    pub fn new_for_future_fee_payer(raw_txn: RawTransaction, sender: AccountAuthenticator) -> Self {
+        let authenticator = TransactionAuthenticator::FeePayer {
+            sender,
+            secondary_signer_addresses: vec![],
+            secondary_signers: vec![],
+            fee_payer: FeePayerAuthenticator {
+                address: AccountAddress::ZERO,
+                // This gets ignored for the future fee payer use case.
+                authenticator: AccountAuthenticator::NoAuthenticator { },
+            },
+        };
+        SignedTransaction::new(raw_txn, authenticator)
+    }
+
     pub fn raw_txn(&self) -> &RawTransaction {
         &self.raw_txn
     }