Replace security anyhow errors with enum variants (#1946)

* Replace anyhow error with variants

* Update changelog

* Update tests

* Use box to keep error enum small

Author: JulianGCalderon

CHANGELOG.md

@@ -2,6 +2,8 @@
 
 #### Upcoming Changes
 
+* refactor: Replaces security anyhow errors with enum variants [#1946](https://github.com/lambdaclass/cairo-vm/pull/1946)
+
 * fix: `mod_builtin_fill_memory` could be stuck in an infinite loop [#1975](https://github.com/lambdaclass/cairo-vm/issues/1975)
 
 * feat: replace `thiserror-no-std` with `thiserror 2` [#1919](https://github.com/lambdaclass/cairo-vm/pull/1919)

vm/src/vm/errors/vm_errors.rs

@@ -140,6 +140,16 @@ pub enum VirtualMachineError {
     RelocationNotFound(usize),
     #[error("{} batch size is not {}", (*.0).0, (*.0).1)]
     ModBuiltinBatchSize(Box<(BuiltinName, usize)>),
+    #[error("Initial FP should have been initialized")]
+    MissingInitialFp,
+    #[error("Return FP address should be in memory: {0}")]
+    MissingReturnFp(Box<Relocatable>),
+    #[error("Return FP { } should equal expected final FP { }", (*.0).0, (*.0).1)]
+    MismatchReturnFP(Box<(Relocatable, Relocatable)>),
+    #[error("Return FP { } offset should equal expected final FP { } offset", (*.0).0, (*.0).1)]
+    MismatchReturnFPOffset(Box<(Relocatable, Relocatable)>),
+    #[error("Return FP felt { } should equal expected final FP { } offset", (*.0).0, (*.0).1)]
+    MismatchReturnFPFelt(Box<(Felt252, Relocatable)>),
     #[error("Blake2s opcode invalid operand: op{0} does not point to {1} u32 numbers.")]
     Blake2sInvalidOperand(u8, u8),
     #[error("Blake2s opcode invalid flags {0}")]

vm/src/vm/security.rs

@@ -81,37 +81,33 @@ pub fn verify_secure_runner(
     }
 
     // Validate ret FP.
-    let initial_fp = runner.get_initial_fp().ok_or_else(|| {
-        VirtualMachineError::Other(anyhow::anyhow!(
-            "Failed to retrieve the initial_fp: it is None. \
-                     The initial_fp field should be initialized after running the entry point."
-        ))
-    })?;
+    let initial_fp = runner
+        .get_initial_fp()
+        .ok_or(VirtualMachineError::MissingInitialFp)?;
     let ret_fp_addr = (initial_fp - 2).map_err(VirtualMachineError::Math)?;
-    let ret_fp = runner.vm.get_maybe(&ret_fp_addr).ok_or_else(|| {
-        VirtualMachineError::Other(anyhow::anyhow!(
-            "Ret FP address is not in memory: {ret_fp_addr}"
-        ))
-    })?;
+    let ret_fp = runner
+        .vm
+        .get_maybe(&ret_fp_addr)
+        .ok_or(VirtualMachineError::MissingReturnFp(Box::new(ret_fp_addr)))?;
     let final_fp = runner.vm.get_fp();
     match ret_fp {
         MaybeRelocatable::RelocatableValue(value) => {
             if runner.runner_mode == RunnerMode::ProofModeCanonical && value != final_fp {
-                return Err(VirtualMachineError::Other(anyhow::anyhow!(
-                    "Return FP is not equal to final FP: ret_f={ret_fp}, final_fp={final_fp}"
-                )));
+                return Err(VirtualMachineError::MismatchReturnFP(Box::new((
+                    value, final_fp,
+                ))));
             }
             if runner.runner_mode == RunnerMode::ExecutionMode && value.offset != final_fp.offset {
-                return Err(VirtualMachineError::Other(anyhow::anyhow!(
-                    "Return FP offset is not equal to final FP offset: ret_f={ret_fp}, final_fp={final_fp}"
-                )));
+                return Err(VirtualMachineError::MismatchReturnFPOffset(Box::new((
+                    value, final_fp,
+                ))));
             }
         }
         MaybeRelocatable::Int(value) => {
             if Felt252::from(final_fp.offset) != value {
-                return Err(VirtualMachineError::Other(anyhow::anyhow!(
-                    "Return FP felt value is not equal to final FP offset: ret_fp={ret_fp}, final_fp={final_fp}"
-                )));
+                return Err(VirtualMachineError::MismatchReturnFPFelt(Box::new((
+                    value, final_fp,
+                ))));
             }
         }
     }
@@ -340,7 +336,7 @@ mod test {
 
         assert_matches!(
             verify_secure_runner(&runner, true, None),
-            Err(VirtualMachineError::Other(ref err)) if err.to_string().contains("Failed to retrieve the initial_fp: it is None")
+            Err(VirtualMachineError::MissingInitialFp)
         );
     }
 
@@ -354,8 +350,7 @@ mod test {
         runner.vm.segments.memory = crate::vm::vm_memory::memory::Memory::new();
         assert_matches!(
             verify_secure_runner(&runner, true, None),
-            Err(VirtualMachineError::Other(ref err))
-                if err.to_string().contains("Ret FP address is not in memory")
+            Err(VirtualMachineError::MissingReturnFp(..))
         );
     }
 
@@ -372,8 +367,7 @@ mod test {
 
         assert_matches!(
             verify_secure_runner(&runner, true, None),
-            Err(VirtualMachineError::Other(ref err))
-                if err.to_string().contains("Return FP is not equal to final FP")
+            Err(VirtualMachineError::MismatchReturnFP(..))
         );
     }
 
@@ -387,8 +381,7 @@ mod test {
         // ExecutionMode only requires offset equality, not the entire relocatable.
         assert_matches!(
             verify_secure_runner(&runner, true, None),
-            Err(VirtualMachineError::Other(ref err))
-                if err.to_string().contains("Return FP offset is not equal to final FP offset")
+            Err(VirtualMachineError::MismatchReturnFPOffset(..))
         );
     }
 
@@ -404,8 +397,7 @@ mod test {
         // ExecutionMode only requires offset equality, not the entire relocatable.
         assert_matches!(
             verify_secure_runner(&runner, true, None),
-            Err(VirtualMachineError::Other(ref err))
-                if err.to_string().contains("Return FP felt value is not equal to final FP offset")
+            Err(VirtualMachineError::MismatchReturnFPFelt(..))
         );
     }
 }