Update logging for block policy errors

Author: bamrith

Cargo.lock

@@ -16,6 +16,8 @@ monad-state-backend = { workspace = true }
 monad-types = { workspace = true }
 monad-validator = { workspace = true }
 
+tracing = { workspace = true }
+
 [dev-dependencies]
 monad-crypto = { workspace = true }
 monad-eth-types = { workspace = true }

monad-blocktree/Cargo.toml

@@ -20,7 +20,7 @@ use std::{
 
 use monad_chain_config::{revision::ChainRevision, ChainConfig};
 use monad_consensus_types::{
-    block::{BlockPolicy, BlockPolicyError, BlockRange, ConsensusBlockHeader},
+    block::{BlockPolicy, BlockRange, ConsensusBlockHeader},
     checkpoint::RootInfo,
     metrics::Metrics,
     payload::{ConsensusBlockBody, ConsensusBlockBodyId},
@@ -29,9 +29,10 @@ use monad_consensus_types::{
 use monad_crypto::certificate_signature::{
     CertificateSignaturePubKey, CertificateSignatureRecoverable,
 };
-use monad_state_backend::{StateBackend, StateBackendError};
+use monad_state_backend::StateBackend;
 use monad_types::{BlockId, ExecutionProtocol, Round, SeqNum};
 use monad_validator::signature_collection::SignatureCollection;
+use tracing::debug;
 
 use crate::tree::{BlockTreeEntry, Tree};
 
@@ -279,6 +280,7 @@ where
                 self.root.info,
                 state_backend,
                 chain_config,
+                metrics,
             ) {
                 Ok(()) => {
                     let next_block = next_block.clone();
@@ -298,24 +300,8 @@ where
                             .cloned(),
                     );
                 }
-                Err(BlockPolicyError::StateBackendError(StateBackendError::NotAvailableYet)) => {
-                    metrics.consensus_events.rx_execution_lagging += 1;
-                }
-                Err(BlockPolicyError::ExecutionResultMismatch) => {
-                    metrics.consensus_events.rx_bad_state_root += 1;
-                }
-                Err(BlockPolicyError::BaseFeeError) => {
-                    metrics.consensus_events.rx_base_fee_error += 1;
-                }
-                Err(
-                    BlockPolicyError::BlockPolicyBlockValidatorError(_)
-                    | BlockPolicyError::BlockNotCoherent
-                    | BlockPolicyError::Eip7702Error
-                    | BlockPolicyError::TimestampError
-                    | BlockPolicyError::StateBackendError(StateBackendError::NeverAvailable)
-                    | BlockPolicyError::SystemTransactionError,
-                ) => {
-                    // TODO add metrics
+                Err(err) => {
+                    debug!(?err, block_id =? next_block.get_id(), block_seq_num =? next_block.get_seq_num(), "block failed coherency check");
                 }
             }
         }

monad-blocktree/src/blocktree.rs

@@ -1307,8 +1307,7 @@ where
             // when epoch boundary block is committed, this updates
             // epoch manager records
             self.metrics.consensus_events.commit_block += 1;
-            self.block_policy
-                .update_committed_block(block, &self.config.chain_config);
+            self.block_policy.update_committed_block(block);
             self.epoch_manager
                 .schedule_epoch_start(block.header().seq_num, block.get_block_round());
 

monad-consensus-state/src/lib.rs

@@ -37,6 +37,7 @@ use serde::Serialize;
 
 use crate::{
     checkpoint::RootInfo,
+    metrics::Metrics,
     payload::{ConsensusBlockBody, ConsensusBlockBodyId, RoundSignature},
     quorum_certificate::QuorumCertificate,
 };
@@ -300,24 +301,6 @@ where
     }
 }
 
-#[derive(Debug, PartialEq)]
-pub enum BlockPolicyError {
-    BlockNotCoherent,
-    StateBackendError(StateBackendError),
-    TimestampError,
-    ExecutionResultMismatch,
-    BaseFeeError,
-    BlockPolicyBlockValidatorError(BlockPolicyBlockValidatorError),
-    Eip7702Error,
-    SystemTransactionError,
-}
-
-impl From<StateBackendError> for BlockPolicyError {
-    fn from(err: StateBackendError) -> Self {
-        Self::StateBackendError(err)
-    }
-}
-
 #[derive(Debug, Clone)]
 pub struct AccountBalanceState {
     pub balance: Balance,
@@ -339,15 +322,6 @@ impl AccountBalanceState {
     }
 }
 
-pub type AccountBalanceStates = BTreeMap<Address, AccountBalanceState>;
-
-#[derive(Debug, PartialEq)]
-pub enum BlockPolicyBlockValidatorError {
-    AccountBalanceMissing,
-    InsufficientBalance,
-    InsufficientReserveBalance,
-}
-
 #[derive(Debug, Default, Clone)]
 pub struct TxnFee {
     pub first_txn_value: Balance,
@@ -378,15 +352,17 @@ where
         + Debug
         + Send
         + Deref<Target = ConsensusFullBlock<ST, SCT, EPT>>;
+    type BlockPolicyError: Debug;
 
     fn check_coherency(
         &self,
         block: &Self::ValidatedBlock,
         extending_blocks: Vec<&Self::ValidatedBlock>,
         blocktree_root: RootInfo,
         state_backend: &SBT,
-        chain_cnfig: &CCT,
-    ) -> Result<(), BlockPolicyError>;
+        chain_config: &CCT,
+        metrics: &mut Metrics,
+    ) -> Result<(), Self::BlockPolicyError>;
 
     fn get_expected_execution_results(
         &self,
@@ -397,15 +373,11 @@ where
 
     // TODO delete this function, pass recently committed blocks to check_coherency instead
     // This way, BlockPolicy doesn't need to be mutated
-    fn update_committed_block(&mut self, block: &Self::ValidatedBlock, chain_config: &CCT);
+    fn update_committed_block(&mut self, block: &Self::ValidatedBlock);
 
     // TODO delete this function, pass recently committed blocks to check_coherency instead
     // This way, BlockPolicy doesn't need to be mutated
-    fn reset(
-        &mut self,
-        last_delay_committed_blocks: Vec<&Self::ValidatedBlock>,
-        chain_config: &CCT,
-    );
+    fn reset(&mut self, last_delay_committed_blocks: Vec<&Self::ValidatedBlock>);
 }
 
 /// A block policy which does not validate the inner contents of the block
