feat: wrap big variants of errors in Box

CHANGELOG.md

@@ -1,6 +1,10 @@
 ## Cairo-VM Changelog
 
 #### Upcoming Changes
+
+* feat: wrap big variants of `HintError`, `VirtualMachineError`, `RunnerError`, `MemoryError`, `MathError`, `InsufficientAllocatedCellsError` in `Box` [#1193](https://github.com/lambdaclass/cairo-rs/pull/1193)
+  * BREAKING: all tuple variants of `HintError` with a single `Felt252` or multiple elements now receive a single `Box`
+
 * Add `Program::builtins_len method` [#1194](https://github.com/lambdaclass/cairo-rs/pull/1194)
 
 * fix: Handle the deserialization of serde_json::Number with scientific notation (e.g.: Number(1e27)) in felt_from_number function [#1188](https://github.com/lambdaclass/cairo-rs/pull/1188)

src/hint_processor/builtin_hint_processor/blake2s_utils.rs

@@ -285,7 +285,7 @@ pub fn example_blake2s_compress(
     let n_bytes = get_integer_from_var_name("n_bytes", vm, ids_data, ap_tracking).map(|x| {
         x.to_u32()
             .ok_or(HintError::Math(MathError::Felt252ToU32Conversion(
-                x.into_owned(),
+                Box::new(x.into_owned()),
             )))
     })??;
 
@@ -339,10 +339,8 @@ mod tests {
         //Execute the hint
         assert_matches!(
             run_hint!(vm, ids_data, hint_code),
-            Err(HintError::Math(MathError::RelocatableSubNegOffset(
-                x,
-                y
-            ))) if x == relocatable!(2,5) && y == 26
+            Err(HintError::Math(MathError::RelocatableSubNegOffset(bx)))
+            if *bx == (relocatable!(2,5), 26)
         );
     }
 
@@ -363,8 +361,8 @@ mod tests {
         assert_matches!(
             run_hint!(vm, ids_data, hint_code),
             Err(HintError::Memory(MemoryError::UnknownMemoryCell(
-                x
-            ))) if x == Relocatable::from((2, 0))
+                bx
+            ))) if *bx == Relocatable::from((2, 0))
         );
     }
 
@@ -383,8 +381,8 @@ mod tests {
         //Execute the hint
         assert_matches!(
             run_hint!(vm, ids_data, hint_code),
-            Err(HintError::IdentifierNotRelocatable(x, y)
-            ) if x == "output" && y == (1,0).into()
+            Err(HintError::IdentifierNotRelocatable(bx))
+            if *bx == ("output".to_string(), (1,0).into())
         );
     }
 
@@ -433,8 +431,8 @@ mod tests {
         assert_matches!(
             run_hint!(vm, ids_data, hint_code),
             Err(HintError::Memory(MemoryError::ExpectedInteger(
-                x
-            ))) if x == Relocatable::from((2, 0))
+                bx
+            ))) if *bx == Relocatable::from((2, 0))
         );
     }
 
@@ -500,14 +498,10 @@ mod tests {
         assert_matches!(
             run_hint!(vm, ids_data, hint_code),
             Err(HintError::Memory(
-                MemoryError::InconsistentMemory(
-                    x,
-                    y,
-                    z
-                )
-            )) if x == Relocatable::from((2, 0)) &&
-                    y == MaybeRelocatable::from((2, 0)) &&
-                    z == MaybeRelocatable::from(Felt252::new(1795745351))
+                MemoryError::InconsistentMemory(bx)
+            )) if *bx == (Relocatable::from((2, 0)),
+                    MaybeRelocatable::from((2, 0)),
+                    MaybeRelocatable::from(Felt252::new(1795745351)))
         );
     }
 
@@ -522,7 +516,7 @@ mod tests {
         //Execute the hint
         assert_matches!(
             run_hint!(vm, HashMap::new(), hint_code),
-            Err(HintError::UnknownIdentifier(x)) if x == "blake2s_ptr_end"
+            Err(HintError::UnknownIdentifier(bx)) if *bx == "blake2s_ptr_end"
         );
     }
 
