feat: support loading verifier and protocol version from db (#1293)

## What ❔

* Support loading the verification key and protocol version from DB

## Why ❔

* This way proving system can pick the right provers when processing a
given batch (based on the batch protocol version rather than environment
variables)

---------

Co-authored-by: Emil <evl@matterlabs.dev>

core/lib/types/src/protocol_version.rs

@@ -140,22 +140,43 @@ impl TryFrom<U256> for ProtocolVersionId {
     }
 }
 
+// TODO: Do we even need this? I reckon we could merge this with `ProtocolVersionId`.
 #[repr(u16)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 #[derive(TryFromPrimitive, Serialize, Deserialize)]
 pub enum FriProtocolVersionId {
     Version0 = 0,
     Version1,
     Version2,
+    Version3,
+    Version4,
+    Version5,
+    Version6,
+    Version7,
+    Version8,
+    Version9,
+    Version10,
+    Version11,
+    Version12,
+    Version13,
+    Version14,
+    Version15,
+    Version16,
+    Version17,
+    Version18,
+    Version19,
+    Version20,
+    Version21,
+    Version22,
 }
 
 impl FriProtocolVersionId {
     pub fn latest() -> Self {
-        Self::Version1
+        Self::Version21
     }
 
     pub fn next() -> Self {
-        Self::Version2
+        Self::Version22
     }
 }
 
@@ -165,6 +186,36 @@ impl Default for FriProtocolVersionId {
     }
 }
 
+impl From<ProtocolVersionId> for FriProtocolVersionId {
+    fn from(protocol_version: ProtocolVersionId) -> Self {
+        match protocol_version {
+            ProtocolVersionId::Version0 => FriProtocolVersionId::Version0,
+            ProtocolVersionId::Version1 => FriProtocolVersionId::Version1,
+            ProtocolVersionId::Version2 => FriProtocolVersionId::Version2,
+            ProtocolVersionId::Version3 => FriProtocolVersionId::Version3,
+            ProtocolVersionId::Version4 => FriProtocolVersionId::Version4,
+            ProtocolVersionId::Version5 => FriProtocolVersionId::Version5,
+            ProtocolVersionId::Version6 => FriProtocolVersionId::Version6,
+            ProtocolVersionId::Version7 => FriProtocolVersionId::Version7,
+            ProtocolVersionId::Version8 => FriProtocolVersionId::Version8,
+            ProtocolVersionId::Version9 => FriProtocolVersionId::Version9,
+            ProtocolVersionId::Version10 => FriProtocolVersionId::Version10,
+            ProtocolVersionId::Version11 => FriProtocolVersionId::Version11,
+            ProtocolVersionId::Version12 => FriProtocolVersionId::Version12,
+            ProtocolVersionId::Version13 => FriProtocolVersionId::Version13,
+            ProtocolVersionId::Version14 => FriProtocolVersionId::Version14,
+            ProtocolVersionId::Version15 => FriProtocolVersionId::Version15,
+            ProtocolVersionId::Version16 => FriProtocolVersionId::Version16,
+            ProtocolVersionId::Version17 => FriProtocolVersionId::Version17,
+            ProtocolVersionId::Version18 => FriProtocolVersionId::Version18,
+            ProtocolVersionId::Version19 => FriProtocolVersionId::Version19,
+            ProtocolVersionId::Version20 => FriProtocolVersionId::Version20,
+            ProtocolVersionId::Version21 => FriProtocolVersionId::Version21,
+            ProtocolVersionId::Version22 => FriProtocolVersionId::Version22,
+        }
+    }
+}
+
 #[derive(Debug, Clone, Copy, Default, Eq, PartialEq, Serialize, Deserialize)]
 pub struct VerifierParams {
     pub recursion_node_level_vk_hash: H256,

core/lib/zksync_core/src/proof_data_handler/request_processor.rs

@@ -104,17 +104,42 @@ impl RequestProcessor {
             .await
             .map_err(RequestProcessorError::ObjectStore)?;
 
-        let fri_protocol_version_id =
-            FriProtocolVersionId::try_from(self.config.fri_protocol_version_id)
-                .expect("Invalid FRI protocol version id");
-
-        let l1_verifier_config= match self.config.protocol_version_loading_mode {
+        let (l1_verifier_config, fri_protocol_version_id) = match self.config.protocol_version_loading_mode {
             ProtocolVersionLoadingMode::FromDb => {
-                panic!("Loading protocol version from db is not implemented yet")
+
+                let header = self
+                .pool
+                .access_storage()
+                .await
+                .unwrap()
+                .blocks_dal()
+                .get_l1_batch_header(l1_batch_number)
+                .await
+                .unwrap()
+                .expect(&format!("Missing header for {}", l1_batch_number));
+
+            let protocol_version = header.protocol_version.unwrap();
+            // TODO: What invariants have to hold such that protocol version = fri protocol version?
+            let fri_protocol_version = FriProtocolVersionId::from(protocol_version);
+            (self
+                .pool
+                .access_storage()
+                .await
+                .unwrap()
+                .protocol_versions_dal()
+                .l1_verifier_config_for_version(protocol_version)
+                .await
+                .expect(&format!(
+                    "Missing l1 verifier info for protocol version {protocol_version:?}",
+                )), fri_protocol_version)
+
             }
             ProtocolVersionLoadingMode::FromEnvVar => {
-                self.l1_verifier_config
-                    .expect("l1_verifier_config must be set while running ProtocolVersionLoadingMode::FromEnvVar mode")
+                (self.l1_verifier_config
+                    .expect("l1_verifier_config must be set while running ProtocolVersionLoadingMode::FromEnvVar mode"),
+                    FriProtocolVersionId::try_from(self.config.fri_protocol_version_id)
+                .expect("Invalid FRI protocol version id"))
+
             }
         };