wip

Author: d4mr

executors/src/eoa/eoa_confirmation_worker.rs

@@ -182,7 +182,6 @@ where
                 message: format!("Failed to get cached nonce: {}", e),
             })
             .map_err_fail()?
-            .map(|n| n.to::<u64>())
             .unwrap_or(0);
 
         tracing::debug!(

executors/src/eoa/error_classifier.rs

@@ -11,28 +11,28 @@ use twmq::job::RequeuePosition;
 pub enum EoaExecutionError {
     /// Nonce too low - transaction might already be in mempool
     NonceTooLow { message: String },
-    
+
     /// Nonce too high - indicates nonce gap or desync
     NonceTooHigh { message: String },
-    
+
     /// Transaction already known in mempool
     AlreadyKnown { message: String },
-    
+
     /// Replacement transaction underpriced
     ReplacementUnderpriced { message: String },
-    
+
     /// Insufficient funds for transaction
     InsufficientFunds { message: String },
-    
+
     /// Gas-related error (limit, estimation, etc.)
     GasError { message: String },
-    
+
     /// Transaction pool is full or has limits
     PoolLimitExceeded { message: String },
-    
+
     /// Account does not exist or invalid
     AccountError { message: String },
-    
+
     /// Network/connectivity issues - use existing handling
     RpcError {
         message: String,
@@ -65,9 +65,10 @@ impl EoaErrorMapper {
         chain: &C,
     ) -> Result<EoaExecutionError, EngineError> {
         match error {
-            RpcError::ErrorResp(error_payload) => {
-                Ok(Self::map_ethereum_error(error_payload.code, &error_payload.message))
-            }
+            RpcError::ErrorResp(error_payload) => Ok(Self::map_ethereum_error(
+                error_payload.code,
+                &error_payload.message,
+            )),
             _ => {
                 // Use existing engine error handling for non-actionable errors
                 Err(error.to_engine_error(chain))
@@ -78,7 +79,7 @@ impl EoaErrorMapper {
     /// Map Ethereum-specific errors that we need to act on
     fn map_ethereum_error(code: i64, message: &str) -> EoaExecutionError {
         let msg_lower = message.to_lowercase();
-        
+
         match code {
             -32000 => {
                 // Only handle the specific ethereum errors we care about
@@ -118,15 +119,19 @@ impl EoaErrorMapper {
                     // Not an actionable error - let engine error handle it
                     EoaExecutionError::RpcError {
                         message: message.to_string(),
-                        inner_error: Some(EngineError::InternalError { message: message.to_string() }),
+                        inner_error: Some(EngineError::InternalError {
+                            message: message.to_string(),
+                        }),
                     }
                 }
             }
             _ => {
                 // Not an actionable error code
                 EoaExecutionError::RpcError {
                     message: format!("RPC error code {}: {}", code, message),
-                    inner_error: Some(EngineError::InternalError { message: message.to_string() }),
+                    inner_error: Some(EngineError::InternalError {
+                        message: message.to_string(),
+                    }),
                 }
             }
         }
@@ -142,63 +147,63 @@ impl EoaErrorMapper {
                 retryable: false,
                 retry_delay: None,
             },
-            
+
             EoaExecutionError::NonceTooHigh { .. } => RecoveryStrategy {
                 queue_confirmation: false,
                 recycle_nonce: true,
                 needs_resync: true,
                 retryable: true,
                 retry_delay: Some(Duration::from_secs(10)),
             },
-            
+
             EoaExecutionError::AlreadyKnown { .. } => RecoveryStrategy {
                 queue_confirmation: true,
                 recycle_nonce: false,
                 needs_resync: false,
                 retryable: false,
                 retry_delay: None,
             },
-            
+
             EoaExecutionError::ReplacementUnderpriced { .. } => RecoveryStrategy {
                 queue_confirmation: true,
                 recycle_nonce: false,
                 needs_resync: false,
                 retryable: true,
                 retry_delay: Some(Duration::from_secs(10)),
             },
-            
+
             EoaExecutionError::InsufficientFunds { .. } => RecoveryStrategy {
                 queue_confirmation: false,
                 recycle_nonce: true,
                 needs_resync: false,
                 retryable: true,
                 retry_delay: Some(Duration::from_secs(60)),
             },
-            
+
             EoaExecutionError::GasError { .. } => RecoveryStrategy {
                 queue_confirmation: false,
                 recycle_nonce: true,
                 needs_resync: false,
                 retryable: true,
                 retry_delay: Some(Duration::from_secs(30)),
             },
-            
+
             EoaExecutionError::PoolLimitExceeded { .. } => RecoveryStrategy {
                 queue_confirmation: false,
                 recycle_nonce: true,
                 needs_resync: false,
                 retryable: true,
                 retry_delay: Some(Duration::from_secs(30)),
             },
-            
+
             EoaExecutionError::AccountError { .. } => RecoveryStrategy {
                 queue_confirmation: false,
                 recycle_nonce: true,
                 needs_resync: false,
                 retryable: false,
                 retry_delay: None,
             },
-            
+
             EoaExecutionError::RpcError { .. } => {
                 // This should not be used - let engine error handle it
                 RecoveryStrategy {
@@ -208,7 +213,7 @@ impl EoaErrorMapper {
                     retryable: false,
                     retry_delay: None,
                 }
-            },
+            }
         }
     }
 }
@@ -229,7 +234,7 @@ impl EoaExecutionError {
             | EoaExecutionError::RpcError { message, .. } => message,
         }
     }
-    
+
     /// Convert to appropriate job result for send operations
     pub fn to_send_job_result<T, E>(
         &self,
@@ -244,9 +249,11 @@ impl EoaExecutionError {
             Ok(success_factory())
         } else if strategy.retryable {
             if let Some(delay) = strategy.retry_delay {
-                Err(error_factory(self.message().to_string()).nack(Some(delay), RequeuePosition::Last))
+                Err(error_factory(self.message().to_string())
+                    .nack(Some(delay), RequeuePosition::Last))
             } else {
-                Err(error_factory(self.message().to_string()).nack(Some(Duration::from_secs(5)), RequeuePosition::Last))
+                Err(error_factory(self.message().to_string())
+                    .nack(Some(Duration::from_secs(5)), RequeuePosition::Last))
             }
         } else {
             // Permanent failure
@@ -263,26 +270,29 @@ mod tests {
     fn test_nonce_too_low_mapping() {
         let error = EoaErrorMapper::map_ethereum_error(-32000, "nonce too low");
         let strategy = EoaErrorMapper::get_recovery_strategy(&error);
-        
+
         match error {
             EoaExecutionError::NonceTooLow { .. } => {}
             _ => panic!("Expected NonceTooLow error"),
         }
-        
+
         assert!(strategy.queue_confirmation);
         assert!(!strategy.recycle_nonce);
     }
 
     #[test]
     fn test_insufficient_funds_mapping() {
-        let error = EoaErrorMapper::map_ethereum_error(-32000, "insufficient funds for gas * price + value");
+        let error = EoaErrorMapper::map_ethereum_error(
+            -32000,
+            "insufficient funds for gas * price + value",
+        );
         let strategy = EoaErrorMapper::get_recovery_strategy(&error);
-        
+
         match error {
             EoaExecutionError::InsufficientFunds { .. } => {}
             _ => panic!("Expected InsufficientFunds error"),
         }
-        
+
         assert!(!strategy.queue_confirmation);
         assert!(strategy.recycle_nonce);
         assert!(strategy.retryable);
@@ -292,13 +302,13 @@ mod tests {
     fn test_already_known_mapping() {
         let error = EoaErrorMapper::map_ethereum_error(-32000, "already known");
         let strategy = EoaErrorMapper::get_recovery_strategy(&error);
-        
+
         match error {
             EoaExecutionError::AlreadyKnown { .. } => {}
             _ => panic!("Expected AlreadyKnown error"),
         }
-        
+
         assert!(strategy.queue_confirmation);
         assert!(!strategy.recycle_nonce);
     }
-}
+}

executors/src/eoa/mod.rs

@@ -4,9 +4,6 @@ pub mod nonce_manager;
 pub mod send;
 pub mod transaction_store;
 
-pub use confirm::{
-    EoaConfirmationError, EoaConfirmationHandler, EoaConfirmationJobData, EoaConfirmationResult,
-};
 pub use eoa_confirmation_worker::{
     EoaConfirmationWorker, EoaConfirmationWorkerError, EoaConfirmationWorkerJobData,
     EoaConfirmationWorkerResult,

executors/src/eoa/send.rs

@@ -21,6 +21,7 @@ use twmq::{
     job::{BorrowedJob, DelayOptions, JobResult, RequeuePosition, ToJobError, ToJobResult},
 };
 
+use crate::eoa::{EoaConfirmationWorker, EoaConfirmationWorkerJobData};
 use crate::{
     transaction_registry::TransactionRegistry,
     webhook::{
@@ -47,7 +48,6 @@ pub struct EoaSendJobData {
     pub webhook_options: Option<Vec<WebhookOptions>>,
 
     pub assigned_nonce: Option<u64>,
-
     pub gas_limit: Option<u64>,
 
     pub signing_credential: SigningCredential,
@@ -83,12 +83,18 @@ pub enum EoaSendError {
     ChainServiceError { chain_id: u64, message: String },
 
     #[error("Transaction simulation failed: {message}")]
-    SimulationFailed {
+    SimulationFailedWithRevert {
         message: String,
         revert_reason: Option<String>,
         revert_data: Option<Bytes>,
     },
 
+    #[error("Transaction simulation failed: {message}")]
+    SimulationFailed {
+        message: String,
+        inner_error: EngineError,
+    },
+
     #[error("Gas estimation failed: {message}")]
     GasEstimationFailed { message: String },
 
@@ -168,6 +174,7 @@ where
     pub transaction_registry: Arc<TransactionRegistry>,
     pub eoa_signer: Arc<EoaSigner>,
     pub max_in_flight: u32,
+    pub confirm_queue: Arc<Queue<EoaConfirmationWorker<CS>>>,
 }
 
 impl<CS> ExecutorStage for EoaSendHandler<CS>
@@ -247,13 +254,14 @@ where
         if let Some(gas_limit) = job_data.gas_limit {
             tx_request = tx_request.with_gas_limit(gas_limit);
         } else {
-            match chain.provider().estimate_gas(tx_request).await {
-                Ok(gas) => {
-                    let gas_with_buffer = gas * 110 / 100; // Add 10% buffer
+            let gas_limit_result = chain.provider().estimate_gas(tx_request.clone()).await;
+            match gas_limit_result {
+                Ok(gas_limit) => {
+                    let gas_with_buffer = gas_limit * 110 / 100; // Add 10% buffer
                     tx_request = tx_request.with_gas_limit(gas_with_buffer);
                 }
-                Err(rpc_error) => {
-                    return self.handle_simulation_error(rpc_error, &chain).await;
+                Err(e) => {
+                    return self.handle_simulation_error(e, &chain);
                 }
             }
         }
@@ -383,14 +391,9 @@ where
         let confirm_job = self
             .confirm_queue
             .clone()
-            .job(EoaConfirmationJobData {
-                transaction_id: job.job.data.transaction_id.clone(),
+            .job(EoaConfirmationWorkerJobData {
                 chain_id: job.job.data.chain_id,
-                eoa_address: job.job.data.from,
-                nonce: success_data.result.nonce_used,
-                transaction_hash: success_data.result.transaction_hash,
-                webhook_options: job.job.data.webhook_options.clone(),
-                rpc_credentials: job.job.data.rpc_credentials.clone(),
+                eoa: job.job.data.from,
             })
             .with_id(&job.job.data.transaction_id)
             .with_delay(DelayOptions {
@@ -508,21 +511,21 @@ impl<CS> EoaSendHandler<CS>
 where
     CS: ChainService + Send + Sync + 'static,
 {
-    async fn handle_simulation_error(
+    fn handle_simulation_error(
         &self,
         rpc_error: RpcError<TransportErrorKind>,
         chain: &impl Chain,
     ) -> JobResult<EoaSendResult, EoaSendError> {
         // Check if this is a revert first
         if let RpcError::ErrorResp(error_payload) = &rpc_error {
-            if error_payload.as_revert_data().is_some() {
-                return Err(EoaSendError::SimulationFailed {
+            if let Some(revert_data) = error_payload.as_revert_data() {
+                return Err(EoaSendError::SimulationFailedWithRevert {
                     message: format!(
                         "Transaction reverted during simulation: {}",
                         error_payload.message
                     ),
-                    revert_reason: Some(error_payload.message.clone()),
-                    revert_data: None,
+                    revert_reason: Some(error_payload.message.to_string()),
+                    revert_data: Some(revert_data),
                 }
                 .fail());
             }
@@ -539,16 +542,11 @@ where
                         EoaSendResult {
                             transaction_hash: B256::ZERO,
                             nonce_used: U256::ZERO,
-                            gas_limit: U256::ZERO,
-                            max_fee_per_gas: U256::ZERO,
-                            max_priority_fee_per_gas: U256::ZERO,
                             possibly_duplicate: None,
                         }
                     },
                     |reason| EoaSendError::SimulationFailed {
                         message: reason.clone(),
-                        revert_reason: None,
-                        revert_data: None,
                     },
                 )
             }

executors/src/eoa/transaction_store.rs

@@ -1,4 +1,4 @@
-use alloy::consensus::Transaction;
+use alloy::consensus::{Receipt, Transaction};
 use alloy::network::AnyTransactionReceipt;
 use alloy::primitives::{Address, B256, U256};
 use alloy::rpc::types::{TransactionReceipt, TransactionRequest};
@@ -55,7 +55,7 @@ impl ActiveAttempt {
 pub struct ConfirmationData {
     pub transaction_hash: B256,
     pub confirmed_at: u64,
-    pub receipt: AnyTransactionReceipt,
+    pub receipt: TransactionReceipt,
 }
 
 /// Transaction store focused on transaction_id operations and nonce indexing