fix: integration test

benchmarks/execute/benches/execute.rs

@@ -1,31 +1,29 @@
 use eyre::Result;
 use openvm_benchmarks_utils::{get_elf_path, get_programs_dir, read_elf_file};
-use openvm_bigint_circuit::Int256;
+use openvm_bigint_circuit::{Int256, Int256Executor, Int256Periphery};
 use openvm_bigint_transpiler::Int256TranspilerExtension;
 use openvm_circuit::{
     arch::{instructions::exe::VmExe, SystemConfig, VmExecutor},
     derive::VmConfig,
 };
-use openvm_keccak256_circuit::Keccak256;
+use openvm_keccak256_circuit::{Keccak256, Keccak256Executor, Keccak256Periphery};
 use openvm_keccak256_transpiler::Keccak256TranspilerExtension;
-use openvm_rv32im_circuit::{Rv32I, Rv32Io, Rv32M};
+use openvm_rv32im_circuit::{
+    Rv32I, Rv32IExecutor, Rv32IPeriphery, Rv32Io, Rv32IoExecutor, Rv32IoPeriphery, Rv32M,
+    Rv32MExecutor, Rv32MPeriphery,
+};
 use openvm_rv32im_transpiler::{
     Rv32ITranspilerExtension, Rv32IoTranspilerExtension, Rv32MTranspilerExtension,
 };
-use openvm_sha256_circuit::Sha256;
+use openvm_sha256_circuit::{Sha256, Sha256Executor, Sha256Periphery};
 use openvm_sha256_transpiler::Sha256TranspilerExtension;
-use openvm_stark_sdk::p3_baby_bear::BabyBear;
+use openvm_stark_sdk::{
+    openvm_stark_backend::{self, p3_field::PrimeField32},
+    p3_baby_bear::BabyBear,
+};
 use openvm_transpiler::{transpiler::Transpiler, FromElf};
 use serde::{Deserialize, Serialize};
 
