diff --git a/rln-wasm/tests/rln-wasm.rs b/rln-wasm/tests/rln-wasm.rs
index 2f52fb6..29a1972 100644
--- a/rln-wasm/tests/rln-wasm.rs
+++ b/rln-wasm/tests/rln-wasm.rs
@@ -4,6 +4,7 @@
 mod tests {
     use js_sys::{BigInt as JsBigInt, Object, Uint8Array};
     use rln::circuit::TEST_TREE_HEIGHT;
+    use rln::utils::normalize_usize;
     use rln_wasm::*;
     use wasm_bindgen::prelude::*;
     use wasm_bindgen::JsValue;
@@ -41,20 +42,19 @@ mod tests {
 
         // Prepare the message
         let signal = "Hello World".as_bytes();
-        let signal_len: u64 = signal.len() as u64;
 
         // Setting up the epoch (With 0s for the test)
         let epoch = Uint8Array::new_with_length(32);
         epoch.fill(0, 0, 32);
 
-        let identity_index: u64 = 0;
+        let identity_index: usize = 0;
 
         // Serializing the message
         let mut serialized_vec: Vec<u8> = Vec::new();
         serialized_vec.append(&mut idkey.to_vec());
-        serialized_vec.append(&mut identity_index.to_le_bytes().to_vec());
+        serialized_vec.append(&mut normalize_usize(identity_index));
         serialized_vec.append(&mut epoch.to_vec());
-        serialized_vec.append(&mut signal_len.to_le_bytes().to_vec());
+        serialized_vec.append(&mut normalize_usize(signal.len()));
         serialized_vec.append(&mut signal.to_vec());
         let serialized_message = Uint8Array::from(&serialized_vec[..]);
 
@@ -88,7 +88,7 @@ mod tests {
 
         // Add signal_len | signal
         let mut proof_bytes = proof.to_vec();
-        proof_bytes.append(&mut signal_len.to_le_bytes().to_vec());
+        proof_bytes.append(&mut normalize_usize(signal.len()));
         proof_bytes.append(&mut signal.to_vec());
         let proof_with_signal = Uint8Array::from(&proof_bytes[..]);
 
diff --git a/rln/src/protocol.rs b/rln/src/protocol.rs
index 240dc9c..9524461 100644
--- a/rln/src/protocol.rs
+++ b/rln/src/protocol.rs
@@ -156,18 +156,18 @@ pub fn proof_inputs_to_rln_witness(
     let (identity_secret, read) = bytes_le_to_fr(&serialized[all_read..]);
     all_read += read;
 
-    let id_index = u64::from_le_bytes(serialized[all_read..all_read + 8].try_into()?);
+    let id_index = usize::from_le_bytes(serialized[all_read..all_read + 8].try_into()?);
     all_read += 8;
 
     let (epoch, read) = bytes_le_to_fr(&serialized[all_read..]);
     all_read += read;
 
-    let signal_len = u64::from_le_bytes(serialized[all_read..all_read + 8].try_into()?);
+    let signal_len = usize::from_le_bytes(serialized[all_read..all_read + 8].try_into()?);
     all_read += 8;
 
-    let signal: Vec<u8> = serialized[all_read..all_read + (signal_len as usize)].to_vec();
+    let signal: Vec<u8> = serialized[all_read..all_read + signal_len].to_vec();
 
-    let merkle_proof = tree.proof(id_index as usize).expect("proof should exist");
+    let merkle_proof = tree.proof(id_index).expect("proof should exist");
     let path_elements = merkle_proof.get_path_elements();
     let identity_path_index = merkle_proof.get_path_index();
 
@@ -358,31 +358,27 @@ pub fn prepare_prove_input(
     id_index: usize,
     epoch: Fr,
     signal: &[u8],
-) -> Result<Vec<u8>> {
-    let signal_len = u64::try_from(signal.len())?;
-
+) -> Vec<u8> {
     let mut serialized: Vec<u8> = Vec::new();
 
     serialized.append(&mut fr_to_bytes_le(&identity_secret));
-    serialized.append(&mut id_index.to_le_bytes().to_vec());
+    serialized.append(&mut normalize_usize(id_index));
     serialized.append(&mut fr_to_bytes_le(&epoch));
-    serialized.append(&mut signal_len.to_le_bytes().to_vec());
+    serialized.append(&mut normalize_usize(signal.len()));
     serialized.append(&mut signal.to_vec());
 
-    Ok(serialized)
+    serialized
 }
 
 #[allow(clippy::redundant_clone)]
-pub fn prepare_verify_input(proof_data: Vec<u8>, signal: &[u8]) -> Result<Vec<u8>> {
-    let signal_len = u64::try_from(signal.len())?;
-
+pub fn prepare_verify_input(proof_data: Vec<u8>, signal: &[u8]) -> Vec<u8> {
     let mut serialized: Vec<u8> = Vec::new();
 
     serialized.append(&mut proof_data.clone());
-    serialized.append(&mut signal_len.to_le_bytes().to_vec());
+    serialized.append(&mut normalize_usize(signal.len()));
     serialized.append(&mut signal.to_vec());
 
-    Ok(serialized)
+    serialized
 }
 
 ///////////////////////////////////////////////////////
diff --git a/rln/src/public.rs b/rln/src/public.rs
index 8989433..4bdf702 100644
--- a/rln/src/public.rs
+++ b/rln/src/public.rs
@@ -500,8 +500,6 @@ impl RLN<'_> {
     /// // We generate a random signal
     /// let mut rng = rand::thread_rng();
     /// let signal: [u8; 32] = rng.gen();
-    /// let signal_len = u64::try_from(signal.len()).unwrap();
-    ///
     /// // We generate a random epoch
     /// let epoch = hash_to_field(b"test-epoch");
     ///
@@ -509,9 +507,9 @@ impl RLN<'_> {
     /// // input_data is [ identity_secret<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]
     /// let mut serialized: Vec<u8> = Vec::new();
     /// serialized.append(&mut fr_to_bytes_le(&identity_secret_hash));
-    /// serialized.append(&mut identity_index.to_le_bytes().to_vec());
+    /// serialized.append(&mut normalize_usize(identity_index));
     /// serialized.append(&mut fr_to_bytes_le(&epoch));
-    /// serialized.append(&mut signal_len.to_le_bytes().to_vec());
+    /// serialized.append(&mut normalize_usize(signal_len).resize(8,0));
     /// serialized.append(&mut signal.to_vec());
     ///
     /// let mut input_buffer = Cursor::new(serialized);
@@ -587,7 +585,7 @@ impl RLN<'_> {
     /// // We prepare input for verify_rln_proof API
     /// // input_data is [ proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> | signal_len<8> | signal<var> ]
     /// // that is [ proof_data || signal_len<8> | signal<var> ]
-    /// proof_data.append(&mut signal_len.to_le_bytes().to_vec());
+    /// proof_data.append(&mut normalize_usize(signal_len));
     /// proof_data.append(&mut signal.to_vec());
     ///
     /// let mut input_buffer = Cursor::new(proof_data);
@@ -604,8 +602,7 @@ impl RLN<'_> {
         let (proof_values, read) = deserialize_proof_values(&serialized[all_read..]);
         all_read += read;
 
-        let signal_len =
-            u64::from_le_bytes(serialized[all_read..all_read + 8].try_into()?) as usize;
+        let signal_len = usize::from_le_bytes(serialized[all_read..all_read + 8].try_into()?);
         all_read += 8;
 
         let signal: Vec<u8> = serialized[all_read..all_read + signal_len].to_vec();
@@ -680,8 +677,7 @@ impl RLN<'_> {
         let (proof_values, read) = deserialize_proof_values(&serialized[all_read..]);
         all_read += read;
 
-        let signal_len =
-            u64::from_le_bytes(serialized[all_read..all_read + 8].try_into()?) as usize;
+        let signal_len = usize::from_le_bytes(serialized[all_read..all_read + 8].try_into()?);
         all_read += 8;
 
         let signal: Vec<u8> = serialized[all_read..all_read + signal_len].to_vec();
@@ -1325,14 +1321,13 @@ mod test {
         let (identity_secret_hash, id_commitment) = keygen();
 
         // We set as leaf id_commitment after storing its index
-        let identity_index = u64::try_from(rln.tree.leaves_set()).unwrap();
+        let identity_index = rln.tree.leaves_set();
         let mut buffer = Cursor::new(fr_to_bytes_le(&id_commitment));
         rln.set_next_leaf(&mut buffer).unwrap();
 
         // We generate a random signal
         let mut rng = rand::thread_rng();
         let signal: [u8; 32] = rng.gen();
-        let signal_len = u64::try_from(signal.len()).unwrap();
 
         // We generate a random epoch
         let epoch = hash_to_field(b"test-epoch");
@@ -1341,9 +1336,9 @@ mod test {
         // input_data is [ identity_secret<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]
         let mut serialized: Vec<u8> = Vec::new();
         serialized.append(&mut fr_to_bytes_le(&identity_secret_hash));
-        serialized.append(&mut identity_index.to_le_bytes().to_vec());
+        serialized.append(&mut normalize_usize(identity_index));
         serialized.append(&mut fr_to_bytes_le(&epoch));
-        serialized.append(&mut signal_len.to_le_bytes().to_vec());
+        serialized.append(&mut normalize_usize(signal.len()));
         serialized.append(&mut signal.to_vec());
 
         let mut input_buffer = Cursor::new(serialized);
@@ -1357,7 +1352,7 @@ mod test {
         // We prepare input for verify_rln_proof API
         // input_data is [ proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> | signal_len<8> | signal<var> ]
         // that is [ proof_data || signal_len<8> | signal<var> ]
-        proof_data.append(&mut signal_len.to_le_bytes().to_vec());
+        proof_data.append(&mut normalize_usize(signal.len()));
         proof_data.append(&mut signal.to_vec());
 
         let mut input_buffer = Cursor::new(proof_data);
@@ -1390,14 +1385,13 @@ mod test {
         let (identity_secret_hash, id_commitment) = keygen();
 
         // We set as leaf id_commitment after storing its index
-        let identity_index = u64::try_from(rln.tree.leaves_set()).unwrap();
+        let identity_index = rln.tree.leaves_set();
         let mut buffer = Cursor::new(fr_to_bytes_le(&id_commitment));
         rln.set_next_leaf(&mut buffer).unwrap();
 
         // We generate a random signal
         let mut rng = rand::thread_rng();
         let signal: [u8; 32] = rng.gen();
-        let signal_len = u64::try_from(signal.len()).unwrap();
 
         // We generate a random epoch
         let epoch = hash_to_field(b"test-epoch");
@@ -1406,9 +1400,9 @@ mod test {
         // input_data is [ identity_secret<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]
         let mut serialized: Vec<u8> = Vec::new();
         serialized.append(&mut fr_to_bytes_le(&identity_secret_hash));
-        serialized.append(&mut identity_index.to_le_bytes().to_vec());
+        serialized.append(&mut normalize_usize(identity_index));
         serialized.append(&mut fr_to_bytes_le(&epoch));
-        serialized.append(&mut signal_len.to_le_bytes().to_vec());
+        serialized.append(&mut normalize_usize(signal.len()));
         serialized.append(&mut signal.to_vec());
 
         let mut input_buffer = Cursor::new(serialized);
@@ -1453,7 +1447,7 @@ mod test {
         // We prepare input for verify_rln_proof API
         // input_data is [ proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> | signal_len<8> | signal<var> ]
         // that is [ proof_data || signal_len<8> | signal<var> ]
-        proof_data.append(&mut signal_len.to_le_bytes().to_vec());
+        proof_data.append(&mut normalize_usize(signal.len()));
         proof_data.append(&mut signal.to_vec());
 
         let mut input_buffer = Cursor::new(proof_data);
@@ -1487,14 +1481,13 @@ mod test {
         let (identity_secret_hash, id_commitment) = keygen();
 
         // We set as leaf id_commitment after storing its index
-        let identity_index = u64::try_from(rln.tree.leaves_set()).unwrap();
+        let identity_index = rln.tree.leaves_set();
         let mut buffer = Cursor::new(fr_to_bytes_le(&id_commitment));
         rln.set_next_leaf(&mut buffer).unwrap();
 
         // We generate a random signal
         let mut rng = rand::thread_rng();
         let signal: [u8; 32] = rng.gen();
-        let signal_len = u64::try_from(signal.len()).unwrap();
 
         // We generate a random epoch
         let epoch = hash_to_field(b"test-epoch");
@@ -1503,9 +1496,9 @@ mod test {
         // input_data is [ identity_secret<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]
         let mut serialized: Vec<u8> = Vec::new();
         serialized.append(&mut fr_to_bytes_le(&identity_secret_hash));
-        serialized.append(&mut identity_index.to_le_bytes().to_vec());
+        serialized.append(&mut normalize_usize(identity_index));
         serialized.append(&mut fr_to_bytes_le(&epoch));
-        serialized.append(&mut signal_len.to_le_bytes().to_vec());
+        serialized.append(&mut normalize_usize(signal.len()));
         serialized.append(&mut signal.to_vec());
 
         let mut input_buffer = Cursor::new(serialized);
@@ -1519,7 +1512,7 @@ mod test {
         // We prepare input for verify_rln_proof API
         // input_data is [ proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> | signal_len<8> | signal<var> ]
         // that is [ proof_data || signal_len<8> | signal<var> ]
-        proof_data.append(&mut signal_len.to_le_bytes().to_vec());
+        proof_data.append(&mut normalize_usize(signal.len()));
         proof_data.append(&mut signal.to_vec());
         let input_buffer = Cursor::new(proof_data);
 
@@ -1570,17 +1563,15 @@ mod test {
         let (identity_secret_hash, id_commitment) = keygen();
 
         // We set as leaf id_commitment after storing its index
-        let identity_index = u64::try_from(rln.tree.leaves_set()).unwrap();
+        let identity_index = rln.tree.leaves_set();
         let mut buffer = Cursor::new(fr_to_bytes_le(&id_commitment));
         rln.set_next_leaf(&mut buffer).unwrap();
 
         // We generate two random signals
         let mut rng = rand::thread_rng();
         let signal1: [u8; 32] = rng.gen();
-        let signal1_len = u64::try_from(signal1.len()).unwrap();
 
         let signal2: [u8; 32] = rng.gen();
-        let signal2_len = u64::try_from(signal2.len()).unwrap();
 
         // We generate a random epoch
         let epoch = hash_to_field(b"test-epoch");
@@ -1591,18 +1582,18 @@ mod test {
         // input_data is [ identity_secret<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]
         let mut serialized1: Vec<u8> = Vec::new();
         serialized1.append(&mut fr_to_bytes_le(&identity_secret_hash));
-        serialized1.append(&mut identity_index.to_le_bytes().to_vec());
+        serialized1.append(&mut normalize_usize(identity_index));
         serialized1.append(&mut fr_to_bytes_le(&epoch));
 
         // The first part is the same for both proof input, so we clone
         let mut serialized2 = serialized1.clone();
 
         // We attach the first signal to the first proof input
-        serialized1.append(&mut signal1_len.to_le_bytes().to_vec());
+        serialized1.append(&mut normalize_usize(signal1.len()));
         serialized1.append(&mut signal1.to_vec());
 
         // We attach the second signal to the first proof input
-        serialized2.append(&mut signal2_len.to_le_bytes().to_vec());
+        serialized2.append(&mut normalize_usize(signal2.len()));
         serialized2.append(&mut signal2.to_vec());
 
         // We generate the first proof
@@ -1644,21 +1635,20 @@ mod test {
         let (identity_secret_hash_new, id_commitment_new) = keygen();
 
         // We add it to the tree
-        let identity_index_new = u64::try_from(rln.tree.leaves_set()).unwrap();
+        let identity_index_new = rln.tree.leaves_set();
         let mut buffer = Cursor::new(fr_to_bytes_le(&id_commitment_new));
         rln.set_next_leaf(&mut buffer).unwrap();
 
         // We generate a random signals
         let signal3: [u8; 32] = rng.gen();
-        let signal3_len = u64::try_from(signal3.len()).unwrap();
 
         // We prepare proof input. Note that epoch is the same as before
         // input_data is [ identity_secret<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]
         let mut serialized3: Vec<u8> = Vec::new();
         serialized3.append(&mut fr_to_bytes_le(&identity_secret_hash_new));
-        serialized3.append(&mut identity_index_new.to_le_bytes().to_vec());
+        serialized3.append(&mut normalize_usize(identity_index_new));
         serialized3.append(&mut fr_to_bytes_le(&epoch));
-        serialized3.append(&mut signal3_len.to_le_bytes().to_vec());
+        serialized3.append(&mut normalize_usize(signal3.len()));
         serialized3.append(&mut signal3.to_vec());
 
         // We generate the proof
diff --git a/rln/src/utils.rs b/rln/src/utils.rs
index 9eba031..804414a 100644
--- a/rln/src/utils.rs
+++ b/rln/src/utils.rs
@@ -75,7 +75,8 @@ pub fn fr_to_bytes_be(input: &Fr) -> Vec<u8> {
 pub fn vec_fr_to_bytes_le(input: &[Fr]) -> Result<Vec<u8>> {
     let mut bytes: Vec<u8> = Vec::new();
     //We store the vector length
-    bytes.extend(u64::try_from(input.len())?.to_le_bytes().to_vec());
+    bytes.extend(input.len().to_le_bytes().to_vec());
+
     // We store each element
     input.iter().for_each(|el| bytes.extend(fr_to_bytes_le(el)));
 
@@ -85,7 +86,8 @@ pub fn vec_fr_to_bytes_le(input: &[Fr]) -> Result<Vec<u8>> {
 pub fn vec_fr_to_bytes_be(input: &[Fr]) -> Result<Vec<u8>> {
     let mut bytes: Vec<u8> = Vec::new();
     //We store the vector length
-    bytes.extend(u64::try_from(input.len())?.to_be_bytes().to_vec());
+    bytes.extend(input.len().to_be_bytes().to_vec());
+
     // We store each element
     input.iter().for_each(|el| bytes.extend(fr_to_bytes_be(el)));
 
@@ -95,15 +97,18 @@ pub fn vec_fr_to_bytes_be(input: &[Fr]) -> Result<Vec<u8>> {
 pub fn vec_u8_to_bytes_le(input: &[u8]) -> Result<Vec<u8>> {
     let mut bytes: Vec<u8> = Vec::new();
     //We store the vector length
-    bytes.extend(u64::try_from(input.len())?.to_le_bytes().to_vec());
+    bytes.extend(input.len().to_le_bytes().to_vec());
+
     bytes.extend(input);
 
     Ok(bytes)
 }
 
 pub fn vec_u8_to_bytes_be(input: Vec<u8>) -> Result<Vec<u8>> {
+    let mut bytes: Vec<u8> = Vec::new();
     //We store the vector length
-    let mut bytes: Vec<u8> = u64::try_from(input.len())?.to_be_bytes().to_vec();
+    bytes.extend(input.len().to_be_bytes().to_vec());
+
     bytes.extend(input);
 
     Ok(bytes)
@@ -112,7 +117,7 @@ pub fn vec_u8_to_bytes_be(input: Vec<u8>) -> Result<Vec<u8>> {
 pub fn bytes_le_to_vec_u8(input: &[u8]) -> Result<(Vec<u8>, usize)> {
     let mut read: usize = 0;
 
-    let len = u64::from_le_bytes(input[0..8].try_into()?) as usize;
+    let len = usize::from_le_bytes(input[0..8].try_into()?);
     read += 8;
 
     let res = input[8..8 + len].to_vec();
@@ -124,7 +129,7 @@ pub fn bytes_le_to_vec_u8(input: &[u8]) -> Result<(Vec<u8>, usize)> {
 pub fn bytes_be_to_vec_u8(input: &[u8]) -> Result<(Vec<u8>, usize)> {
     let mut read: usize = 0;
 
-    let len = u64::from_be_bytes(input[0..8].try_into()?) as usize;
+    let len = usize::from_be_bytes(input[0..8].try_into()?);
     read += 8;
 
     let res = input[8..8 + len].to_vec();
@@ -138,7 +143,7 @@ pub fn bytes_le_to_vec_fr(input: &[u8]) -> Result<(Vec<Fr>, usize)> {
     let mut read: usize = 0;
     let mut res: Vec<Fr> = Vec::new();
 
-    let len = u64::from_le_bytes(input[0..8].try_into()?) as usize;
+    let len = usize::from_le_bytes(input[0..8].try_into()?);
     read += 8;
 
     let el_size = fr_byte_size();
@@ -155,7 +160,7 @@ pub fn bytes_be_to_vec_fr(input: &[u8]) -> Result<(Vec<Fr>, usize)> {
     let mut read: usize = 0;
     let mut res: Vec<Fr> = Vec::new();
 
-    let len = u64::from_be_bytes(input[0..8].try_into()?) as usize;
+    let len = usize::from_be_bytes(input[0..8].try_into()?);
     read += 8;
 
     let el_size = fr_byte_size();
@@ -168,6 +173,12 @@ pub fn bytes_be_to_vec_fr(input: &[u8]) -> Result<(Vec<Fr>, usize)> {
     Ok((res, read))
 }
 
+pub fn normalize_usize(input: usize) -> Vec<u8> {
+    let mut normalized_usize = input.to_le_bytes().to_vec();
+    normalized_usize.resize(8, 0);
+    normalized_usize
+}
+
 /* Old conversion utilities between different libraries data types
 
 // Conversion Utilities between poseidon-rs Field and arkworks Fr (in order to call directly poseidon-rs' poseidon_hash)
diff --git a/rln/tests/ffi.rs b/rln/tests/ffi.rs
index fc09edf..ad516ec 100644
--- a/rln/tests/ffi.rs
+++ b/rln/tests/ffi.rs
@@ -609,12 +609,11 @@ mod test {
         let success = set_next_leaf(rln_pointer, input_buffer);
         assert!(success, "set next leaf call failed");
 
-        let identity_index: u64 = no_of_leaves;
+        let identity_index: usize = no_of_leaves;
 
         // We generate a random signal
         let mut rng = rand::thread_rng();
         let signal: [u8; 32] = rng.gen();
-        let signal_len = u64::try_from(signal.len()).unwrap();
 
         // We generate a random epoch
         let epoch = hash_to_field(b"test-epoch");
@@ -623,9 +622,9 @@ mod test {
         // input_data is [ identity_secret<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]
         let mut serialized: Vec<u8> = Vec::new();
         serialized.append(&mut fr_to_bytes_le(&identity_secret_hash));
-        serialized.append(&mut identity_index.to_le_bytes().to_vec());
+        serialized.append(&mut normalize_usize(identity_index));
         serialized.append(&mut fr_to_bytes_le(&epoch));
-        serialized.append(&mut signal_len.to_le_bytes().to_vec());
+        serialized.append(&mut normalize_usize(signal.len()));
         serialized.append(&mut signal.to_vec());
 
         // We call generate_rln_proof
@@ -640,7 +639,7 @@ mod test {
         // We prepare input for verify_rln_proof API
         // input_data is [ proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> | signal_len<8> | signal<var> ]
         // that is [ proof_data | signal_len<8> | signal<var> ]
-        proof_data.append(&mut signal_len.to_le_bytes().to_vec());
+        proof_data.append(&mut normalize_usize(signal.len()));
         proof_data.append(&mut signal.to_vec());
 
         // We call verify_rln_proof
@@ -694,12 +693,11 @@ mod test {
         let success = set_next_leaf(rln_pointer, input_buffer);
         assert!(success, "set next leaf call failed");
 
-        let identity_index: u64 = no_of_leaves;
+        let identity_index: usize = no_of_leaves;
 
         // We generate a random signal
         let mut rng = rand::thread_rng();
         let signal: [u8; 32] = rng.gen();
-        let signal_len = u64::try_from(signal.len()).unwrap();
 
         // We generate a random epoch
         let epoch = hash_to_field(b"test-epoch");
@@ -708,9 +706,9 @@ mod test {
         // input_data is [ identity_secret<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]
         let mut serialized: Vec<u8> = Vec::new();
         serialized.append(&mut fr_to_bytes_le(&identity_secret_hash));
-        serialized.append(&mut identity_index.to_le_bytes().to_vec());
+        serialized.append(&mut normalize_usize(identity_index));
         serialized.append(&mut fr_to_bytes_le(&epoch));
-        serialized.append(&mut signal_len.to_le_bytes().to_vec());
+        serialized.append(&mut normalize_usize(signal.len()));
         serialized.append(&mut signal.to_vec());
 
         // We call generate_rln_proof
@@ -725,7 +723,7 @@ mod test {
         // We prepare input for verify_rln_proof API
         // input_data is [ proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> | signal_len<8> | signal<var> ]
         // that is [ proof_data | signal_len<8> | signal<var> ]
-        proof_data.append(&mut signal_len.to_le_bytes().to_vec());
+        proof_data.append(&mut normalize_usize(signal.len()));
         proof_data.append(&mut signal.to_vec());
 
         // We test verify_with_roots
@@ -807,18 +805,16 @@ mod test {
         let success = set_next_leaf(rln_pointer, input_buffer);
         assert!(success, "set next leaf call failed");
 
-        let identity_index: u64 = 0;
+        let identity_index: usize = 0;
 
         // We generate two proofs using same epoch but different signals.
 
         // We generate two random signals
         let mut rng = rand::thread_rng();
         let signal1: [u8; 32] = rng.gen();
-        let signal1_len = u64::try_from(signal1.len()).unwrap();
 
         // We generate two random signals
         let signal2: [u8; 32] = rng.gen();
-        let signal2_len = u64::try_from(signal2.len()).unwrap();
 
         // We generate a random epoch
         let epoch = hash_to_field(b"test-epoch");
@@ -827,18 +823,18 @@ mod test {
         // input_data is [ identity_secret<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]
         let mut serialized1: Vec<u8> = Vec::new();
         serialized1.append(&mut fr_to_bytes_le(&identity_secret_hash));
-        serialized1.append(&mut identity_index.to_le_bytes().to_vec());
+        serialized1.append(&mut normalize_usize(identity_index));
         serialized1.append(&mut fr_to_bytes_le(&epoch));
 
         // The first part is the same for both proof input, so we clone
         let mut serialized2 = serialized1.clone();
 
         // We attach the first signal to the first proof input
-        serialized1.append(&mut signal1_len.to_le_bytes().to_vec());
+        serialized1.append(&mut normalize_usize(signal1.len()));
         serialized1.append(&mut signal1.to_vec());
 
         // We attach the second signal to the first proof input
-        serialized2.append(&mut signal2_len.to_le_bytes().to_vec());
+        serialized2.append(&mut normalize_usize(signal2.len()));
         serialized2.append(&mut signal2.to_vec());
 
         // We call generate_rln_proof for first proof values
@@ -897,20 +893,19 @@ mod test {
         let success = set_next_leaf(rln_pointer, input_buffer);
         assert!(success, "set next leaf call failed");
 
-        let identity_index_new: u64 = 1;
+        let identity_index_new: usize = 1;
 
         // We generate a random signals
         let signal3: [u8; 32] = rng.gen();
-        let signal3_len = u64::try_from(signal3.len()).unwrap();
 
         // We prepare input for generate_rln_proof API
         // input_data is [ identity_secret<32> | id_index<8> | epoch<32> | signal_len<8> | signal<var> ]
         // Note that epoch is the same as before
         let mut serialized: Vec<u8> = Vec::new();
         serialized.append(&mut fr_to_bytes_le(&identity_secret_hash_new));
-        serialized.append(&mut identity_index_new.to_le_bytes().to_vec());
+        serialized.append(&mut normalize_usize(identity_index_new));
         serialized.append(&mut fr_to_bytes_le(&epoch));
-        serialized.append(&mut signal3_len.to_le_bytes().to_vec());
+        serialized.append(&mut normalize_usize(signal3.len()));
         serialized.append(&mut signal3.to_vec());
 
         // We call generate_rln_proof