feat(Prover CLI): status l1 command

prover/Cargo.toml

@@ -86,6 +86,8 @@ zksync_state = { path = "../core/lib/state" }
 zksync_system_constants = { path = "../core/lib/constants" }
 zksync_types = { path = "../core/lib/types" }
 zksync_utils = { path = "../core/lib/utils" }
+zksync_eth_client = { path = "../core/lib/eth_client" }
+zksync_contracts = { path = "../core/lib/contracts" }
 
 # for `perf` profiling
 [profile.perf]

prover/prover_cli/Cargo.toml

@@ -10,14 +10,10 @@ keywords.workspace = true
 categories.workspace = true
 
 [dependencies]
-tokio = { version = "1", features = ["rt-multi-thread", "macros"] }
-env_logger = "0.10"
-log = "0.4"
-colored = "2.1.0"
-
+tokio = { workspace = true, features = ["rt-multi-thread", "macros"] }
 clap = { workspace = true, features = ["derive"] }
-tracing.workspace = true
 tracing-subscriber = { workspace = true, features = ["env-filter"] }
+tracing.workspace = true
 bincode.workspace = true
 hex.workspace = true
 anyhow.workspace = true
@@ -29,4 +25,9 @@ zksync_types.workspace = true
 zksync_prover_fri_types.workspace = true
 zksync_prover_interface.workspace = true
 prover_dal.workspace = true
+zksync_eth_client.workspace = true
+zksync_contracts.workspace = true
+zksync_dal.workspace = true
 strum.workspace = true
+colored.workspace = true
+sqlx.workspace = true

prover/prover_cli/README.md

