Merge pull request #1083 from openmina/feat/heartbeats-block-proof

feat(heartbeats): Verify block proofs

Author: tizoc

Cargo.lock

@@ -4,6 +4,8 @@ pub use block_with_hash::{BlockHeaderWithHash, BlockWithHash};
 mod applied_block;
 pub use applied_block::AppliedBlock;
 
+pub mod prevalidate;
+
 pub mod genesis;
 
 use std::sync::Arc;

core/src/block/mod.rs

@@ -0,0 +1,114 @@
+use serde::{Deserialize, Serialize};
+
+use super::ArcBlockWithHash;
+use crate::constants::PROTOCOL_VERSION;
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum BlockPrevalidationError {
+    GenesisNotReady,
+    ReceivedTooEarly {
+        current_global_slot: u32,
+        block_global_slot: u32,
+    },
+    ReceivedTooLate {
+        current_global_slot: u32,
+        block_global_slot: u32,
+        delta: u32,
+    },
+    InvalidGenesisProtocolState,
+    InvalidProtocolVersion,
+    MismatchedProtocolVersion,
+    ConsantsMismatch,
+    InvalidDeltaBlockChainProof,
+}
+
+pub fn validate_block_timing(
+    block: &ArcBlockWithHash,
+    genesis: &ArcBlockWithHash,
+    cur_global_slot: u32,
+    allow_block_too_late: bool,
+) -> Result<(), BlockPrevalidationError> {
+    let block_global_slot = block.global_slot();
+    let delta = genesis.constants().delta.as_u32();
+
+    if cur_global_slot < block_global_slot {
+        return Err(BlockPrevalidationError::ReceivedTooEarly {
+            current_global_slot: cur_global_slot,
+            block_global_slot,
+        });
+    } else if !allow_block_too_late && cur_global_slot.saturating_sub(block_global_slot) > delta {
+        return Err(BlockPrevalidationError::ReceivedTooLate {
+            current_global_slot: cur_global_slot,
+            block_global_slot,
+            delta,
+        });
+    }
+
+    Ok(())
+}
+
+pub fn validate_genesis_state(
+    block: &ArcBlockWithHash,
+    genesis: &ArcBlockWithHash,
+) -> Result<(), BlockPrevalidationError> {
+    if block.header().genesis_state_hash() != genesis.hash() {
+        return Err(BlockPrevalidationError::InvalidGenesisProtocolState);
+    }
+    Ok(())
+}
+
+pub fn validate_protocol_versions(block: &ArcBlockWithHash) -> Result<(), BlockPrevalidationError> {
+    let min_transaction_version = 1.into();
+    let v = &block.header().current_protocol_version;
+    let nv = block
+        .header()
+        .proposed_protocol_version_opt
+        .as_ref()
+        .unwrap_or(v);
+
+    // Our version values are unsigned, so there is no need to check that the
+    // other parts are not negative.
+    let valid =
+        v.transaction >= min_transaction_version && nv.transaction >= min_transaction_version;
+    if !valid {
+        return Err(BlockPrevalidationError::InvalidProtocolVersion);
+    }
+
+    let compatible =
+        v.transaction == PROTOCOL_VERSION.transaction && v.network == PROTOCOL_VERSION.network;
+    if !compatible {
+        return Err(BlockPrevalidationError::MismatchedProtocolVersion);
+    }
+
+    Ok(())
+}
+
+pub fn validate_constants(
+    block: &ArcBlockWithHash,
+    genesis: &ArcBlockWithHash,
+) -> Result<(), BlockPrevalidationError> {
+    // NOTE: currently these cannot change between blocks, but that
+    // may not always be true?
+    if block.constants() != genesis.constants() {
+        return Err(BlockPrevalidationError::ConsantsMismatch);
+    }
+    Ok(())
+}
+
+pub fn prevalidate_block(
+    block: &ArcBlockWithHash,
+    genesis: &ArcBlockWithHash,
+    cur_global_slot: u32,
+    allow_block_too_late: bool,
+) -> Result<(), BlockPrevalidationError> {
+    validate_block_timing(block, genesis, cur_global_slot, allow_block_too_late)?;
+    validate_genesis_state(block, genesis)?;
+    validate_protocol_versions(block)?;
+    validate_constants(block, genesis)?;
+
+    // TODO(tizoc): check for InvalidDeltaBlockChainProof
+    // https://github.com/MinaProtocol/mina/blob/d800da86a764d8d37ffb8964dd8d54d9f522b358/src/lib/mina_block/validation.ml#L369
+    // https://github.com/MinaProtocol/mina/blob/d800da86a764d8d37ffb8964dd8d54d9f522b358/src/lib/transition_chain_verifier/transition_chain_verifier.ml
+
+    Ok(())
+}

core/src/block/prevalidate.rs

@@ -3,7 +3,11 @@ use mina_p2p_messages::{
     gossip::GossipNetMessageV2,
     v2::{MinaLedgerSyncLedgerAnswerStableV2, StateHash},
 };
