Change the Dictionary used in dict hints to store MaybeRelocatable instead of BigInt

CHANGELOG.md

@@ -25,4 +25,10 @@
 * Add new error type `HintError` [#676](https://github.com/lambdaclass/cairo-rs/pull/676)
     * Public Api changes:
         * `HintProcessor::execute_hint()` now returns a `HintError` instead of a `VirtualMachineError`
-        * helper functions on `hint_processor_utils.rs` now return a `HintError`
+        * Helper functions on `hint_processor_utils.rs` now return a `HintError`
+
+* Change the Dictionary used in dict hints to store MaybeRelocatable instead of BigInt [#687](https://github.com/lambdaclass/cairo-rs/pull/687)
+    * Public Api changes:
+        * `DictManager`, its dictionaries, and all dict module hints implemented in rust now use `MaybeRelocatable` for keys and values instead of `BigInt`
+        * Add helper functions that allow extracting ids variables as `MaybeRelocatable`: `get_maybe_relocatable_from_var_name` & `get_maybe_relocatable_from_reference`
+        * Change inner value type of dict-related `HintError` variants to `MaybeRelocatable`

cairo_programs/dict_store_cast_ptr.cairo

@@ -0,0 +1,40 @@
+from starkware.cairo.common.dict_access import DictAccess
+from starkware.cairo.common.alloc import alloc
+from starkware.cairo.common.default_dict import default_dict_new
+from starkware.cairo.common.dict import dict_write, dict_read
+
+struct Structure {
+    a: felt,
+    b: felt,
+    c: felt,
+}
+
+func main() {
+    // Create dictionary
+    let (dictionary: DictAccess*) = default_dict_new(default_value=0);
+    // Create & initialize struct_pointer
+    let (struct_ptr: Structure*) = alloc();
+    assert struct_ptr[0] = Structure(1, 2, 3);
+    // Cast ptr to felt and store it in the dictionary
+    tempvar struct_ptr_cast_felt = cast(struct_ptr, felt);
+    dict_write{dict_ptr=dictionary}(key=0, new_value=struct_ptr_cast_felt);
+    // Read the casted ptr from the dictionary and compare it to the one we stored
+    let read_struct_ptr_cast_felt: felt = dict_read{dict_ptr=dictionary}(key=0);
+    assert struct_ptr_cast_felt = read_struct_ptr_cast_felt;
+    // Cast he ptr back to Structure* and check its value
+    let read_struct_ptr_cast_struct_ptr = cast(read_struct_ptr_cast_felt, Structure*);
+    assert struct_ptr = read_struct_ptr_cast_struct_ptr;
+    // Confirm that the ptr still leads to the data we initialized
+    assert read_struct_ptr_cast_struct_ptr[0].a = 1;
+    assert read_struct_ptr_cast_struct_ptr[0].b = 2;
+    assert read_struct_ptr_cast_struct_ptr[0].c = 3;
+    // Now we do the same, but we read the struct_ptr from the dictionary as a Struct*
+    // without an explicit cast
+    let read_struct_ptr: Structure* = dict_read{dict_ptr=dictionary}(key=0);
+    assert struct_ptr = read_struct_ptr;
+    // Confirm that the ptr still leads to the data we initialized
+    assert read_struct_ptr[0].a = 1;
+    assert read_struct_ptr[0].b = 2;
+    assert read_struct_ptr[0].c = 3;
+    return ();
+}