feat(prover): Add prover_cli stats command

core/lib/basic_types/src/prover_dal.rs

@@ -10,10 +10,6 @@ use crate::{
     L1BatchNumber,
 };
 
-// This currently lives in `zksync_prover_types` -- we don't want a dependency between prover types (`zkevm_test_harness`) and DAL.
-// This will be gone as part of 1.5.0, when EIP4844 becomes normal jobs, rather than special cased ones.
-pub const EIP_4844_CIRCUIT_ID: u8 = 255;
-
 #[derive(Debug, Clone)]
 pub struct FriProverJobMetadata {
     pub id: u32,
@@ -382,3 +378,12 @@ pub struct ProofCompressionJobInfo {
     pub time_taken: Option<NaiveTime>,
     pub picked_by: Option<String>,
 }
+
+// Used for transferring information about L1 Batches from DAL to public interfaces (currently prover_cli stats).
+/// DTO containing information about L1 Batch Proof.
+#[derive(Debug, Clone)]
+pub struct ProofGenerationTime {
+    pub l1_batch_number: L1BatchNumber,
+    pub time_taken: NaiveTime,
+    pub created_at: NaiveDateTime,
+}

core/lib/db_connection/src/utils.rs

@@ -9,6 +9,10 @@ pub(crate) struct InternalMarker;
 
 impl DbMarker for InternalMarker {}
 
+const MICROSECONDS_IN_A_SECOND: i64 = 1_000_000;
+const MICROSECONDS_IN_A_MINUTE: i64 = MICROSECONDS_IN_A_SECOND * 60;
+const MICROSECONDS_IN_AN_HOUR: i64 = MICROSECONDS_IN_A_MINUTE * 60;
+
 pub fn duration_to_naive_time(duration: Duration) -> NaiveTime {
     let total_seconds = duration.as_secs() as u32;
     NaiveTime::from_hms_opt(
@@ -26,3 +30,16 @@ pub const fn pg_interval_from_duration(processing_timeout: Duration) -> PgInterv
         microseconds: processing_timeout.as_micros() as i64,
     }
 }
+
+// Note: this conversion purposefully ignores `.days` and `.months` fields of PgInterval.
+// The PgIntervals expected are below 24h (represented by `.microseconds`). If that's not the case,
+// the function will trim days and months. Use at your own risk.
+pub fn naive_time_from_pg_interval(pg_interval: PgInterval) -> NaiveTime {
+    NaiveTime::from_hms_micro_opt(
+        (pg_interval.microseconds / MICROSECONDS_IN_AN_HOUR) as u32,
+        ((pg_interval.microseconds / MICROSECONDS_IN_A_MINUTE) % 60) as u32,
+        ((pg_interval.microseconds / MICROSECONDS_IN_A_SECOND) % 60) as u32,
+        (pg_interval.microseconds as u32) % 1_000_000,
+    )
+    .expect("failed to convert PgInterval to NaiveTime")
+}

prover/Cargo.toml

@@ -32,6 +32,7 @@ categories = ["cryptography"]
 anyhow = "1.0"
 async-trait = "0.1"
 bincode = "1"
+chrono = "0.4.38"
 circuit_definitions = { git = "https://github.com/matter-labs/era-zkevm_test_harness.git", branch = "v1.5.0" }
 circuit_sequencer_api = { package = "circuit_sequencer_api", git = "https://github.com/matter-labs/era-zkevm_test_harness.git", branch = "v1.5.0" }
 clap = "4.4.6"

prover/prover_cli/Cargo.toml

@@ -36,6 +36,7 @@ sqlx.workspace = true
 circuit_definitions.workspace = true
 serde_json.workspace = true
 zkevm_test_harness = { workspace = true, optional = true, features = ["verbose_circuits"] }
+chrono.workspace = true
 
 [features]
 # enable verbose circuits, if you want to use debug_circuit command (as it is quite heavy dependency).

prover/prover_cli/src/cli.rs

@@ -1,12 +1,12 @@
 use clap::{command, Args, Parser, Subcommand};
 use zksync_types::url::SensitiveUrl;
 
-use crate::commands::{self, config, debug_proof, delete, get_file_info, requeue, restart};
+use crate::commands::{self, config, debug_proof, delete, get_file_info, requeue, restart, stats};
 
 pub const VERSION_STRING: &str = env!("CARGO_PKG_VERSION");
 
 #[derive(Parser)]
-#[command(name="prover-cli", version=VERSION_STRING, about, long_about = None)]
+#[command(name = "prover-cli", version = VERSION_STRING, about, long_about = None)]
 struct ProverCLI {
     #[command(subcommand)]
     command: ProverCommand,
@@ -35,6 +35,8 @@ enum ProverCommand {
     Status(commands::StatusCommand),
     Requeue(requeue::Args),
     Restart(restart::Args),
+    #[command(about = "Displays L1 Batch proving stats for a given period")]
+    Stats(stats::Options),
 }
 
 pub async fn start() -> anyhow::Result<()> {
@@ -47,6 +49,7 @@ pub async fn start() -> anyhow::Result<()> {
         ProverCommand::Requeue(args) => requeue::run(args, config).await?,
         ProverCommand::Restart(args) => restart::run(args).await?,
         ProverCommand::DebugProof(args) => debug_proof::run(args).await?,
+        ProverCommand::Stats(args) => stats::run(args, config).await?,
     };
 
     Ok(())

prover/prover_cli/src/commands/mod.rs

@@ -1,8 +1,9 @@
+pub(crate) use status::StatusCommand;
 pub(crate) mod config;
 pub(crate) mod debug_proof;
 pub(crate) mod delete;
 pub(crate) mod get_file_info;
 pub(crate) mod requeue;
 pub(crate) mod restart;
+pub(crate) mod stats;
 pub(crate) mod status;
-pub(crate) use status::StatusCommand;

prover/prover_cli/src/commands/stats.rs

@@ -0,0 +1,63 @@
+use anyhow::Context;
+use chrono::{self, NaiveTime};
+use clap::{Args, ValueEnum};
+use zksync_basic_types::prover_dal::ProofGenerationTime;
+use zksync_db_connection::connection_pool::ConnectionPool;
+use zksync_prover_dal::{Prover, ProverDal};
+
+use crate::cli::ProverCLIConfig;
+
+#[derive(ValueEnum, Clone)]
+enum StatsPeriod {
+    Day,
+    Week,
+}
+
+#[derive(Args)]
+pub(crate) struct Options {
+    #[clap(
+        short = 'p',
+        long = "period",
+        help = "Specify the time frame to look for stats",
+        default_value = "day"
+    )]
+    period: StatsPeriod,
+}
+
+pub(crate) async fn run(opts: Options, config: ProverCLIConfig) -> anyhow::Result<()> {
+    let prover_connection_pool = ConnectionPool::<Prover>::singleton(config.db_url)
+        .build()
+        .await
+        .context("failed to build a prover_connection_pool")?;
+    let mut conn = prover_connection_pool
+        .connection()
+        .await
+        .context("failed to get connection from pool")?;
+
+    let start_date = match opts.period {
+        StatsPeriod::Day => chrono::offset::Local::now().date_naive(),
+        StatsPeriod::Week => {
+            (chrono::offset::Local::now() - chrono::Duration::days(7)).date_naive()
+        }
+    };
+    let start_date =
+        start_date.and_time(NaiveTime::from_num_seconds_from_midnight_opt(0, 0).unwrap());
+    let proof_generation_times = conn
+        .fri_witness_generator_dal()
+        .get_proof_generation_times_for_time_frame(start_date)
+        .await?;
+    display_proof_generation_time(proof_generation_times);
+    Ok(())
+}
+
+fn display_proof_generation_time(proof_generation_times: Vec<ProofGenerationTime>) {
+    println!("Batch\tTime Taken\t\tCreated At");
+    for proof_generation_time in proof_generation_times {
+        println!(
+            "{}\t{:?}\t\t{}",
+            proof_generation_time.l1_batch_number,
+            proof_generation_time.time_taken,
+            proof_generation_time.created_at
+        );
+    }
+}