change: Replace u64 for usize for length vars (#94)

* change: Replace `u64` for `usize` for length vars

Resolves: #39

* fix(rln): usize instead of u64 in tests

* fix(rln): linter

* fix: outlier u64 usage

* fix(rln|rln-wasm): serde of usize types

---------

Co-authored-by: Aaryamann Challani <43716372+rymnc@users.noreply.github.com>

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[..]);
 

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
 }
 
 ///////////////////////////////////////////////////////

rln/src/public.rs

@@ -500,18 +500,16 @@ 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");
     ///
     /// // We prepare input for generate_rln_proof API
     /// // 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