@@ -55,6 +55,38 @@ Scheduler: In progress ⌛️
 > Compressor job not found 🚫
 ```
 
+## Status
+
+### Status l1
+
+Retrieve information about the state of the batches sent to L1 and compare the contract hashes in L1 with those stored
+in the prover database.
+
+Example:
+
+```bash
+$ zk f run --release -- status l1
+
+====== L1 Status ======
+State keeper: First batch: 0, recent batch: 10
+L1 state: block verified: 7, block committed: 9
+Eth sender is 1 behind. Last block committed: 9. Most recent sealed state keeper batch: 10.
+ -----------------------
+Verifier key hash matches: 0x063c9c1e9d39fc0b1633c78a49f1905s65ee0982ad96d97ef7fe3d4f1f1a72c7
+ -----------------------
+Verification node hash in DB differs from the one in contract.
+Contract hash: 0x1186ec268d49f1905f8d9c1e9d39fc33e98c74f91d91a21b8f7ef78bd09a8db8
+DB hash: 0x5a3ef282b21e12fe1f4438e5bb158fc5060b160559c5158c6389d62d9fe3d080
+ -----------------------
+Verification leaf hash in DB differs from the one in contract.
+Contract hash: 0x101e08b00193e529145ee09823378ef51a3bc8966504064f1f6ba3f1ba863210
+DB hash: 0x400a4b532c6f072c00d1806ef299300d4c104f4ac55bd8698ade78894fcadc0a
+ -----------------------
+Verification circuits hash in DB differs from the one in contract.
+Contract hash: 0x18c1639094f58177409186e8c48d9f577c9410901d2f1d486b3e7d6cf553ae4c
+DB hash: 0x0000000000000000000000000000000000000000000000000000000000000000
+```
+
 ## File-Info
 
 Displays the information about a given file:

prover/prover_cli/src/commands/status/l1.rs

@@ -0,0 +1,202 @@
+use anyhow::Context;
+use prover_dal::{Prover, ProverDal};
+use zksync_basic_types::{
+    ethabi::{Contract, Token},
+    protocol_version::{L1VerifierConfig, VerifierParams},
+    web3::contract::tokens::Detokenize,
+    Address, L1BatchNumber, H256, U256,
+};
+use zksync_config::{ContractsConfig, EthConfig, PostgresConfig};
+use zksync_dal::{ConnectionPool, Core, CoreDal};
+use zksync_env_config::FromEnv;
+use zksync_eth_client::{clients::QueryClient, CallFunctionArgs, EthInterface};
+
+pub(crate) async fn run() -> anyhow::Result<()> {
+    println!(" ====== L1 Status ====== ");
+    let postgres_config = PostgresConfig::from_env().context("PostgresConfig::from_env")?;
+    let contracts_config = ContractsConfig::from_env().context("ContractsConfig::from_env()")?;
+    let eth_config = EthConfig::from_env().context("EthConfig::from_env")?;
+    let query_client = QueryClient::new(eth_config.web3_url)?;
+
+    let total_batches_committed_tokens = contract_call(
+        "getTotalBatchesCommitted",
+        contracts_config.diamond_proxy_addr,
+        zksync_contracts::hyperchain_contract(),
+        &query_client,
+    )
+    .await?;
+
+    let mut total_batches_committed: U256 = U256::zero();
+    if let Some(Token::Uint(value)) = total_batches_committed_tokens.first() {
+        total_batches_committed = value.into();
+    }
+
+    let total_batches_verified_tokens = contract_call(
+        "getTotalBatchesVerified",
+        contracts_config.diamond_proxy_addr,
+        zksync_contracts::hyperchain_contract(),
+        &query_client,
+    )
+    .await?;
+
+    let mut total_batches_verified: U256 = U256::zero();
+    if let Some(Token::Uint(value)) = total_batches_verified_tokens.first() {
+        total_batches_verified = value.into();
+    }
+
+    let connection_pool = ConnectionPool::<Core>::builder(
+        postgres_config
+            .replica_url()
+            .context("postgres_config.replica_url()")?,
+        postgres_config
+            .max_connections()
+            .context("postgres_config.max_connections()")?,
+    )
+    .build()
+    .await
+    .context("ConnectionPoolBuilder::build()")?;
+
+    let mut conn = connection_pool.connection().await?;
+
+    // Using unwrap() safely as there will always be at least one block.
+    let first_state_keeper_l1_batch = conn
+        .blocks_dal()
+        .get_earliest_l1_batch_number()
+        .await?
+        .unwrap();
+    let last_state_keeper_l1_batch = conn
+        .blocks_dal()
+        .get_sealed_l1_batch_number()
+        .await?
+        .unwrap();
+
+    pretty_print_l1_status(
+        total_batches_committed,
+        total_batches_verified,
+        first_state_keeper_l1_batch,
+        last_state_keeper_l1_batch,
+    );
+
+    let node_verification_key_hash_tokens = contract_call(
+        "verificationKeyHash",
+        contracts_config.verifier_addr,
+        zksync_contracts::verifier_contract(),
+        &query_client,
+    )
+    .await?;
+
+    let node_verifier_params_tokens = contract_call(
+        "getVerifierParams",
+        contracts_config.diamond_proxy_addr,
+        zksync_contracts::hyperchain_contract(),
+        &query_client,
+    )
+    .await?;
+
+    let node_l1_verifier_config = L1VerifierConfig {
+        params: VerifierParams::from_tokens(node_verifier_params_tokens)?,
+        recursion_scheduler_level_vk_hash: H256::from_tokens(node_verification_key_hash_tokens)?,
+    };
+
+    let prover_connection_pool = ConnectionPool::<Prover>::builder(
+        postgres_config
+            .prover_url()
+            .context("postgres_config.replica_url()")?,
+        postgres_config
+            .max_connections()
+            .context("postgres_config.max_connections()")?,
+    )
+    .build()
+    .await
+    .context("ConnectionPoolBuilder::build()")?;
+
+    let mut conn = prover_connection_pool.connection().await.unwrap();
+
+    let db_l1_verifier_config = conn
+        .fri_protocol_versions_dal()
+        .get_l1_verifier_config()
+        .await?;
+
+    pretty_print_l1_verifier_config(node_l1_verifier_config, db_l1_verifier_config);
+
+    Ok(())
+}
+
+fn pretty_print_l1_status(
+    total_batches_committed: U256,
+    total_batches_verified: U256,
+    first_state_keeper_l1_batch: L1BatchNumber,
+    last_state_keeper_l1_batch: L1BatchNumber,
+) {
+    println!(
+        "State keeper: First batch: {}, recent batch: {}",
+        first_state_keeper_l1_batch, last_state_keeper_l1_batch
+    );
+
+    println!(
+        "L1 state: block verified: {}, block committed: {}",
+        total_batches_verified, total_batches_committed
+    );
+
+    let eth_sender_lag = U256::from(last_state_keeper_l1_batch.0) - total_batches_committed;
+    if eth_sender_lag > U256::zero() {
+        println!(
+            "Eth sender is {} behind. Last block committed: {}. Most recent sealed state keeper batch: {}.", 
+            eth_sender_lag,
+            total_batches_committed,
+            last_state_keeper_l1_batch
+        );
+    }
+}
+
+fn print_hash_comparison(name: &str, contract_hash: H256, db_hash: H256) {
+    println!(" ----------------------- ");
+    if contract_hash != db_hash {
+        println!("{name} hash in DB differs from the one in contract.");
+        println!("Contract hash: {contract_hash:?}");
+        println!("DB hash: {db_hash:?}");
+    } else {
+        println!("{name} hash matches: {contract_hash:}");
+    }
+}
+
+fn pretty_print_l1_verifier_config(
+    node_l1_verifier_config: L1VerifierConfig,
+    db_l1_verifier_config: L1VerifierConfig,
+) {
+    print_hash_comparison(
+        "Verifier key",
+        node_l1_verifier_config.recursion_scheduler_level_vk_hash,
+        db_l1_verifier_config.recursion_scheduler_level_vk_hash,
+    );
+    print_hash_comparison(
+        "Verification node",
+        node_l1_verifier_config.params.recursion_node_level_vk_hash,
+        db_l1_verifier_config.params.recursion_node_level_vk_hash,
+    );
+    print_hash_comparison(
+        "Verification leaf",
+        node_l1_verifier_config.params.recursion_leaf_level_vk_hash,
+        db_l1_verifier_config.params.recursion_leaf_level_vk_hash,
+    );
+    print_hash_comparison(
+        "Verification circuits",
+        node_l1_verifier_config
+            .params
+            .recursion_circuits_set_vks_hash,
+        db_l1_verifier_config.params.recursion_circuits_set_vks_hash,
+    );
+}
+
+async fn contract_call(
+    method: &str,
+    address: Address,
+    contract: Contract,
+    query_client: &QueryClient,
+) -> Result<Vec<Token>, zksync_eth_client::Error> {
+    let args_for_total_batches_committed: zksync_eth_client::ContractCall =
+        CallFunctionArgs::new(method, ()).for_contract(address, contract);
+    query_client
+        .call_contract_function(args_for_total_batches_committed)
+        .await
+}