nits

Author: patrick-ogrady

consensus/src/marshal/coding/marshaled.rs

@@ -125,6 +125,15 @@ use rand::Rng;
 use std::sync::{Arc, OnceLock};
 use tracing::{debug, warn};
 
+/// Which marshal cache a verified coded block should land in.
+#[derive(Clone, Copy, Debug)]
+enum CodingPersistMode {
+    /// Write to `verified_blocks` via `Mailbox::verified`.
+    Verified,
+    /// Write to `notarized_blocks` via `Mailbox::certified`.
+    Certified,
+}
+
 /// The [`CodingConfig`] used for genesis blocks. These blocks are never broadcasted in
 /// the proposal phase, and thus the configuration is irrelevant.
 const GENESIS_CODING_CONFIG: CodingConfig = CodingConfig {
@@ -299,6 +308,7 @@ where
         consensus_context: Context<Commitment, <Z::Scheme as CertificateScheme>::PublicKey>,
         commitment: Commitment,
         prefetched_block: Option<CodedBlock<B, C, H>>,
+        persist: CodingPersistMode,
     ) -> oneshot::Receiver<bool> {
         let mut marshal = self.marshal.clone();
         let mut application = self.application.clone();
@@ -424,9 +434,15 @@ where
                     is_valid = validity_request => is_valid,
                 };
                 timer.observe();
-                if application_valid && !marshal.verified(round, block).await {
-                    debug!(?round, "marshal unable to accept block");
-                    return;
+                if application_valid {
+                    let persisted = match persist {
+                        CodingPersistMode::Verified => marshal.verified(round, block).await,
+                        CodingPersistMode::Certified => marshal.certified(round, block).await,
+                    };
+                    if !persisted {
+                        debug!(?round, "marshal unable to accept block");
+                        return;
+                    }
                 }
                 tx.send_lossy(application_valid);
             });
@@ -779,7 +795,8 @@ where
         // Kick off deferred verification early to hide verification latency behind
         // shard validity checks and network latency for collecting votes.
         let round = consensus_context.round;
-        let task = self.deferred_verify(consensus_context, payload, None);
+        let task =
+            self.deferred_verify(consensus_context, payload, None, CodingPersistMode::Verified);
         self.verification_tasks.insert(round, payload, task);
 
         match scheme.me() {
@@ -917,18 +934,13 @@ where
 
                 // Use the block's embedded context for verification, passing the
                 // prefetched block to avoid fetching it again inside deferred_verify.
-                let block_for_certify = block.clone();
-                let verify_rx = marshaled.deferred_verify(embedded_context, payload, Some(block));
+                let verify_rx = marshaled.deferred_verify(
+                    embedded_context,
+                    payload,
+                    Some(block),
+                    CodingPersistMode::Certified,
+                );
                 if let Ok(result) = verify_rx.await {
-                    if result
-                        && !marshaled
-                            .marshal
-                            .certified(round, block_for_certify)
-                            .await
-                    {
-                        debug!(?round, "marshal unable to accept certified block");
-                        return;
-                    }
                     tx.send_lossy(result);
                 }
             });

consensus/src/marshal/standard/deferred.rs

@@ -81,6 +81,7 @@ use crate::{
         standard::{
             validation::{
                 fetch_parent, precheck_epoch_and_reproposal, verify_with_parent, Decision,
+                PersistMode,
             },
             Standard,
         },
@@ -203,6 +204,7 @@ where
         &mut self,
         context: <Self as Automaton>::Context,
         block: B,
+        persist: PersistMode,
     ) -> oneshot::Receiver<bool> {
         let mut marshal = self.marshal.clone();
         let mut application = self.application.clone();
@@ -226,6 +228,7 @@ where
                     &mut application,
                     &mut marshal,
                     &mut tx,
+                    persist,
                 )
                 .await
                 {
@@ -500,7 +503,7 @@ where
 
                 // Begin the rest of the verification process asynchronously.
                 let round = context.round;
-                let task = marshaled.deferred_verify(context, block);
+                let task = marshaled.deferred_verify(context, block, PersistMode::Verified);
                 marshaled.verification_tasks.insert(round, digest, task);
 
                 tx.send_lossy(true);
@@ -595,18 +598,9 @@ where
                     return;
                 }
 
-                let block_for_certify = block.clone();
-                let verify_rx = marshaled.deferred_verify(embedded_context, block);
+                let verify_rx =
+                    marshaled.deferred_verify(embedded_context, block, PersistMode::Certified);
                 if let Ok(result) = verify_rx.await {
-                    if result
-                        && !marshaled
-                            .marshal
-                            .certified(round, block_for_certify)
-                            .await
-                    {
-                        debug!(?round, "marshal unable to accept certified block");
-                        return;
-                    }
                     tx.send_lossy(result);
                 }
             });

consensus/src/marshal/standard/inline.rs

@@ -50,6 +50,7 @@ use crate::{
         standard::{
             validation::{
                 fetch_parent, precheck_epoch_and_reproposal, verify_with_parent, Decision,
+                PersistMode,
             },
             Standard,
         },
@@ -411,6 +412,7 @@ where
                     &mut application,
                     &mut marshal,
                     &mut tx,
+                    PersistMode::Verified,
                 )
                 .await
                 {

consensus/src/marshal/standard/validation.rs

@@ -58,6 +58,18 @@ pub(super) enum Decision<B> {
     Continue(B),
 }
 
+/// Which marshal cache a verified block should land in.
+///
+/// Selected by the caller based on context: `Verified` for the initial verify
+/// path, `Certified` when the caller has a notarization for the block.
+#[derive(Clone, Copy, Debug)]
+pub(super) enum PersistMode {
+    /// Write to `verified_blocks` via `Mailbox::verified`.
+    Verified,
+    /// Write to `notarized_blocks` via `Mailbox::certified`.
+    Certified,
+}
+
 /// Performs shared pre-checks used by both inline and deferred verification paths.
 ///
 /// This enforces:
@@ -125,6 +137,7 @@ pub(super) async fn verify_with_parent<E, S, A, B>(
     application: &mut A,
     marshal: &mut Mailbox<S, Standard<B>>,
     tx: &mut oneshot::Sender<bool>,
+    persist: PersistMode,
 ) -> Option<bool>
 where
     E: Rng + Spawner + Metrics + Clock,
@@ -201,9 +214,15 @@ where
         valid = validity_request => valid,
     };
 
-    if application_valid && !marshal.verified(context.round, block).await {
-        debug!(round = ?context.round, "marshal unable to accept block");
-        return None;
+    if application_valid {
+        let persisted = match persist {
+            PersistMode::Verified => marshal.verified(context.round, block).await,
+            PersistMode::Certified => marshal.certified(context.round, block).await,
+        };
+        if !persisted {
+            debug!(round = ?context.round, "marshal unable to accept block");
+            return None;
+        }
     }
     Some(application_valid)
 }