feat: add empty Ethereum block proving pipeline

- Add `prove_with_input()` and `private_input` param to `prove_with_options()`
  so guest programs can receive input through the prover API
- Add `Exit = 3` syscall (Rust std runtime exit path)
- Fix commit output being overwritten by std cleanup (store in dedicated field)
- Make commit syscall no-op for fd != 1 (stderr writes from std)
- Add `tools/generate_input/` fixture generator for empty block ProgramInput
- Add `tools/run_ethrex/` to measure execution (11M instructions, 148ms)
- Add `test_ethrex_empty_block` executor test (passes)
- Add `test_prove_ethrex_empty_block` prover test (ignored, needs ~64GB RAM)
- Add empty block fixture `executor/tests/ethrex_empty_block.bin` (1876 bytes)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ColoCarletti

bin/cli/src/main.rs

@@ -276,7 +276,7 @@ fn cmd_prove(elf_path: PathBuf, output_path: PathBuf, blowup: Option<u8>, time:
                 "Generating proof (blowup={b}, queries={})...",
                 opts.fri_number_of_queries
             );
-            prover::prove_with_options(&elf_data, &opts, &Default::default())
+            prover::prove_with_options(&elf_data, vec![], &opts, &Default::default())
         }
         None => {
             eprintln!("Generating proof...");

executor/src/vm/instruction/execution.rs

@@ -10,6 +10,7 @@ const REGULAR_PC_UPDATE: u64 = 4;
 pub enum SyscallNumbers {
     Print = 1,
     Panic = 2,
+    Exit = 3,
     GetPrivateInputs = 4,
     Commit = 64,
     Halt = 93,
@@ -21,6 +22,7 @@ impl TryFrom<u64> for SyscallNumbers {
         match value {
             1 => Ok(SyscallNumbers::Print),
             2 => Ok(SyscallNumbers::Panic),
+            3 => Ok(SyscallNumbers::Exit),
             4 => Ok(SyscallNumbers::GetPrivateInputs),
             64 => Ok(SyscallNumbers::Commit),
             93 => Ok(SyscallNumbers::Halt),
@@ -309,12 +311,11 @@ impl Instruction {
                         // x11 = buf_addr (buffer address in memory)
                         // x12 = count (number of bytes to write)
                         let fd = registers.read(10)?;
-                        if fd != 1 {
-                            return Err(ExecutionError::InvalidCommitFd(fd));
-                        }
                         let buf_addr = registers.read(11)?;
                         let count = registers.read(12)?;
-                        memory.commit_public_output(buf_addr, count)?;
+                        if fd == 1 {
+                            memory.commit_public_output(buf_addr, count)?;
+                        }
                         src2_val = buf_addr;
                         dst_val = count;
                     }
@@ -326,8 +327,8 @@ impl Instruction {
                             memory.store_byte(pointer + i as u64, *byte);
                         }
                     }
-                    SyscallNumbers::Halt => {
-                        // halt
+                    SyscallNumbers::Exit | SyscallNumbers::Halt => {
+                        // halt / exit
                         return Ok(Log {
                             current_pc: pc,
                             next_pc: 0,                   // We halt by setting pc to 0

executor/src/vm/memory.rs

@@ -47,19 +47,23 @@ const MAX_PRIVATE_INPUT_SIZE: u64 = 6700000;
 const PRIVATE_INPUT_START_INDEX: u64 = 0xFF000000;
 
 #[derive(Default, Debug)]
-pub struct Memory(U64HashMap<[u8; 4]>);
+pub struct Memory {
+    data: U64HashMap<[u8; 4]>,
+    /// Committed public output bytes, stored separately so std cleanup can't overwrite them.
+    committed_output: Vec<u8>,
+}
 
 impl Memory {
     pub fn load_byte(&self, address: u64) -> u8 {
         let aligned_address = address - address % 4;
-        let value = self.0.get(&aligned_address).cloned().unwrap_or_default();
+        let value = self.data.get(&aligned_address).cloned().unwrap_or_default();
         value[(address % 4) as usize]
     }
 
     pub fn store_byte(&mut self, address: u64, value: u8) {
         let aligned_address = address - address % 4;
         let entry = self
-            .0
+            .data
             .entry(aligned_address)
             .or_insert_with(|| [0, 0, 0, 0]);
         entry[(address % 4) as usize] = value;
@@ -69,7 +73,7 @@ impl Memory {
         if !address.is_multiple_of(4) {
             return Err(MemoryError::UnalignedAccess);
         }
-        let bytes = self.0.get(&address).cloned().unwrap_or_default();
+        let bytes = self.data.get(&address).cloned().unwrap_or_default();
         Ok(u32::from_le_bytes(bytes))
     }
 
@@ -78,7 +82,7 @@ impl Memory {
             return Err(MemoryError::UnalignedAccess);
         }
         let bytes = value.to_le_bytes();
-        self.0.insert(address, bytes);
+        self.data.insert(address, bytes);
         Ok(())
     }
 
@@ -87,8 +91,8 @@ impl Memory {
         if !address.is_multiple_of(8) {
             return Err(MemoryError::UnalignedAccess);
         }
-        let low_bytes = self.0.get(&address).cloned().unwrap_or_default();
-        let high_bytes = self.0.get(&(address + 4)).cloned().unwrap_or_default();
+        let low_bytes = self.data.get(&address).cloned().unwrap_or_default();
+        let high_bytes = self.data.get(&(address + 4)).cloned().unwrap_or_default();
         let low = u32::from_le_bytes(low_bytes) as u64;
         let high = u32::from_le_bytes(high_bytes) as u64;
         Ok(low | (high << 32))
@@ -101,8 +105,8 @@ impl Memory {
         }
         let low = (value & 0xFFFFFFFF) as u32;
         let high = (value >> 32) as u32;
-        self.0.insert(address, low.to_le_bytes());
-        self.0.insert(address + 4, high.to_le_bytes());
+        self.data.insert(address, low.to_le_bytes());
+        self.data.insert(address + 4, high.to_le_bytes());
         Ok(())
     }
 
@@ -114,7 +118,7 @@ impl Memory {
             );
         }
         let aligned_address = address - address % 4;
-        let bytes = self.0.get(&aligned_address).cloned().unwrap_or_default();
+        let bytes = self.data.get(&aligned_address).cloned().unwrap_or_default();
         let value = &bytes[(address % 4) as usize..(address % 4) as usize + 2];
         Ok(u16::from_le_bytes(
             value.try_into().map_err(|_| MemoryError::LoadHalf)?,
@@ -127,7 +131,7 @@ impl Memory {
         }
         let aligned_address = address - address % 4;
         let entry = self
-            .0
+            .data
             .entry(aligned_address)
             .or_insert_with(|| [0, 0, 0, 0]);
         let bytes = value.to_le_bytes();
@@ -140,15 +144,17 @@ impl Memory {
         if length > MAX_PUBLIC_OUTPUT_COMMIT_SIZE {
             return Err(MemoryError::CommitSizeExceeded);
         }
+        // Store in the regular memory address space (for prover trace compatibility)
         self.store_word(PUBLIC_OUTPUT_START_INDEX, length as u32)?;
         let inputs = self.load_bytes(address, length);
         self.set_bytes_aligned(PUBLIC_OUTPUT_START_INDEX + 4, &inputs)?;
+        // Also store in the dedicated field so std runtime cleanup can't overwrite it
+        self.committed_output = inputs;
         Ok(())
     }
 
     pub fn read_return_value(&self) -> Result<Vec<u8>, MemoryError> {
-        let size = self.load_word(PUBLIC_OUTPUT_START_INDEX)?;
-        Ok(self.load_bytes(PUBLIC_OUTPUT_START_INDEX + 4, size as u64))
+        Ok(self.committed_output.clone())
     }
 
     pub fn store_private_inputs(&mut self, inputs: Vec<u8>) -> Result<(), MemoryError> {
@@ -172,7 +178,7 @@ impl Memory {
         let end = addr + len;
         while addr < end {
             let aligned = addr - (addr % 4);
-            let bytes = self.0.get(&aligned).cloned().unwrap_or_default();
+            let bytes = self.data.get(&aligned).cloned().unwrap_or_default();
             let offset = (addr % 4) as usize;
             let take = std::cmp::min(4 - offset, (end - addr) as usize);
             result.extend_from_slice(&bytes[offset..offset + take]);
@@ -190,7 +196,7 @@ impl Memory {
         for chunk in inputs.chunks(4) {
             let mut bytes = [0u8; 4];
             bytes[..chunk.len()].copy_from_slice(chunk);
-            self.0.insert(addr, bytes);
+            self.data.insert(addr, bytes);
             addr += 4;
         }
         Ok(())

executor/tests/ethrex_empty_block.bin

@@ -278,6 +278,22 @@ fn test_ethrex() {
     );
 }
 
+#[ignore = "Ignored until the vm is fast enough to run this test"]
+#[test]
+fn test_ethrex_empty_block() {
+    use guest_program::{execution::execution_program, input::ProgramInput};
+    use rkyv::rancor::Error;
+    use std::fs;
+    let inputs = fs::read("tests/ethrex_empty_block.bin").unwrap();
+    let input = rkyv::from_bytes::<ProgramInput, Error>(&inputs).unwrap();
+    let output = execution_program(input).unwrap();
+    run_program_and_check_public_output(
+        "./program_artifacts/rust/ethrex.elf",
+        output.encode(),
+        inputs,
+    );
+}
+
 #[ignore = "Ignored until the vm is fast enough to run this test"]
 #[test]
 fn test_ckzg() {

executor/tests/rust.rs

@@ -463,6 +463,17 @@ pub(crate) fn compute_expected_commit_bus_balance(
 pub fn prove(elf_bytes: &[u8]) -> Result<VmProof, Error> {
     prove_with_options(
         elf_bytes,
+        vec![],
+        &GoldilocksCubicProofOptions::with_blowup(2).expect("blowup=2 is always valid"),
+        &MaxRowsConfig::default(),
+    )
+}
+
+/// Prove an ELF binary execution with private input.
+pub fn prove_with_input(elf_bytes: &[u8], private_input: Vec<u8>) -> Result<VmProof, Error> {
+    prove_with_options(
+        elf_bytes,
+        private_input,
         &GoldilocksCubicProofOptions::with_blowup(2).expect("blowup=2 is always valid"),
         &MaxRowsConfig::default(),
     )
@@ -471,6 +482,7 @@ pub fn prove(elf_bytes: &[u8]) -> Result<VmProof, Error> {
 /// Prove an ELF binary execution with custom proof options and max rows config.
 pub fn prove_with_options(
     elf_bytes: &[u8],
+    private_input: Vec<u8>,
     proof_options: &ProofOptions,
     max_rows: &MaxRowsConfig,
 ) -> Result<VmProof, Error> {
@@ -482,7 +494,8 @@ pub fn prove_with_options(
     let phase_start = std::time::Instant::now();
 
     let program = Elf::load(elf_bytes).map_err(|e| Error::ElfLoad(format!("{e}")))?;
-    let executor = Executor::new(&program, vec![]).map_err(|e| Error::Execution(format!("{e}")))?;
+    let executor =
+        Executor::new(&program, private_input).map_err(|e| Error::Execution(format!("{e}")))?;
     let result = executor
         .run()
         .map_err(|e| Error::Execution(format!("{e}")))?;

prover/src/lib.rs

@@ -801,7 +801,7 @@ 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, &proof_options, &Default::default())
+    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)
@@ -1669,7 +1669,7 @@ 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, &proof_options, &Default::default())
+    let vm_proof = crate::prove_with_options(&elf_bytes, vec![], &proof_options, &Default::default())
         .expect("Prover should succeed on valid program");
 
     assert!(
@@ -1703,7 +1703,7 @@ 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, &proof_options, &Default::default())
+    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 {
@@ -1724,7 +1724,7 @@ 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, &proof_options, &Default::default())
+    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 {
@@ -1799,7 +1799,7 @@ fn test_small_max_rows_splits_tables() {
     let proof_options = ProofOptions::default_test_options();
     let max_rows = crate::tables::MaxRowsConfig::small();
 
-    let vm_proof = crate::prove_with_options(&elf_bytes, &proof_options, &max_rows)
+    let vm_proof = crate::prove_with_options(&elf_bytes, vec![], &proof_options, &max_rows)
         .expect("Prover should succeed with small max_rows");
 
     // With 2^5 max rows and 64+ instructions, tables should have multiple chunks.
@@ -1850,7 +1850,7 @@ 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, &proof_options, &Default::default())
+    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()
@@ -1870,6 +1870,24 @@ fn test_verify_rejects_inflated_table_counts() {
     );
 }
 
+/// Prove and verify an empty Ethereum block via the ethrex guest program.
+/// Requires ~64GB RAM (11M instructions generate large multi-table traces).
+#[test]
+#[ignore = "Requires ~64GB RAM: proves an empty Ethereum block (11M instructions)"]
+fn test_prove_ethrex_empty_block() {
+    let _ = env_logger::builder().is_test(true).try_init();
+    let elf_bytes = std::fs::read("../executor/program_artifacts/rust/ethrex.elf")
+        .expect("Failed to read ethrex ELF");
+    let input = std::fs::read("../executor/tests/ethrex_empty_block.bin")
+        .expect("Failed to read empty block fixture");
+    let vm_proof = crate::prove_with_input(&elf_bytes, input).expect("Proving failed");
+    assert!(
+        crate::verify(&vm_proof, &elf_bytes).expect("Verification failed"),
+        "Empty block proof should verify"
+    );
+    assert_eq!(vm_proof.public_output.len(), 160, "L1 output should be 160 bytes (5 * 32)");
+}
+
 /// Regression test: addiw with negative immediate must verify.
 /// arg2_sign_bit is the sign bit of rv2 (bit 31), not of arg2, per spec
 /// constraint CPU-CE61: MSB16[arg2_sign_bit; rv2[1]].

prover/src/tests/prove_elfs_tests.rs

@@ -0,0 +1,14 @@
+[workspace]
+
+[package]
+name = "generate-input"
+version = "0.1.0"
+edition = "2024"
+
+[dependencies]
+ethrex-blockchain = { git = "https://github.com/lambdaclass/ethrex.git", branch = "crypto-default-features" }
+ethrex-storage = { git = "https://github.com/lambdaclass/ethrex.git", branch = "crypto-default-features" }
+ethrex-common = { git = "https://github.com/lambdaclass/ethrex.git", branch = "crypto-default-features" }
+guest-program = { git = "https://github.com/lambdaclass/ethrex.git", package = "guest_program", default-features = false, branch = "crypto-default-features" }
+rkyv = { version = "0.8.10", features = ["std", "unaligned"] }
+tokio = { version = "1", features = ["full"] }