@@ -669,7 +663,7 @@ mod tests {
         vm.segments = segments![((1, 0), 9999999999_u64), ((1, 1), (1, 0)), ((1, 2), (2, 0))];
         let ids_data = ids_data!["n_bytes", "output", "blake2s_start"];
         //Execute the hint
-        assert_matches!(run_hint!(vm, ids_data, hint_code::EXAMPLE_BLAKE2S_COMPRESS), Err(HintError::Math(MathError::Felt252ToU32Conversion(x))) if x == Felt252::from(9999999999_u64));
+        assert_matches!(run_hint!(vm, ids_data, hint_code::EXAMPLE_BLAKE2S_COMPRESS), Err(HintError::Math(MathError::Felt252ToU32Conversion(bx))) if *bx == Felt252::from(9999999999_u64));
     }
 
     #[test]
@@ -683,6 +677,6 @@ mod tests {
         vm.segments = segments![((1, 0), 9), ((1, 1), (1, 0)), ((1, 2), (2, 0))];
         let ids_data = ids_data!["n_bytes", "output", "blake2s_start"];
         //Execute the hint
-        assert_matches!(run_hint!(vm, ids_data, hint_code::EXAMPLE_BLAKE2S_COMPRESS), Err(HintError::Memory(MemoryError::UnknownMemoryCell(x))) if x == (2, 0).into());
+        assert_matches!(run_hint!(vm, ids_data, hint_code::EXAMPLE_BLAKE2S_COMPRESS), Err(HintError::Memory(MemoryError::UnknownMemoryCell(bx))) if *bx == (2, 0).into());
     }
 }

src/hint_processor/builtin_hint_processor/builtin_hint_processor_definition.rs

@@ -796,7 +796,7 @@ impl HintProcessor for BuiltinHintProcessor {
             hint_code::SPLIT_XX => split_xx(vm, &hint_data.ids_data, &hint_data.ap_tracking),
             #[cfg(feature = "skip_next_instruction_hint")]
             hint_code::SKIP_NEXT_INSTRUCTION => skip_next_instruction(vm),
-            code => Err(HintError::UnknownHint(code.to_string())),
+            code => Err(HintError::UnknownHint(Box::new(code.to_string()))),
         }
     }
 }
@@ -865,18 +865,13 @@ mod tests {
         add_segments!(vm, 1);
         //ids and references are not needed for this test
         assert_matches!(
-                    run_hint!(vm, HashMap::new(), hint_code),
-                    Err(HintError::Memory(
-                        MemoryError::InconsistentMemory(
-                            x,
-                            y,
-                            z
-                        )
-                    )) if x ==
-        Relocatable::from((1, 6)) &&
-                            y == MaybeRelocatable::from((1, 6)) &&
-                            z == MaybeRelocatable::from((3, 0))
-                );
+            run_hint!(vm, HashMap::new(), hint_code),
+            Err(HintError::Memory(
+                MemoryError::InconsistentMemory(bx)
+            )) if *bx == (Relocatable::from((1, 6)),
+                    MaybeRelocatable::from((1, 6)),
+                    MaybeRelocatable::from((3, 0)))
+        );
     }
 
     #[test]
@@ -886,7 +881,7 @@ mod tests {
         let mut vm = vm!();
         assert_matches!(
             run_hint!(vm, HashMap::new(), hint_code),
-            Err(HintError::UnknownHint(x)) if x == *hint_code.to_string()
+            Err(HintError::UnknownHint(bx)) if *bx == hint_code
         );
     }
 
@@ -921,8 +916,8 @@ mod tests {
         let ids_data = ids_data!["len"];
         assert_matches!(
             run_hint!(vm, ids_data, hint_code),
-            Err(HintError::IdentifierNotInteger(x, y))
-            if x == "len" && y == (1,1).into()
+            Err(HintError::IdentifierNotInteger(bx))
+            if *bx == ("len".to_string(), (1,1).into())
         );
     }
 
