feat(prover): Update witness generator to zkevm_test_harness 0.150.6

Cargo.toml

@@ -217,15 +217,15 @@ circuit_sequencer_api_1_3_3 = { package = "circuit_sequencer_api", version = "0.
 circuit_sequencer_api_1_4_0 = { package = "circuit_sequencer_api", version = "0.140" }
 circuit_sequencer_api_1_4_1 = { package = "circuit_sequencer_api", version = "0.141" }
 circuit_sequencer_api_1_4_2 = { package = "circuit_sequencer_api", version = "0.142" }
-circuit_sequencer_api_1_5_0 = { package = "circuit_sequencer_api", version = "=0.150.5" }
+circuit_sequencer_api_1_5_0 = { git = "https://github.com/matter-labs/zksync-protocol.git", package = "circuit_sequencer_api" }
 crypto_codegen = { package = "zksync_solidity_vk_codegen", version = "=0.30.1" }
-kzg = { package = "zksync_kzg", version = "=0.150.5" }
+kzg = { git = "https://github.com/matter-labs/zksync-protocol.git", package = "zksync_kzg" }
 zk_evm = { version = "=0.133.0" }
 zk_evm_1_3_1 = { package = "zk_evm", version = "0.131.0-rc.2" }
 zk_evm_1_3_3 = { package = "zk_evm", version = "0.133" }
 zk_evm_1_4_0 = { package = "zk_evm", version = "0.140" }
 zk_evm_1_4_1 = { package = "zk_evm", version = "0.141" }
-zk_evm_1_5_0 = { package = "zk_evm", version = "=0.150.5" }
+zk_evm_1_5_0 = { git = "https://github.com/matter-labs/zksync-protocol.git", package = "zk_evm" }
 
 # New VM; pinned to a specific commit because of instability
 zksync_vm2 = { git = "https://github.com/matter-labs/vm2.git", rev = "74577d9be13b1bff9d1a712389731f669b179e47" }

prover/Cargo.toml

@@ -58,9 +58,9 @@ tracing-subscriber = "0.3"
 vise = "0.2.0"
 
 # Proving dependencies
-circuit_definitions = "=0.150.5"
-circuit_sequencer_api = "=0.150.5"
-zkevm_test_harness = "=0.150.5"
+circuit_definitions = { git = "https://github.com/matter-labs/zksync-protocol.git", package = "circuit_definitions" }
+circuit_sequencer_api = { git = "https://github.com/matter-labs/zksync-protocol.git", package = "circuit_sequencer_api" }
+zkevm_test_harness = { git = "https://github.com/matter-labs/zksync-protocol.git", package = "zkevm_test_harness" }
 
 # GPU proving dependencies
 wrapper_prover = { package = "zksync-wrapper-prover", version = "=0.150.9" }

prover/crates/bin/witness_generator/src/rounds/basic_circuits/utils.rs

@@ -5,7 +5,7 @@ use std::{
 };
 
 use circuit_definitions::{
- circuit_definitions::base_layer::{ZkSyncBaseLayerCircuit, ZkSyncBaseLayerStorage},
+ circuit_definitions::base_layer::ZkSyncBaseLayerStorage,
  encodings::recursion_request::RecursionQueueSimulator,
  zkevm_circuits::fsm_input_output::ClosedFormInputCompactFormWitness,
 };
@@ -21,7 +21,7 @@ use zksync_multivm::{
  zk_evm_latest::ethereum_types::Address,
 };
 use zksync_object_store::ObjectStore;
-use zksync_prover_fri_types::{keys::ClosedFormInputKey, CircuitAuxData};
+use zksync_prover_fri_types::keys::ClosedFormInputKey;
 use zksync_prover_interface::inputs::WitnessInputData;
 use zksync_system_constants::BOOTLOADER_ADDRESS;
 use zksync_types::L1BatchNumber;
@@ -31,8 +31,7 @@ use crate::{
  rounds::basic_circuits::Witness,
  storage_oracle::StorageOracle,
  utils::{
- expand_bootloader_contents, save_circuit, save_ram_premutation_queue_witness,
- ClosedFormInputWrapper, KZG_TRUSTED_SETUP_FILE,
+ expand_bootloader_contents, save_circuit, ClosedFormInputWrapper, KZG_TRUSTED_SETUP_FILE,
  },
  witness::WitnessStorage,
 };
@@ -64,17 +63,38 @@ pub(super) async fn generate_witness(
 
  let (circuit_sender, mut circuit_receiver) = tokio::sync::mpsc::channel(1);
  let (queue_sender, mut queue_receiver) = tokio::sync::mpsc::channel(1);
- let (ram_permutation_queue_sender, mut ram_permutation_queue_receiver) =
- tokio::sync::mpsc::channel(1);
 
  let make_circuits_span = tracing::info_span!("make_circuits");
  let make_circuits_span_copy = make_circuits_span.clone();
+
+ use std::{sync::mpsc::sync_channel, thread};
+ let (artifacts_sender, artifacts_receiver) = sync_channel(1);
+
+ let artifacts_receiver_handle = thread::spawn(move || {
+ let span = tracing::info_span!(parent: make_circuits_span_copy, "make_circuits_blocking");
+
+ while let Ok(artifact) = artifacts_receiver.recv() {
+ match artifact {
+ WitnessGenerationArtifact::BaseLayerCircuit(circuit) => {
+ let parent_span = span.clone();
+ tracing::info_span!(parent: parent_span, "send_circuit").in_scope(|| {
+ circuit_sender
+ .blocking_send(circuit)
+ .expect("failed to send circuit from harness");
+ });
+ }
+ WitnessGenerationArtifact::RecursionQueue((a, b, c)) => queue_sender
+ .blocking_send((a as u8, b, c))
+ .expect("failed to send recursion queue from harness"),
+ _ => {}
+ }
+ }
+ });
+
  // Blocking call from harness that does the CPU heavy lifting.
  // Provides circuits and recursion queue via callback functions and returns scheduler witnesses.
  // Circuits are "streamed" one by one as they're being generated.
  let make_circuits_handle = tokio::task::spawn_blocking(move || {
- let span = tracing::info_span!(parent: make_circuits_span_copy, "make_circuits_blocking");
-
  let witness_storage = WitnessStorage::new(input.vm_run_data.witness_block_state);
  let storage_view = StorageView::new(witness_storage).to_rc_ptr();
 
@@ -91,29 +111,6 @@ pub(super) async fn generate_witness(
  .to_str()
  .expect("Path to KZG trusted setup is not a UTF-8 string");
 
- let artifacts_callback = |artifact: WitnessGenerationArtifact| match artifact {
- WitnessGenerationArtifact::BaseLayerCircuit(circuit) => {
- let parent_span = span.clone();
- tracing::info_span!(parent: parent_span, "send_circuit").in_scope(|| {
- circuit_sender
- .blocking_send(circuit)
- .expect("failed to send circuit from harness");
- });
- }
- WitnessGenerationArtifact::RecursionQueue((a, b, c)) => queue_sender
- .blocking_send((a as u8, b, c))
- .expect("failed to send recursion queue from harness"),
- a @ WitnessGenerationArtifact::MemoryQueueWitness(_) => {
- let parent_span = span.clone();
- tracing::info_span!(parent: parent_span, "send_ram_permutation_queue_witness")
- .in_scope(|| {
- ram_permutation_queue_sender
- .blocking_send(a)
- .expect("failed to send ram permutation queue sitness from harness");
- });
- }
- };
-
  let (scheduler_witness, block_witness) = zkevm_test_harness::external_calls::run(
  Address::zero(),
  BOOTLOADER_ADDRESS,
@@ -129,9 +126,9 @@ pub(super) async fn generate_witness(
  geometry_config,
  storage_oracle,
  tree,
- path,
+ path.to_owned(),
  input.eip_4844_blobs.blobs(),
- artifacts_callback,
+ artifacts_sender,
  );
  (scheduler_witness, block_witness)
  })
@@ -150,8 +147,6 @@ pub(super) async fn generate_witness(
  // If the order is tampered with, proving will fail (as the proof would be computed for a different sequence of instruction).
  let mut circuit_sequence = 0;
 
- let mut ram_circuit_sequence = 0;
-
  while let Some(circuit) = circuit_receiver
  .recv()
  .instrument(tracing::info_span!("wait_for_circuit"))
@@ -166,84 +161,16 @@ pub(super) async fn generate_witness(
  .await
  .expect("failed to get permit for running save circuit task");
 
- let partial_circuit_aux_data = match &circuit {
- ZkSyncBaseLayerCircuit::RAMPermutation(_) => {
- let circuit_subsequence_number = ram_circuit_sequence;
- ram_circuit_sequence += 1;
- Some(CircuitAuxData {
- circuit_subsequence_number,
- })
- }
- _ => None,
- };
-
  save_circuit_handles.push(tokio::task::spawn(async move {
- let (circuit_id, circuit_url) = save_circuit(
- block_number,
- circuit,
- sequence,
- partial_circuit_aux_data,
- object_store,
- )
- .await;
+ let (circuit_id, circuit_url) =
+ save_circuit(block_number, circuit, sequence, object_store).await;
  drop(permit);
  (circuit_id, circuit_url)
  }));
  }
  }
  .instrument(save_circuits_span);
 
- let mut save_ram_queue_witness_handles = vec![];
-
- let save_ram_queue_witness_span = tracing::info_span!("save_circuits");
-
- // Future which receives part of RAM permutation circuits witnesses and saves them async.
- // Uses semaphore because these artifacts are of significant size
- let ram_queue_witness_receiver_handle = async {
- let mut sorted_sequence = 0;
- let mut unsorted_sequence = 0;
-
- while let Some(witness_artifact) = ram_permutation_queue_receiver
- .recv()
- .instrument(tracing::info_span!("wait_for_ram_witness"))
- .await
- {
- let object_store = object_store.clone();
- let semaphore = semaphore.clone();
- let permit = semaphore
- .acquire_owned()
- .await
- .expect("failed to get permit for running save ram permutation queue witness task");
- let (is_sorted, witness, sequence) = match witness_artifact {
- WitnessGenerationArtifact::MemoryQueueWitness((witness, sorted)) => {
- let sequence = if sorted {
- let sequence = sorted_sequence;
- sorted_sequence += 1;
- sequence
- } else {
- let sequence = unsorted_sequence;
- unsorted_sequence += 1;
- sequence
- };
- (sorted, witness, sequence)
- }
- _ => panic!("Invalid artifact received"),
- };
- save_ram_queue_witness_handles.push(tokio::task::spawn(async move {
- let _ = save_ram_premutation_queue_witness(
- block_number,
- sequence,
- is_sorted,
- witness,
- object_store,
- )
- .await;
- drop(permit);
- }));
- }
- }
- .instrument(save_ram_queue_witness_span);
-
  let mut save_queue_handles = vec![];
 
  let save_queues_span = tracing::info_span!("save_queues");
@@ -260,7 +187,7 @@ pub(super) async fn generate_witness(
  let object_store = object_store.clone();
  save_queue_handles.push(tokio::task::spawn(save_recursion_queue(
  block_number,
- circuit_id,
+ circuit_id.try_into().unwrap(),
  queue,
  inputs,
  object_store,
@@ -269,11 +196,10 @@ pub(super) async fn generate_witness(
  }
  .instrument(save_queues_span);
 
- let (witnesses, _, _, _) = tokio::join!(
+ let (witnesses, _, _) = tokio::join!(
  make_circuits_handle,
  circuit_receiver_handle,
- queue_receiver_handle,
- ram_queue_witness_receiver_handle
+ queue_receiver_handle
  );
  let (mut scheduler_witness, block_aux_witness) = witnesses.unwrap();
 
@@ -298,11 +224,7 @@ pub(super) async fn generate_witness(
  .filter(|(circuit_id, _, _)| circuits_present.contains(circuit_id))
  .collect();
 
- let _: Vec<_> = futures::future::join_all(save_ram_queue_witness_handles)
- .await
- .into_iter()
- .map(|result| result.expect("failed to save ram permutation queue witness"))
- .collect();
+ artifacts_receiver_handle.join().unwrap();
 
  scheduler_witness.previous_block_meta_hash = input.previous_batch_metadata.meta_hash.0;
  scheduler_witness.previous_block_aux_hash = input.previous_batch_metadata.aux_hash.0;

prover/crates/bin/witness_generator/src/utils.rs

@@ -3,10 +3,7 @@ use std::{
  sync::Arc,
 };
 
-use circuit_definitions::{
- circuit_definitions::base_layer::ZkSyncBaseLayerCircuit,
- encodings::memory_query::MemoryQueueStateWitnesses,
-};
+use circuit_definitions::circuit_definitions::base_layer::ZkSyncBaseLayerCircuit;
 use once_cell::sync::Lazy;
 use zkevm_test_harness::boojum::field::goldilocks::GoldilocksField;
 use zksync_multivm::utils::get_used_bootloader_memory_bytes;
@@ -24,8 +21,8 @@ use zksync_prover_fri_types::{
  encodings::recursion_request::RecursionQueueSimulator,
  zkevm_circuits::scheduler::input::SchedulerCircuitInstanceWitness,
  },
- keys::{AggregationsKey, ClosedFormInputKey, FriCircuitKey, RamPermutationQueueWitnessKey},
- CircuitAuxData, CircuitWrapper, FriProofWrapper, RamPermutationQueueWitness,
+ keys::{AggregationsKey, ClosedFormInputKey, FriCircuitKey},
+ CircuitWrapper, FriProofWrapper,
 };
 use zksync_types::{basic_fri_types::AggregationRound, L1BatchNumber, ProtocolVersionId, U256};
 
@@ -121,7 +118,6 @@ pub async fn save_circuit(
  block_number: L1BatchNumber,
  circuit: ZkSyncBaseLayerCircuit,
  sequence_number: usize,
- aux_data_for_partial_circuit: Option<CircuitAuxData>,
  object_store: Arc<dyn ObjectStore>,
 ) -> (u8, String) {
  let circuit_id = circuit.numeric_circuit_type();
@@ -133,43 +129,12 @@ pub async fn save_circuit(
  depth: 0,
  };
 
- let blob_url = if let Some(aux_data_for_partial_circuit) = aux_data_for_partial_circuit {
- object_store
- .put(
- circuit_key,
- &CircuitWrapper::BasePartial((circuit, aux_data_for_partial_circuit)),
- )
- .await
- .unwrap()
- } else {
- object_store
- .put(circuit_key, &CircuitWrapper::Base(circuit))
- .await
- .unwrap()
- };
- (circuit_id, blob_url)
-}
-
-#[tracing::instrument(
- skip_all,
- fields(l1_batch = %block_number)
-)]
-pub async fn save_ram_premutation_queue_witness(
- block_number: L1BatchNumber,
- circuit_subsequence_number: usize,
- is_sorted: bool,
- witness: MemoryQueueStateWitnesses<GoldilocksField>,
- object_store: Arc<dyn ObjectStore>,
-) -> String {
- let witness_key = RamPermutationQueueWitnessKey {
- block_number,
- circuit_subsequence_number,
- is_sorted,
- };
- object_store
- .put(witness_key, &RamPermutationQueueWitness { witness })
+ let blob_url = object_store
+ .put(circuit_key, &CircuitWrapper::Base(circuit))
  .await
- .unwrap()
+ .unwrap();
+
+ (circuit_id, blob_url)
 }
 
 #[tracing::instrument(

prover/crates/lib/keystore/Cargo.toml

@@ -15,7 +15,7 @@ zksync_basic_types.workspace = true
 zksync_utils.workspace = true
 zksync_prover_fri_types.workspace = true
 zkevm_test_harness.workspace = true
-circuit_definitions = { workspace = true, features = ["log_tracing"] }
+circuit_definitions = { git = "https://github.com/matter-labs/zksync-protocol.git", package = "circuit_definitions", features = [ "log_tracing" ]  }
 shivini = { workspace = true, optional = true }
 
 anyhow.workspace = true

prover/crates/lib/keystore/src/keystore.rs

@@ -470,6 +470,7 @@ impl Keystore {
  }
 
  /// Async loads mapping of all circuits to setup key, if successful
+ #[cfg(feature = "gpu")]
  pub async fn load_all_setup_key_mapping(
  &self,
  ) -> anyhow::Result<HashMap<ProverServiceDataKey, Arc<GoldilocksGpuProverSetupData>>> {

prover/crates/lib/prover_fri_types/Cargo.toml

@@ -13,5 +13,5 @@ categories.workspace = true
 [dependencies]
 zksync_object_store.workspace = true
 zksync_types.workspace = true
-circuit_definitions = { workspace = true, features = [ "log_tracing" ] }
+circuit_definitions = { git = "https://github.com/matter-labs/zksync-protocol.git", package = "circuit_definitions", features = [ "log_tracing" ]  }
 serde = { workspace = true, features = ["derive"] }