diff --git a/cairo_vm_hints/src/hints/tests/construct_mmr.rs b/cairo_vm_hints/src/hints/tests/construct_mmr.rs
index 227e1c0..2f82571 100644
--- a/cairo_vm_hints/src/hints/tests/construct_mmr.rs
+++ b/cairo_vm_hints/src/hints/tests/construct_mmr.rs
@@ -1,8 +1,6 @@
 use crate::mmr::{Keccak, Mmr, Poseidon};
+use crate::utils::{split_u256, write_struct, write_value, write_vector};
 use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::HintProcessorData;
-use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::{
-    get_ptr_from_var_name, get_relocatable_from_var_name, insert_value_from_var_name,
-};
 use cairo_vm::types::exec_scope::ExecutionScopes;
 use cairo_vm::types::relocatable::MaybeRelocatable;
 use cairo_vm::vm::{errors::hint_errors::HintError, vm_core::VirtualMachine};
@@ -78,13 +76,6 @@ ids.expected_new_root_poseidon = mmr_poseidon.get_root()
 ids.expected_new_root_keccak.low, ids.expected_new_root_keccak.high = split_128(mmr_keccak.get_root())
 ids.expected_new_len = len(mmr_poseidon.pos_hash)";
 
-fn split_u256(number: &BigUint) -> [BigUint; 2] {
-    let mut iter = number.to_bytes_le().into_iter();
-    let low = &iter.by_ref().take(16).collect::<Vec<_>>();
-    let high = &iter.collect::<Vec<_>>();
-    [BigUint::from_bytes_le(low), BigUint::from_bytes_le(high)]
-}
-
 pub fn test_construct_mmr(
     vm: &mut VirtualMachine,
     _exec_scope: &mut ExecutionScopes,
@@ -106,13 +97,7 @@ pub fn test_construct_mmr(
 
     let previous_n_values = rng.gen_range(1..=200);
     let n_values_to_append = rng.gen_range(1..=200);
-    insert_value_from_var_name(
-        "n_values_to_append",
-        n_values_to_append,
-        vm,
-        &hint_data.ids_data,
-        &hint_data.ap_tracking,
-    )?;
+    write_value("n_values_to_append", n_values_to_append, vm, hint_data)?;
 
     let poseidon_hash_array = (0..n_values_to_append)
         .map(|_| rng.gen_biguint_range(&BigUint::one(), &stark_prime))
@@ -121,30 +106,24 @@ pub fn test_construct_mmr(
         .map(|_| rng.gen_biguint_range(&BigUint::one(), &two_pow_256))
         .collect::<Vec<_>>();
 
-    vm.segments.load_data(
-        get_ptr_from_var_name(
-            "poseidon_hash_array",
-            vm,
-            &hint_data.ids_data,
-            &hint_data.ap_tracking,
-        )?,
+    write_vector(
+        "poseidon_hash_array",
         &poseidon_hash_array
             .iter()
             .map(|x| MaybeRelocatable::Int(x.into()))
             .collect::<Vec<_>>(),
+        vm,
+        &hint_data,
     )?;
-    vm.segments.load_data(
-        get_ptr_from_var_name(
-            "keccak_hash_array",
-            vm,
-            &hint_data.ids_data,
-            &hint_data.ap_tracking,
-        )?,
+    write_vector(
+        "keccak_hash_array",
         &keccak_hash_array
             .iter()
             .flat_map(split_u256)
             .map(|x| MaybeRelocatable::Int(x.into()))
             .collect::<Vec<_>>(),
+        vm,
+        &hint_data,
     )?;
 
     let mut mmr_poseidon = Mmr::<Poseidon>::new();
@@ -158,62 +137,44 @@ pub fn test_construct_mmr(
         .map(|_| rng.gen_biguint_range(&BigUint::one(), &two_pow_256))
         .for_each(|x| mmr_keccak.append(x));
 
-    insert_value_from_var_name(
-        "mmr_offset",
-        mmr_poseidon.size(),
-        vm,
-        &hint_data.ids_data,
-        &hint_data.ap_tracking,
-    )?;
+    write_value("mmr_offset", mmr_poseidon.size(), vm, &hint_data)?;
 
     let previous_peaks_poseidon = mmr_poseidon.retrieve_nodes(mmr_poseidon.get_peaks());
     let previous_peaks_keccak = mmr_keccak.retrieve_nodes(mmr_keccak.get_peaks());
 
-    vm.segments.load_data(
-        get_ptr_from_var_name(
-            "previous_peaks_values_poseidon",
-            vm,
-            &hint_data.ids_data,
-            &hint_data.ap_tracking,
-        )?,
+    write_vector(
+        "previous_peaks_values_poseidon",
         &previous_peaks_poseidon
             .iter()
             .map(|x| MaybeRelocatable::Int(x.into()))
             .collect::<Vec<_>>(),
+        vm,
+        &hint_data,
     )?;
-
-    vm.segments.load_data(
-        get_ptr_from_var_name(
-            "previous_peaks_values_keccak",
-            vm,
-            &hint_data.ids_data,
-            &hint_data.ap_tracking,
-        )?,
+    write_vector(
+        "previous_peaks_values_keccak",
         &previous_peaks_keccak
             .iter()
             .flat_map(split_u256)
             .map(|x| MaybeRelocatable::Int(x.into()))
             .collect::<Vec<_>>(),
+        vm,
+        &hint_data,
     )?;
-
-    insert_value_from_var_name(
+    write_value(
         "mmr_last_root_poseidon",
         MaybeRelocatable::Int(mmr_poseidon.get_root().into()),
         vm,
-        &hint_data.ids_data,
-        &hint_data.ap_tracking,
+        &hint_data,
     )?;
-    vm.segments.load_data(
-        get_relocatable_from_var_name(
-            "mmr_last_root_keccak",
-            vm,
-            &hint_data.ids_data,
-            &hint_data.ap_tracking,
-        )?,
+    write_struct(
+        "mmr_last_root_keccak",
         &split_u256(&mmr_keccak.get_root())
             .iter()
             .map(|x| MaybeRelocatable::Int(x.into()))
             .collect::<Vec<_>>(),
+        vm,
+        &hint_data,
     )?;
 
     for elem in poseidon_hash_array.iter().rev() {
@@ -223,32 +184,22 @@ pub fn test_construct_mmr(
         mmr_keccak.append(elem.clone());
     }
 
-    insert_value_from_var_name(
+    write_value(
         "expected_new_root_poseidon",
         MaybeRelocatable::Int(mmr_poseidon.get_root().into()),
         vm,
-        &hint_data.ids_data,
-        &hint_data.ap_tracking,
+        &hint_data,
     )?;
-    vm.segments.load_data(
-        get_relocatable_from_var_name(
-            "expected_new_root_keccak",
-            vm,
-            &hint_data.ids_data,
-            &hint_data.ap_tracking,
-        )?,
+    write_struct(
+        "expected_new_root_keccak",
         &split_u256(&mmr_keccak.get_root())
             .iter()
             .map(|x| MaybeRelocatable::Int(x.into()))
             .collect::<Vec<_>>(),
-    )?;
-    insert_value_from_var_name(
-        "expected_new_len",
-        mmr_keccak.size(),
         vm,
-        &hint_data.ids_data,
-        &hint_data.ap_tracking,
+        &hint_data,
     )?;
+    write_value("expected_new_len", mmr_keccak.size(), vm, &hint_data)?;
 
     Ok(())
 }
diff --git a/cairo_vm_hints/src/hints/tests/dw_hack.rs b/cairo_vm_hints/src/hints/tests/dw_hack.rs
index 9b16bda..1183065 100644
--- a/cairo_vm_hints/src/hints/tests/dw_hack.rs
+++ b/cairo_vm_hints/src/hints/tests/dw_hack.rs
@@ -1,7 +1,5 @@
+use crate::utils::{get_value, write_value};
 use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::HintProcessorData;
-use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::{
-    get_integer_from_var_name, insert_value_from_var_name,
-};
 use cairo_vm::types::exec_scope::ExecutionScopes;
 use cairo_vm::types::relocatable::MaybeRelocatable;
 use cairo_vm::vm::{errors::hint_errors::HintError, vm_core::VirtualMachine};
@@ -16,12 +14,11 @@ pub fn hint_bit_length_assign_140(
     hint_data: &HintProcessorData,
     _constants: &HashMap<String, Felt252>,
 ) -> Result<(), HintError> {
-    insert_value_from_var_name(
+    write_value(
         "bit_length",
         MaybeRelocatable::Int(Felt252::from_hex_unchecked("0x8C")),
         vm,
-        &hint_data.ids_data,
-        &hint_data.ap_tracking,
+        &hint_data,
     )?;
 
     Ok(())
@@ -35,12 +32,11 @@ pub fn hint_bit_length_assign_negative_one(
     hint_data: &HintProcessorData,
     _constants: &HashMap<String, Felt252>,
 ) -> Result<(), HintError> {
-    insert_value_from_var_name(
+    write_value(
         "bit_length",
         MaybeRelocatable::Int(Felt252::ZERO - Felt252::ONE),
         vm,
-        &hint_data.ids_data,
-        &hint_data.ap_tracking,
+        &hint_data,
     )?;
 
     Ok(())
@@ -54,12 +50,11 @@ pub fn hint_bit_length_assign_2500(
     hint_data: &HintProcessorData,
     _constants: &HashMap<String, Felt252>,
 ) -> Result<(), HintError> {
-    insert_value_from_var_name(
+    write_value(
         "bit_length",
         MaybeRelocatable::Int(Felt252::from_hex_unchecked("0x9C4")),
         vm,
-        &hint_data.ids_data,
-        &hint_data.ap_tracking,
+        &hint_data,
     )?;
 
     Ok(())
@@ -75,8 +70,8 @@ pub fn hint_print_ns(
 ) -> Result<(), HintError> {
     println!(
         "N: {}, n: {}",
-        get_integer_from_var_name("N", vm, &hint_data.ids_data, &hint_data.ap_tracking)?,
-        get_integer_from_var_name("n", vm, &hint_data.ids_data, &hint_data.ap_tracking)?
+        get_value("N", vm, &hint_data)?,
+        get_value("n", vm, &hint_data)?
     );
     Ok(())
 }
diff --git a/cairo_vm_hints/src/hints/tests/encode_packed_256.rs b/cairo_vm_hints/src/hints/tests/encode_packed_256.rs
index bbac654..ebd1bb9 100644
--- a/cairo_vm_hints/src/hints/tests/encode_packed_256.rs
+++ b/cairo_vm_hints/src/hints/tests/encode_packed_256.rs
@@ -1,7 +1,4 @@
 use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::HintProcessorData;
-use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::{
-    get_ptr_from_var_name, insert_value_from_var_name,
-};
 use cairo_vm::types::exec_scope::ExecutionScopes;
 use cairo_vm::types::relocatable::MaybeRelocatable;
 use cairo_vm::vm::{errors::hint_errors::HintError, vm_core::VirtualMachine};
@@ -11,6 +8,8 @@ use sha3::Digest;
 use sha3::Keccak256;
 use std::collections::HashMap;
 
+use crate::utils::{write_value, write_vector};
+
 fn get_random() -> [u8; 32] {
     let mut rng = rand::thread_rng();
     let mut arr = [0u8; 32];
@@ -52,8 +51,6 @@ pub fn hint_generate_test_vector(
         .map(|(x, y)| keccak(x, y))
         .collect();
 
-    let x_array_ptr =
-        get_ptr_from_var_name("x_array", vm, &hint_data.ids_data, &hint_data.ap_tracking)?;
     let x_array: Vec<MaybeRelocatable> = x_list
         .into_iter()
         .flat_map(|x| {
@@ -64,10 +61,8 @@ pub fn hint_generate_test_vector(
             ]
         })
         .collect();
-    vm.segments.load_data(x_array_ptr, &x_array)?;
+    write_vector("x_array", &x_array, vm, &hint_data)?;
 
-    let y_array_ptr =
-        get_ptr_from_var_name("y_array", vm, &hint_data.ids_data, &hint_data.ap_tracking)?;
     let y_array: Vec<MaybeRelocatable> = y_list
         .into_iter()
         .flat_map(|x| {
@@ -78,14 +73,8 @@ pub fn hint_generate_test_vector(
             ]
         })
         .collect();
-    vm.segments.load_data(y_array_ptr, &y_array)?;
+    write_vector("y_array", &y_array, vm, &hint_data)?;
 
-    let keccak_result_array_ptr = get_ptr_from_var_name(
-        "keccak_result_array",
-        vm,
-        &hint_data.ids_data,
-        &hint_data.ap_tracking,
-    )?;
     let keccak_result_array: Vec<MaybeRelocatable> = keccak_result_list
         .into_iter()
         .flat_map(|x| {
@@ -96,15 +85,13 @@ pub fn hint_generate_test_vector(
             ]
         })
         .collect();
-    vm.segments
-        .load_data(keccak_result_array_ptr, &keccak_result_array)?;
+    write_vector("keccak_result_array", &keccak_result_array, vm, &hint_data)?;
 
-    insert_value_from_var_name(
+    write_value(
         "len",
         MaybeRelocatable::Int(Felt252::from(keccak_result_array.len() / 2)),
         vm,
-        &hint_data.ids_data,
-        &hint_data.ap_tracking,
+        &hint_data,
     )?;
 
     Ok(())
diff --git a/cairo_vm_hints/src/hints/tests/mmr_size_generate.rs b/cairo_vm_hints/src/hints/tests/mmr_size_generate.rs
index 9cd107c..bad41e9 100644
--- a/cairo_vm_hints/src/hints/tests/mmr_size_generate.rs
+++ b/cairo_vm_hints/src/hints/tests/mmr_size_generate.rs
@@ -1,7 +1,4 @@
 use cairo_vm::hint_processor::builtin_hint_processor::builtin_hint_processor_definition::HintProcessorData;
-use cairo_vm::hint_processor::builtin_hint_processor::hint_utils::{
-    get_integer_from_var_name, get_ptr_from_var_name,
-};
 use cairo_vm::types::exec_scope::ExecutionScopes;
 use cairo_vm::types::relocatable::MaybeRelocatable;
 use cairo_vm::vm::{errors::hint_errors::HintError, vm_core::VirtualMachine};
@@ -10,6 +7,8 @@ use rand::{thread_rng, Rng};
 use starknet_types_core::felt::Felt;
 use std::collections::{HashMap, HashSet};
 
+use crate::utils::{get_value, write_vector};
+
 fn is_valid_mmr_size(mut mmr_size: u64) -> bool {
     if mmr_size == 0 {
         return false;
@@ -36,10 +35,7 @@ pub fn hint_generate_random(
     // let ap_tracking = &hint_data.ap_tracking;
     // let a = get_integer_from_var_name("x", vm, ids_data, ap_tracking)?;
     // vm.segments.write_arg(vm.seg, arg)
-    let num_sizes: u64 =
-        get_integer_from_var_name("num_sizes", vm, &hint_data.ids_data, &hint_data.ap_tracking)?
-            .try_into()
-            .unwrap();
+    let num_sizes: u64 = get_value("num_sizes", vm, &hint_data)?.try_into().unwrap();
 
     println!(
         "Testing is_valid_mmr_size against python implementation with {} random sizes in [0, 20000000)...",
@@ -56,23 +52,8 @@ pub fn hint_generate_random(
         expected_output.push(MaybeRelocatable::Int(y.into()));
     }
 
-    let expected_output_ptr = get_ptr_from_var_name(
-        "expected_output",
-        vm,
-        &hint_data.ids_data,
-        &hint_data.ap_tracking,
-    )?;
-
-    let input_array_ptr = get_ptr_from_var_name(
-        "input_array",
-        vm,
-        &hint_data.ids_data,
-        &hint_data.ap_tracking,
-    )?;
-
-    vm.segments.load_data(input_array_ptr, &input_array)?;
-    vm.segments
-        .load_data(expected_output_ptr, &expected_output)?;
+    write_vector("input_array", &input_array, vm, &hint_data)?;
+    write_vector("expected_output", &expected_output, vm, &hint_data)?;
 
     Ok(())
 }
@@ -89,10 +70,7 @@ pub fn hint_generate_sequential(
     // let ap_tracking = &hint_data.ap_tracking;
     // let a = get_integer_from_var_name("x", vm, ids_data, ap_tracking)?;
     // vm.segments.write_arg(vm.seg, arg)
-    let num_elems: u64 =
-        get_integer_from_var_name("num_elems", vm, &hint_data.ids_data, &hint_data.ap_tracking)?
-            .try_into()
-            .unwrap();
+    let num_elems: u64 = get_value("num_elems", vm, &hint_data)?.try_into().unwrap();
 
     println!(
         "Testing is_valid_mmr_size by creating the mmr for all sizes in [0, {})...",
@@ -112,23 +90,8 @@ pub fn hint_generate_sequential(
         .map(|x| MaybeRelocatable::Int(x.into()))
         .collect::<Vec<_>>();
 
-    let expected_output_ptr = get_ptr_from_var_name(
-        "expected_output",
-        vm,
-        &hint_data.ids_data,
-        &hint_data.ap_tracking,
-    )?;
-
-    let input_array_ptr = get_ptr_from_var_name(
-        "input_array",
-        vm,
-        &hint_data.ids_data,
-        &hint_data.ap_tracking,
-    )?;
-
-    vm.segments.load_data(input_array_ptr, &input_array)?;
-    vm.segments
-        .load_data(expected_output_ptr, &expected_output)?;
+    write_vector("input_array", &input_array, vm, &hint_data)?;
+    write_vector("expected_output", &expected_output, vm, &hint_data)?;
 
     Ok(())
 }
diff --git a/cairo_vm_hints/src/lib.rs b/cairo_vm_hints/src/lib.rs
index 8d286f5..b7c9b04 100644
--- a/cairo_vm_hints/src/lib.rs
+++ b/cairo_vm_hints/src/lib.rs
@@ -1,6 +1,7 @@
 pub mod hint_processor;
 pub mod hints;
 pub mod mmr;
+pub mod utils;
 
 pub use hint_processor::{CustomHintProcessor, ExtendedHintProcessor};
 
diff --git a/cairo_vm_hints/src/utils.rs b/cairo_vm_hints/src/utils.rs
new file mode 100644
index 0000000..88ef751
--- /dev/null
+++ b/cairo_vm_hints/src/utils.rs
@@ -0,0 +1,69 @@
+use cairo_vm::{
+    hint_processor::builtin_hint_processor::{
+        builtin_hint_processor_definition::HintProcessorData,
+        hint_utils::{
+            get_integer_from_var_name, get_ptr_from_var_name, get_relocatable_from_var_name,
+            insert_value_from_var_name,
+        },
+    },
+    types::relocatable::MaybeRelocatable,
+    vm::{errors::hint_errors::HintError, vm_core::VirtualMachine},
+    Felt252,
+};
+use num_bigint::BigUint;
+
+pub fn split_u256(number: &BigUint) -> [BigUint; 2] {
+    let mut iter = number.to_bytes_le().into_iter();
+    let low = &iter.by_ref().take(16).collect::<Vec<_>>();
+    let high = &iter.collect::<Vec<_>>();
+    [BigUint::from_bytes_le(low), BigUint::from_bytes_le(high)]
+}
+
+pub fn write_value(
+    var_name: &str,
+    value: impl Into<MaybeRelocatable>,
+    vm: &mut VirtualMachine,
+    hint_data: &HintProcessorData,
+) -> Result<(), HintError> {
+    insert_value_from_var_name(
+        var_name,
+        value,
+        vm,
+        &hint_data.ids_data,
+        &hint_data.ap_tracking,
+    )
+}
+
+pub fn write_struct(
+    var_name: &str,
+    values: &[MaybeRelocatable],
+    vm: &mut VirtualMachine,
+    hint_data: &HintProcessorData,
+) -> Result<(), HintError> {
+    vm.segments.load_data(
+        get_relocatable_from_var_name(var_name, vm, &hint_data.ids_data, &hint_data.ap_tracking)?,
+        values,
+    )?;
+    Ok(())
+}
+
+pub fn write_vector(
+    var_name: &str,
+    vector: &[MaybeRelocatable],
+    vm: &mut VirtualMachine,
+    hint_data: &HintProcessorData,
+) -> Result<(), HintError> {
+    vm.segments.load_data(
+        get_ptr_from_var_name(var_name, vm, &hint_data.ids_data, &hint_data.ap_tracking)?,
+        vector,
+    )?;
+    Ok(())
+}
+
+pub fn get_value(
+    var_name: &str,
+    vm: &mut VirtualMachine,
+    hint_data: &HintProcessorData,
+) -> Result<Felt252, HintError> {
+    get_integer_from_var_name(var_name, vm, &hint_data.ids_data, &hint_data.ap_tracking)
+}