@@ -959,7 +954,7 @@ mod tests {
         let ids_data = ids_data!["continue_copying"];
         assert_matches!(
             run_hint!(vm, ids_data, hint_code),
-            Err(HintError::VariableNotInScopeError(x)) if x == *"n".to_string()
+            Err(HintError::VariableNotInScopeError(bx)) if *bx == "n"
         );
     }
 
@@ -980,18 +975,14 @@ mod tests {
 
         let ids_data = ids_data!["continue_copying"];
         assert_matches!(
-                    run_hint!(vm, ids_data, hint_code, &mut exec_scopes),
-                    Err(HintError::Memory(
-                        MemoryError::InconsistentMemory(
-                            x,
-                            y,
-                            z
-                        )
-                    )) if x ==
-        Relocatable::from((1, 1)) &&
-                            y == MaybeRelocatable::from(Felt252::new(5)) &&
-                            z == MaybeRelocatable::from(Felt252::zero())
-                );
+            run_hint!(vm, ids_data, hint_code, &mut exec_scopes),
+            Err(HintError::Memory(
+                MemoryError::InconsistentMemory(bx)
+            )) if *bx ==
+                    (Relocatable::from((1, 1)),
+                    MaybeRelocatable::from(Felt252::new(5)),
+                    MaybeRelocatable::from(Felt252::zero()))
+        );
     }
 
     #[test]
@@ -1086,7 +1077,7 @@ mod tests {
         let mut exec_scopes = scope![("__keccak_max_size", Felt252::new(2))];
         assert_matches!(
             run_hint!(vm, ids_data, hint_code, &mut exec_scopes),
-            Err(HintError::KeccakMaxSize(x, y)) if x == Felt252::new(5) && y == Felt252::new(2)
+            Err(HintError::KeccakMaxSize(bx)) if *bx == (Felt252::new(5), Felt252::new(2))
         );
     }
 
@@ -1134,7 +1125,7 @@ mod tests {
         let mut exec_scopes = scope![("__keccak_max_size", Felt252::new(10))];
         assert_matches!(
             run_hint!(vm, ids_data, hint_code, &mut exec_scopes),
-            Err(HintError::InvalidWordSize(x)) if x == Felt252::new(-1)
+            Err(HintError::InvalidWordSize(bx)) if *bx == Felt252::new(-1)
         );
     }
 

src/hint_processor/builtin_hint_processor/cairo_keccak/keccak_hints.rs

@@ -1,5 +1,6 @@
 use crate::stdlib::{
     borrow::{Cow, ToOwned},
+    boxed::Box,
     collections::HashMap,
     prelude::*,
 };
@@ -93,7 +94,7 @@
     // Felt252::new(BYTES_INTO_WORD) into a lazy_static!
     let bytes_in_word = constants
         .get(BYTES_IN_WORD)
-        .ok_or(HintError::MissingConstant(BYTES_IN_WORD))?;
+        .ok_or(HintError::MissingConstant(Box::new(BYTES_IN_WORD)))?;
     let value = Felt252::new((n_bytes < bytes_in_word) as usize);
     insert_value_into_ap(vm, value)
 }
@@ -118,7 +119,9 @@
     let keccak_full_rate_in_bytes = constants
         .get(KECCAK_FULL_RATE_IN_BYTES_CAIRO_KECCAK)
         .or_else(|| constants.get(KECCAK_FULL_RATE_IN_BYTES_BUILTIN_KECCAK))
-        .ok_or(HintError::MissingConstant(KECCAK_FULL_RATE_IN_BYTES))?;
+        .ok_or(HintError::MissingConstant(Box::new(
+            KECCAK_FULL_RATE_IN_BYTES,
+        )))?;
     let value = Felt252::new((n_bytes >= keccak_full_rate_in_bytes) as usize);
     insert_value_into_ap(vm, value)
 }
