feat(prover): Adding first support for 4844 circuit

prover/proof_fri_compressor/src/compressor.rs

@@ -153,6 +153,9 @@ impl JobProcessor for ProofCompressor {
         let scheduler_proof = match fri_proof {
             FriProofWrapper::Base(_) => anyhow::bail!("Must be a scheduler proof not base layer"),
             FriProofWrapper::Recursive(proof) => proof,
+            FriProofWrapper::Eip4844(_) => {
+                anyhow::bail!("Must be a scheduler proof not base layer")
+            }
         };
         Ok(Some((l1_batch_number, scheduler_proof)))
     }

prover/prover_fri/src/gpu_prover_job_processor.rs

@@ -3,6 +3,7 @@ pub mod gpu_prover {
     use std::{collections::HashMap, sync::Arc, time::Instant};
 
     use anyhow::Context as _;
+    use circuit_definitions::eip4844_proof_config;
     use shivini::{gpu_prove_from_external_witness_data, ProverContext};
     use tokio::task::JoinHandle;
     use zksync_config::configs::{fri_prover_group::FriProverGroupConfig, FriProverConfig};
@@ -137,6 +138,10 @@ pub mod gpu_prover {
                     base_layer_proof_config(),
                     recursive_circuit.numeric_circuit_type(),
                 ),
+                CircuitWrapper::Eip4844(_) => (
+                    eip4844_proof_config(),
+                    ProverServiceDataKey::eip4844().circuit_id,
+                ),
             };
 
             let started_at = Instant::now();
@@ -180,6 +185,7 @@ pub mod gpu_prover {
                 CircuitWrapper::Recursive(_) => FriProofWrapper::Recursive(
                     ZkSyncRecursionLayerProof::from_inner(circuit_id, proof),
                 ),
+                CircuitWrapper::Eip4844(_) => FriProofWrapper::Eip4844(proof),
             };
             ProverArtifacts::new(prover_job.block_number, proof_wrapper)
         }

prover/prover_fri/src/prover_job_processor.rs

@@ -1,8 +1,11 @@
 use std::{collections::HashMap, sync::Arc, time::Instant};
 
 use anyhow::Context as _;
+use circuit_definitions::{circuit_definitions::eip4844::EIP4844Circuit, eip4844_proof_config};
 use tokio::task::JoinHandle;
-use zkevm_test_harness::prover_utils::{prove_base_layer_circuit, prove_recursion_layer_circuit};
+use zkevm_test_harness::prover_utils::{
+    prove_base_layer_circuit, prove_eip4844_circuit, prove_recursion_layer_circuit,
+};
 use zksync_config::configs::{fri_prover_group::FriProverGroupConfig, FriProverConfig};
 use zksync_dal::ConnectionPool;
 use zksync_env_config::FromEnv;
@@ -110,10 +113,49 @@ impl Prover {
             CircuitWrapper::Recursive(recursive_circuit) => {
                 Self::prove_recursive_layer(job.job_id, recursive_circuit, config, setup_data)
             }
+            CircuitWrapper::Eip4844(circuit) => {
+                Self::prove_eip4844(job.job_id, circuit, setup_data)
+            }
         };
         ProverArtifacts::new(job.block_number, proof)
     }
 
+    fn prove_eip4844(
+        job_id: u32,
+        circuit: EIP4844Circuit<GoldilocksField, ZkSyncDefaultRoundFunction>,
+        artifact: Arc<GoldilocksProverSetupData>,
+    ) -> FriProofWrapper {
+        let worker = Worker::new();
+        let started_at = Instant::now();
+
+        let proof = prove_eip4844_circuit::<NoPow>(
+            circuit.clone(),
+            &worker,
+            eip4844_proof_config(),
+            &artifact.setup_base,
+            &artifact.setup,
+            &artifact.setup_tree,
+            &artifact.vk,
+            &artifact.vars_hint,
+            &artifact.wits_hint,
+            &artifact.finalization_hint,
+        );
+
+        let label = CircuitLabels {
+            circuit_type: ProverServiceDataKey::eip4844().circuit_id,
+            layer: Layer::Base,
+        };
+        METRICS.proof_generation_time[&label].observe(started_at.elapsed());
+
+        verify_proof(
+            &CircuitWrapper::Eip4844(circuit),
+            &proof,
+            &artifact.vk,
+            job_id,
+        );
+        FriProofWrapper::Eip4844(proof)
+    }
+
     fn prove_recursive_layer(
         job_id: u32,
         circuit: ZkSyncRecursiveLayerCircuit,

prover/prover_fri/src/socket_listener.rs

@@ -196,6 +196,14 @@ pub mod gpu_socket_listener {
                     .context("get_finalization_hints()")?;
                 init_recursive_layer_cs_for_repeated_proving(recursive_circuit, &finalization_hint)
             }
+            CircuitWrapper::Eip4844(_) => {
+                let key = ProverServiceDataKey::eip4844();
+                let finalization_hint = keystore
+                    .load_finalization_hints(key)
+                    .context("get_finalization_hints()")?;
+                // Check shivini's support.
+                todo!();
+            }
         };
         tracing::info!(
             "Successfully generated assembly without witness vector for job: {}, took: {:?}",

prover/prover_fri/src/utils.rs

@@ -3,7 +3,9 @@
 use std::{sync::Arc, time::Instant};
 
 use tokio::sync::Mutex;
-use zkevm_test_harness::prover_utils::{verify_base_layer_proof, verify_recursion_layer_proof};
+use zkevm_test_harness::prover_utils::{
+    verify_base_layer_proof, verify_eip4844_proof, verify_recursion_layer_proof,
+};
 use zksync_dal::StorageProcessor;
 use zksync_object_store::ObjectStore;
 use zksync_prover_fri_types::{
@@ -96,6 +98,7 @@ pub async fn save_proof(
             }
             _ => (recursive_circuit.numeric_circuit_type(), false),
         },
+        FriProofWrapper::Eip4844(_) => (ProverServiceDataKey::eip4844().circuit_id, false),
     };
 
     let blob_save_started_at = Instant::now();