-use openmina_core::{block::BlockWithHash, bug_condition, log, transaction::TransactionWithHash};
+use openmina_core::{
+    block::{prevalidate::BlockPrevalidationError, BlockWithHash},
+    bug_condition, log,
+    transaction::TransactionWithHash,
+};
 use p2p::{
     channels::{
         best_tip::P2pChannelsBestTipAction,
@@ -18,7 +22,6 @@ use redux::{ActionMeta, ActionWithMeta, Dispatcher};
 use crate::{
     p2p_ready,
     snark_pool::candidate::SnarkPoolCandidateAction,
-    state::BlockPrevalidationError,
     transaction_pool::candidate::TransactionPoolCandidateAction,
     transition_frontier::candidate::{allow_block_too_late, TransitionFrontierCandidateAction},
     transition_frontier::sync::{

node/src/p2p/callbacks/p2p_callbacks_reducer.rs

@@ -3,7 +3,7 @@ use std::time::Duration;
 
 use malloc_size_of_derive::MallocSizeOf;
 use mina_p2p_messages::v2;
-use openmina_core::constants::PROTOCOL_VERSION;
+use openmina_core::block::prevalidate::{prevalidate_block, BlockPrevalidationError};
 use openmina_core::transaction::{TransactionInfo, TransactionWithHash};
 use p2p::P2pNetworkPubsubMessageCacheId;
 use rand::prelude::*;
@@ -80,25 +80,6 @@ pub struct State {
     applied_actions_count: u64,
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub enum BlockPrevalidationError {
-    GenesisNotReady,
-    ReceivedTooEarly {
-        current_global_slot: u32,
-        block_global_slot: u32,
-    },
-    ReceivedTooLate {
-        current_global_slot: u32,
-        block_global_slot: u32,
-        delta: u32,
-    },
-    InvalidGenesisProtocolState,
-    InvalidProtocolVersion,
-    MismatchedProtocolVersion,
-    ConsantsMismatch,
-    InvalidDeltaBlockChainProof,
-}
-
 // Substate accessors that will be used in reducers
 use openmina_core::{bug_condition, impl_substate_access, SubstateAccess};
 
@@ -408,70 +389,7 @@ impl State {
             return Err(BlockPrevalidationError::GenesisNotReady);
         };
 
-        // received_at_valid_time
-        // https://github.com/minaprotocol/mina/blob/6af211ad58e9356f00ea4a636cea70aa8267c072/src/lib/consensus/proof_of_stake.ml#L2746
-        {
-            let block_global_slot = block.global_slot();
-
-            let delta = genesis.constants().delta.as_u32();
-            if cur_global_slot < block_global_slot {
-                // Too_early
-                return Err(BlockPrevalidationError::ReceivedTooEarly {
-                    current_global_slot: cur_global_slot,
-                    block_global_slot,
-                });
-            } else if !allow_block_too_late
-                && cur_global_slot.saturating_sub(block_global_slot) > delta
-            {
-                // Too_late
-                return Err(BlockPrevalidationError::ReceivedTooLate {
-                    current_global_slot: cur_global_slot,
-                    block_global_slot,
-                    delta,
-                });
-            }
-        }
-
-        if block.header().genesis_state_hash() != genesis.hash() {
-            return Err(BlockPrevalidationError::InvalidGenesisProtocolState);
-        }
-
-        let (protocol_versions_are_valid, protocol_version_matches_daemon) = {
-            let min_transaction_version = 1.into();
-            let v = &block.header().current_protocol_version;
-            let nv = block
-                .header()
-                .proposed_protocol_version_opt
-                .as_ref()
-                .unwrap_or(v);
-
-            // Our version values are unsigned, so there is no need to check that the
-            // other parts are not negative.
-            let valid = v.transaction >= min_transaction_version
-                && nv.transaction >= min_transaction_version;
-            let compatible = v.transaction == PROTOCOL_VERSION.transaction
-                && v.network == PROTOCOL_VERSION.network;
-
-            (valid, compatible)
-        };
-
-        if !protocol_versions_are_valid {
-            return Err(BlockPrevalidationError::InvalidProtocolVersion);
-        } else if !protocol_version_matches_daemon {
-            return Err(BlockPrevalidationError::MismatchedProtocolVersion);
-        }
-
-        // NOTE: currently these cannot change between blocks, but that
-        // may not always be true?
-        if block.constants() != genesis.constants() {
-            return Err(BlockPrevalidationError::ConsantsMismatch);
-        }
-
-        // TODO(tizoc): check for InvalidDeltaBlockChainProof
-        // https://github.com/MinaProtocol/mina/blob/d800da86a764d8d37ffb8964dd8d54d9f522b358/src/lib/mina_block/validation.ml#L369
-        // https://github.com/MinaProtocol/mina/blob/d800da86a764d8d37ffb8964dd8d54d9f522b358/src/lib/transition_chain_verifier/transition_chain_verifier.ml
-
-        Ok(())
+        prevalidate_block(block, &genesis, cur_global_slot, allow_block_too_late)
     }
 
     pub fn should_log_node_id(&self) -> bool {

node/src/state.rs

@@ -1,14 +1,14 @@
 use std::sync::Arc;
 
 use mina_p2p_messages::v2::{MinaBlockBlockStableV2, StateHash};
+use openmina_core::block::prevalidate::BlockPrevalidationError;
 use openmina_core::block::{ArcBlockWithHash, BlockWithHash};
 use openmina_core::consensus::consensus_take;
 use openmina_core::{action_event, ActionEvent};
 use serde::{Deserialize, Serialize};
 use snark::block_verify::SnarkBlockVerifyError;
 
 use crate::snark::block_verify::SnarkBlockVerifyId;
-use crate::state::BlockPrevalidationError;
 
 use super::TransitionFrontierCandidateStatus;
 

node/src/transition_frontier/candidate/transition_frontier_candidate_actions.rs

@@ -15,6 +15,8 @@ dotenv = "0.15"
 clap = { version = "4.4", features = ["derive"] }
 gcloud-sdk = { version = "0.26.0", default-features = false, features = ["google-firestore-v1"] }
 base64 = "0.22"
+mina-tree = { path = "../../ledger" }
+snark = { path = "../../snark" }
 
 mina-p2p-messages = { workspace = true }
 openmina-core = { path = "../../core" }