@@ -150,13 +153,16 @@
     ap_tracking: &ApTracking,
     constants: &HashMap<String, Felt252>,
 ) -> Result<(), HintError> {
-    let keccak_state_size_felts = constants
-        .get(KECCAK_STATE_SIZE_FELTS)
-        .ok_or(HintError::MissingConstant(KECCAK_STATE_SIZE_FELTS))?;
+    let keccak_state_size_felts =
+        constants
+            .get(KECCAK_STATE_SIZE_FELTS)
+            .ok_or(HintError::MissingConstant(Box::new(
+                KECCAK_STATE_SIZE_FELTS,
+            )))?;
     if keccak_state_size_felts >= &Felt252::new(100_i32) {
-        return Err(HintError::InvalidKeccakStateSizeFelt252s(
+        return Err(HintError::InvalidKeccakStateSizeFelt252s(Box::new(
             keccak_state_size_felts.clone(),
-        ));
+        )));
     }
 
     let keccak_ptr = get_ptr_from_var_name("keccak_ptr", vm, ids_data, ap_tracking)?;
@@ -217,13 +223,16 @@
     ap_tracking: &ApTracking,
     constants: &HashMap<String, Felt252>,
 ) -> Result<(), HintError> {
-    let keccak_state_size_felts = constants
-        .get(KECCAK_STATE_SIZE_FELTS)
-        .ok_or(HintError::MissingConstant(KECCAK_STATE_SIZE_FELTS))?;
+    let keccak_state_size_felts =
+        constants
+            .get(KECCAK_STATE_SIZE_FELTS)
+            .ok_or(HintError::MissingConstant(Box::new(
+                KECCAK_STATE_SIZE_FELTS,
+            )))?;
     if keccak_state_size_felts >= &Felt252::from(100_i32) {
-        return Err(HintError::InvalidKeccakStateSizeFelt252s(
+        return Err(HintError::InvalidKeccakStateSizeFelt252s(Box::new(
             keccak_state_size_felts.clone(),
-        ));
+        )));
     }
 
     let keccak_ptr = get_ptr_from_var_name("keccak_ptr_start", vm, ids_data, ap_tracking)?;
@@ -254,21 +263,24 @@
     constants: &HashMap<String, Felt252>,
     block_size_limit: usize,
 ) -> Result<(), HintError> {
-    let keccak_state_size_felts = constants
-        .get(KECCAK_STATE_SIZE_FELTS)
-        .ok_or(HintError::MissingConstant(KECCAK_STATE_SIZE_FELTS))?;
+    let keccak_state_size_felts =
+        constants
+            .get(KECCAK_STATE_SIZE_FELTS)
+            .ok_or(HintError::MissingConstant(Box::new(
+                KECCAK_STATE_SIZE_FELTS,
+            )))?;
     let block_size = constants
         .get(BLOCK_SIZE)
-        .ok_or(HintError::MissingConstant(BLOCK_SIZE))?;
+        .ok_or(HintError::MissingConstant(Box::new(BLOCK_SIZE)))?;
 
     if keccak_state_size_felts >= &Felt252::new(100_i32) {
-        return Err(HintError::InvalidKeccakStateSizeFelt252s(
+        return Err(HintError::InvalidKeccakStateSizeFelt252s(Box::new(
             keccak_state_size_felts.clone(),
-        ));
+        )));
     }
 
     if block_size >= &Felt252::new(block_size_limit) {
-        return Err(HintError::InvalidBlockSize(block_size.clone()));
+        return Err(HintError::InvalidBlockSize(Box::new(block_size.clone())));
     };
 
     let keccak_state_size_felts = keccak_state_size_felts.to_usize().unwrap();
@@ -349,10 +361,10 @@
             Some(Cow::Owned(MaybeRelocatable::Int(ref num)))
             | Some(Cow::Borrowed(MaybeRelocatable::Int(ref num))) => num
                 .to_u64()
-                .ok_or_else(|| MathError::Felt252ToU64Conversion(num.clone()).into()),
-            _ => Err(VirtualMachineError::ExpectedIntAtRange(
+                .ok_or_else(|| MathError::Felt252ToU64Conversion(Box::new(num.clone())).into()),
+            _ => Err(VirtualMachineError::ExpectedIntAtRange(Box::new(
                 n.as_ref().map(|x| x.as_ref().to_owned()),
-            )),
+            ))),
         })
         .collect::<Result<Vec<u64>, VirtualMachineError>>()?;