GitHub ci

.github/workflows/ci.yml

@@ -0,0 +1,46 @@
+name: CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  ci:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install Rust stable
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
+
+      - name: Install Rust nightly (for fmt)
+        uses: dtolnay/rust-toolchain@nightly
+        with:
+          components: rustfmt
+
+      - name: Setup Rust cache
+        uses: Swatinem/rust-cache@v2
+
+      - name: Check formatting
+        run: cargo +nightly fmt --all --check
+
+      - name: Cargo check (warnings as errors)
+        run: cargo +stable check --all-targets
+        env:
+          RUSTFLAGS: "-D warnings"
+
+      - name: Run clippy
+        run: cargo +stable clippy --all-targets -- -D warnings
+
+      - name: Build
+        run: cargo +stable build --verbose
+
+      - name: Run tests
+        run: cargo +stable test --verbose

rustfmt.toml

@@ -0,0 +1,13 @@
+reorder_imports = true
+use_field_init_shorthand = true
+use_small_heuristics = "Max"
+
+# Nightly
+max_width = 100
+comment_width = 100
+imports_granularity = "Crate"
+wrap_comments = true
+format_code_in_doc_comments = true
+doc_comment_code_block_width = 100
+format_macro_matchers = true
+

src/checkpoint/executor.rs

@@ -1,5 +1,7 @@
-use std::path::{Path, PathBuf};
-use std::process::Stdio;
+use std::{
+    path::{Path, PathBuf},
+    process::Stdio,
+};
 use tokio::process::Command;
 
 use crate::error::{CheckpointerError, Result};
@@ -14,11 +16,7 @@ pub struct CheckpointExecutor {
 impl CheckpointExecutor {
     /// Create a new checkpoint executor
     pub fn new(mdbx_copy_path: PathBuf, reth_path: PathBuf, compact: bool) -> Self {
-        Self {
-            mdbx_copy_path,
-            reth_path,
-            compact,
-        }
+        Self { mdbx_copy_path, reth_path, compact }
     }
 
     /// Verify that mdbx_copy and reth binaries are available and executable
@@ -61,10 +59,7 @@ impl CheckpointExecutor {
             )));
         }
 
-        let output = Command::new(&self.reth_path)
-            .arg("--version")
-            .output()
-            .await;
+        let output = Command::new(&self.reth_path).arg("--version").output().await;
 
         match output {
             Ok(out) if out.status.success() => {
@@ -160,11 +155,7 @@ impl CheckpointExecutor {
             )));
         }
 
-        tracing::info!(
-            "Copying static_files from {:?} to {:?}",
-            source_static,
-            dest_static
-        );
+        tracing::info!("Copying static_files from {:?} to {:?}", source_static, dest_static);
 
         let start = std::time::Instant::now();
 