@@ -442,6 +414,20 @@ where
     }
 }
 
+#[derive(Debug)]
+pub enum PassthruBlockPolicyError {
+    InvalidSeqNum,
+    TimestampError,
+    ExecutionResultMismatch,
+    StateBackendError(StateBackendError),
+}
+
+impl From<StateBackendError> for PassthruBlockPolicyError {
+    fn from(err: StateBackendError) -> Self {
+        Self::StateBackendError(err)
+    }
+}
+
 impl<ST, SCT, EPT>
     BlockPolicy<ST, SCT, EPT, InMemoryState<ST, SCT>, MockChainConfig, MockChainRevision>
     for PassthruBlockPolicy
@@ -451,15 +437,17 @@ where
     EPT: ExecutionProtocol,
 {
     type ValidatedBlock = PassthruWrappedBlock<ST, SCT, EPT>;
+    type BlockPolicyError = PassthruBlockPolicyError;
 
     fn check_coherency(
         &self,
         block: &Self::ValidatedBlock,
         extending_blocks: Vec<&Self::ValidatedBlock>,
         blocktree_root: RootInfo,
         state_backend: &InMemoryState<ST, SCT>,
-        chain_config: &MockChainConfig,
-    ) -> Result<(), BlockPolicyError> {
+        _: &MockChainConfig,
+        _: &mut Metrics,
+    ) -> Result<(), PassthruBlockPolicyError> {
         // check coherency against the block being extended or against the root of the blocktree if
         // there is no extending branch
         let (extending_seq_num, extending_timestamp) =
@@ -470,12 +458,12 @@ where
             };
 
         if block.get_seq_num() != extending_seq_num + SeqNum(1) {
-            return Err(BlockPolicyError::BlockNotCoherent);
+            return Err(PassthruBlockPolicyError::InvalidSeqNum);
         }
 
         if block.get_timestamp() <= extending_timestamp {
             // timestamps must be monotonically increasing
-            return Err(BlockPolicyError::TimestampError);
+            return Err(PassthruBlockPolicyError::TimestampError);
         }
 
         let expected_execution_results = self.get_expected_execution_results(
@@ -484,7 +472,7 @@ where
             state_backend,
         )?;
         if block.get_execution_results() != &expected_execution_results {
-            return Err(BlockPolicyError::ExecutionResultMismatch);
+            return Err(PassthruBlockPolicyError::ExecutionResultMismatch);
         }
 
         Ok(())
@@ -499,8 +487,8 @@ where
         Ok(Vec::new())
     }
 
-    fn update_committed_block(&mut self, _: &Self::ValidatedBlock, _: &MockChainConfig) {}
-    fn reset(&mut self, _: Vec<&Self::ValidatedBlock>, _: &MockChainConfig) {}
+    fn update_committed_block(&mut self, _: &Self::ValidatedBlock) {}
+    fn reset(&mut self, _: Vec<&Self::ValidatedBlock>) {}
 }
 
 #[derive(Debug, Clone, RlpEncodable, RlpDecodable, Serialize)]

monad-consensus-types/src/block.rs

@@ -0,0 +1,54 @@
+// Copyright (C) 2025 Category Labs, Inc.
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+use monad_state_backend::StateBackendError;
+use monad_system_calls::validator::SystemTransactionValidationError;
+
+#[derive(Debug, PartialEq)]
+pub enum EthBlockPolicyError {
+    InvalidSeqNum,
+    StateBackendError(StateBackendError),
+    TimestampError,
+    ExecutionResultMismatch,
+    BaseFeeError,
+    BlockPolicyBlockValidatorError(EthBlockPolicyBlockValidatorError),
+    InvalidNonce,
+    SystemTransactionError(SystemTransactionValidationError),
+}
+
+#[derive(Debug, PartialEq)]
+pub enum EthBlockPolicyBlockValidatorError {
+    AccountBalanceMissing,
+    InsufficientBalance,
+    InsufficientReserveBalance,
+}
+
+impl From<EthBlockPolicyBlockValidatorError> for EthBlockPolicyError {
+    fn from(err: EthBlockPolicyBlockValidatorError) -> Self {
+        Self::BlockPolicyBlockValidatorError(err)
+    }
+}
+
+impl From<StateBackendError> for EthBlockPolicyError {
+    fn from(err: StateBackendError) -> Self {
+        Self::StateBackendError(err)
+    }
+}
+
+impl From<SystemTransactionValidationError> for EthBlockPolicyError {
+    fn from(err: SystemTransactionValidationError) -> Self {
+        Self::SystemTransactionError(err)
+    }
+}