update optimistic nonce if behind

Author: d4mr

executors/src/eoa/store/atomic.rs

@@ -401,6 +401,7 @@ impl AtomicEoaExecutorStore {
 
         // First, read current health data
         let current_health = self.get_eoa_health().await?;
+        let optimistic_nonce = self.get_optimistic_transaction_count().await?;
 
         // Prepare health update if health data exists
         let health_update = if let Some(mut health) = current_health {
@@ -417,6 +418,18 @@ impl AtomicEoaExecutorStore {
             // Update cached transaction count
             pipeline.set(&tx_count_key, current_chain_tx_count);
 
+            if current_chain_tx_count + 1 > optimistic_nonce {
+                tracing::warn!(
+                    current_chain_tx_count = current_chain_tx_count,
+                    optimistic_nonce = optimistic_nonce,
+                    "Optimistic nonce was behind fresh chain transaction count, updating to match"
+                );
+                pipeline.set(
+                    self.optimistic_transaction_count_key_name(),
+                    current_chain_tx_count + 1,
+                );
+            }
+
             // Update health data only if it exists
             if let Some(ref health_json) = health_update {
                 let health_key = self.eoa_health_key_name();

executors/src/eoa/store/pending.rs

@@ -59,7 +59,7 @@ impl SafeRedisTransaction for MovePendingToBorrowedWithIncrementedNonces<'_> {
         let current_optimistic: Option<u64> = conn
             .get(self.keys.optimistic_transaction_count_key_name())
             .await?;
-        let current_nonce = current_optimistic.ok_or(TransactionStoreError::NonceSyncRequired {
+        let current_optimistic_nonce = current_optimistic.ok_or(TransactionStoreError::NonceSyncRequired {
             eoa: self.eoa,
             chain_id: self.chain_id,
         })?;
@@ -74,7 +74,7 @@ impl SafeRedisTransaction for MovePendingToBorrowedWithIncrementedNonces<'_> {
 
         // Check that nonces are sequential with no gaps
         for (i, &nonce) in nonces.iter().enumerate() {
-            let expected_nonce = current_nonce + i as u64;
+            let expected_nonce = current_optimistic_nonce + i as u64;
             if nonce != expected_nonce {
                 return Err(TransactionStoreError::InternalError {
                     message: format!(

executors/src/eoa/worker/send.rs

@@ -293,6 +293,7 @@ impl<C: Chain> EoaExecutorWorker<C> {
     /// Process new transactions with fixed iterations and simple sequential nonces
     async fn process_new_transactions(&self, budget: u64) -> Result<u32, EoaExecutorWorkerError> {
         if budget == 0 {
+            tracing::warn!("No budget to process new transactions");
             return Ok(0);
         }