@@ -195,11 +186,7 @@ impl CheckpointExecutor {
 
     /// Unwind the database to epoch_block - 2 using reth
     pub async fn unwind_database(&self, checkpoint_dir: &Path, target_block: u64) -> Result<()> {
-        tracing::info!(
-            "Unwinding database at {:?} to block {}",
-            checkpoint_dir,
-            target_block
-        );
+        tracing::info!("Unwinding database at {:?} to block {}", checkpoint_dir, target_block);
 
         let mut cmd = Command::new(&self.reth_path);
         cmd.arg("stage")
@@ -230,11 +217,7 @@ impl CheckpointExecutor {
         }
 
         let stdout = String::from_utf8_lossy(&output.stdout);
-        tracing::info!(
-            "reth unwind completed successfully in {:?}: {}",
-            duration,
-            stdout.trim()
-        );
+        tracing::info!("reth unwind completed successfully in {:?}: {}", duration, stdout.trim());
 
         Ok(())
     }
@@ -248,10 +231,7 @@ impl CheckpointExecutor {
 
         // Build tar command to compress db, static_files, and summit_checkpoint
         let mut cmd = Command::new("tar");
-        cmd.arg("-czf")
-            .arg(&archive_name)
-            .arg("db")
-            .arg("static_files");
+        cmd.arg("-czf").arg(&archive_name).arg("db").arg("static_files");
 
         // Only include summit_checkpoint if it exists
         let summit_checkpoint_dir = checkpoint_dir.join("summit_checkpoint");

src/checkpoint/manager.rs

@@ -1,11 +1,12 @@
-use std::path::PathBuf;
-use std::sync::Arc;
+use std::{path::PathBuf, sync::Arc};
 
-use crate::checkpoint::{CheckpointExecutor, CheckpointMetadata};
-use crate::config::{CheckpointConfig, Config};
-use crate::error::Result;
-use crate::rpc::RpcClient;
-use crate::state::StateTracker;
+use crate::{
+    checkpoint::{CheckpointExecutor, CheckpointMetadata},
+    config::{CheckpointConfig, Config},
+    error::Result,
+    rpc::RpcClient,
+    state::StateTracker,
+};
 
 /// Checkpoint manager orchestrates checkpoint creation
 pub struct CheckpointManager {
@@ -56,9 +57,7 @@ impl CheckpointManager {
         // Step 1: Copy MDBX database
         tracing::info!("Step 1/7: Copying MDBX database");
         let db_dest = checkpoint_path.join("db").join("mdbx.dat");
-        self.executor
-            .copy_mdbx_database(&self.db_path, &db_dest)
-            .await?;
+        self.executor.copy_mdbx_database(&self.db_path, &db_dest).await?;
 
         // Step 2: Copy static_files directory
         tracing::info!("Step 2/7: Copying static_files");
@@ -67,24 +66,16 @@ impl CheckpointManager {
                 "Could not determine parent directory of db_path".to_string(),
             )
         })?;
-        self.executor
-            .copy_static_files(source_db_dir, &checkpoint_path)
-            .await?;
+        self.executor.copy_static_files(source_db_dir, &checkpoint_path).await?;
 
         // Step 3: Delete lock file
         tracing::info!("Step 3/7: Deleting lock file");
         self.executor.delete_lock_file(&checkpoint_path).await?;
 
         // Step 4: Unwind database to epoch_block - 2
-        let unwind_target = if block_number >= 2 {
-            block_number - 2
-        } else {
-            0
-        };
+        let unwind_target = block_number.saturating_sub(2);
         tracing::info!("Step 4/7: Unwinding database to block {}", unwind_target);
-        self.executor
-            .unwind_database(&checkpoint_path, unwind_target)
-            .await?;
+        self.executor.unwind_database(&checkpoint_path, unwind_target).await?;
 
         // Step 5: Fetch and write Summit checkpoint data
         tracing::info!("Step 5/7: Fetching Summit checkpoint data");
@@ -161,14 +152,10 @@ impl CheckpointManager {
 
         // Step 7: Compress and cleanup
         tracing::info!("Step 7/7: Compressing checkpoint and cleaning up");
-        self.executor
-            .compress_and_cleanup(&checkpoint_path, epoch)
-            .await?;
+        self.executor.compress_and_cleanup(&checkpoint_path, epoch).await?;
 
         // Update state tracker
-        self.state_tracker
-            .update_last_checkpoint(epoch, block_number)
-            .await?;
+        self.state_tracker.update_last_checkpoint(epoch, block_number).await?;
 
         let duration = start.elapsed();
         tracing::info!(

src/checkpoint/metadata.rs

@@ -16,10 +16,6 @@ pub struct CheckpointMetadata {
 impl CheckpointMetadata {
     /// Create new checkpoint metadata
     pub fn new(epoch: u64, block_number: u64) -> Self {
-        Self {
-            epoch,
-            block_number,
-            timestamp: chrono::Utc::now(),
-        }
+        Self { epoch, block_number, timestamp: chrono::Utc::now() }
     }
 }

src/config.rs

@@ -128,9 +128,7 @@ impl Config {
 
         // Override with environment variables (e.g., CHECKPOINTER_RETH_RPC_URL)
         builder = builder.add_source(
-            config::Environment::with_prefix("CHECKPOINTER")
-                .separator("_")
-                .try_parsing(true),
+            config::Environment::with_prefix("CHECKPOINTER").separator("_").try_parsing(true),
         );
 
         // Build the config
@@ -222,14 +220,14 @@ impl Config {
 }
 
 /// Expand tilde and environment variables in paths
+#[allow(clippy::ptr_arg)]
 fn expand_path(path: &PathBuf) -> Result<PathBuf> {
     let path_str = path
         .to_str()
         .ok_or_else(|| CheckpointerError::InvalidPath("Invalid UTF-8 in path".to_string()))?;
 
-    let expanded = shellexpand::full(path_str).map_err(|e| {
-        CheckpointerError::InvalidPath(format!("Failed to expand path: {}", e))
-    })?;
+    let expanded = shellexpand::full(path_str)
+        .map_err(|e| CheckpointerError::InvalidPath(format!("Failed to expand path: {}", e)))?;
 
     Ok(PathBuf::from(expanded.as_ref()))
 }

src/lib.rs

@@ -10,8 +10,10 @@ pub mod state;
 pub use server::api::CheckpointerRpcClient;
 
 // Re-export jsonrpsee client utilities for constructing a CheckpointerRpcClient
-pub use jsonrpsee::core::ClientError;
-pub use jsonrpsee::http_client::{HttpClient, HttpClientBuilder};
+pub use jsonrpsee::{
+    core::ClientError,
+    http_client::{HttpClient, HttpClientBuilder},
+};
 
 // Re-export commonly used types
 pub use checkpoint::CheckpointManager;

src/main.rs

@@ -33,11 +33,8 @@ async fn main() -> Result<()> {
     let rpc_client = RpcClient::new(&config)?;
 
     // Create checkpoint manager
-    let checkpoint_manager = Arc::new(CheckpointManager::new(
-        &config,
-        state_tracker.clone(),
-        rpc_client.clone(),
-    ));
+    let checkpoint_manager =
+        Arc::new(CheckpointManager::new(&config, state_tracker.clone(), rpc_client.clone()));
 
     // Verify checkpoint tools are available
     tracing::info!("Verifying checkpoint tools (mdbx_copy, reth)...");

src/monitor.rs

@@ -1,11 +1,12 @@
-use std::sync::Arc;
-use std::time::Duration;
+use std::{sync::Arc, time::Duration};
 use tokio_util::sync::CancellationToken;
 
-use crate::checkpoint::CheckpointManager;
-use crate::config::MonitorConfig;
-use crate::error::{CheckpointerError, Result};
-use crate::rpc::RpcClient;
+use crate::{
+    checkpoint::CheckpointManager,
+    config::MonitorConfig,
+    error::{CheckpointerError, Result},
+    rpc::RpcClient,
+};
 
 /// Block monitor that watches for epoch boundaries and triggers checkpoints
 pub struct BlockMonitor {
@@ -25,13 +26,7 @@ impl BlockMonitor {
         epoch_blocks: u64,
         checkpoint_delay_blocks: u64,
     ) -> Self {
-        Self {
-            rpc_client,
-            checkpoint_manager,
-            config,
-            epoch_blocks,
-            checkpoint_delay_blocks,
-        }
+        Self { rpc_client, checkpoint_manager, config, epoch_blocks, checkpoint_delay_blocks }
     }
 
     /// Run the monitoring loop until cancelled
@@ -101,9 +96,7 @@ impl BlockMonitor {
                 );
 
                 // Create checkpoint for the epoch block, not the current block
-                self.checkpoint_manager
-                    .create_checkpoint(current_epoch, epoch_block)
-                    .await?;
+                self.checkpoint_manager.create_checkpoint(current_epoch, epoch_block).await?;
             } else {
                 let blocks_waited = current_block - epoch_block;
                 let blocks_to_wait = self.checkpoint_delay_blocks - blocks_waited;

src/rpc/client.rs

@@ -1,8 +1,10 @@
 use std::sync::Arc;
 
-use crate::config::Config;
-use crate::error::Result;
-use crate::rpc::{RethRpcClient, SummitRpcClient};
+use crate::{
+    config::Config,
+    error::Result,
+    rpc::{RethRpcClient, SummitRpcClient},
+};
 
 /// Combined RPC client wrapper
 #[derive(Clone)]

src/rpc/reth.rs

@@ -1,5 +1,7 @@
-use jsonrpsee::core::client::ClientT;
-use jsonrpsee::http_client::{HttpClient, HttpClientBuilder};
+use jsonrpsee::{
+    core::client::ClientT,
+    http_client::{HttpClient, HttpClientBuilder},
+};
 use serde::{Deserialize, Serialize};
 
 use crate::error::Result;
@@ -12,8 +14,7 @@ pub struct RethRpcClient {
 impl RethRpcClient {
     /// Create a new Reth RPC client
     pub fn new(url: &str) -> Result<Self> {
-        let client = HttpClientBuilder::default()
-            .build(url)?;
+        let client = HttpClientBuilder::default().build(url)?;
 
         tracing::info!("Reth RPC client initialized: {}", url);
         Ok(Self { client })
@@ -40,10 +41,7 @@ impl RethRpcClient {
         params.insert(block_param)?;
         params.insert(false)?; // Don't include full transactions
 
-        let response: BlockInfo = self
-            .client
-            .request("eth_getBlockByNumber", params)
-            .await?;
+        let response: BlockInfo = self.client.request("eth_getBlockByNumber", params).await?;
 
         Ok(response)
     }