Renames for consistency accross executors (#17)

* normalize stage names

* rename hash to transaction_hash

Author: joaquim-verges

core/src/execution_options/mod.rs

@@ -38,7 +38,7 @@ pub enum SpecificExecutionOptions {
     #[schema(title = "ERC-4337 Execution Options")]
     ERC4337(aa::Erc4337ExecutionOptions),
 
-    #[serde(rename = "eoa")]
+    #[serde(rename = "EOA")]
     #[schema(title = "EOA Execution Options")]
     EOA(eoa::EoaExecutionOptions),
 
@@ -188,7 +188,7 @@ impl ExecutionOptions {
 #[cfg(test)]
 mod tests {
     use super::*;
-    
+
     #[test]
     fn test_webhook_options_user_metadata_validation() {
         // Test valid metadata
@@ -197,27 +197,33 @@ mod tests {
             "secret": "test_secret",
             "userMetadata": "test metadata"
         }"#;
-        
+
         let webhook_options: Result<WebhookOptions, _> = serde_json::from_str(valid_json);
         assert!(webhook_options.is_ok());
-        assert_eq!(webhook_options.unwrap().user_metadata, Some("test metadata".to_string()));
-        
+        assert_eq!(
+            webhook_options.unwrap().user_metadata,
+            Some("test metadata".to_string())
+        );
+
         // Test metadata that's too large (over 4KB)
         let large_metadata = "x".repeat(5000); // 5KB string
-        let invalid_json = format!(r#"{{
+        let invalid_json = format!(
+            r#"{{
             "url": "https://example.com/webhook", 
             "secret": "test_secret",
             "userMetadata": "{}"
-        }}"#, large_metadata);
-        
+        }}"#,
+            large_metadata
+        );
+
         let webhook_options: Result<WebhookOptions, _> = serde_json::from_str(&invalid_json);
         assert!(webhook_options.is_err());
-        
+
         // Test missing metadata (should default to None)
         let minimal_json = r#"{
             "url": "https://example.com/webhook"
         }"#;
-        
+
         let webhook_options: Result<WebhookOptions, _> = serde_json::from_str(minimal_json);
         assert!(webhook_options.is_ok());
         assert_eq!(webhook_options.unwrap().user_metadata, None);

core/src/signer.rs

@@ -115,7 +115,7 @@ impl Erc4337SigningOptions {
 #[derive(Debug, Clone, Serialize, Deserialize, utoipa::ToSchema)]
 #[serde(tag = "type", rename_all = "camelCase")]
 pub enum SigningOptions {
-    #[serde(rename = "eoa")]
+    #[serde(rename = "EOA")]
     #[schema(title = "EOA Signing Options")]
     Eoa(EoaSigningOptions),
 

executors/src/eip7702_executor/send.rs

@@ -160,7 +160,7 @@ where
     }
 
     fn stage_name() -> &'static str {
-        "prepare_and_send"
+        "send"
     }
 }
 

executors/src/eoa/events.rs

@@ -49,7 +49,7 @@ impl Display for EoaExecutorStage {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             EoaExecutorStage::Send => write!(f, "send"),
-            EoaExecutorStage::Confirmation => write!(f, "confirmation"),
+            EoaExecutorStage::Confirmation => write!(f, "confirm"),
         }
     }
 }
