fmt

Author: ColoCarletti

prover/src/lib.rs

@@ -620,12 +620,11 @@ pub fn verify_with_options(
     vm_proof.table_counts.validate()?;
 
     let program = Elf::load(elf_bytes).map_err(|e| Error::ElfLoad(format!("{e}")))?;
-    let page_configs =
-        Traces::page_configs_from_elf_and_runtime(
-            &program,
-            &vm_proof.runtime_page_ranges,
-            &vm_proof.private_input,
-        );
+    let page_configs = Traces::page_configs_from_elf_and_runtime(
+        &program,
+        &vm_proof.runtime_page_ranges,
+        &vm_proof.private_input,
+    );
 
     // Cross-check: table_counts must match the number of sub-proofs.
     // Fixed tables (bitwise, decode, halt, commit, register) = 5, plus page tables.

prover/src/tests/prove_elfs_tests.rs

@@ -731,7 +731,8 @@ fn test_prove_elfs_test_commit_4() {
         "Public output should match committed bytes"
     );
 
-    let mut traces = Traces::from_elf_and_logs(&elf, &result.logs, &Default::default(), &[]).unwrap();
+    let mut traces =
+        Traces::from_elf_and_logs(&elf, &result.logs, &Default::default(), &[]).unwrap();
     assert_eq!(
         traces.public_output_bytes,
         result.return_values.memory_values
@@ -756,7 +757,8 @@ fn test_prove_elfs_test_commit_4_wrong_pages_rejected() {
     let executor =
         executor::vm::execution::Executor::new(&elf, vec![]).expect("Failed to create executor");
     let result = executor.run().expect("Failed to run program");
-    let mut traces = Traces::from_elf_and_logs(&elf, &result.logs, &Default::default(), &[]).unwrap();
+    let mut traces =
+        Traces::from_elf_and_logs(&elf, &result.logs, &Default::default(), &[]).unwrap();
 
     // Prover uses correct page configs
     let table_counts = traces.table_counts();
@@ -801,8 +803,9 @@ fn test_prove_elfs_test_commit_4_wrong_pages_rejected() {
 fn test_verify_rejects_tampered_public_output() {
     let elf_bytes = crate::test_utils::asm_elf_bytes("test_commit_4");
     let proof_options = ProofOptions::default_test_options();
-    let vm_proof = crate::prove_with_options(&elf_bytes, vec![], &proof_options, &Default::default())
-        .expect("Prover should succeed for test_commit_4");
+    let vm_proof =
+        crate::prove_with_options(&elf_bytes, vec![], &proof_options, &Default::default())
+            .expect("Prover should succeed for test_commit_4");
     assert!(
         crate::verify_with_options(&vm_proof, &elf_bytes, &proof_options)
             .expect("Valid commit proof should verify"),
@@ -1477,7 +1480,8 @@ fn test_deep_stack_runtime_pages_roundtrip() {
     let executor =
         executor::vm::execution::Executor::new(&elf, vec![]).expect("Failed to create executor");
     let result = executor.run().expect("Failed to run program");
-    let mut traces = Traces::from_elf_and_logs(&elf, &result.logs, &Default::default(), &[]).unwrap();
+    let mut traces =
+        Traces::from_elf_and_logs(&elf, &result.logs, &Default::default(), &[]).unwrap();
 
     let runtime_page_ranges = traces.runtime_page_ranges();
     let table_counts = traces.table_counts();
@@ -1499,7 +1503,8 @@ fn test_deep_stack_runtime_pages_roundtrip() {
     )
     .expect("Prover failed");
     // Verifier reconstructs from ELF + runtime_page_ranges hint
-    let verifier_configs = Traces::page_configs_from_elf_and_runtime(&elf, &runtime_page_ranges, &[]);
+    let verifier_configs =
+        Traces::page_configs_from_elf_and_runtime(&elf, &runtime_page_ranges, &[]);
     let verifier_airs =
         crate::VmAirs::new(&elf, &proof_options, true, &verifier_configs, &table_counts);
     let verifier_air_refs = verifier_airs.air_refs();
@@ -1536,7 +1541,8 @@ fn test_deep_stack_missing_pages_rejected() {
     let executor =
         executor::vm::execution::Executor::new(&elf, vec![]).expect("Failed to create executor");
     let result = executor.run().expect("Failed to run program");
-    let mut traces = Traces::from_elf_and_logs(&elf, &result.logs, &Default::default(), &[]).unwrap();
+    let mut traces =
+        Traces::from_elf_and_logs(&elf, &result.logs, &Default::default(), &[]).unwrap();
 
     // Prover uses correct page configs (auto-detected from MemoryState)
     let table_counts = traces.table_counts();
@@ -1614,7 +1620,8 @@ fn test_heap_alloc_runtime_pages_roundtrip() {
     let executor =
         executor::vm::execution::Executor::new(&elf, vec![]).expect("Failed to create executor");
     let result = executor.run().expect("Failed to run program");
-    let mut traces = Traces::from_elf_and_logs(&elf, &result.logs, &Default::default(), &[]).unwrap();
+    let mut traces =
+        Traces::from_elf_and_logs(&elf, &result.logs, &Default::default(), &[]).unwrap();
 
     let runtime_page_ranges = traces.runtime_page_ranges();
     let table_counts = traces.table_counts();
@@ -1640,7 +1647,8 @@ fn test_heap_alloc_runtime_pages_roundtrip() {
     )
     .expect("Prover failed");
     // Verifier reconstructs from ELF + runtime hint (ranges decoded to pages)
-    let verifier_configs = Traces::page_configs_from_elf_and_runtime(&elf, &runtime_page_ranges, &[]);
+    let verifier_configs =
+        Traces::page_configs_from_elf_and_runtime(&elf, &runtime_page_ranges, &[]);
     let verifier_airs =
         crate::VmAirs::new(&elf, &proof_options, true, &verifier_configs, &table_counts);
     let verifier_air_refs = verifier_airs.air_refs();
@@ -1696,8 +1704,9 @@ fn test_verify_rejects_zero_table_counts() {
     let elf_bytes = crate::test_utils::asm_elf_bytes("sub");
     let proof_options = ProofOptions::default_test_options();
 
-    let vm_proof = crate::prove_with_options(&elf_bytes, vec![], &proof_options, &Default::default())
-        .expect("Prover should succeed on valid program");
+    let vm_proof =
+        crate::prove_with_options(&elf_bytes, vec![], &proof_options, &Default::default())
+            .expect("Prover should succeed on valid program");
 
     assert!(
         crate::verify_with_options(&vm_proof, &elf_bytes, &proof_options)
@@ -1731,8 +1740,9 @@ fn test_verify_rejects_zero_cpu_count() {
     let elf_bytes = crate::test_utils::asm_elf_bytes("sub");
     let proof_options = ProofOptions::default_test_options();
 
-    let vm_proof = crate::prove_with_options(&elf_bytes, vec![], &proof_options, &Default::default())
-        .expect("Prover should succeed on valid program");
+    let vm_proof =
+        crate::prove_with_options(&elf_bytes, vec![], &proof_options, &Default::default())
+            .expect("Prover should succeed on valid program");
 
     let tampered_proof = crate::VmProof {
         table_counts: crate::TableCounts {
@@ -1752,8 +1762,9 @@ fn test_verify_rejects_zero_memw_count() {
     let elf_bytes = crate::test_utils::asm_elf_bytes("sub");
     let proof_options = ProofOptions::default_test_options();
 
-    let vm_proof = crate::prove_with_options(&elf_bytes, vec![], &proof_options, &Default::default())
-        .expect("Prover should succeed on valid program");
+    let vm_proof =
+        crate::prove_with_options(&elf_bytes, vec![], &proof_options, &Default::default())
+            .expect("Prover should succeed on valid program");
 
     let tampered_proof = crate::VmProof {
         table_counts: crate::TableCounts {
@@ -1879,8 +1890,9 @@ fn test_verify_rejects_inflated_table_counts() {
     let elf_bytes = crate::test_utils::asm_elf_bytes("sub");
     let proof_options = ProofOptions::default_test_options();
 
-    let vm_proof = crate::prove_with_options(&elf_bytes, vec![], &proof_options, &Default::default())
-        .expect("Prover should succeed on valid program");
+    let vm_proof =
+        crate::prove_with_options(&elf_bytes, vec![], &proof_options, &Default::default())
+            .expect("Prover should succeed on valid program");
 
     // Inflate cpu count — total won't match proof.proofs.len()
     let tampered_proof = crate::VmProof {
@@ -1937,10 +1949,14 @@ fn test_prove_private_input_xpage() {
 fn test_prove_private_input_different_values() {
     let elf_bytes = crate::test_utils::asm_elf_bytes("test_private_input_xpage");
     let input: Vec<u8> = vec![
-        0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0x00,
+        0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99,
+        0x00,
     ];
     let proof = crate::prove_with_input(&elf_bytes, input.clone()).expect("prove");
-    assert!(crate::verify(&proof, &elf_bytes).expect("verify"), "proof should verify");
+    assert!(
+        crate::verify(&proof, &elf_bytes).expect("verify"),
+        "proof should verify"
+    );
     // ASM commits 8 bytes starting at 0xFF000008 = input[4..12]
     assert_eq!(proof.public_output, input[4..12].to_vec());
 }
@@ -2049,8 +2065,9 @@ fn test_prove_ethrex_empty_block() {
         .parent()
         .unwrap()
         .to_path_buf();
-    let elf_bytes = std::fs::read(workspace_root.join("executor/program_artifacts/rust/ethrex.elf"))
-        .expect("need ethrex.elf");
+    let elf_bytes =
+        std::fs::read(workspace_root.join("executor/program_artifacts/rust/ethrex.elf"))
+            .expect("need ethrex.elf");
     let input =
         std::fs::read(workspace_root.join("executor/tests/ethrex_empty_block.bin")).unwrap();
     let proof = crate::prove_with_input(&elf_bytes, input).expect("prove");