feat: seperate vm_read and vm_write into good and bad versions

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: 876pol

crates/vm/src/arch/execution_mode/metered/ctx.rs

@@ -235,6 +235,27 @@ impl<const PAGE_BITS: usize> ExecutionCtxTrait for MeteredCtx<PAGE_BITS> {
         }
     }
 
+    #[inline(always)]
+    fn on_memory_operation_no_adapter(&mut self, address_space: u32, ptr: u32, size: u32) {
+        debug_assert!(
+            address_space != RV32_IMM_AS,
+            "address space must not be immediate"
+        );
+        debug_assert!(size > 0, "size must be greater than 0, got {size}");
+        debug_assert!(
+            size.is_power_of_two(),
+            "size must be a power of 2, got {size}"
+        );
+
+        // No access adapter updates for non-Native extensions
+
+        // Handle merkle tree updates
+        if address_space != RV32_REGISTER_AS {
+            self.memory_ctx
+                .update_boundary_merkle_heights(address_space, ptr, size);
+        }
+    }
+
     #[inline(always)]
     fn should_suspend<F>(exec_state: &mut VmExecState<F, GuestMemory, Self>) -> bool {
         // ATTENTION: Please make sure to update the corresponding logic in the

crates/vm/src/arch/execution_mode/metered_cost.rs

@@ -122,6 +122,24 @@ impl ExecutionCtxTrait for MeteredCostCtx {
         }
     }
 
+    #[inline(always)]
+    fn on_memory_operation_no_adapter(&mut self, address_space: u32, _ptr: u32, size: u32) {
+        debug_assert!(
+            address_space != RV32_IMM_AS,
+            "address space must not be immediate"
+        );
+        debug_assert!(size > 0, "size must be greater than 0, got {size}");
+        debug_assert!(
+            size.is_power_of_two(),
+            "size must be a power of 2, got {size}"
+        );
+        // Prevent unbounded memory accesses per instruction
+        if self.cost > 2 * std::cmp::max(self.max_execution_cost, DEFAULT_MAX_COST) {
+            self.panic_cost_exceeded();
+        }
+        // No access adapter updates for non-Native extensions
+    }
+
     #[inline(always)]
     fn should_suspend<F>(exec_state: &mut VmExecState<F, GuestMemory, Self>) -> bool {
         if exec_state.ctx.cost > exec_state.ctx.max_execution_cost {

crates/vm/src/arch/execution_mode/mod.rs

@@ -13,6 +13,8 @@ pub use pure::ExecutionCtx;
 pub trait ExecutionCtxTrait: Sized {
     fn on_memory_operation(&mut self, address_space: u32, ptr: u32, size: u32);
 
+    fn on_memory_operation_no_adapter(&mut self, address_space: u32, ptr: u32, size: u32);
+
     fn should_suspend<F>(exec_state: &mut VmExecState<F, GuestMemory, Self>) -> bool;
 
     fn on_terminate<F>(_exec_state: &mut VmExecState<F, GuestMemory, Self>) {}

crates/vm/src/arch/execution_mode/pure.rs

@@ -24,6 +24,9 @@ impl ExecutionCtxTrait for ExecutionCtx {
     #[inline(always)]
     fn on_memory_operation(&mut self, _address_space: u32, _ptr: u32, _size: u32) {}
 
+    #[inline(always)]
+    fn on_memory_operation_no_adapter(&mut self, _address_space: u32, _ptr: u32, _size: u32) {}
+
     #[inline(always)]
     fn should_suspend<F>(exec_state: &mut VmExecState<F, GuestMemory, Self>) -> bool {
         // ATTENTION: Please make sure to update the corresponding logic in the

crates/vm/src/arch/state.rs

@@ -180,7 +180,6 @@ impl<F, CTX> VmExecState<F, GuestMemory, CTX>
 where
     CTX: ExecutionCtxTrait,
 {
-    /// Runtime read operation for a block of memory
     #[inline(always)]
     pub fn vm_read<T: Copy + Debug, const BLOCK_SIZE: usize>(
         &mut self,
@@ -192,7 +191,17 @@ where
         self.host_read(addr_space, ptr)
     }
 
-    /// Runtime write operation for a block of memory
+    #[inline(always)]
+    pub fn vm_read_no_adapter<T: Copy + Debug, const BLOCK_SIZE: usize>(
+        &mut self,
+        addr_space: u32,
+        ptr: u32,
+    ) -> [T; BLOCK_SIZE] {
+        self.ctx
+            .on_memory_operation_no_adapter(addr_space, ptr, BLOCK_SIZE as u32);
+        self.host_read(addr_space, ptr)
+    }
+
     #[inline(always)]
     pub fn vm_write<T: Copy + Debug, const BLOCK_SIZE: usize>(
         &mut self,
@@ -205,6 +214,18 @@ where
         self.host_write(addr_space, ptr, data)
     }
 
+    #[inline(always)]
+    pub fn vm_write_no_adapter<T: Copy + Debug, const BLOCK_SIZE: usize>(
+        &mut self,
+        addr_space: u32,
+        ptr: u32,
+        data: &[T; BLOCK_SIZE],
+    ) {
+        self.ctx
+            .on_memory_operation_no_adapter(addr_space, ptr, BLOCK_SIZE as u32);
+        self.host_write(addr_space, ptr, data)
+    }
+
     #[inline(always)]
     pub fn vm_read_slice<T: Copy + Debug>(
         &mut self,
@@ -216,6 +237,18 @@ where
         self.host_read_slice(addr_space, ptr, len)
     }
 
+    #[inline(always)]
+    pub fn vm_read_slice_no_adapter<T: Copy + Debug>(
+        &mut self,
+        addr_space: u32,
+        ptr: u32,
+        len: usize,
+    ) -> &[T] {
+        self.ctx
+            .on_memory_operation_no_adapter(addr_space, ptr, len as u32);
+        self.host_read_slice(addr_space, ptr, len)
+    }
+
     #[inline(always)]
     pub fn host_read<T: Copy + Debug, const BLOCK_SIZE: usize>(
         &self,