test

Author: lispc

integration-tests/Cargo.toml

@@ -25,7 +25,7 @@ ff =  "0.11"
 pretty_assertions = "1.0.0"
 
 [features]
-default = []
+default = ["circuits"]
 rpc = []
 circuit_input_builder = []
 circuits = []

integration-tests/src/lib.rs

@@ -47,6 +47,18 @@ lazy_static! {
         Err(VarError::NotPresent) => GETH0_URL_DEFAULT.to_string(),
         Err(e) => panic!("Error in GETH0_URL env var: {:?}", e),
     };
+    /// ..
+    pub static ref START_BLOCK: usize =  match env::var("START_BLOCK") {
+        Ok(val) => str::parse::<usize>(&val).unwrap(),
+        Err(VarError::NotPresent) => 1,
+        Err(e) => panic!("Error in START_BLOCK env var: {:?}", e),
+    };
+    /// ..
+    pub static ref END_BLOCK: usize =  match env::var("END_BLOCK") {
+        Ok(val) => str::parse::<usize>(&val).unwrap(),
+        Err(VarError::NotPresent) => 8,
+        Err(e) => panic!("Error in END_BLOCK env var: {:?}", e),
+    };
 }
 
 static LOG_INIT: Once = Once::new();

integration-tests/tests/circuits.rs

@@ -1,29 +1,60 @@
 #![cfg(feature = "circuits")]
 
-use bus_mapping::circuit_input_builder::BuilderClient;
+use bus_mapping::circuit_input_builder::{BuilderClient, ExecState};
+use bus_mapping::evm::OpcodeId;
 use bus_mapping::operation::OperationContainer;
 use halo2_proofs::dev::MockProver;
-use integration_tests::{get_client, log_init, GenDataOutput};
+use integration_tests::{get_client, log_init, GenDataOutput, END_BLOCK, START_BLOCK};
 use lazy_static::lazy_static;
 use log::trace;
 use zkevm_circuits::evm_circuit::witness::RwMap;
 use zkevm_circuits::evm_circuit::{
-    test::run_test_circuit_complete_fixed_table, witness::block_convert,
+    test::run_test_circuit_complete_fixed_table, test::run_test_circuit_incomplete_fixed_table,
+    witness::block_convert,
 };
 use zkevm_circuits::state_circuit::StateCircuit;
 
 lazy_static! {
     pub static ref GEN_DATA: GenDataOutput = GenDataOutput::load();
 }
 
+#[tokio::test]
+async fn test_evm_circuit_all_block() {
+    log_init();
+    let start: usize = *START_BLOCK;
+    let end: usize = *END_BLOCK;
+    for blk in start..=end {
+        test_evm_circuit_block(blk as u64).await;
+    }
+}
+
 async fn test_evm_circuit_block(block_num: u64) {
     log::info!("test evm circuit, block number: {}", block_num);
     let cli = get_client();
     let cli = BuilderClient::new(cli).await.unwrap();
     let builder = cli.gen_inputs(block_num).await.unwrap();
 
+    if builder.block.txs.is_empty() {
+        log::info!("skip empty block");
+        return;
+    }
+
     let block = block_convert(&builder.block, &builder.code_db);
-    run_test_circuit_complete_fixed_table(block).expect("evm_circuit verification failed");
+    let need_bitwise_lookup = builder.block.txs.iter().any(|tx| {
+        tx.steps().iter().any(|step| {
+            matches!(
+                step.exec_state,
+                ExecState::Op(OpcodeId::ADD)
+                    | ExecState::Op(OpcodeId::OR)
+                    | ExecState::Op(OpcodeId::XOR)
+            )
+        })
+    });
+    if need_bitwise_lookup {
+        run_test_circuit_complete_fixed_table(block).expect("evm_circuit verification failed");
+    } else {
+        run_test_circuit_incomplete_fixed_table(block).expect("evm_circuit verification failed");
+    }
 }
 
 async fn test_state_circuit_block(block_num: u64) {