feat: Prover interface and L1 interface crates (matter-labs#959)

tl;dr:
- Removes crypto stuff from `zksync_types` (this was a primary goal for
this PR)
- Reduces public API surface for general-purpose crates
- Introduces `l1_contract_interface` crate for stuff related to
interacting with our main L1 contract.
- Introduces `prover_interface` crate as a point of interaction between
prover and core subsystems.

❕Note: this is not a complete refactoring, there is still a lot of stuff
that can be moved to either of these two crates, this will be worked on
iteratively. This PR is meant to be just an improvement over what we
currently have.

Rationale: `l1_contract_interface` and `prover_interface` are currently
scattered across several crates (`zksync_types`, most notably) while
actually being used only by few. Encapsulating them both reduces the
public API surface plus reduces the number of (transitive) dependencies,
including getting rid of some heavyweight stuff.

Cargo.toml

@@ -23,12 +23,14 @@ members = [
     "core/lib/env_config",
     "core/lib/eth_client",
     "core/lib/eth_signer",
+    "core/lib/l1_contract_interface",
     "core/lib/mempool",
     "core/lib/merkle_tree",
     "core/lib/mini_merkle_tree",
     "core/lib/node",
     "core/lib/object_store",
     "core/lib/prometheus_exporter",
+    "core/lib/prover_interface",
     "core/lib/queued_job_processor",
     "core/lib/state",
     "core/lib/storage",

core/lib/basic_types/src/basic_fri_types.rs

@@ -1,5 +1,9 @@
 //! Basic types for FRI prover.
 
+// TODO (PLA-773): Should be moved to the prover workspace.
+
+use std::{convert::TryFrom, str::FromStr};
+
 use serde::{Deserialize, Serialize};
 
 #[derive(Debug, Deserialize, Serialize, Clone, Eq, Hash, PartialEq, PartialOrd, Ord)]
@@ -16,3 +20,82 @@ impl CircuitIdRoundTuple {
         }
     }
 }
+
+/// Represents the sequential number of the proof aggregation round.
+/// Mostly used to be stored in `aggregation_round` column  in `prover_jobs` table
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
+pub enum AggregationRound {
+    BasicCircuits = 0,
+    LeafAggregation = 1,
+    NodeAggregation = 2,
+    Scheduler = 3,
+}
+
+impl From<u8> for AggregationRound {
+    fn from(item: u8) -> Self {
+        match item {
+            0 => AggregationRound::BasicCircuits,
+            1 => AggregationRound::LeafAggregation,
+            2 => AggregationRound::NodeAggregation,
+            3 => AggregationRound::Scheduler,
+            _ => panic!("Invalid round"),
+        }
+    }
+}
+
+impl AggregationRound {
+    pub fn next(&self) -> Option<AggregationRound> {
+        match self {
+            AggregationRound::BasicCircuits => Some(AggregationRound::LeafAggregation),
+            AggregationRound::LeafAggregation => Some(AggregationRound::NodeAggregation),
+            AggregationRound::NodeAggregation => Some(AggregationRound::Scheduler),
+            AggregationRound::Scheduler => None,
+        }
+    }
+}
+
+impl std::fmt::Display for AggregationRound {
+    fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter.write_str(match self {
+            Self::BasicCircuits => "basic_circuits",
+            Self::LeafAggregation => "leaf_aggregation",
+            Self::NodeAggregation => "node_aggregation",
+            Self::Scheduler => "scheduler",
+        })
+    }
+}
+
+impl FromStr for AggregationRound {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "basic_circuits" => Ok(AggregationRound::BasicCircuits),
+            "leaf_aggregation" => Ok(AggregationRound::LeafAggregation),
+            "node_aggregation" => Ok(AggregationRound::NodeAggregation),
+            "scheduler" => Ok(AggregationRound::Scheduler),
+            other => Err(format!(
+                "{} is not a valid round name for witness generation",
+                other
+            )),
+        }
+    }
+}
+
+impl TryFrom<i32> for AggregationRound {
+    type Error = ();
+
+    fn try_from(v: i32) -> Result<Self, Self::Error> {
+        match v {
+            x if x == AggregationRound::BasicCircuits as i32 => Ok(AggregationRound::BasicCircuits),
+            x if x == AggregationRound::LeafAggregation as i32 => {
+                Ok(AggregationRound::LeafAggregation)
+            }
+            x if x == AggregationRound::NodeAggregation as i32 => {
+                Ok(AggregationRound::NodeAggregation)
+            }
+            x if x == AggregationRound::Scheduler as i32 => Ok(AggregationRound::Scheduler),
+            _ => Err(()),
+        }
+    }
+}

core/lib/dal/Cargo.toml

@@ -50,6 +50,7 @@ hex = "0.4"
 once_cell = "1.7"
 strum = { version = "0.24", features = ["derive"] }
 tracing = "0.1"
+chrono = { version = "0.4", features = ["serde"] }
 
 [dev-dependencies]
 assert_matches = "1.5.0"

core/lib/dal/src/fri_gpu_prover_queue_dal.rs

@@ -1,8 +1,10 @@
 use std::time::Duration;
 
-use zksync_types::proofs::{GpuProverInstanceStatus, SocketAddress};
-
-use crate::{time_utils::pg_interval_from_duration, StorageProcessor};
+use crate::{
+    fri_prover_dal::types::{GpuProverInstanceStatus, SocketAddress},
+    time_utils::pg_interval_from_duration,
+    StorageProcessor,
+};
 
 #[derive(Debug)]
 pub struct FriGpuProverQueueDal<'a, 'c> {

core/lib/dal/src/fri_proof_compressor_dal.rs

@@ -2,12 +2,10 @@ use std::{collections::HashMap, str::FromStr, time::Duration};
 
 use sqlx::Row;
 use strum::{Display, EnumString};
-use zksync_types::{
-    proofs::{JobCountStatistics, StuckJobs},
-    L1BatchNumber,
-};
+use zksync_types::L1BatchNumber;
 
 use crate::{
+    fri_prover_dal::types::{JobCountStatistics, StuckJobs},
     time_utils::{duration_to_naive_time, pg_interval_from_duration},
     StorageProcessor,
 };