-use openvm_bigint_circuit::{Int256Executor, Int256Periphery};
-use openvm_keccak256_circuit::{Keccak256Executor, Keccak256Periphery};
-use openvm_rv32im_circuit::{
-    Rv32IExecutor, Rv32IPeriphery, Rv32IoExecutor, Rv32IoPeriphery, Rv32MExecutor, Rv32MPeriphery,
-};
-use openvm_sha256_circuit::{Sha256Executor, Sha256Periphery};
-use openvm_stark_sdk::openvm_stark_backend::{self, p3_field::PrimeField32};
-
 static AVAILABLE_PROGRAMS: &[&str] = &[
     "fibonacci_recursive",
     "fibonacci_iterative",

crates/circuits/mod-builder/src/core_chip.rs

@@ -289,6 +289,9 @@ where
     // We will be setting is_valid = 0. That forces all flags be 0 (otherwise setup will be -1).
     // We generate a dummy row with all flags set to 0, then we set is_valid = 0.
     fn fill_dummy_trace_row(&self, _mem_helper: &MemoryAuxColsFactory<F>, row: &mut [F]) {
+        if !self.should_finalize {
+            return;
+        }
         let inputs: Vec<BigUint> = vec![BigUint::zero(); self.num_inputs()];
         let flags: Vec<bool> = vec![false; self.num_flags()];
         let core_row = &mut row[A::WIDTH..];

crates/sdk/src/prover/vm/local.rs

@@ -99,7 +99,7 @@ where
                 exe.clone(),
                 input.clone(),
                 |seg_idx, mut seg| {
-                    final_memory = mem::take(&mut seg.control.final_memory);
+                    final_memory = mem::take(&mut seg.ctrl.final_memory);
                     let proof_input = info_span!("trace_gen", segment = seg_idx)
                         .in_scope(|| seg.generate_proof_input(Some(committed_program.clone())))?;
                     info_span!("prove_segment", segment = seg_idx)

extensions/ecc/circuit/src/weierstrass_chip/double.rs

@@ -101,7 +101,7 @@ impl<F: PrimeField32, const BLOCKS: usize, const BLOCK_SIZE: usize>
             vec![],
             range_checker,
             "EcDouble",
-            false,
+            true,
         );
         Self(WeierstrassChip::new(air, step, height, mem_helper))
     }

extensions/ecc/circuit/src/weierstrass_extension.rs

@@ -184,7 +184,7 @@ impl<F: PrimeField32> VmExtension<F> for WeierstrassExtension {
                 );
 
                 inventory.add_executor(
-                    WeierstrassExtensionExecutor::EcAddNeRv32_32(add_ne_chip),
+                    WeierstrassExtensionExecutor::EcAddNeRv32_48(add_ne_chip),
                     ec_add_ne_opcodes
                         .clone()
                         .map(|x| VmOpcode::from_usize(x + start_offset)),
@@ -202,7 +202,7 @@ impl<F: PrimeField32> VmExtension<F> for WeierstrassExtension {
                     MAX_INS_CAPACITY,
                 );
                 inventory.add_executor(
-                    WeierstrassExtensionExecutor::EcDoubleRv32_32(double_chip),
+                    WeierstrassExtensionExecutor::EcDoubleRv32_48(double_chip),
                     ec_double_opcodes
                         .clone()
                         .map(|x| VmOpcode::from_usize(x + start_offset)),
@@ -237,11 +237,14 @@ pub(crate) mod phantom {
     use num_traits::{FromPrimitive, One};
     use openvm_circuit::{
         arch::{PhantomSubExecutor, Streams},
-        system::memory::{online::GuestMemory, MemoryController},
+        system::memory::online::GuestMemory,
     };
     use openvm_ecc_guest::weierstrass::DecompressionHint;
-    use openvm_instructions::{riscv::RV32_MEMORY_AS, PhantomDiscriminant};
-    use openvm_rv32im_circuit::adapters::unsafe_read_rv32_register;
+    use openvm_instructions::{
+        riscv::{RV32_MEMORY_AS, RV32_REGISTER_AS},
+        PhantomDiscriminant,
+    };
+    use openvm_rv32im_circuit::adapters::new_read_rv32_register;
     use openvm_stark_backend::p3_field::PrimeField32;
     use rand::{rngs::StdRng, SeedableRng};
 
@@ -268,36 +271,30 @@ pub(crate) mod phantom {
             b: u32,
             c_upper: u16,
         ) -> eyre::Result<()> {
-            /*let c_idx = c_upper as usize;
+            let c_idx = c_upper as usize;
             if c_idx >= self.supported_curves.len() {
                 bail!(
                     "Curve index {c_idx} out of range: {} supported curves",
                     self.supported_curves.len()
                 );
             }
             let curve = &self.supported_curves[c_idx];
-            let rs1 = unsafe_read_rv32_register(memory, a);
+            let rs1 = new_read_rv32_register(memory, RV32_REGISTER_AS, a);
             let num_limbs: usize = if curve.modulus.bits().div_ceil(8) <= 32 {
                 32
             } else if curve.modulus.bits().div_ceil(8) <= 48 {
                 48
             } else {
                 bail!("Modulus too large")
             };
-            let mut x_limbs: Vec<u8> = Vec::with_capacity(num_limbs);
-            for i in 0..num_limbs {
-                let limb = memory.unsafe_read_cell::<u8>(
-                    F::from_canonical_u32(RV32_MEMORY_AS),
-                    F::from_canonical_u32(rs1 + i as u32),
-                );
-                x_limbs.push(limb);
-            }
+            let x_limbs: Vec<u8> = memory
+                .memory
+                .read_range_generic((RV32_MEMORY_AS, rs1), num_limbs);
             let x = BigUint::from_bytes_le(&x_limbs);
-            let rs2 = unsafe_read_rv32_register(memory, b);
-            let rec_id = memory.unsafe_read_cell::<u8>(
-                F::from_canonical_u32(RV32_MEMORY_AS),
-                F::from_canonical_u32(rs2),
-            );
+            let rs2 = new_read_rv32_register(memory, RV32_REGISTER_AS, b);
+            let rec_id = memory
+                .memory
+                .read_range_generic::<u8>((RV32_MEMORY_AS, rs2), 1)[0];
             let hint = self.decompress_point(x, rec_id & 1 == 1, c_idx);
             let hint_bytes = once(F::from_bool(hint.possible))
                 .chain(repeat(F::ZERO))
@@ -312,7 +309,7 @@ pub(crate) mod phantom {
                 )
                 .collect();
             streams.hint_stream = hint_bytes;
-            */
+
             Ok(())
         }
     }

extensions/keccak256/circuit/src/lib.rs

@@ -3,7 +3,6 @@
 
 use openvm_circuit_primitives::bitwise_op_lookup::SharedBitwiseOperationLookupChip;
 use openvm_stark_backend::p3_field::PrimeField32;
-
 use p3_keccak_air::NUM_ROUNDS;
 use tiny_keccak::{Hasher, Keccak};
 

extensions/native/circuit/src/adapters/alu_native_adapter.rs

@@ -24,13 +24,12 @@ use openvm_stark_backend::{
     p3_field::{Field, FieldAlgebra, PrimeField32},
 };
 
+use super::tracing_write_native;
 use crate::adapters::{
     memory_read_or_imm_native_from_state, memory_write_native_from_state,
     tracing_read_or_imm_native,
 };
 
-use super::tracing_write_native;
-
 #[repr(C)]
 #[derive(AlignedBorrow)]
 pub struct AluNativeAdapterCols<T> {

extensions/native/circuit/src/adapters/branch_native_adapter.rs

@@ -1,12 +1,13 @@
-use std::borrow::{Borrow, BorrowMut};
-use std::mem::size_of;
+use std::{
+    borrow::{Borrow, BorrowMut},
+    mem::size_of,
+};
 
-use openvm_circuit::arch::execution_mode::E1E2ExecutionCtx;
-use openvm_circuit::arch::VmStateMut;
 use openvm_circuit::{
     arch::{
-        AdapterAirContext, AdapterExecutorE1, AdapterTraceStep, BasicAdapterInterface,
-        ExecutionBridge, ExecutionState, ImmInstruction, VmAdapterAir,
+        execution_mode::E1E2ExecutionCtx, AdapterAirContext, AdapterExecutorE1, AdapterTraceStep,
+        BasicAdapterInterface, ExecutionBridge, ExecutionState, ImmInstruction, VmAdapterAir,
+        VmStateMut,
     },
     system::memory::{
         offline_checker::{MemoryBridge, MemoryReadOrImmediateAuxCols},

extensions/native/circuit/src/field_extension/tests.rs

@@ -19,12 +19,11 @@ use openvm_stark_sdk::{p3_baby_bear::BabyBear, utils::create_seeded_rng};
 use rand::Rng;
 use strum::EnumCount;
 
+use super::{FieldExtension, FieldExtensionChip, FieldExtensionCoreAir, FieldExtensionCoreStep};
 use crate::adapters::native_vectorized_adapter::{
     NativeVectorizedAdapterAir, NativeVectorizedAdapterStep,
 };
 
-use super::{FieldExtension, FieldExtensionChip, FieldExtensionCoreAir, FieldExtensionCoreStep};
-
 const MAX_INS_CAPACITY: usize = 128;
 type F = BabyBear;
 

extensions/native/circuit/src/fri/tests.rs

@@ -15,12 +15,11 @@ use openvm_stark_backend::{
 use openvm_stark_sdk::{p3_baby_bear::BabyBear, utils::create_seeded_rng};
 use rand::Rng;
 
-use crate::fri::OVERALL_WIDTH;
-
 use super::{
     super::field_extension::FieldExtension, elem_to_ext, FriReducedOpeningAir,
     FriReducedOpeningChip, FriReducedOpeningStep, EXT_DEG,
 };
+use crate::fri::OVERALL_WIDTH;
 
 const MAX_INS_CAPACITY: usize = 1024;
 type F = BabyBear;
@@ -99,9 +98,9 @@ fn fri_mat_opening_air_test() {
         let address_space = 4usize;
 
         // tracing::debug!(
-        //     "{opcode:?} d = {}, e = {}, f = {}, result_addr = {}, addr1 = {}, addr2 = {}, z = {}, x = {}, y = {}",
-        //     result_as, as1, as2, result_pointer, address1, address2, result, operand1, operand2,
-        // );
+        //     "{opcode:?} d = {}, e = {}, f = {}, result_addr = {}, addr1 = {}, addr2 = {}, z = {},
+        // x = {}, y = {}",     result_as, as1, as2, result_pointer, address1, address2,
+        // result, operand1, operand2, );
 
         tester.write(address_space, alpha_pointer, alpha);
         tester.write(

extensions/native/circuit/src/jal/tests.rs

@@ -16,9 +16,8 @@ use openvm_stark_backend::{
 use openvm_stark_sdk::{p3_baby_bear::BabyBear, utils::create_seeded_rng};
 use rand::{rngs::StdRng, Rng};
 
-use crate::jal::{JalRangeCheckChip, JalRangeCheckCols};
-
 use super::{JalRangeCheckAir, JalRangeCheckStep};
+use crate::jal::{JalRangeCheckChip, JalRangeCheckCols};
 
 const MAX_INS_CAPACITY: usize = 128;
 type F = BabyBear;

extensions/native/circuit/src/loadstore/tests.rs

@@ -7,12 +7,11 @@ use openvm_stark_backend::p3_field::{FieldAlgebra, PrimeField32};
 use openvm_stark_sdk::{config::setup_tracing, p3_baby_bear::BabyBear, utils::create_seeded_rng};
 use rand::{rngs::StdRng, Rng};
 
+use super::{NativeLoadStoreChip, NativeLoadStoreCoreAir, NativeLoadStoreCoreStep};
 use crate::adapters::loadstore_native_adapter::{
     NativeLoadStoreAdapterAir, NativeLoadStoreAdapterStep,
 };
 
-use super::{NativeLoadStoreChip, NativeLoadStoreCoreAir, NativeLoadStoreCoreStep};
-
 const MAX_INS_CAPACITY: usize = 128;
 type F = BabyBear;
 

extensions/pairing/circuit/src/pairing_extension.rs

@@ -94,7 +94,7 @@ pub(crate) mod phantom {
     use eyre::bail;
     use openvm_circuit::{
         arch::{PhantomSubExecutor, Streams},
-        system::memory::MemoryController,
+        system::memory::online::GuestMemory,
     };
     use openvm_ecc_guest::{algebra::field::FieldExtension, halo2curves::ff, AffinePoint};
     use openvm_instructions::{
@@ -106,7 +106,7 @@ pub(crate) mod phantom {
         bn254::BN254_NUM_LIMBS,
         pairing::{FinalExp, MultiMillerLoop},
     };
-    use openvm_rv32im_circuit::adapters::unsafe_read_rv32_register;
+    use openvm_rv32im_circuit::adapters::{memory_read, new_read_rv32_register};
     use openvm_stark_backend::p3_field::PrimeField32;
 
     use super::PairingCurve;
@@ -116,43 +116,40 @@ pub(crate) mod phantom {
     impl<F: PrimeField32> PhantomSubExecutor<F> for PairingHintSubEx {
         fn phantom_execute(
             &mut self,
-            memory: &MemoryController<F>,
+            memory: &GuestMemory,
             streams: &mut Streams<F>,
             _: PhantomDiscriminant,
-            a: F,
-            b: F,
+            a: u32,
+            b: u32,
             c_upper: u16,
         ) -> eyre::Result<()> {
-            let rs1 = unsafe_read_rv32_register(memory, a);
-            let rs2 = unsafe_read_rv32_register(memory, b);
+            let rs1 = new_read_rv32_register(memory, 1, a);
+            let rs2 = new_read_rv32_register(memory, 1, b);
             hint_pairing(memory, &mut streams.hint_stream, rs1, rs2, c_upper)
         }
     }
 
     fn hint_pairing<F: PrimeField32>(
-        memory: &MemoryController<F>,
+        memory: &GuestMemory,
         hint_stream: &mut VecDeque<F>,
         rs1: u32,
         rs2: u32,
         c_upper: u16,
     ) -> eyre::Result<()> {
-        let p_ptr = u32::from_le_bytes(memory.unsafe_read::<u8, 4>(
-            F::from_canonical_u32(RV32_MEMORY_AS),
-            F::from_canonical_u32(rs1),
-        ));
+        let p_ptr = u32::from_le_bytes(memory_read(memory, RV32_MEMORY_AS, rs1));
         // len in bytes
-        let p_len = u32::from_le_bytes(memory.unsafe_read::<u8, 4>(
-            F::from_canonical_u32(RV32_MEMORY_AS),
-            F::from_canonical_u32(rs1 + RV32_REGISTER_NUM_LIMBS as u32),
-        ));
-        let q_ptr = u32::from_le_bytes(memory.unsafe_read::<u8, 4>(
-            F::from_canonical_u32(RV32_MEMORY_AS),
-            F::from_canonical_u32(rs2),
+        let p_len = u32::from_le_bytes(memory_read(
+            memory,
+            RV32_MEMORY_AS,
+            rs1 + RV32_REGISTER_NUM_LIMBS as u32,
         ));
+
+        let q_ptr = u32::from_le_bytes(memory_read(memory, RV32_MEMORY_AS, rs2));
         // len in bytes
-        let q_len = u32::from_le_bytes(memory.unsafe_read::<u8, 4>(
-            F::from_canonical_u32(RV32_MEMORY_AS),
-            F::from_canonical_u32(rs2 + RV32_REGISTER_NUM_LIMBS as u32),
+        let q_len = u32::from_le_bytes(memory_read(
+            memory,
+            RV32_MEMORY_AS,
+            rs2 + RV32_REGISTER_NUM_LIMBS as u32,
         ));
 
         match PairingCurve::from_repr(c_upper as usize) {
@@ -248,19 +245,17 @@ pub(crate) mod phantom {
     }
 
     fn read_fp<const N: usize, F: PrimeField32, Fp: ff::PrimeField>(
-        memory: &MemoryController<F>,
+        memory: &GuestMemory,
         ptr: u32,
     ) -> eyre::Result<Fp>
     where
         Fp::Repr: From<[u8; N]>,
     {
-        let mut repr = [0u8; N];
-        for (i, byte) in repr.iter_mut().enumerate() {
-            *byte = memory.unsafe_read_cell::<u8>(
-                F::from_canonical_u32(RV32_MEMORY_AS),
-                F::from_canonical_u32(ptr + i as u32),
-            );
-        }
+        let repr: [u8; N] = memory
+            .memory
+            .read_range_generic((RV32_MEMORY_AS, ptr), N)
+            .try_into()
+            .unwrap();
         Fp::from_repr(repr.into())
             .into_option()
             .ok_or(eyre::eyre!("bad ff::PrimeField repr"))

extensions/rv32im/circuit/src/loadstore/tests.rs

@@ -39,7 +39,6 @@ type F = BabyBear;
 
 fn create_test_chip(tester: &mut VmChipTestBuilder<F>) -> Rv32LoadStoreChip<F> {
     let range_checker_chip = tester.range_checker();
-
 
     Rv32LoadStoreChip::<F>::new(
         VmAirWrapper::new(