Merge pull request #789 from openmina/feat/block-verify-works

feat: Enable stronger verification for blocks close to the best tip

Author: tizoc

node/src/ledger/ledger_manager.rs

@@ -1,6 +1,6 @@
 use std::collections::BTreeMap;
 
-use ledger::staged_ledger::staged_ledger::StagedLedger;
+use ledger::staged_ledger::staged_ledger::{SkipVerification, StagedLedger};
 use mina_p2p_messages::v2::{self, LedgerHash, MinaBaseAccountBinableArgStableV2};
 use openmina_core::channels::mpsc;
 use openmina_core::thread;
@@ -154,9 +154,18 @@ impl LedgerRequest {
                         result: result.map(Into::into),
                     }
                 }
-                LedgerWriteRequest::BlockApply { block, pred_block } => {
+                LedgerWriteRequest::BlockApply {
+                    block,
+                    pred_block,
+                    skip_verification,
+                } => {
                     let block_hash = block.hash().clone();
-                    let result = ledger_ctx.block_apply(block, pred_block);
+                    let skip_verification = if skip_verification {
+                        Some(SkipVerification::All)
+                    } else {
+                        None
+                    };
+                    let result = ledger_ctx.block_apply(block, pred_block, skip_verification);
                     LedgerWriteResponse::BlockApply { block_hash, result }
                 }
                 LedgerWriteRequest::Commit {

node/src/ledger/ledger_service.rs

@@ -638,6 +638,7 @@ impl LedgerCtx {
         &mut self,
         block: ArcBlockWithHash,
         pred_block: AppliedBlock,
+        skip_verification: Option<SkipVerification>,
     ) -> Result<BlockApplyResult, String> {
         openmina_core::info!(openmina_core::log::system_time();
             kind = "LedgerService::block_apply",
@@ -674,8 +675,7 @@ impl LedgerCtx {
 
         let result = staged_ledger
             .apply(
-                // TODO(binier): SEC
-                Some(SkipVerification::All),
+                skip_verification,
                 constraint_constants(),
                 Slot::from_u32(global_slot),
                 diff,

node/src/ledger/write/mod.rs

@@ -50,6 +50,7 @@ pub enum LedgerWriteRequest {
     BlockApply {
         block: ArcBlockWithHash,
         pred_block: AppliedBlock,
+        skip_verification: bool,
     },
     Commit {
         ledgers_to_keep: BTreeSet<v2::LedgerHash>,

node/src/transition_frontier/sync/mod.rs

@@ -25,3 +25,8 @@ pub enum SyncError {
     #[error("sync failed due to block({}, {}) application error: {1}", .0.height(), .0.hash())]
     BlockApplyFailed(ArcBlockWithHash, String),
 }
+
+/// How close to the best tip we have to be for the full
+/// verification of proofs contained in the block
+/// body (zkApp txns and completed works) to be enabled.
+const CATCHUP_BLOCK_VERIFY_TAIL_LENGTH: usize = 5;

node/src/transition_frontier/sync/transition_frontier_sync_effects.rs

@@ -243,17 +243,27 @@ impl TransitionFrontierSyncAction {
                 };
                 let hash = block.hash.clone();
 
+                // During catchup, we skip the verificationf of completed work and zkApp txn proofs
+                // until get closer to the best tip, at which point full verification is enabled.
+                let skip_verification = super::CATCHUP_BLOCK_VERIFY_TAIL_LENGTH
+                    < store.state().transition_frontier.sync.pending_count();
+
                 if let Some(stats) = store.service.stats() {
                     stats.block_producer().block_apply_start(meta.time(), &hash);
                 }
 
                 store.dispatch(LedgerWriteAction::Init {
-                    request: LedgerWriteRequest::BlockApply { block, pred_block },
+                    request: LedgerWriteRequest::BlockApply {
+                        block,
+                        pred_block,
+                        skip_verification,
+                    },
                     on_init: redux::callback!(
                         on_block_next_apply_init(request: LedgerWriteRequest) -> crate::Action {
                             let LedgerWriteRequest::BlockApply {
                                 block,
                                 pred_block: _,
+                                skip_verification: _,
                             } = request
                             else {
                                 unreachable!()

node/src/transition_frontier/sync/transition_frontier_sync_state.rs

@@ -277,6 +277,12 @@ impl TransitionFrontierSyncState {
         }
     }
 
+    pub fn pending_count(&self) -> usize {
+        self.blocks_iter()
+            .filter(|b| !matches!(b, TransitionFrontierSyncBlockState::ApplySuccess { .. }))
+            .count()
+    }
+
     pub fn blocks_fetch_retry_iter(&self) -> impl '_ + Iterator<Item = StateHash> {
         self.blocks_iter().filter_map(|s| s.retry_hash()).cloned()
     }