feat(ethexe-consensus): mini-announces for instant injected TX promises

ethexe/compute/src/compute.rs

@@ -310,13 +310,21 @@ pub(crate) mod utils {
     ) -> Result<ExecutableData> {
         let block_hash = announce.block_hash;
 
-        let matured_events =
-            find_canonical_events_post_quarantine(db, block_hash, canonical_quarantine)?;
-
-        let events = matured_events
-            .into_iter()
-            .filter_map(|event| event.to_request())
-            .collect();
+        // Check if parent announce is for the same block (mini-announce case).
+        // If so, canonical events were already processed by the parent — skip them.
+        let is_same_block = db
+            .announce(announce.parent)
+            .is_some_and(|parent| parent.block_hash == block_hash);
+        let events = if is_same_block {
+            vec![]
+        } else {
+            let matured_events =
+                find_canonical_events_post_quarantine(db, block_hash, canonical_quarantine)?;
+            matured_events
+                .into_iter()
+                .filter_map(|event| event.to_request())
+                .collect()
+        };
 
         Ok(ExecutableData {
             block: SimpleBlockData {

ethexe/consensus/src/validator/coordinator.rs

@@ -40,6 +40,8 @@ pub struct Coordinator {
     ctx: ValidatorContext,
     validators: BTreeSet<Address>,
     multisigned_batch: MultisignedBatchCommitment,
+    /// Buffered next block to process after submission completes.
+    next_block: Option<SimpleBlockData>,
 }
 
 impl StateHandler for Coordinator {
@@ -55,6 +57,12 @@ impl StateHandler for Coordinator {
         self.ctx
     }
 
+    fn process_new_head(mut self, block: SimpleBlockData) -> Result<ValidatorState> {
+        // Buffer the new head instead of dying. Process it after submission.
+        self.next_block = Some(block);
+        Ok(self.into())
+    }
+
     fn process_validation_reply(
         mut self,
         reply: BatchCommitmentValidationReply,
@@ -72,7 +80,7 @@ impl StateHandler for Coordinator {
         }
 
         if self.multisigned_batch.signatures().len() as u64 >= self.ctx.core.signatures_threshold {
-            Self::submission(self.ctx, self.multisigned_batch)
+            Self::submission(self.ctx, self.multisigned_batch, self.next_block)
         } else {
             Ok(self.into())
         }
@@ -110,7 +118,7 @@ impl Coordinator {
             .set(block.header.height);
 
         if multisigned_batch.signatures().len() as u64 >= ctx.core.signatures_threshold {
-            return Self::submission(ctx, multisigned_batch);
+            return Self::submission(ctx, multisigned_batch, None);
         }
 
         let era_index = ctx
@@ -131,13 +139,15 @@ impl Coordinator {
             ctx,
             validators: validators.into_iter().collect(),
             multisigned_batch,
+            next_block: None,
         }
         .into())
     }
 
     pub fn submission(
         ctx: ValidatorContext,
         multisigned_batch: MultisignedBatchCommitment,
+        next_block: Option<SimpleBlockData>,
     ) -> Result<ValidatorState> {
         let (batch, signatures) = multisigned_batch.into_parts();
         let cloned_committer = ctx.core.committer.clone_boxed();
@@ -150,16 +160,21 @@ impl Coordinator {
                         block_hash,
                         batch_digest,
                         tx,
-                    }.into(),
+                    }
+                    .into(),
                     Err(err) => ConsensusEvent::Warning(format!(
                         "Failed to submit commitment for block {block_hash}, digest {batch_digest}: {err}"
-                    ))
+                    )),
                 };
                 Ok(event)
             }
             .boxed(),
         );
-        Initial::create(ctx)
+        let state = Initial::create(ctx)?;
+        match next_block {
+            Some(block) => state.process_new_head(block),
+            None => Ok(state),
+        }
     }
 }
 

ethexe/consensus/src/validator/mock.rs

@@ -74,6 +74,7 @@ impl ElectionProvider for MockEthereum {
 #[async_trait]
 pub trait WaitFor {
     async fn wait_for_event(self) -> Result<(ValidatorState, ConsensusEvent)>;
+    #[allow(dead_code)]
     async fn wait_for_state<F>(self, f: F) -> Result<ValidatorState>
     where
         F: Fn(&ValidatorState) -> bool + Unpin + Send;