feat: implemented delete_unaccessed function (#2282)

* feat: implemented delete_unaccessed function (#2099)

Signed-off-by: Dori Medini <dori@starkware.co>

* Update CHANGELOG

---------

Signed-off-by: Dori Medini <dori@starkware.co>
Co-authored-by: dorimedini-starkware <dori@starkware.co>

Author: gabrielbosio

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 #### Upcoming Changes
 
+* feat: implemented delete_unaccessed function [#2282](https://github.com/lambdaclass/cairo-vm/pull/2282)
+
 * fix: rename y_cube_int to y_square_int in get_point_from_x [#2271](https://github.com/lambdaclass/cairo-vm/pull/2271)
 
 * fix: correct duplicate tuple index in InvalidTrackingGroup error message [#2276](https://github.com/lambdaclass/cairo-vm/pull/2276)

vm/src/vm/errors/memory_errors.rs

@@ -15,6 +15,10 @@ use crate::types::{
 
 #[derive(Debug, PartialEq, Error)]
 pub enum MemoryError {
+    #[error("Cell {0} has already been accessed; it cannot be removed.")]
+    UnsetAccessedCell(Relocatable),
+    #[error("Cell {0} is not allocated; it cannot be removed.")]
+    UnsetUnallocatedCell(Relocatable),
     #[error(transparent)]
     Math(#[from] MathError),
     #[error(transparent)]

vm/src/vm/vm_core.rs

@@ -1021,6 +1021,17 @@ impl VirtualMachine {
         self.segments.memory.insert_value(key, val)
     }
 
+    /// Removes (unsets) a value from a memory cell that was not accessed by the VM.
+    ///
+    /// This function can be used to implement lazy opening of merkelized contracts. The full
+    /// program is initially loaded into memory via a hint. After execution, any entry points to
+    /// contract segments that were not accessed are replaced with an invalid opcode.
+    ///
+    /// [Use case](https://github.com/starkware-libs/cairo-lang/blob/master/src/starkware/starknet/core/os/contract_class/compiled_class.cairo#L244-L253)
+    pub fn delete_unaccessed(&mut self, addr: Relocatable) -> Result<(), MemoryError> {
+        self.segments.memory.delete_unaccessed(addr)
+    }
+
     ///Writes data into the memory from address ptr and returns the first address after the data.
     pub fn load_data(
         &mut self,
@@ -4813,6 +4824,84 @@ mod tests {
         assert_eq!(vm.segments.compute_effective_sizes(), &vec![4]);
     }
 
+    #[test]
+    #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
+    fn test_delete_unaccessed() {
+        let mut vm = vm!();
+
+        let segment0 = vm.segments.add();
+        let segment1 = vm.segments.add();
+        let segment2 = vm.segments.add();
+        let segment3 = vm.segments.add();
+        let tmp_segment = vm.add_temporary_segment();
+        assert_eq!(segment0.segment_index, 0);
+        assert_eq!(segment1.segment_index, 1);
+        assert_eq!(segment2.segment_index, 2);
+        assert_eq!(segment3.segment_index, 3);
+        assert_eq!(tmp_segment.segment_index, -1);
+        vm.segments.memory = memory![
+            ((0, 1), 1),
+            ((1, 0), 3),
+            ((1, 1), 4),
+            ((2, 0), 7),
+            ((3, 0), 7),
+            ((-1, 0), 5),
+            ((-1, 1), 5),
+            ((-1, 2), 5)
+        ];
+        vm.run_finished = true;
+
+        vm.mark_address_range_as_accessed((2, 0).into(), 1).unwrap();
+
+        let cell0 = Relocatable::from((0, 0));
+        let cell1 = Relocatable::from((1, 1));
+        let cell2 = Relocatable::from((2, 0));
+        let cell3 = Relocatable::from((3, 7));
+        let cell7 = Relocatable::from((7, 17));
+        let cell_tmp = Relocatable::from((-1, 1));
+        vm.delete_unaccessed(cell0).unwrap();
+        vm.delete_unaccessed(cell1).unwrap();
+        vm.delete_unaccessed(cell_tmp).unwrap();
+
+        // Check that the cells were set to NONE.
+        assert!(vm
+            .segments
+            .memory
+            .get_cell_for_testing(cell0)
+            .unwrap()
+            .is_none());
+        assert!(vm
+            .segments
+            .memory
+            .get_cell_for_testing(cell1)
+            .unwrap()
+            .is_none());
+        assert!(vm
+            .segments
+            .memory
+            .get_cell_for_testing(cell_tmp)
+            .unwrap()
+            .is_none());
+        // Segment 3 cell was out of offset range, so it should not be modified or allocated.
+        assert!(vm.segments.memory.get_cell_for_testing(cell3).is_none());
+        // Segment 2 cell was accessed, so attempting to unset the memory should result in error.
+        assert_matches!(
+            vm.delete_unaccessed(cell2).unwrap_err(),
+            MemoryError::UnsetAccessedCell(relocatable) if relocatable == cell2
+        );
+        // Segment 3 is unallocated, so attempting to unset the memory should result in error.
+        assert_matches!(
+            vm.delete_unaccessed(cell3).unwrap_err(),
+            MemoryError::UnsetUnallocatedCell(relocatable) if relocatable == cell3
+        );
+        // Segment 7 was not allocated, so attempting to unset the memory should result in error.
+        assert_matches!(
+            vm.delete_unaccessed(cell7).unwrap_err(),
+            MemoryError::UnallocatedSegment(boxed)
+            if *boxed == (cell7.segment_index.try_into().unwrap(), vm.segments.memory.data.len())
+        );
+    }
+
     #[test]
     #[cfg_attr(target_arch = "wasm32", wasm_bindgen_test)]
     fn mark_as_accessed() {

vm/src/vm/vm_memory/memory.rs

@@ -186,6 +186,18 @@ impl Memory {
         }
     }
 
+    fn get_segment(&mut self, key: Relocatable) -> Result<&mut Vec<MemoryCell>, MemoryError> {
+        let (value_index, _) = from_relocatable_to_indexes(key);
+        let data = if key.segment_index.is_negative() {
+            &mut self.temp_data
+        } else {
+            &mut self.data
+        };
+        let data_len = data.len();
+        data.get_mut(value_index)
+            .ok_or_else(|| MemoryError::UnallocatedSegment(Box::new((value_index, data_len))))
+    }
+
     /// Inserts a value into a memory address
     /// Will return an Error if the segment index given by the address corresponds to a non-allocated segment,
     /// or if the inserted value is inconsistent with the current value at the memory cell
@@ -195,18 +207,8 @@ impl Memory {
         MaybeRelocatable: From<V>,
     {
         let val = MaybeRelocatable::from(val);
-        let (value_index, value_offset) = from_relocatable_to_indexes(key);
-
-        let data = if key.segment_index.is_negative() {
-            &mut self.temp_data
-        } else {
-            &mut self.data
-        };
-
-        let data_len = data.len();
-        let segment = data
-            .get_mut(value_index)
-            .ok_or_else(|| MemoryError::UnallocatedSegment(Box::new((value_index, data_len))))?;
+        let segment = self.get_segment(key)?;
+        let (_, value_offset) = from_relocatable_to_indexes(key);
 
         //Check if the element is inserted next to the last one on the segment
         //Forgoing this check would allow data to be inserted in a different index
@@ -238,6 +240,25 @@ impl Memory {
         self.validate_memory_cell(key)
     }
 
+    pub(crate) fn delete_unaccessed(&mut self, addr: Relocatable) -> Result<(), MemoryError> {
+        let (_, offset) = from_relocatable_to_indexes(addr);
+        let segment = self.get_segment(addr)?;
+
+        // Make sure the offset exists.
+        if offset >= segment.len() {
+            return Err(MemoryError::UnsetUnallocatedCell(addr));
+        }
+
+        // Ensure the cell has not been accessed.
+        if segment[offset].is_accessed() {
+            return Err(MemoryError::UnsetAccessedCell(addr));
+        }
+
+        // Unset the cell.
+        segment[offset] = MemoryCell::NONE;
+        Ok(())
+    }
+
     /// Retrieve a value from memory (either normal or temporary) and apply relocation rules
     pub(crate) fn get<'a, 'b: 'a, K: 'a>(&'b self, key: &'a K) -> Option<Cow<'b, MaybeRelocatable>>
     where
@@ -764,6 +785,11 @@ impl Memory {
         data.get(i)?.get(j)
     }
 
+    #[cfg(test)]
+    pub(crate) fn get_cell_for_testing(&self, addr: Relocatable) -> Option<&MemoryCell> {
+        self.get_cell(addr)
+    }
+
     pub fn is_accessed(&self, addr: &Relocatable) -> Result<bool, MemoryError> {
         Ok(self
             .get_cell(*addr)