@@ -110,7 +110,7 @@ impl EoaExecutorEvent {
             payload: SerializableNackData {
                 error: EoaConfirmationError::TransactionReplaced {
                     nonce: replaced_transaction.nonce,
-                    hash: replaced_transaction.hash,
+                    hash: replaced_transaction.transaction_hash,
                 },
                 delay_ms: None,
                 position: RequeuePosition::Last,

executors/src/eoa/store/borrowed.rs

@@ -129,7 +129,7 @@ impl SafeRedisTransaction for ProcessBorrowedTransactions<'_> {
                     // Update hash-to-ID mapping
                     let hash_to_id_key = self
                         .keys
-                        .transaction_hash_to_id_key_name(&result.transaction.hash);
+                        .transaction_hash_to_id_key_name(&result.transaction.transaction_hash);
 
                     pipeline.set(&hash_to_id_key, transaction_id);
 

executors/src/eoa/store/hydrate.rs

@@ -35,7 +35,7 @@ impl Dehydrated<SubmittedTransactionHydrator> for SubmittedTransactionDehydrated
             SubmittedTransactionHydrator::Noop => {
                 SubmittedTransactionHydrated::Noop(SubmittedNoopTransaction {
                     nonce: self.nonce,
-                    hash: self.hash,
+                    transaction_hash: self.transaction_hash,
                 })
             }
             SubmittedTransactionHydrator::Real(request) => {

executors/src/eoa/store/mod.rs

@@ -30,13 +30,13 @@ pub const NO_OP_TRANSACTION_ID: &str = "noop";
 
 #[derive(Debug, Clone)]
 pub struct ReplacedTransaction {
-    pub hash: String,
+    pub transaction_hash: String,
     pub transaction_id: String,
 }
 
 #[derive(Debug, Clone)]
 pub struct ConfirmedTransaction {
-    pub hash: String,
+    pub transaction_hash: String,
     pub transaction_id: String,
     pub receipt: alloy::rpc::types::TransactionReceipt,
     pub receipt_serialized: String,
@@ -338,7 +338,7 @@ impl From<BorrowedTransactionData> for SubmittedTransactionDehydrated {
     fn from(data: BorrowedTransactionData) -> Self {
         SubmittedTransactionDehydrated {
             nonce: data.signed_transaction.nonce(),
-            hash: data.signed_transaction.hash().to_string(),
+            transaction_hash: data.signed_transaction.hash().to_string(),
             transaction_id: data.transaction_id.clone(),
             queued_at: data.queued_at,
         }

executors/src/eoa/store/submitted.rs

@@ -35,15 +35,15 @@ impl Deref for SubmittedTransaction {
 #[derive(Debug, Clone)]
 pub struct SubmittedNoopTransaction {
     pub nonce: u64,
-    pub hash: String,
+    pub transaction_hash: String,
 }
 
 pub type SubmittedTransactionStringWithNonce = (String, u64);
 
 impl SubmittedNoopTransaction {
     pub fn to_redis_string_with_nonce(&self) -> SubmittedTransactionStringWithNonce {
         (
-            format!("{}:{}:0", self.hash, NO_OP_TRANSACTION_ID),
+            format!("{}:{}:0", self.transaction_hash, NO_OP_TRANSACTION_ID),
             self.nonce,
         )
     }
@@ -58,8 +58,8 @@ pub enum SubmittedTransactionHydrated {
 impl SubmittedTransactionHydrated {
     pub fn hash(&self) -> &str {
         match self {
-            SubmittedTransactionHydrated::Noop(tx) => &tx.hash,
-            SubmittedTransactionHydrated::Real(tx) => &tx.hash,
+            SubmittedTransactionHydrated::Noop(tx) => &tx.transaction_hash,
+            SubmittedTransactionHydrated::Real(tx) => &tx.transaction_hash,
         }
     }
 
@@ -89,7 +89,7 @@ impl SubmittedTransactionHydrated {
 #[serde(rename_all = "camelCase")]
 pub struct SubmittedTransactionDehydrated {
     pub nonce: u64,
-    pub hash: String,
+    pub transaction_hash: String,
     pub transaction_id: String,
     pub queued_at: u64,
 }
@@ -103,7 +103,7 @@ impl SubmittedTransactionDehydrated {
                 if parts.len() == 3 {
                     if let Ok(queued_at) = parts[2].parse::<u64>() {
                         Some(SubmittedTransactionDehydrated {
-                            hash: parts[0].to_string(),
+                            transaction_hash: parts[0].to_string(),
                             transaction_id: parts[1].to_string(),
                             nonce: tx.1,
                             queued_at,
@@ -136,7 +136,10 @@ impl SubmittedTransactionDehydrated {
     /// The nonce is the value of the transaction in the submitted state, and is used as the score of the submitted zset
     pub fn to_redis_string_with_nonce(&self) -> SubmittedTransactionStringWithNonce {
         (
-            format!("{}:{}:{}", self.hash, self.transaction_id, self.queued_at),
+            format!(
+                "{}:{}:{}",
+                self.transaction_hash, self.transaction_id, self.queued_at
+            ),
             self.nonce,
         )
     }
@@ -226,7 +229,7 @@ impl SafeRedisTransaction for CleanSubmittedTransactions<'_> {
         let confirmed_hashes: HashSet<&str> = self
             .confirmed_transactions
             .iter()
-            .map(|tx| tx.hash.as_str())
+            .map(|tx| tx.transaction_hash.as_str())
             .collect();
 
         let confirmed_ids: BTreeMap<&str, ConfirmedTransaction> = self
@@ -396,8 +399,8 @@ fn detect_violations<'a>(
     for (nonce, txs) in &txs_by_nonce {
         let confirmed_hashes_for_nonce: Vec<String> = txs
             .iter()
-            .filter(|tx| confirmed_hashes.contains(tx.hash.as_str()))
-            .map(|tx| tx.hash.clone())
+            .filter(|tx| confirmed_hashes.contains(tx.transaction_hash.as_str()))
+            .map(|tx| tx.transaction_hash.clone())
             .collect();
 
         if confirmed_hashes_for_nonce.len() > 1 {
@@ -411,9 +414,9 @@ fn detect_violations<'a>(
     for (nonce, txs) in &txs_by_nonce {
         let has_confirmed = txs
             .iter()
-            .any(|tx| confirmed_hashes.contains(tx.hash.as_str()));
+            .any(|tx| confirmed_hashes.contains(tx.transaction_hash.as_str()));
         if !has_confirmed {
-            let hashes: Vec<String> = txs.iter().map(|tx| tx.hash.clone()).collect();
+            let hashes: Vec<String> = txs.iter().map(|tx| tx.transaction_hash.clone()).collect();
             report.nonces_without_receipts.push((*nonce, hashes));
         }
     }

executors/src/eoa/worker/confirm.rs

@@ -19,7 +19,7 @@ const NONCE_STALL_TIMEOUT: u64 = 300_000; // 5 minutes in milliseconds - after t
 #[serde(rename_all = "camelCase")]
 pub struct ConfirmedTransactionWithRichReceipt {
     pub nonce: u64,
-    pub hash: String,
+    pub transaction_hash: String,
     pub transaction_id: String,
     pub receipt: alloy::rpc::types::TransactionReceipt,
 }
@@ -122,7 +122,7 @@ impl<C: Chain> EoaExecutorWorker<C> {
                     Err(e) => {
                         tracing::warn!(
                             transaction_id = %tx.transaction_id,
-                            hash = %tx.hash,
+                            hash = %tx.transaction_hash,
                             error = %e,
                             "Failed to serialize receipt as JSON, using debug format"
                         );
@@ -133,12 +133,12 @@ impl<C: Chain> EoaExecutorWorker<C> {
                 tracing::info!(
                     transaction_id = %tx.transaction_id,
                     nonce = tx.nonce,
-                    hash = %tx.hash,
+                    hash = %tx.transaction_hash,
                     "Transaction confirmed"
                 );
 
                 ConfirmedTransaction {
-                    hash: tx.hash,
+                    transaction_hash: tx.transaction_hash,
                     transaction_id: tx.transaction_id,
                     receipt: tx.receipt.into(),
                     receipt_serialized: receipt_data,
@@ -169,7 +169,7 @@ impl<C: Chain> EoaExecutorWorker<C> {
         // Fetch all receipts in parallel
         let receipt_futures: Vec<_> = submitted_txs
             .iter()
-            .filter_map(|tx| match tx.hash.parse::<B256>() {
+            .filter_map(|tx| match tx.transaction_hash.parse::<B256>() {
                 Ok(hash_bytes) => Some(async move {
                     let receipt = self
                         .chain
@@ -179,7 +179,7 @@ impl<C: Chain> EoaExecutorWorker<C> {
                     (tx, receipt)
                 }),
                 Err(_) => {
-                    tracing::warn!("Invalid hash format: {}, skipping", tx.hash);
+                    tracing::warn!("Invalid hash format: {}, skipping", tx.transaction_hash);
                     None
                 }
             })
@@ -196,14 +196,14 @@ impl<C: Chain> EoaExecutorWorker<C> {
                 Ok(Some(receipt)) => {
                     confirmed_txs.push(ConfirmedTransactionWithRichReceipt {
                         nonce: tx.nonce,
-                        hash: tx.hash.clone(),
+                        transaction_hash: tx.transaction_hash.clone(),
                         transaction_id: tx.transaction_id.clone(),
                         receipt,
                     });
                 }
                 Ok(None) | Err(_) => {
                     failed_txs.push(ReplacedTransaction {
-                        hash: tx.hash.clone(),
+                        transaction_hash: tx.transaction_hash.clone(),
                         transaction_id: tx.transaction_id.clone(),
                     });
                 }
@@ -323,7 +323,7 @@ impl<C: Chain> EoaExecutorWorker<C> {
                 .add_gas_bump_attempt(
                     &SubmittedTransactionDehydrated {
                         nonce: expected_nonce,
-                        hash: bumped_tx.hash().to_string(),
+                        transaction_hash: bumped_tx.hash().to_string(),
                         transaction_id: transaction_id.to_string(),
                         queued_at: tx_data.created_at,
                     },

executors/src/eoa/worker/transaction.rs

@@ -156,7 +156,7 @@ impl<C: Chain> EoaExecutorWorker<C> {
             })
             .map(|pending| SubmittedNoopTransaction {
                 nonce,
-                hash: pending.tx_hash().to_string(),
+                transaction_hash: pending.tx_hash().to_string(),
             })
     }