@@ -143,14 +146,16 @@ pub fn verify_proof(
             verify_recursion_layer_proof::<NoPow>(recursive_circuit, proof, vk),
             recursive_circuit.numeric_circuit_type(),
         ),
+        CircuitWrapper::Eip4844(circuit) => (
+            verify_eip4844_proof::<NoPow>(circuit, proof, vk),
+            ProverServiceDataKey::eip4844().circuit_id,
+        ),
     };
 
     METRICS.proof_verification_time[&circuit_id.to_string()].observe(started_at.elapsed());
 
     if !is_valid {
-        let msg = format!(
-            "Failed to verify base layer proof for job-id: {job_id} circuit_type {circuit_id}"
-        );
+        let msg = format!("Failed to verify proof for job-id: {job_id} circuit_type {circuit_id}");
         tracing::error!("{}", msg);
         panic!("{}", msg);
     }

prover/prover_fri/tests/basic_test.rs

@@ -54,7 +54,7 @@ async fn prover_and_assert_base_layer(
         .context("circuit missing")?;
     let circuit = match &circuit_wrapper {
         CircuitWrapper::Base(base) => base.clone(),
-        CircuitWrapper::Recursive(_) => anyhow::bail!("Expected base layer circuit"),
+        _ => anyhow::bail!("Expected base layer circuit"),
     };
     let keystore = Keystore::default();
     let circuit_setup_data =

prover/prover_fri_types/src/lib.rs

@@ -5,7 +5,8 @@ use circuit_definitions::{
     aux_definitions::witness_oracle::VmWitnessOracle,
     boojum::{cs::implementations::witness::WitnessVec, field::goldilocks::GoldilocksField},
     circuit_definitions::{
-        base_layer::{ZkSyncBaseLayerCircuit, ZkSyncBaseLayerProof},
+        base_layer::{ZkSyncBaseLayerCircuit, ZkSyncBaseLayerProof, ZkSyncBaseProof},
+        eip4844::EIP4844Circuit,
         recursion_layer::{
             ZkSyncRecursionLayerProof, ZkSyncRecursionLayerStorageType, ZkSyncRecursiveLayerCircuit,
         },
@@ -32,6 +33,7 @@ pub enum CircuitWrapper {
         >,
     ),
     Recursive(ZkSyncRecursiveLayerCircuit),
+    Eip4844(EIP4844Circuit<GoldilocksField, ZkSyncDefaultRoundFunction>),
 }
 
 impl StoredObject for CircuitWrapper {
@@ -56,6 +58,7 @@ impl StoredObject for CircuitWrapper {
 pub enum FriProofWrapper {
     Base(ZkSyncBaseLayerProof),
     Recursive(ZkSyncRecursionLayerProof),
+    Eip4844(ZkSyncBaseProof),
 }
 
 impl StoredObject for FriProofWrapper {

prover/prover_fri_utils/src/lib.rs

@@ -103,6 +103,7 @@ pub fn get_numeric_circuit_id(circuit_wrapper: &CircuitWrapper) -> u8 {
     match circuit_wrapper {
         CircuitWrapper::Base(circuit) => circuit.numeric_circuit_type(),
         CircuitWrapper::Recursive(circuit) => circuit.numeric_circuit_type(),
+        CircuitWrapper::Eip4844(_) => ProverServiceDataKey::eip4844().circuit_id,
     }
 }
 

prover/witness_generator/src/leaf_aggregation.rs

@@ -229,6 +229,9 @@ pub async fn prepare_leaf_aggregation_job(
             FriProofWrapper::Recursive(_) => {
                 anyhow::bail!("Expected only base proofs for leaf agg {}", metadata.id);
             }
+            FriProofWrapper::Eip4844(_) => {
+                anyhow::bail!("EIP4844 should be run as a leaf.");
+            }
         }
     }
     let leaf_params = compute_leaf_params(metadata.circuit_id, base_vk.clone(), leaf_vk);

prover/witness_generator/src/node_aggregation.rs

@@ -259,6 +259,7 @@ pub async fn prepare_job(
                 );
             }
             FriProofWrapper::Recursive(recursive_proof) => recursive_proofs.push(recursive_proof),
+            FriProofWrapper::Eip4844(_) => anyhow::bail!("EIP 4844 should not be run as a node."),
         }
     }
 

prover/witness_generator/src/scheduler.rs

@@ -250,6 +250,9 @@ pub async fn prepare_job(
             FriProofWrapper::Recursive(recursive_proof) => {
                 recursive_proofs.push(recursive_proof.into_inner())
             }
+            FriProofWrapper::Eip4844(_) => {
+                anyhow::bail!("EIP 4844 should not be run as a scheduler")
+            }
         }
     }
 

prover/witness_vector_generator/src/generator.rs

@@ -66,6 +66,10 @@ impl WitnessVectorGenerator {
             CircuitWrapper::Recursive(recursive_circuit) => {
                 recursive_circuit.synthesis::<GoldilocksField>(&finalization_hints)
             }
+            CircuitWrapper::Eip4844(_) => {
+                // TODO: figure out if we support 4844 circuit as GPU.
+                todo!()
+            }
         };
         Ok(WitnessVectorArtifacts::new(cs.witness.unwrap(), job))
     }