Metrics in separated files. (#12)

* Metrics and Checks are separated files and work in a similar way 
 - checks are calculated based on pre/post states: `pub async fn run(&self, pre_state: &State, post_state: &State)`
 - metrics are updated the same way: `pub fn update(&self, pre_state: &State, post_state: &State)`
* A single current_state is maintained in the mainloop
* Initial height from config or tip
* States attempt to be at the blockchain latest height (Expects blocks are consecutive (can not skip blocks))
* lru of blocks disabled.

Author: feliam

Cargo.lock

@@ -1,34 +1,49 @@
-use anyhow::anyhow;
+use crate::state::State;
+use anyhow::{anyhow, Ok};
 
 #[derive(Clone, Debug, Default)]
 pub struct BlockHeigtCheck {}
 
 impl BlockHeigtCheck {
-    pub async fn run(
-        &self,
-        pre_state: &crate::state::State,
-        post_state: &crate::state::State,
-    ) -> anyhow::Result<()> {
-        match (
-            pre_state.latest_block_height,
-            post_state.latest_block_height,
-        ) {
-            (None, None) => Ok(()),    // nothing happen yet
-            (None, Some(_)) => Ok(()), // first block
-            (Some(pre_block_height), None) => Err(anyhow!(
-                "Invalid state: pre {} -> post None",
-                pre_block_height
-            )), // should never happen
-            (Some(pre_block_height), Some(post_block_height)) => {
-                if pre_block_height < post_block_height {
-                    Ok(())
-                } else {
-                    Err(anyhow!(
-                        "Invalid block height: pre {} -> post {}",
-                        pre_block_height,
-                        post_block_height
-                    ))
-                }
+    pub async fn run(&self, pre_state: &State, post_state: &State) -> anyhow::Result<()> {
+        let pre_block = pre_state.get_last_block();
+        let post_block = post_state.get_last_block();
+        if pre_block.height + 1 != post_block.height {
+            Err(anyhow!(
+                "Blocks are not consecutive: pre {} -> post {}",
+                pre_block.height,
+                post_block.height
+            ))
+        } else {
+            Ok(())
+        }
+    }
+}
+
+pub struct BlockTimeCheck {
+    max_time: u64,
+}
+impl BlockTimeCheck {
+    pub async fn run(&self, pre_state: &State, post_state: &State) -> anyhow::Result<()> {
+        let pre_block = pre_state.get_last_block();
+        let post_block = post_state.get_last_block();
+        let max_estimated_block_time = pre_state.get_max_block_time_estimate() as u64;
+        if max_estimated_block_time > self.max_time {
+            Err(anyhow!(
+                "Max estimated block time is too high: {}",
+                max_estimated_block_time
+            ))
+        } else {
+            let estimated_post_time = pre_state.max_next_block_timestamp_estimate();
+            if estimated_post_time < post_block.timestamp {
+                Err(anyhow!(
+                    "Block at height {} took too long to be produced {} (vs {:?})",
+                    post_block.height,
+                    post_block.timestamp - pre_block.timestamp,
+                    pre_state.get_max_block_time_estimate()
+                ))
+            } else {
+                Ok(())
             }
         }
     }

src/checks/block.rs

@@ -1,31 +1,21 @@
+use crate::state::State;
 use anyhow::anyhow;
 
 #[derive(Clone, Debug, Default)]
 pub struct EpochCheck {}
 
 impl EpochCheck {
-    pub async fn run(
-        &self,
-        pre_state: &crate::state::State,
-        post_state: &crate::state::State,
-    ) -> anyhow::Result<()> {
-        match (pre_state.latest_epoch, post_state.latest_epoch) {
-            (None, None) => Ok(()),    // nothing happen yet
-            (None, Some(_)) => Ok(()), // first epoch
-            (Some(pre_epoch), None) => {
-                Err(anyhow!("Invalid state: pre {} -> post None", pre_epoch))
-            } // should never happen
-            (Some(pre_epoch), Some(post_epoch)) => {
-                if pre_epoch <= post_epoch {
-                    Ok(())
-                } else {
-                    Err(anyhow!(
-                        "Invalid epoch: pre {} -> post {}",
-                        pre_epoch,
-                        post_epoch
-                    ))
-                }
-            }
+    pub async fn run(&self, pre_state: &State, post_state: &State) -> anyhow::Result<()> {
+        let pre_epoch = pre_state.get_last_block().epoch;
+        let post_epoch = post_state.get_last_block().epoch;
+        if pre_epoch == post_epoch || pre_epoch.checked_add(1).unwrap_or_default() == post_epoch {
+            Ok(())
+        } else {
+            Err(anyhow!(
+                "Invalid epoch: pre {} -> post {}",
+                pre_epoch,
+                post_epoch
+            ))
         }
     }
 }

src/checks/epoch.rs

@@ -3,23 +3,56 @@ pub mod epoch;
 pub mod total_supply_native;
 pub mod tx_size;
 
+use crate::config::AppConfig;
+use crate::state::State;
 use block::BlockHeigtCheck;
+use block::BlockTimeCheck;
 use epoch::EpochCheck;
 use total_supply_native::TotalSupplyNativeCheck;
 use tx_size::TxSizeCheck;
 
 pub enum Checks {
     BlockHeightCheck(BlockHeigtCheck),
+    BlockTimeCheck(BlockTimeCheck),
     EpochCheck(EpochCheck),
     TotalSupplyNative(TotalSupplyNativeCheck),
     TxSize(TxSizeCheck),
 }
 
-pub fn all_checks() -> Vec<Checks> {
-    vec![
-        Checks::BlockHeightCheck(BlockHeigtCheck::default()),
-        Checks::EpochCheck(EpochCheck::default()),
-        Checks::TotalSupplyNative(TotalSupplyNativeCheck::default()),
-        Checks::TxSize(TxSizeCheck::default()),
-    ]
+impl Checks {
+    pub async fn run(&self, pre_state: &State, post_state: &State) -> anyhow::Result<()> {
+        match self {
+            Checks::BlockHeightCheck(check) => check.run(pre_state, post_state).await,
+            Checks::BlockTimeCheck(check) => check.run(pre_state, post_state).await,
+            Checks::EpochCheck(check) => check.run(pre_state, post_state).await,
+            Checks::TotalSupplyNative(check) => check.run(pre_state, post_state).await,
+            Checks::TxSize(check) => check.run(pre_state, post_state).await,
+        }
+    }
+}
+
+pub struct CheckCollection {
+    checks: Vec<Checks>,
+}
+
+impl CheckCollection {
+    pub fn new(config: &AppConfig) -> Self {
+        let checks = vec![
+            Checks::BlockHeightCheck(BlockHeigtCheck::default()),
+            Checks::EpochCheck(EpochCheck::default()),
+            Checks::TotalSupplyNative(TotalSupplyNativeCheck::default()),
+            Checks::TxSize(TxSizeCheck::new(
+                config.max_tx_size,
+                config.max_tx_inner_len,
+            )),
+        ];
+        Self { checks }
+    }
+
+    pub async fn run(&self, pre_state: &State, post_state: &State) -> anyhow::Result<()> {
+        for check in &self.checks {
+            check.run(pre_state, post_state).await?;
+        }
+        Ok(())
+    }
 }

src/checks/mod.rs

@@ -1,35 +1,29 @@
+use crate::shared::namada::Address;
+use crate::state::State;
 use anyhow::anyhow;
 
 #[derive(Clone, Debug, Default)]
-pub struct TotalSupplyNativeCheck {}
+pub struct TotalSupplyNativeCheck {
+    token: Address,
+}
 
 impl TotalSupplyNativeCheck {
-    pub async fn run(
-        &self,
-        pre_state: &crate::state::State,
-        post_state: &crate::state::State,
-    ) -> anyhow::Result<()> {
-        match (
-            pre_state.latest_total_supply_native,
-            post_state.latest_total_supply_native,
-        ) {
-            (None, None) => Ok(()),    // nothing happen yet
-            (None, Some(_)) => Ok(()), // first epoch
-            (Some(pre_total_supply), None) => Err(anyhow!(
-                "Invalid state: pre {} -> post None",
-                pre_total_supply
-            )), // should never happen
-            (Some(pre_total_supply), Some(post_total_supply)) => {
-                if pre_total_supply <= post_total_supply {
-                    Ok(())
-                } else {
-                    Err(anyhow!(
-                        "Invalid total supply: pre {} -> post {}. Could be valid in case of slashes or rejected governance proposal.",
-                        pre_total_supply,
-                        post_total_supply
-                    ))
-                }
-            }
+    pub fn new(token: Address) -> Self {
+        Self { token }
+    }
+
+    pub async fn run(&self, pre_state: &State, post_state: &State) -> anyhow::Result<()> {
+        let pre_total_supply = pre_state.get_total_supply(&self.token).unwrap_or_default();
+        let post_total_supply = post_state.get_total_supply(&self.token).unwrap_or_default();
+
+        if pre_total_supply <= post_total_supply {
+            Ok(())
+        } else {
+            Err(anyhow!(
+                "Invalid total supply: pre {} -> post {}. Could be valid in case of slashes or rejected governance proposal.",
+                    pre_total_supply,
+                    post_total_supply
+                ))
         }
     }
 }

src/checks/total_supply_native.rs

@@ -1,12 +1,34 @@
-#[derive(Clone, Debug, Default)]
-pub struct TxSizeCheck {}
+use crate::state::State;
+use anyhow::anyhow;
+
+#[derive(Clone, Debug)]
+pub struct TxSizeCheck {
+    max_tx_size: u64,
+    max_inner_len: u64,
+}
 
 impl TxSizeCheck {
-    pub async fn run(
-        &self,
-        pre_state: &crate::state::State,
-        post_state: &crate::state::State,
-    ) -> anyhow::Result<()> {
+    pub fn new(max_tx_size: u64, max_inner_len: u64) -> Self {
+        Self {
+            max_tx_size,
+            max_inner_len,
+        }
+    }
+
+    pub async fn run(&self, _pre_state: &State, post_state: &State) -> anyhow::Result<()> {
+        for tx in &post_state.get_last_block().transactions {
+            if tx.inners.len() > self.max_inner_len as usize {
+                return Err(anyhow!(
+                    "Transaction inner length is too large: {}",
+                    tx.inners.len()
+                ));
+            }
+            for inner in &tx.inners {
+                if inner.size > self.max_tx_size as usize {
+                    return Err(anyhow!("Transaction size is too large: {}", inner.size));
+                }
+            }
+        }
         Ok(())
     }
 }

src/checks/tx_size.rs

@@ -1,3 +1,5 @@
+use std::u64;
+
 use crate::log::LogConfig;
 
 #[derive(clap::Parser)]
@@ -6,7 +8,7 @@ pub struct AppConfig {
     pub cometbft_urls: Vec<String>,
 
     #[clap(long, env)]
-    pub chain_id: String,
+    pub chain_id: Option<String>,
 
     #[clap(long, env)]
     pub slack_token: Option<String>,
@@ -20,12 +22,18 @@ pub struct AppConfig {
     #[clap(long, env, default_value_t = 9184)]
     pub prometheus_port: u64,
 
-    #[clap(long, env, default_value_t = 1)]
+    #[clap(long, env, default_value_t = u64::MAX)]
     pub initial_block_height: u64,
 
-    #[clap(long, env, default_value_t = 5)]
+    #[clap(long, env, default_value_t = 1000)]
     pub sleep_for: u64,
 
     #[clap(flatten)]
     pub log: LogConfig,
+
+    #[clap(long, env, default_value_t = 100000)]
+    pub max_tx_size: u64,
+
+    #[clap(long, env, default_value_t = 100)]
+    pub max_tx_inner_len: u64,
 }