diff --git a/Cargo.lock b/Cargo.lock index 859342e..0ccdaed 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3596,6 +3596,7 @@ dependencies = [ "color-eyre", "criterion 0.4.0", "hex-literal", + "lazy_static 1.4.0", "num-bigint", "num-traits", "pmtree", diff --git a/rln/Cargo.toml b/rln/Cargo.toml index da97360..cae108b 100644 --- a/rln/Cargo.toml +++ b/rln/Cargo.toml @@ -87,3 +87,7 @@ harness = false [[bench]] name = "circuit_loading_benchmark" harness = false + +[[bench]] +name = "poseidon_tree_benchmark" +harness = false diff --git a/rln/benches/poseidon_tree_benchmark.rs b/rln/benches/poseidon_tree_benchmark.rs new file mode 100644 index 0000000..5d9421e --- /dev/null +++ b/rln/benches/poseidon_tree_benchmark.rs @@ -0,0 +1,79 @@ +use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion}; +use rln::{ + circuit::{Fr, TEST_TREE_HEIGHT}, + hashers::PoseidonHash, +}; +use utils::{FullMerkleTree, OptimalMerkleTree, ZerokitMerkleTree}; + +pub fn get_leaves(n: u32) -> Vec { + (0..n).map(|s| Fr::from(s)).collect() +} + +pub fn optimal_merkle_tree_poseidon_benchmark(c: &mut Criterion) { + c.bench_function("OptimalMerkleTree::::full_height_gen", |b| { + b.iter(|| { + OptimalMerkleTree::::default(TEST_TREE_HEIGHT).unwrap(); + }) + }); + + let mut group = c.benchmark_group("Set"); + for &n in [1u32, 10, 100].iter() { + let leaves = get_leaves(n); + + let mut tree = OptimalMerkleTree::::default(TEST_TREE_HEIGHT).unwrap(); + group.bench_function( + BenchmarkId::new("OptimalMerkleTree::::set", n), + |b| { + b.iter(|| { + for (i, l) in leaves.iter().enumerate() { + let _ = tree.set(i, *l); + } + }) + }, + ); + + group.bench_function( + BenchmarkId::new("OptimalMerkleTree::::set_range", n), + |b| b.iter(|| tree.set_range(0, leaves.iter().cloned())), + ); + } + group.finish(); +} + +pub fn full_merkle_tree_poseidon_benchmark(c: &mut Criterion) { + c.bench_function("FullMerkleTree::::full_height_gen", |b| { + b.iter(|| { + FullMerkleTree::::default(TEST_TREE_HEIGHT).unwrap(); + }) + }); + + let mut group = c.benchmark_group("Set"); + for &n in [1u32, 10, 100].iter() { + let leaves = get_leaves(n); + + let mut tree = FullMerkleTree::::default(TEST_TREE_HEIGHT).unwrap(); + group.bench_function( + BenchmarkId::new("FullMerkleTree::::set", n), + |b| { + b.iter(|| { + for (i, l) in leaves.iter().enumerate() { + let _ = tree.set(i, *l); + } + }) + }, + ); + + group.bench_function( + BenchmarkId::new("FullMerkleTree::::set_range", n), + |b| b.iter(|| tree.set_range(0, leaves.iter().cloned())), + ); + } + group.finish(); +} + +criterion_group!( + benches, + optimal_merkle_tree_poseidon_benchmark, + full_merkle_tree_poseidon_benchmark +); +criterion_main!(benches); diff --git a/rln/tests/ffi.rs b/rln/tests/ffi.rs index 6db75dd..63e6e11 100644 --- a/rln/tests/ffi.rs +++ b/rln/tests/ffi.rs @@ -14,26 +14,67 @@ mod test { use std::mem::MaybeUninit; use std::time::{Duration, Instant}; + const NO_OF_LEAVES: usize = 256; + + fn create_rln_instance() -> &'static mut RLN<'static> { + let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit(); + let input_config = json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string(); + let input_buffer = &Buffer::from(input_config.as_bytes()); + let success = new(TEST_TREE_HEIGHT, input_buffer, rln_pointer.as_mut_ptr()); + assert!(success, "RLN object creation failed"); + unsafe { &mut *rln_pointer.assume_init() } + } + + fn set_leaves_init(rln_pointer: &mut RLN, leaves: &[Fr]) { + let leaves_ser = vec_fr_to_bytes_le(&leaves).unwrap(); + let input_buffer = &Buffer::from(leaves_ser.as_ref()); + let success = init_tree_with_leaves(rln_pointer, input_buffer); + assert!(success, "init tree with leaves call failed"); + assert_eq!(rln_pointer.leaves_set(), leaves.len()); + } + + fn get_random_leaves() -> Vec { + let mut rng = thread_rng(); + (0..NO_OF_LEAVES).map(|_| Fr::rand(&mut rng)).collect() + } + + fn get_tree_root(rln_pointer: &mut RLN) -> Fr { + let mut output_buffer = MaybeUninit::::uninit(); + let success = get_root(rln_pointer, output_buffer.as_mut_ptr()); + assert!(success, "get root call failed"); + let output_buffer = unsafe { output_buffer.assume_init() }; + let result_data = <&[u8]>::from(&output_buffer).to_vec(); + let (root, _) = bytes_le_to_fr(&result_data); + root + } + + fn identity_pair_gen(rln_pointer: &mut RLN) -> (Fr, Fr) { + let mut output_buffer = MaybeUninit::::uninit(); + let success = key_gen(rln_pointer, output_buffer.as_mut_ptr()); + assert!(success, "key gen call failed"); + let output_buffer = unsafe { output_buffer.assume_init() }; + let result_data = <&[u8]>::from(&output_buffer).to_vec(); + let (identity_secret_hash, read) = bytes_le_to_fr(&result_data); + let (id_commitment, _) = bytes_le_to_fr(&result_data[read..].to_vec()); + (identity_secret_hash, id_commitment) + } + + fn rln_proof_gen(rln_pointer: &mut RLN, serialized: &[u8]) -> Vec { + let input_buffer = &Buffer::from(serialized); + let mut output_buffer = MaybeUninit::::uninit(); + let success = generate_rln_proof(rln_pointer, input_buffer, output_buffer.as_mut_ptr()); + assert!(success, "generate rln proof call failed"); + let output_buffer = unsafe { output_buffer.assume_init() }; + <&[u8]>::from(&output_buffer).to_vec() + } + #[test] // We test merkle batch Merkle tree additions fn test_merkle_operations_ffi() { - let tree_height = TEST_TREE_HEIGHT; - let no_of_leaves = 256; - // We generate a vector of random leaves - let mut leaves: Vec = Vec::new(); - let mut rng = thread_rng(); - for _ in 0..no_of_leaves { - leaves.push(Fr::rand(&mut rng)); - } - + let leaves = get_random_leaves(); // We create a RLN instance - let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit(); - let input_config = json!({ "resource_folder": TEST_RESOURCES_FOLDER }).to_string(); - let input_buffer = &Buffer::from(input_config.as_bytes()); - let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr()); - assert!(success, "RLN object creation failed"); - let rln_pointer = unsafe { &mut *rln_pointer.assume_init() }; + let rln_pointer = create_rln_instance(); // We first add leaves one by one specifying the index for (i, leaf) in leaves.iter().enumerate() { @@ -45,15 +86,10 @@ mod test { } // We get the root of the tree obtained adding one leaf per time - let mut output_buffer = MaybeUninit::::uninit(); - let success = get_root(rln_pointer, output_buffer.as_mut_ptr()); - assert!(success, "get root call failed"); - let output_buffer = unsafe { output_buffer.assume_init() }; - let result_data = <&[u8]>::from(&output_buffer).to_vec(); - let (root_single, _) = bytes_le_to_fr(&result_data); + let root_single = get_tree_root(rln_pointer); // We reset the tree to default - let success = set_tree(rln_pointer, tree_height); + let success = set_tree(rln_pointer, TEST_TREE_HEIGHT); assert!(success, "set tree call failed"); // We add leaves one by one using the internal index (new leaves goes in next available position) @@ -65,63 +101,40 @@ mod test { } // We get the root of the tree obtained adding leaves using the internal index - let mut output_buffer = MaybeUninit::::uninit(); - let success = get_root(rln_pointer, output_buffer.as_mut_ptr()); - assert!(success, "get root call failed"); - let output_buffer = unsafe { output_buffer.assume_init() }; - let result_data = <&[u8]>::from(&output_buffer).to_vec(); - let (root_next, _) = bytes_le_to_fr(&result_data); + let root_next = get_tree_root(rln_pointer); // We check if roots are the same assert_eq!(root_single, root_next); // We reset the tree to default - let success = set_tree(rln_pointer, tree_height); + let success = set_tree(rln_pointer, TEST_TREE_HEIGHT); assert!(success, "set tree call failed"); // We add leaves in a batch into the tree - let leaves_ser = vec_fr_to_bytes_le(&leaves).unwrap(); - let input_buffer = &Buffer::from(leaves_ser.as_ref()); - let success = init_tree_with_leaves(rln_pointer, input_buffer); - assert!(success, "init tree with leaves call failed"); + set_leaves_init(rln_pointer, &leaves); // We get the root of the tree obtained adding leaves in batch - let mut output_buffer = MaybeUninit::::uninit(); - let success = get_root(rln_pointer, output_buffer.as_mut_ptr()); - assert!(success, "get root call failed"); - let output_buffer = unsafe { output_buffer.assume_init() }; - let result_data = <&[u8]>::from(&output_buffer).to_vec(); - let (root_batch, _) = bytes_le_to_fr(&result_data); + let root_batch = get_tree_root(rln_pointer); // We check if roots are the same assert_eq!(root_single, root_batch); // We now delete all leaves set and check if the root corresponds to the empty tree root // delete calls over indexes higher than no_of_leaves are ignored and will not increase self.tree.next_index - for i in 0..no_of_leaves { + for i in 0..NO_OF_LEAVES { let success = delete_leaf(rln_pointer, i); assert!(success, "delete leaf call failed"); } // We get the root of the tree obtained deleting all leaves - let mut output_buffer = MaybeUninit::::uninit(); - let success = get_root(rln_pointer, output_buffer.as_mut_ptr()); - assert!(success, "get root call failed"); - let output_buffer = unsafe { output_buffer.assume_init() }; - let result_data = <&[u8]>::from(&output_buffer).to_vec(); - let (root_delete, _) = bytes_le_to_fr(&result_data); + let root_delete = get_tree_root(rln_pointer); // We reset the tree to default - let success = set_tree(rln_pointer, tree_height); + let success = set_tree(rln_pointer, TEST_TREE_HEIGHT); assert!(success, "set tree call failed"); // We get the root of the empty tree - let mut output_buffer = MaybeUninit::::uninit(); - let success = get_root(rln_pointer, output_buffer.as_mut_ptr()); - assert!(success, "get root call failed"); - let output_buffer = unsafe { output_buffer.assume_init() }; - let result_data = <&[u8]>::from(&output_buffer).to_vec(); - let (root_empty, _) = bytes_le_to_fr(&result_data); + let root_empty = get_tree_root(rln_pointer); // We check if roots are the same assert_eq!(root_delete, root_empty); @@ -131,54 +144,28 @@ mod test { // This test is similar to the one in public.rs but it uses the RLN object as a pointer // Uses `set_leaves_from` to set leaves in a batch fn test_leaf_setting_with_index_ffi() { - // We create a new tree - let tree_height = TEST_TREE_HEIGHT; - let no_of_leaves = 256; - // We create a RLN instance - let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit(); - let input_config = json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string(); - let input_buffer = &Buffer::from(input_config.as_bytes()); - let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr()); - assert!(success, "RLN object creation failed"); - let rln_pointer = unsafe { &mut *rln_pointer.assume_init() }; - + let rln_pointer = create_rln_instance(); assert_eq!(rln_pointer.leaves_set(), 0); // We generate a vector of random leaves - let mut leaves: Vec = Vec::new(); - let mut rng = thread_rng(); - for _ in 0..no_of_leaves { - leaves.push(Fr::rand(&mut rng)); - } + let leaves = get_random_leaves(); // set_index is the index from which we start setting leaves // random number between 0..no_of_leaves - let set_index = rng.gen_range(0..no_of_leaves) as usize; + let mut rng = thread_rng(); + let set_index = rng.gen_range(0..NO_OF_LEAVES) as usize; // We add leaves in a batch into the tree - let leaves_ser = vec_fr_to_bytes_le(&leaves).unwrap(); - let input_buffer = &Buffer::from(leaves_ser.as_ref()); - let success = init_tree_with_leaves(rln_pointer, input_buffer); - assert!(success, "init tree with leaves call failed"); - assert_eq!(rln_pointer.leaves_set(), no_of_leaves); + set_leaves_init(rln_pointer, &leaves); // We get the root of the tree obtained adding leaves in batch - let mut output_buffer = MaybeUninit::::uninit(); - let success = get_root(rln_pointer, output_buffer.as_mut_ptr()); - assert!(success, "get root call failed"); - - let output_buffer = unsafe { output_buffer.assume_init() }; - let result_data = <&[u8]>::from(&output_buffer).to_vec(); - let (root_batch_with_init, _) = bytes_le_to_fr(&result_data); + let root_batch_with_init = get_tree_root(rln_pointer); // `init_tree_with_leaves` resets the tree to the height it was initialized with, using `set_tree` // We add leaves in a batch starting from index 0..set_index - let leaves_m = vec_fr_to_bytes_le(&leaves[0..set_index]).unwrap(); - let buffer = &Buffer::from(leaves_m.as_ref()); - let success = init_tree_with_leaves(rln_pointer, buffer); - assert!(success, "init tree with leaves call failed"); + set_leaves_init(rln_pointer, &leaves[0..set_index]); // We add the remaining n leaves in a batch starting from index set_index let leaves_n = vec_fr_to_bytes_le(&leaves[set_index..]).unwrap(); @@ -187,18 +174,11 @@ mod test { assert!(success, "set leaves from call failed"); // We get the root of the tree obtained adding leaves in batch - let mut output_buffer = MaybeUninit::::uninit(); - let success = get_root(rln_pointer, output_buffer.as_mut_ptr()); - assert!(success, "get root call failed"); - - let output_buffer = unsafe { output_buffer.assume_init() }; - let result_data = <&[u8]>::from(&output_buffer).to_vec(); - let (root_batch_with_custom_index, _) = bytes_le_to_fr(&result_data); - + let root_batch_with_custom_index = get_tree_root(rln_pointer); assert_eq!(root_batch_with_init, root_batch_with_custom_index); // We reset the tree to default - let success = set_tree(rln_pointer, tree_height); + let success = set_tree(rln_pointer, TEST_TREE_HEIGHT); assert!(success, "set tree call failed"); // We add leaves one by one using the internal index (new leaves goes in next available position) @@ -210,55 +190,26 @@ mod test { } // We get the root of the tree obtained adding leaves using the internal index - let mut output_buffer = MaybeUninit::::uninit(); - let success = get_root(rln_pointer, output_buffer.as_mut_ptr()); - assert!(success, "get root call failed"); - - let output_buffer = unsafe { output_buffer.assume_init() }; - let result_data = <&[u8]>::from(&output_buffer).to_vec(); - let (root_single_additions, _) = bytes_le_to_fr(&result_data); - + let root_single_additions = get_tree_root(rln_pointer); assert_eq!(root_batch_with_init, root_single_additions); } #[test] // This test is similar to the one in public.rs but it uses the RLN object as a pointer fn test_atomic_operation_ffi() { - let tree_height = TEST_TREE_HEIGHT; - let no_of_leaves = 256; - - // We create a RLN instance - let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit(); - let input_config = json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string(); - let input_buffer = &Buffer::from(input_config.as_bytes()); - let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr()); - assert!(success, "RLN object creation failed"); - let rln_pointer = unsafe { &mut *rln_pointer.assume_init() }; - // We generate a vector of random leaves - let mut leaves: Vec = Vec::new(); - let mut rng = thread_rng(); - for _ in 0..no_of_leaves { - leaves.push(Fr::rand(&mut rng)); - } + let leaves = get_random_leaves(); + // We create a RLN instance + let rln_pointer = create_rln_instance(); // We add leaves in a batch into the tree - let leaves_ser = vec_fr_to_bytes_le(&leaves).unwrap(); - let input_buffer = &Buffer::from(leaves_ser.as_ref()); - let success = init_tree_with_leaves(rln_pointer, input_buffer); - assert!(success, "init tree with leaves call failed"); + set_leaves_init(rln_pointer, &leaves); // We get the root of the tree obtained adding leaves in batch - let mut output_buffer = MaybeUninit::::uninit(); - let success = get_root(rln_pointer, output_buffer.as_mut_ptr()); - assert!(success, "get root call failed"); - - let output_buffer = unsafe { output_buffer.assume_init() }; - let result_data = <&[u8]>::from(&output_buffer).to_vec(); - let (root_after_insertion, _) = bytes_le_to_fr(&result_data); + let root_after_insertion = get_tree_root(rln_pointer); let last_leaf = leaves.last().unwrap(); - let last_leaf_index = no_of_leaves - 1; + let last_leaf_index = NO_OF_LEAVES - 1; let indices = vec![last_leaf_index as u8]; let last_leaf = vec![*last_leaf]; let indices = vec_u8_to_bytes_le(&indices).unwrap(); @@ -275,48 +226,23 @@ mod test { assert!(success, "atomic operation call failed"); // We get the root of the tree obtained after a no-op - let mut output_buffer = MaybeUninit::::uninit(); - let success = get_root(rln_pointer, output_buffer.as_mut_ptr()); - assert!(success, "get root call failed"); - - let output_buffer = unsafe { output_buffer.assume_init() }; - let result_data = <&[u8]>::from(&output_buffer).to_vec(); - let (root_after_noop, _) = bytes_le_to_fr(&result_data); - + let root_after_noop = get_tree_root(rln_pointer); assert_eq!(root_after_insertion, root_after_noop); } #[test] // This test is similar to the one in public.rs but it uses the RLN object as a pointer fn test_set_leaves_bad_index_ffi() { - let tree_height = TEST_TREE_HEIGHT; - let no_of_leaves = 256; - // We generate a vector of random leaves - let mut leaves: Vec = Vec::new(); - let mut rng = thread_rng(); - for _ in 0..no_of_leaves { - leaves.push(Fr::rand(&mut rng)); - } - - let bad_index = (1 << tree_height) - rng.gen_range(0..no_of_leaves) as usize; - + let leaves = get_random_leaves(); // We create a RLN instance - let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit(); - let input_config = json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string(); - let input_buffer = &Buffer::from(input_config.as_bytes()); - let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr()); - assert!(success, "RLN object creation failed"); - let rln_pointer = unsafe { &mut *rln_pointer.assume_init() }; + let rln_pointer = create_rln_instance(); + + let mut rng = thread_rng(); + let bad_index = (1 << TEST_TREE_HEIGHT) - rng.gen_range(0..NO_OF_LEAVES) as usize; // Get root of empty tree - let mut output_buffer = MaybeUninit::::uninit(); - let success = get_root(rln_pointer, output_buffer.as_mut_ptr()); - assert!(success, "get root call failed"); - - let output_buffer = unsafe { output_buffer.assume_init() }; - let result_data = <&[u8]>::from(&output_buffer).to_vec(); - let (root_empty, _) = bytes_le_to_fr(&result_data); + let root_empty = get_tree_root(rln_pointer); // We add leaves in a batch into the tree let leaves = vec_fr_to_bytes_le(&leaves).unwrap(); @@ -325,30 +251,16 @@ mod test { assert!(!success, "set leaves from call succeeded"); // Get root of tree after attempted set - let mut output_buffer = MaybeUninit::::uninit(); - let success = get_root(rln_pointer, output_buffer.as_mut_ptr()); - assert!(success, "get root call failed"); - - let output_buffer = unsafe { output_buffer.assume_init() }; - let result_data = <&[u8]>::from(&output_buffer).to_vec(); - let (root_after_bad_set, _) = bytes_le_to_fr(&result_data); - + let root_after_bad_set = get_tree_root(rln_pointer); assert_eq!(root_empty, root_after_bad_set); } #[test] // This test is similar to the one in lib, but uses only public C API fn test_merkle_proof_ffi() { - let tree_height = TEST_TREE_HEIGHT; let leaf_index = 3; - // We create a RLN instance - let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit(); - let input_config = json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string(); - let input_buffer = &Buffer::from(input_config.as_bytes()); - let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr()); - assert!(success, "RLN object creation failed"); - let rln_pointer = unsafe { &mut *rln_pointer.assume_init() }; + let rln_pointer = create_rln_instance(); // generate identity let identity_secret_hash = hash_to_field(b"test-merkle-proof"); @@ -363,27 +275,19 @@ mod test { assert!(success, "set leaf call failed"); // We obtain the Merkle tree root - let mut output_buffer = MaybeUninit::::uninit(); - let success = get_root(rln_pointer, output_buffer.as_mut_ptr()); - assert!(success, "get root call failed"); - let output_buffer = unsafe { output_buffer.assume_init() }; - let result_data = <&[u8]>::from(&output_buffer).to_vec(); - let (root, _) = bytes_le_to_fr(&result_data); + let root = get_tree_root(rln_pointer); use ark_ff::BigInt; - - if TEST_TREE_HEIGHT == 20 { - assert_eq!( - root, - BigInt([ - 4939322235247991215, - 5110804094006647505, - 4427606543677101242, - 910933464535675827 - ]) - .into() - ); - } + assert_eq!( + root, + BigInt([ + 4939322235247991215, + 5110804094006647505, + 4427606543677101242, + 910933464535675827 + ]) + .into() + ); // We obtain the Merkle tree root let mut output_buffer = MaybeUninit::::uninit(); @@ -396,121 +300,33 @@ mod test { let (identity_path_index, _) = bytes_le_to_vec_u8(&result_data[read..].to_vec()).unwrap(); // We check correct computation of the path and indexes - let mut expected_path_elements = vec![ - str_to_fr( - "0x0000000000000000000000000000000000000000000000000000000000000000", - 16, - ) - .unwrap(), - str_to_fr( - "0x2098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864", - 16, - ) - .unwrap(), - str_to_fr( - "0x1069673dcdb12263df301a6ff584a7ec261a44cb9dc68df067a4774460b1f1e1", - 16, - ) - .unwrap(), - str_to_fr( - "0x18f43331537ee2af2e3d758d50f72106467c6eea50371dd528d57eb2b856d238", - 16, - ) - .unwrap(), - str_to_fr( - "0x07f9d837cb17b0d36320ffe93ba52345f1b728571a568265caac97559dbc952a", - 16, - ) - .unwrap(), - str_to_fr( - "0x2b94cf5e8746b3f5c9631f4c5df32907a699c58c94b2ad4d7b5cec1639183f55", - 16, - ) - .unwrap(), - str_to_fr( - "0x2dee93c5a666459646ea7d22cca9e1bcfed71e6951b953611d11dda32ea09d78", - 16, - ) - .unwrap(), - str_to_fr( - "0x078295e5a22b84e982cf601eb639597b8b0515a88cb5ac7fa8a4aabe3c87349d", - 16, - ) - .unwrap(), - str_to_fr( - "0x2fa5e5f18f6027a6501bec864564472a616b2e274a41211a444cbe3a99f3cc61", - 16, - ) - .unwrap(), - str_to_fr( - "0x0e884376d0d8fd21ecb780389e941f66e45e7acce3e228ab3e2156a614fcd747", - 16, - ) - .unwrap(), - str_to_fr( - "0x1b7201da72494f1e28717ad1a52eb469f95892f957713533de6175e5da190af2", - 16, - ) - .unwrap(), - str_to_fr( - "0x1f8d8822725e36385200c0b201249819a6e6e1e4650808b5bebc6bface7d7636", - 16, - ) - .unwrap(), - str_to_fr( - "0x2c5d82f66c914bafb9701589ba8cfcfb6162b0a12acf88a8d0879a0471b5f85a", - 16, - ) - .unwrap(), - str_to_fr( - "0x14c54148a0940bb820957f5adf3fa1134ef5c4aaa113f4646458f270e0bfbfd0", - 16, - ) - .unwrap(), - str_to_fr( - "0x190d33b12f986f961e10c0ee44d8b9af11be25588cad89d416118e4bf4ebe80c", - 16, - ) - .unwrap(), - ]; + let expected_path_elements: Vec = [ + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x2098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864", + "0x1069673dcdb12263df301a6ff584a7ec261a44cb9dc68df067a4774460b1f1e1", + "0x18f43331537ee2af2e3d758d50f72106467c6eea50371dd528d57eb2b856d238", + "0x07f9d837cb17b0d36320ffe93ba52345f1b728571a568265caac97559dbc952a", + "0x2b94cf5e8746b3f5c9631f4c5df32907a699c58c94b2ad4d7b5cec1639183f55", + "0x2dee93c5a666459646ea7d22cca9e1bcfed71e6951b953611d11dda32ea09d78", + "0x078295e5a22b84e982cf601eb639597b8b0515a88cb5ac7fa8a4aabe3c87349d", + "0x2fa5e5f18f6027a6501bec864564472a616b2e274a41211a444cbe3a99f3cc61", + "0x0e884376d0d8fd21ecb780389e941f66e45e7acce3e228ab3e2156a614fcd747", + "0x1b7201da72494f1e28717ad1a52eb469f95892f957713533de6175e5da190af2", + "0x1f8d8822725e36385200c0b201249819a6e6e1e4650808b5bebc6bface7d7636", + "0x2c5d82f66c914bafb9701589ba8cfcfb6162b0a12acf88a8d0879a0471b5f85a", + "0x14c54148a0940bb820957f5adf3fa1134ef5c4aaa113f4646458f270e0bfbfd0", + "0x190d33b12f986f961e10c0ee44d8b9af11be25588cad89d416118e4bf4ebe80c", + "0x22f98aa9ce704152ac17354914ad73ed1167ae6596af510aa5b3649325e06c92", + "0x2a7c7c9b6ce5880b9f6f228d72bf6a575a526f29c66ecceef8b753d38bba7323", + "0x2e8186e558698ec1c67af9c14d463ffc470043c9c2988b954d75dd643f36b992", + "0x0f57c5571e9a4eab49e2c8cf050dae948aef6ead647392273546249d1c1ff10f", + "0x1830ee67b5fb554ad5f63d4388800e1cfe78e310697d46e43c9ce36134f72cca", + ] + .map(|e| str_to_fr(e, 16).unwrap()) + .to_vec(); - let mut expected_identity_path_index: Vec = - vec![1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; - - if TEST_TREE_HEIGHT == 20 { - expected_path_elements.append(&mut vec![ - str_to_fr( - "0x22f98aa9ce704152ac17354914ad73ed1167ae6596af510aa5b3649325e06c92", - 16, - ) - .unwrap(), - str_to_fr( - "0x2a7c7c9b6ce5880b9f6f228d72bf6a575a526f29c66ecceef8b753d38bba7323", - 16, - ) - .unwrap(), - str_to_fr( - "0x2e8186e558698ec1c67af9c14d463ffc470043c9c2988b954d75dd643f36b992", - 16, - ) - .unwrap(), - str_to_fr( - "0x0f57c5571e9a4eab49e2c8cf050dae948aef6ead647392273546249d1c1ff10f", - 16, - ) - .unwrap(), - ]); - expected_identity_path_index.append(&mut vec![0, 0, 0, 0]); - } - - if TEST_TREE_HEIGHT == 20 { - expected_path_elements.append(&mut vec![str_to_fr( - "0x1830ee67b5fb554ad5f63d4388800e1cfe78e310697d46e43c9ce36134f72cca", - 16, - ) - .unwrap()]); - expected_identity_path_index.append(&mut vec![0]); - } + let expected_identity_path_index: Vec = + vec![1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; assert_eq!(path_elements, expected_path_elements); assert_eq!(identity_path_index, expected_identity_path_index); @@ -529,15 +345,8 @@ mod test { #[test] // Benchmarks proof generation and verification fn test_groth16_proofs_performance_ffi() { - let tree_height = TEST_TREE_HEIGHT; - // We create a RLN instance - let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit(); - let input_config = json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string(); - let input_buffer = &Buffer::from(input_config.as_bytes()); - let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr()); - assert!(success, "RLN object creation failed"); - let rln_pointer = unsafe { &mut *rln_pointer.assume_init() }; + let rln_pointer = create_rln_instance(); // We compute some benchmarks regarding proof and verify API calls // Note that circuit loading requires some initial overhead. @@ -548,7 +357,7 @@ mod test { for _ in 0..sample_size { // We generate random witness instances and relative proof values - let rln_witness = random_rln_witness(tree_height); + let rln_witness = random_rln_witness(TEST_TREE_HEIGHT); let proof_values = proof_values_from_witness(&rln_witness).unwrap(); // We prepare id_commitment and we set the leaf at provided index @@ -592,36 +401,25 @@ mod test { #[test] // Creating a RLN with raw data should generate same results as using a path to resources fn test_rln_raw_ffi() { - let tree_height = TEST_TREE_HEIGHT; - - // We create a RLN instance using a resource folder path - let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit(); - let input_config = json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string(); - let input_buffer = &Buffer::from(input_config.as_bytes()); - let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr()); - assert!(success, "RLN object creation failed"); - let rln_pointer = unsafe { &mut *rln_pointer.assume_init() }; + // We create a RLN instance + let rln_pointer = create_rln_instance(); // We obtain the root from the RLN instance - let mut output_buffer = MaybeUninit::::uninit(); - let success = get_root(rln_pointer, output_buffer.as_mut_ptr()); - assert!(success, "get root call failed"); - let output_buffer = unsafe { output_buffer.assume_init() }; - let result_data = <&[u8]>::from(&output_buffer).to_vec(); - let (root_rln_folder, _) = bytes_le_to_fr(&result_data); + let root_rln_folder = get_tree_root(rln_pointer); // Reading the raw data from the files required for instantiating a RLN instance using raw data - let circom_path = format!("./resources/tree_height_{TEST_TREE_HEIGHT}/rln.wasm"); + let circom_path = "./resources/tree_height_20/rln.wasm"; let mut circom_file = File::open(&circom_path).expect("no file found"); let metadata = std::fs::metadata(&circom_path).expect("unable to read metadata"); let mut circom_buffer = vec![0; metadata.len() as usize]; circom_file .read_exact(&mut circom_buffer) .expect("buffer overflow"); + #[cfg(feature = "arkzkey")] - let zkey_path = format!("./resources/tree_height_{TEST_TREE_HEIGHT}/rln_final.arkzkey"); + let zkey_path = "./resources/tree_height_20/rln_final.arkzkey"; #[cfg(not(feature = "arkzkey"))] - let zkey_path = format!("./resources/tree_height_{TEST_TREE_HEIGHT}/rln_final.zkey"); + let zkey_path = "./resources/tree_height_20/rln_final.zkey"; let mut zkey_file = File::open(&zkey_path).expect("no file found"); let metadata = std::fs::metadata(&zkey_path).expect("unable to read metadata"); let mut zkey_buffer = vec![0; metadata.len() as usize]; @@ -629,8 +427,7 @@ mod test { .read_exact(&mut zkey_buffer) .expect("buffer overflow"); - let vk_path = format!("./resources/tree_height_{TEST_TREE_HEIGHT}/verification_key.json"); - + let vk_path = "./resources/tree_height_20/verification_key.json"; let mut vk_file = File::open(&vk_path).expect("no file found"); let metadata = std::fs::metadata(&vk_path).expect("unable to read metadata"); let mut vk_buffer = vec![0; metadata.len() as usize]; @@ -645,7 +442,7 @@ mod test { let tree_config = "".to_string(); let tree_config_buffer = &Buffer::from(tree_config.as_bytes()); let success = new_with_params( - tree_height, + TEST_TREE_HEIGHT, circom_data, zkey_data, vk_data, @@ -656,57 +453,31 @@ mod test { let rln_pointer2 = unsafe { &mut *rln_pointer_raw_bytes.assume_init() }; // We obtain the root from the RLN instance containing raw data - let mut output_buffer = MaybeUninit::::uninit(); - let success = get_root(rln_pointer2, output_buffer.as_mut_ptr()); - assert!(success, "get root call failed"); - let output_buffer = unsafe { output_buffer.assume_init() }; - let result_data = <&[u8]>::from(&output_buffer).to_vec(); - let (root_rln_raw, _) = bytes_le_to_fr(&result_data); - // And compare that the same root was generated + let root_rln_raw = get_tree_root(rln_pointer2); assert_eq!(root_rln_folder, root_rln_raw); } #[test] // Computes and verifies an RLN ZK proof using FFI APIs fn test_rln_proof_ffi() { - let tree_height = TEST_TREE_HEIGHT; - let no_of_leaves = 256; let user_message_limit = Fr::from(100); // We generate a vector of random leaves - let mut leaves: Vec = Vec::new(); let mut rng = thread_rng(); - for _ in 0..no_of_leaves { - let id_commitment = Fr::rand(&mut rng); - let rate_commitment = utils_poseidon_hash(&[id_commitment, Fr::from(100)]); - leaves.push(rate_commitment); - } + let leaves: Vec = (0..NO_OF_LEAVES) + .map(|_| utils_poseidon_hash(&[Fr::rand(&mut rng), Fr::from(100)])) + .collect(); // We create a RLN instance - let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit(); - let input_config = json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string(); - let input_buffer = &Buffer::from(input_config.as_bytes()); - let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr()); - assert!(success, "RLN object creation failed"); - let rln_pointer = unsafe { &mut *rln_pointer.assume_init() }; + let rln_pointer = create_rln_instance(); // We add leaves in a batch into the tree - let leaves_ser = vec_fr_to_bytes_le(&leaves).unwrap(); - let input_buffer = &Buffer::from(leaves_ser.as_ref()); - let success = init_tree_with_leaves(rln_pointer, input_buffer); - assert!(success, "init tree with leaves call failed"); + set_leaves_init(rln_pointer, &leaves); // We generate a new identity pair - let mut output_buffer = MaybeUninit::::uninit(); - let success = key_gen(rln_pointer, output_buffer.as_mut_ptr()); - assert!(success, "key gen call failed"); - let output_buffer = unsafe { output_buffer.assume_init() }; - let result_data = <&[u8]>::from(&output_buffer).to_vec(); - let (identity_secret_hash, read) = bytes_le_to_fr(&result_data); - let (id_commitment, _) = bytes_le_to_fr(&result_data[read..].to_vec()); - - let identity_index: usize = no_of_leaves; + let (identity_secret_hash, id_commitment) = identity_pair_gen(rln_pointer); + let identity_index: usize = NO_OF_LEAVES; // We generate a random signal let mut rng = rand::thread_rng(); @@ -738,13 +509,8 @@ mod test { serialized.append(&mut signal.to_vec()); // We call generate_rln_proof - let input_buffer = &Buffer::from(serialized.as_ref()); - let mut output_buffer = MaybeUninit::::uninit(); - let success = generate_rln_proof(rln_pointer, input_buffer, output_buffer.as_mut_ptr()); - assert!(success, "generate rln proof call failed"); - let output_buffer = unsafe { output_buffer.assume_init() }; // result_data is [ proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> ] - let mut proof_data = <&[u8]>::from(&output_buffer).to_vec(); + let mut proof_data = rln_proof_gen(rln_pointer, serialized.as_ref()); // 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 ] @@ -765,42 +531,20 @@ mod test { // Computes and verifies an RLN ZK proof by checking proof's root against an input roots buffer fn test_verify_with_roots() { // First part similar to test_rln_proof_ffi - let tree_height = TEST_TREE_HEIGHT; - let no_of_leaves = 256; let user_message_limit = Fr::from(100); // We generate a vector of random leaves - let mut leaves: Vec = Vec::new(); - let mut rng = thread_rng(); - for _ in 0..no_of_leaves { - leaves.push(Fr::rand(&mut rng)); - } - + let leaves = get_random_leaves(); // We create a RLN instance - let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit(); - let input_config = json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string(); - let input_buffer = &Buffer::from(input_config.as_bytes()); - let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr()); - assert!(success, "RLN object creation failed"); - let rln_pointer = unsafe { &mut *rln_pointer.assume_init() }; + let rln_pointer = create_rln_instance(); // We add leaves in a batch into the tree - let leaves_ser = vec_fr_to_bytes_le(&leaves).unwrap(); - let input_buffer = &Buffer::from(leaves_ser.as_ref()); - let success = init_tree_with_leaves(rln_pointer, input_buffer); - assert!(success, "set leaves call failed"); + set_leaves_init(rln_pointer, &leaves); // We generate a new identity pair - let mut output_buffer = MaybeUninit::::uninit(); - let success = key_gen(rln_pointer, output_buffer.as_mut_ptr()); - assert!(success, "key gen call failed"); - let output_buffer = unsafe { output_buffer.assume_init() }; - let result_data = <&[u8]>::from(&output_buffer).to_vec(); - let (identity_secret_hash, read) = bytes_le_to_fr(&result_data); - let (id_commitment, _) = bytes_le_to_fr(&result_data[read..].to_vec()); + let (identity_secret_hash, id_commitment) = identity_pair_gen(rln_pointer); let rate_commitment = utils_poseidon_hash(&[id_commitment, user_message_limit]); - - let identity_index: usize = no_of_leaves; + let identity_index: usize = NO_OF_LEAVES; // We generate a random signal let mut rng = rand::thread_rng(); @@ -832,13 +576,8 @@ mod test { serialized.append(&mut signal.to_vec()); // We call generate_rln_proof - let input_buffer = &Buffer::from(serialized.as_ref()); - let mut output_buffer = MaybeUninit::::uninit(); - let success = generate_rln_proof(rln_pointer, input_buffer, output_buffer.as_mut_ptr()); - assert!(success, "generate rln proof call failed"); - let output_buffer = unsafe { output_buffer.assume_init() }; // result_data is [ proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> ] - let mut proof_data = <&[u8]>::from(&output_buffer).to_vec(); + let mut proof_data = rln_proof_gen(rln_pointer, serialized.as_ref()); // 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 ] @@ -878,12 +617,7 @@ mod test { // We finally include the correct root // We get the root of the tree obtained adding one leaf per time - let mut output_buffer = MaybeUninit::::uninit(); - let success = get_root(rln_pointer, output_buffer.as_mut_ptr()); - assert!(success, "get root call failed"); - let output_buffer = unsafe { output_buffer.assume_init() }; - let result_data = <&[u8]>::from(&output_buffer).to_vec(); - let (root, _) = bytes_le_to_fr(&result_data); + let root = get_tree_root(rln_pointer); // We include the root and verify the proof roots_data.append(&mut fr_to_bytes_le(&root)); @@ -901,24 +635,11 @@ mod test { #[test] // Computes and verifies an RLN ZK proof using FFI APIs fn test_recover_id_secret_ffi() { - let tree_height = TEST_TREE_HEIGHT; - // We create a RLN instance - let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit(); - let input_config = json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string(); - let input_buffer = &Buffer::from(input_config.as_bytes()); - let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr()); - assert!(success, "RLN object creation failed"); - let rln_pointer = unsafe { &mut *rln_pointer.assume_init() }; + let rln_pointer = create_rln_instance(); // We generate a new identity pair - let mut output_buffer = MaybeUninit::::uninit(); - let success = key_gen(rln_pointer, output_buffer.as_mut_ptr()); - assert!(success, "key gen call failed"); - let output_buffer = unsafe { output_buffer.assume_init() }; - let result_data = <&[u8]>::from(&output_buffer).to_vec(); - let (identity_secret_hash, read) = bytes_le_to_fr(&result_data); - let (id_commitment, _) = bytes_le_to_fr(&result_data[read..].to_vec()); + let (identity_secret_hash, id_commitment) = identity_pair_gen(rln_pointer); let user_message_limit = Fr::from(100); let message_id = Fr::from(0); @@ -967,22 +688,12 @@ mod test { serialized2.append(&mut signal2.to_vec()); // We call generate_rln_proof for first proof values - let input_buffer = &Buffer::from(serialized1.as_ref()); - let mut output_buffer = MaybeUninit::::uninit(); - let success = generate_rln_proof(rln_pointer, input_buffer, output_buffer.as_mut_ptr()); - assert!(success, "generate rln proof call failed"); - let output_buffer = unsafe { output_buffer.assume_init() }; // result_data is [ proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> ] - let proof_data_1 = <&[u8]>::from(&output_buffer).to_vec(); + let proof_data_1 = rln_proof_gen(rln_pointer, serialized1.as_ref()); // We call generate_rln_proof - let input_buffer = &Buffer::from(serialized2.as_ref()); - let mut output_buffer = MaybeUninit::::uninit(); - let success = generate_rln_proof(rln_pointer, input_buffer, output_buffer.as_mut_ptr()); - assert!(success, "generate rln proof call failed"); - let output_buffer = unsafe { output_buffer.assume_init() }; // result_data is [ proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> ] - let proof_data_2 = <&[u8]>::from(&output_buffer).to_vec(); + let proof_data_2 = rln_proof_gen(rln_pointer, serialized2.as_ref()); let input_proof_buffer_1 = &Buffer::from(proof_data_1.as_ref()); let input_proof_buffer_2 = &Buffer::from(proof_data_2.as_ref()); @@ -1008,13 +719,7 @@ mod test { // We now test that computing identity_secret_hash is unsuccessful if shares computed from two different identity secret hashes but within same epoch are passed // We generate a new identity pair - let mut output_buffer = MaybeUninit::::uninit(); - let success = key_gen(rln_pointer, output_buffer.as_mut_ptr()); - assert!(success, "key gen call failed"); - let output_buffer = unsafe { output_buffer.assume_init() }; - let result_data = <&[u8]>::from(&output_buffer).to_vec(); - let (identity_secret_hash_new, read) = bytes_le_to_fr(&result_data); - let (id_commitment_new, _) = bytes_le_to_fr(&result_data[read..].to_vec()); + let (identity_secret_hash_new, id_commitment_new) = identity_pair_gen(rln_pointer); let rate_commitment_new = utils_poseidon_hash(&[id_commitment_new, user_message_limit]); // We set as leaf id_commitment, its index would be equal to 1 since at 0 there is id_commitment @@ -1041,13 +746,8 @@ mod test { serialized.append(&mut signal3.to_vec()); // We call generate_rln_proof - let input_buffer = &Buffer::from(serialized.as_ref()); - let mut output_buffer = MaybeUninit::::uninit(); - let success = generate_rln_proof(rln_pointer, input_buffer, output_buffer.as_mut_ptr()); - assert!(success, "generate rln proof call failed"); - let output_buffer = unsafe { output_buffer.assume_init() }; // result_data is [ proof<128> | share_y<32> | nullifier<32> | root<32> | epoch<32> | share_x<32> | rln_identifier<32> ] - let proof_data_3 = <&[u8]>::from(&output_buffer).to_vec(); + let proof_data_3 = rln_proof_gen(rln_pointer, serialized.as_ref()); // We attempt to recover the secret using share1 (coming from identity_secret_hash) and share3 (coming from identity_secret_hash_new) @@ -1074,15 +774,8 @@ mod test { #[test] // Tests hash to field using FFI APIs fn test_seeded_keygen_ffi() { - let tree_height = TEST_TREE_HEIGHT; - // We create a RLN instance - let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit(); - let input_config = json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string(); - let input_buffer = &Buffer::from(input_config.as_bytes()); - let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr()); - assert!(success, "RLN object creation failed"); - let rln_pointer = unsafe { &mut *rln_pointer.assume_init() }; + let rln_pointer = create_rln_instance(); // We generate a new identity pair from an input seed let seed_bytes: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; @@ -1115,14 +808,8 @@ mod test { #[test] // Tests hash to field using FFI APIs fn test_seeded_extended_keygen_ffi() { - let tree_height = TEST_TREE_HEIGHT; // We create a RLN instance - let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit(); - let input_config = json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string(); - let input_buffer = &Buffer::from(input_config.as_bytes()); - let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr()); - assert!(success, "RLN object creation failed"); - let rln_pointer = unsafe { &mut *rln_pointer.assume_init() }; + let rln_pointer = create_rln_instance(); // We generate a new identity tuple from an input seed let seed_bytes: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; @@ -1220,15 +907,10 @@ mod test { #[test] fn test_get_leaf() { // We create a RLN instance - let tree_height = TEST_TREE_HEIGHT; let no_of_leaves = 1 << TEST_TREE_HEIGHT; - let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit(); - let input_config = json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string(); - let input_buffer = &Buffer::from(input_config.as_bytes()); - let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr()); - assert!(success, "RLN object creation failed"); - let rln_pointer = unsafe { &mut *rln_pointer.assume_init() }; + // We create a RLN instance + let rln_pointer = create_rln_instance(); // We generate a new identity tuple from an input seed let seed_bytes: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; @@ -1265,14 +947,7 @@ mod test { #[test] fn test_valid_metadata() { // We create a RLN instance - let tree_height = TEST_TREE_HEIGHT; - - let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit(); - let input_config = json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string(); - let input_buffer = &Buffer::from(input_config.as_bytes()); - let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr()); - assert!(success, "RLN object creation failed"); - let rln_pointer = unsafe { &mut *rln_pointer.assume_init() }; + let rln_pointer = create_rln_instance(); let seed_bytes: &[u8] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; let input_buffer = &Buffer::from(seed_bytes); @@ -1293,21 +968,13 @@ mod test { #[test] fn test_empty_metadata() { // We create a RLN instance - let tree_height = TEST_TREE_HEIGHT; - - let mut rln_pointer = MaybeUninit::<*mut RLN>::uninit(); - let input_config = json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string(); - let input_buffer = &Buffer::from(input_config.as_bytes()); - let success = new(tree_height, input_buffer, rln_pointer.as_mut_ptr()); - assert!(success, "RLN object creation failed"); - let rln_pointer = unsafe { &mut *rln_pointer.assume_init() }; + let rln_pointer = create_rln_instance(); let mut output_buffer = MaybeUninit::::uninit(); let success = get_metadata(rln_pointer, output_buffer.as_mut_ptr()); assert!(success, "get_metadata call failed"); let output_buffer = unsafe { output_buffer.assume_init() }; - assert_eq!(output_buffer.len, 0); } } diff --git a/rln/tests/poseidon_tree.rs b/rln/tests/poseidon_tree.rs index f4b972f..c6bb5d9 100644 --- a/rln/tests/poseidon_tree.rs +++ b/rln/tests/poseidon_tree.rs @@ -9,43 +9,20 @@ mod test { use utils::{FullMerkleTree, OptimalMerkleTree, ZerokitMerkleProof, ZerokitMerkleTree}; #[test] - /// A basic performance comparison between the two supported Merkle Tree implementations - fn test_zerokit_merkle_implementations_performances() { - use std::time::{Duration, Instant}; - - let tree_height = 20; + /// The test is checked correctness for `FullMerkleTree` and `OptimalMerkleTree` with Poseidon hash + fn test_zerokit_merkle_implementations() { let sample_size = 100; - let leaves: Vec = (0..sample_size).map(|s| Fr::from(s)).collect(); - let mut gen_time_full: u128 = 0; - let mut upd_time_full: u128 = 0; - let mut gen_time_opt: u128 = 0; - let mut upd_time_opt: u128 = 0; - - for _ in 0..sample_size.try_into().unwrap() { - let now = Instant::now(); - FullMerkleTree::::default(tree_height).unwrap(); - gen_time_full += now.elapsed().as_nanos(); - - let now = Instant::now(); - OptimalMerkleTree::::default(tree_height).unwrap(); - gen_time_opt += now.elapsed().as_nanos(); - } - - let mut tree_full = FullMerkleTree::::default(tree_height).unwrap(); - let mut tree_opt = OptimalMerkleTree::::default(tree_height).unwrap(); + let mut tree_full = FullMerkleTree::::default(TEST_TREE_HEIGHT).unwrap(); + let mut tree_opt = OptimalMerkleTree::::default(TEST_TREE_HEIGHT).unwrap(); for i in 0..sample_size.try_into().unwrap() { - let now = Instant::now(); tree_full.set(i, leaves[i]).unwrap(); - upd_time_full += now.elapsed().as_nanos(); let proof = tree_full.proof(i).expect("index should be set"); assert_eq!(proof.leaf_index(), i); - let now = Instant::now(); tree_opt.set(i, leaves[i]).unwrap(); - upd_time_opt += now.elapsed().as_nanos(); let proof = tree_opt.proof(i).expect("index should be set"); assert_eq!(proof.leaf_index(), i); } @@ -55,26 +32,5 @@ mod test { let tree_opt_root = tree_opt.root(); assert_eq!(tree_full_root, tree_opt_root); - - println!(" Average tree generation time:"); - println!( - " - Full Merkle Tree: {:?}", - Duration::from_nanos((gen_time_full / sample_size).try_into().unwrap()) - ); - println!( - " - Optimal Merkle Tree: {:?}", - Duration::from_nanos((gen_time_opt / sample_size).try_into().unwrap()) - ); - - println!(" Average update_next execution time:"); - println!( - " - Full Merkle Tree: {:?}", - Duration::from_nanos((upd_time_full / sample_size).try_into().unwrap()) - ); - - println!( - " - Optimal Merkle Tree: {:?}", - Duration::from_nanos((upd_time_opt / sample_size).try_into().unwrap()) - ); } } diff --git a/rln/tests/protocol.rs b/rln/tests/protocol.rs index 3d540f0..165e22c 100644 --- a/rln/tests/protocol.rs +++ b/rln/tests/protocol.rs @@ -71,7 +71,6 @@ mod test { #[test] // We test Merkle tree generation, proofs and verification fn test_merkle_proof() { - let tree_height = TEST_TREE_HEIGHT; let leaf_index = 3; // generate identity @@ -82,7 +81,7 @@ mod test { // generate merkle tree let default_leaf = Fr::from(0); let mut tree = PoseidonTree::new( - tree_height, + TEST_TREE_HEIGHT, default_leaf, ConfigOf::::default(), ) @@ -92,141 +91,49 @@ mod test { // We check correct computation of the root let root = tree.root(); - if TEST_TREE_HEIGHT == 20 { - assert_eq!( - root, - BigInt([ - 4939322235247991215, - 5110804094006647505, - 4427606543677101242, - 910933464535675827 - ]) - .into() - ); - } + assert_eq!( + root, + BigInt([ + 4939322235247991215, + 5110804094006647505, + 4427606543677101242, + 910933464535675827 + ]) + .into() + ); let merkle_proof = tree.proof(leaf_index).expect("proof should exist"); let path_elements = merkle_proof.get_path_elements(); let identity_path_index = merkle_proof.get_path_index(); // We check correct computation of the path and indexes - // These values refers to TEST_TREE_HEIGHT == 16 - let mut expected_path_elements = vec![ - str_to_fr( - "0x0000000000000000000000000000000000000000000000000000000000000000", - 16, - ) - .unwrap(), - str_to_fr( - "0x2098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864", - 16, - ) - .unwrap(), - str_to_fr( - "0x1069673dcdb12263df301a6ff584a7ec261a44cb9dc68df067a4774460b1f1e1", - 16, - ) - .unwrap(), - str_to_fr( - "0x18f43331537ee2af2e3d758d50f72106467c6eea50371dd528d57eb2b856d238", - 16, - ) - .unwrap(), - str_to_fr( - "0x07f9d837cb17b0d36320ffe93ba52345f1b728571a568265caac97559dbc952a", - 16, - ) - .unwrap(), - str_to_fr( - "0x2b94cf5e8746b3f5c9631f4c5df32907a699c58c94b2ad4d7b5cec1639183f55", - 16, - ) - .unwrap(), - str_to_fr( - "0x2dee93c5a666459646ea7d22cca9e1bcfed71e6951b953611d11dda32ea09d78", - 16, - ) - .unwrap(), - str_to_fr( - "0x078295e5a22b84e982cf601eb639597b8b0515a88cb5ac7fa8a4aabe3c87349d", - 16, - ) - .unwrap(), - str_to_fr( - "0x2fa5e5f18f6027a6501bec864564472a616b2e274a41211a444cbe3a99f3cc61", - 16, - ) - .unwrap(), - str_to_fr( - "0x0e884376d0d8fd21ecb780389e941f66e45e7acce3e228ab3e2156a614fcd747", - 16, - ) - .unwrap(), - str_to_fr( - "0x1b7201da72494f1e28717ad1a52eb469f95892f957713533de6175e5da190af2", - 16, - ) - .unwrap(), - str_to_fr( - "0x1f8d8822725e36385200c0b201249819a6e6e1e4650808b5bebc6bface7d7636", - 16, - ) - .unwrap(), - str_to_fr( - "0x2c5d82f66c914bafb9701589ba8cfcfb6162b0a12acf88a8d0879a0471b5f85a", - 16, - ) - .unwrap(), - str_to_fr( - "0x14c54148a0940bb820957f5adf3fa1134ef5c4aaa113f4646458f270e0bfbfd0", - 16, - ) - .unwrap(), - str_to_fr( - "0x190d33b12f986f961e10c0ee44d8b9af11be25588cad89d416118e4bf4ebe80c", - 16, - ) - .unwrap(), - ]; + let expected_path_elements: Vec = [ + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x2098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864", + "0x1069673dcdb12263df301a6ff584a7ec261a44cb9dc68df067a4774460b1f1e1", + "0x18f43331537ee2af2e3d758d50f72106467c6eea50371dd528d57eb2b856d238", + "0x07f9d837cb17b0d36320ffe93ba52345f1b728571a568265caac97559dbc952a", + "0x2b94cf5e8746b3f5c9631f4c5df32907a699c58c94b2ad4d7b5cec1639183f55", + "0x2dee93c5a666459646ea7d22cca9e1bcfed71e6951b953611d11dda32ea09d78", + "0x078295e5a22b84e982cf601eb639597b8b0515a88cb5ac7fa8a4aabe3c87349d", + "0x2fa5e5f18f6027a6501bec864564472a616b2e274a41211a444cbe3a99f3cc61", + "0x0e884376d0d8fd21ecb780389e941f66e45e7acce3e228ab3e2156a614fcd747", + "0x1b7201da72494f1e28717ad1a52eb469f95892f957713533de6175e5da190af2", + "0x1f8d8822725e36385200c0b201249819a6e6e1e4650808b5bebc6bface7d7636", + "0x2c5d82f66c914bafb9701589ba8cfcfb6162b0a12acf88a8d0879a0471b5f85a", + "0x14c54148a0940bb820957f5adf3fa1134ef5c4aaa113f4646458f270e0bfbfd0", + "0x190d33b12f986f961e10c0ee44d8b9af11be25588cad89d416118e4bf4ebe80c", + "0x22f98aa9ce704152ac17354914ad73ed1167ae6596af510aa5b3649325e06c92", + "0x2a7c7c9b6ce5880b9f6f228d72bf6a575a526f29c66ecceef8b753d38bba7323", + "0x2e8186e558698ec1c67af9c14d463ffc470043c9c2988b954d75dd643f36b992", + "0x0f57c5571e9a4eab49e2c8cf050dae948aef6ead647392273546249d1c1ff10f", + "0x1830ee67b5fb554ad5f63d4388800e1cfe78e310697d46e43c9ce36134f72cca", + ] + .map(|e| str_to_fr(e, 16).unwrap()) + .to_vec(); - let mut expected_identity_path_index: Vec = - vec![1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; - - // We add the remaining elements for the case TEST_TREE_HEIGHT = 20 - if TEST_TREE_HEIGHT == 20 { - expected_path_elements.append(&mut vec![ - str_to_fr( - "0x22f98aa9ce704152ac17354914ad73ed1167ae6596af510aa5b3649325e06c92", - 16, - ) - .unwrap(), - str_to_fr( - "0x2a7c7c9b6ce5880b9f6f228d72bf6a575a526f29c66ecceef8b753d38bba7323", - 16, - ) - .unwrap(), - str_to_fr( - "0x2e8186e558698ec1c67af9c14d463ffc470043c9c2988b954d75dd643f36b992", - 16, - ) - .unwrap(), - str_to_fr( - "0x0f57c5571e9a4eab49e2c8cf050dae948aef6ead647392273546249d1c1ff10f", - 16, - ) - .unwrap(), - ]); - expected_identity_path_index.append(&mut vec![0, 0, 0, 0]); - } - - if TEST_TREE_HEIGHT == 20 { - expected_path_elements.append(&mut vec![str_to_fr( - "0x1830ee67b5fb554ad5f63d4388800e1cfe78e310697d46e43c9ce36134f72cca", - 16, - ) - .unwrap()]); - expected_identity_path_index.append(&mut vec![0]); - } + let expected_identity_path_index: Vec = + vec![1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; assert_eq!(path_elements, expected_path_elements); assert_eq!(identity_path_index, expected_identity_path_index); @@ -260,7 +167,6 @@ mod test { #[test] // We test a RLN proof generation and verification fn test_end_to_end() { - let tree_height = TEST_TREE_HEIGHT; let leaf_index = 3; // Generate identity pair @@ -271,7 +177,7 @@ mod test { //// generate merkle tree let default_leaf = Fr::from(0); let mut tree = PoseidonTree::new( - tree_height, + TEST_TREE_HEIGHT, default_leaf, ConfigOf::::default(), ) diff --git a/rln/tests/public.rs b/rln/tests/public.rs index 0bcc416..f863207 100644 --- a/rln/tests/public.rs +++ b/rln/tests/public.rs @@ -14,13 +14,12 @@ mod test { #[test] // This test is similar to the one in lib, but uses only public API fn test_merkle_proof() { - let tree_height = TEST_TREE_HEIGHT; let leaf_index = 3; let user_message_limit = 1; let input_buffer = Cursor::new(json!({ "resources_folder": TEST_RESOURCES_FOLDER }).to_string()); - let mut rln = RLN::new(tree_height, input_buffer).unwrap(); + let mut rln = RLN::new(TEST_TREE_HEIGHT, input_buffer).unwrap(); // generate identity let identity_secret_hash = hash_to_field(b"test-merkle-proof"); @@ -36,17 +35,15 @@ mod test { rln.get_root(&mut buffer).unwrap(); let (root, _) = bytes_le_to_fr(&buffer.into_inner()); - if TEST_TREE_HEIGHT == 20 { - assert_eq!( - root, - Fr::from(BigInt([ - 17110646155607829651, - 5040045984242729823, - 6965416728592533086, - 2328960363755461975 - ])) - ); - } + assert_eq!( + root, + Fr::from(BigInt([ + 17110646155607829651, + 5040045984242729823, + 6965416728592533086, + 2328960363755461975 + ])) + ); // We check correct computation of merkle proof let mut buffer = Cursor::new(Vec::::new()); @@ -57,122 +54,33 @@ mod test { let (identity_path_index, _) = bytes_le_to_vec_u8(&buffer_inner[read..].to_vec()).unwrap(); // We check correct computation of the path and indexes - let mut expected_path_elements = vec![ - str_to_fr( - "0x0000000000000000000000000000000000000000000000000000000000000000", - 16, - ) - .unwrap(), - str_to_fr( - "0x2098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864", - 16, - ) - .unwrap(), - str_to_fr( - "0x1069673dcdb12263df301a6ff584a7ec261a44cb9dc68df067a4774460b1f1e1", - 16, - ) - .unwrap(), - str_to_fr( - "0x18f43331537ee2af2e3d758d50f72106467c6eea50371dd528d57eb2b856d238", - 16, - ) - .unwrap(), - str_to_fr( - "0x07f9d837cb17b0d36320ffe93ba52345f1b728571a568265caac97559dbc952a", - 16, - ) - .unwrap(), - str_to_fr( - "0x2b94cf5e8746b3f5c9631f4c5df32907a699c58c94b2ad4d7b5cec1639183f55", - 16, - ) - .unwrap(), - str_to_fr( - "0x2dee93c5a666459646ea7d22cca9e1bcfed71e6951b953611d11dda32ea09d78", - 16, - ) - .unwrap(), - str_to_fr( - "0x078295e5a22b84e982cf601eb639597b8b0515a88cb5ac7fa8a4aabe3c87349d", - 16, - ) - .unwrap(), - str_to_fr( - "0x2fa5e5f18f6027a6501bec864564472a616b2e274a41211a444cbe3a99f3cc61", - 16, - ) - .unwrap(), - str_to_fr( - "0x0e884376d0d8fd21ecb780389e941f66e45e7acce3e228ab3e2156a614fcd747", - 16, - ) - .unwrap(), - str_to_fr( - "0x1b7201da72494f1e28717ad1a52eb469f95892f957713533de6175e5da190af2", - 16, - ) - .unwrap(), - str_to_fr( - "0x1f8d8822725e36385200c0b201249819a6e6e1e4650808b5bebc6bface7d7636", - 16, - ) - .unwrap(), - str_to_fr( - "0x2c5d82f66c914bafb9701589ba8cfcfb6162b0a12acf88a8d0879a0471b5f85a", - 16, - ) - .unwrap(), - str_to_fr( - "0x14c54148a0940bb820957f5adf3fa1134ef5c4aaa113f4646458f270e0bfbfd0", - 16, - ) - .unwrap(), - str_to_fr( - "0x190d33b12f986f961e10c0ee44d8b9af11be25588cad89d416118e4bf4ebe80c", - 16, - ) - .unwrap(), - ]; + let expected_path_elements: Vec = [ + "0x0000000000000000000000000000000000000000000000000000000000000000", + "0x2098f5fb9e239eab3ceac3f27b81e481dc3124d55ffed523a839ee8446b64864", + "0x1069673dcdb12263df301a6ff584a7ec261a44cb9dc68df067a4774460b1f1e1", + "0x18f43331537ee2af2e3d758d50f72106467c6eea50371dd528d57eb2b856d238", + "0x07f9d837cb17b0d36320ffe93ba52345f1b728571a568265caac97559dbc952a", + "0x2b94cf5e8746b3f5c9631f4c5df32907a699c58c94b2ad4d7b5cec1639183f55", + "0x2dee93c5a666459646ea7d22cca9e1bcfed71e6951b953611d11dda32ea09d78", + "0x078295e5a22b84e982cf601eb639597b8b0515a88cb5ac7fa8a4aabe3c87349d", + "0x2fa5e5f18f6027a6501bec864564472a616b2e274a41211a444cbe3a99f3cc61", + "0x0e884376d0d8fd21ecb780389e941f66e45e7acce3e228ab3e2156a614fcd747", + "0x1b7201da72494f1e28717ad1a52eb469f95892f957713533de6175e5da190af2", + "0x1f8d8822725e36385200c0b201249819a6e6e1e4650808b5bebc6bface7d7636", + "0x2c5d82f66c914bafb9701589ba8cfcfb6162b0a12acf88a8d0879a0471b5f85a", + "0x14c54148a0940bb820957f5adf3fa1134ef5c4aaa113f4646458f270e0bfbfd0", + "0x190d33b12f986f961e10c0ee44d8b9af11be25588cad89d416118e4bf4ebe80c", + "0x22f98aa9ce704152ac17354914ad73ed1167ae6596af510aa5b3649325e06c92", + "0x2a7c7c9b6ce5880b9f6f228d72bf6a575a526f29c66ecceef8b753d38bba7323", + "0x2e8186e558698ec1c67af9c14d463ffc470043c9c2988b954d75dd643f36b992", + "0x0f57c5571e9a4eab49e2c8cf050dae948aef6ead647392273546249d1c1ff10f", + "0x1830ee67b5fb554ad5f63d4388800e1cfe78e310697d46e43c9ce36134f72cca", + ] + .map(|e| str_to_fr(e, 16).unwrap()) + .to_vec(); - let mut expected_identity_path_index: Vec = - vec![1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; - - // We add the remaining elements for the case TEST_TREE_HEIGHT = 20 - if TEST_TREE_HEIGHT == 20 { - expected_path_elements.append(&mut vec![ - str_to_fr( - "0x22f98aa9ce704152ac17354914ad73ed1167ae6596af510aa5b3649325e06c92", - 16, - ) - .unwrap(), - str_to_fr( - "0x2a7c7c9b6ce5880b9f6f228d72bf6a575a526f29c66ecceef8b753d38bba7323", - 16, - ) - .unwrap(), - str_to_fr( - "0x2e8186e558698ec1c67af9c14d463ffc470043c9c2988b954d75dd643f36b992", - 16, - ) - .unwrap(), - str_to_fr( - "0x0f57c5571e9a4eab49e2c8cf050dae948aef6ead647392273546249d1c1ff10f", - 16, - ) - .unwrap(), - ]); - expected_identity_path_index.append(&mut vec![0, 0, 0, 0]); - } - - if TEST_TREE_HEIGHT == 20 { - expected_path_elements.append(&mut vec![str_to_fr( - "0x1830ee67b5fb554ad5f63d4388800e1cfe78e310697d46e43c9ce36134f72cca", - 16, - ) - .unwrap()]); - expected_identity_path_index.append(&mut vec![0]); - } + let expected_identity_path_index: Vec = + vec![1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; assert_eq!(path_elements, expected_path_elements); assert_eq!(identity_path_index, expected_identity_path_index); diff --git a/utils/Cargo.toml b/utils/Cargo.toml index 1472ed0..345f981 100644 --- a/utils/Cargo.toml +++ b/utils/Cargo.toml @@ -18,6 +18,7 @@ color-eyre = "=0.6.2" pmtree = { package = "pmtree", version = "=2.0.0", optional = true} sled = "=0.34.7" serde = "=1.0.163" +lazy_static = "1.4.0" [dev-dependencies] ark-bn254 = "=0.4.0" diff --git a/utils/benches/merkle_tree_benchmark.rs b/utils/benches/merkle_tree_benchmark.rs index ef29bcf..64d81ef 100644 --- a/utils/benches/merkle_tree_benchmark.rs +++ b/utils/benches/merkle_tree_benchmark.rs @@ -1,5 +1,6 @@ use criterion::{criterion_group, criterion_main, Criterion}; use hex_literal::hex; +use lazy_static::lazy_static; use std::{fmt::Display, str::FromStr}; use tiny_keccak::{Hasher as _, Keccak}; use zerokit_utils::{ @@ -45,22 +46,24 @@ impl FromStr for TestFr { } } -pub fn optimal_merkle_tree_benchmark(c: &mut Criterion) { - let mut tree = - OptimalMerkleTree::::new(2, TestFr([0; 32]), OptimalMerkleConfig::default()) - .unwrap(); - - let leaves = [ +lazy_static! { + static ref LEAVES: [TestFr; 4] = [ hex!("0000000000000000000000000000000000000000000000000000000000000001"), hex!("0000000000000000000000000000000000000000000000000000000000000002"), hex!("0000000000000000000000000000000000000000000000000000000000000003"), hex!("0000000000000000000000000000000000000000000000000000000000000004"), ] - .map(|x| TestFr(x)); + .map(TestFr); +} + +pub fn optimal_merkle_tree_benchmark(c: &mut Criterion) { + let mut tree = + OptimalMerkleTree::::new(2, TestFr([0; 32]), OptimalMerkleConfig::default()) + .unwrap(); c.bench_function("OptimalMerkleTree::set", |b| { b.iter(|| { - tree.set(0, leaves[0]).unwrap(); + tree.set(0, LEAVES[0]).unwrap(); }) }); @@ -72,7 +75,7 @@ pub fn optimal_merkle_tree_benchmark(c: &mut Criterion) { c.bench_function("OptimalMerkleTree::override_range", |b| { b.iter(|| { - tree.override_range(0, leaves, [0, 1, 2, 3]).unwrap(); + tree.override_range(0, *LEAVES, [0, 1, 2, 3]).unwrap(); }) }); @@ -93,17 +96,9 @@ pub fn full_merkle_tree_benchmark(c: &mut Criterion) { let mut tree = FullMerkleTree::::new(2, TestFr([0; 32]), FullMerkleConfig::default()).unwrap(); - let leaves = [ - hex!("0000000000000000000000000000000000000000000000000000000000000001"), - hex!("0000000000000000000000000000000000000000000000000000000000000002"), - hex!("0000000000000000000000000000000000000000000000000000000000000003"), - hex!("0000000000000000000000000000000000000000000000000000000000000004"), - ] - .map(|x| TestFr(x)); - c.bench_function("FullMerkleTree::set", |b| { b.iter(|| { - tree.set(0, leaves[0]).unwrap(); + tree.set(0, LEAVES[0]).unwrap(); }) }); @@ -115,7 +110,7 @@ pub fn full_merkle_tree_benchmark(c: &mut Criterion) { c.bench_function("FullMerkleTree::override_range", |b| { b.iter(|| { - tree.override_range(0, leaves, [0, 1, 2, 3]).unwrap(); + tree.override_range(0, *LEAVES, [0, 1, 2, 3]).unwrap(); }) }); diff --git a/utils/tests/merkle_tree.rs b/utils/tests/merkle_tree.rs index a5eefc9..8d49186 100644 --- a/utils/tests/merkle_tree.rs +++ b/utils/tests/merkle_tree.rs @@ -1,9 +1,9 @@ // Tests adapted from https://github.com/worldcoin/semaphore-rs/blob/d462a4372f1fd9c27610f2acfe4841fab1d396aa/src/merkle_tree.rs #[cfg(test)] pub mod test { - use std::{fmt::Display, str::FromStr}; - use hex_literal::hex; + use lazy_static::lazy_static; + use std::{fmt::Display, str::FromStr}; use tiny_keccak::{Hasher as _, Keccak}; use zerokit_utils::{ FullMerkleConfig, FullMerkleTree, Hasher, OptimalMerkleConfig, OptimalMerkleTree, @@ -47,16 +47,27 @@ pub mod test { } } - #[test] - fn test_root() { - let leaves = [ + lazy_static! { + static ref LEAVES: [TestFr; 4] = [ hex!("0000000000000000000000000000000000000000000000000000000000000001"), hex!("0000000000000000000000000000000000000000000000000000000000000002"), hex!("0000000000000000000000000000000000000000000000000000000000000003"), hex!("0000000000000000000000000000000000000000000000000000000000000004"), ] - .map(|x| TestFr(x)); + .map(TestFr); + } + fn default_full_merkle_tree() -> FullMerkleTree { + FullMerkleTree::::new(2, TestFr([0; 32]), FullMerkleConfig::default()).unwrap() + } + + fn default_optimal_merkle_tree() -> OptimalMerkleTree { + OptimalMerkleTree::::new(2, TestFr([0; 32]), OptimalMerkleConfig::default()) + .unwrap() + } + + #[test] + fn test_root() { let default_tree_root = TestFr(hex!( "b4c11951957c6f8f642c4af61cd6b24640fec6dc7fc607ee8206a99e92410d30" )); @@ -67,44 +78,30 @@ pub mod test { hex!("222ff5e0b5877792c2bc1670e2ccd0c2c97cd7bb1672a57d598db05092d3d72c"), hex!("a9bb8c3f1f12e9aa903a50c47f314b57610a3ab32f2d463293f58836def38d36"), ] - .map(|x| TestFr(x)); + .map(TestFr); - let mut tree = - FullMerkleTree::::new(2, TestFr([0; 32]), FullMerkleConfig::default()) - .unwrap(); + let mut tree = default_full_merkle_tree(); assert_eq!(tree.root(), default_tree_root); - for i in 0..leaves.len() { - tree.set(i, leaves[i]).unwrap(); + for i in 0..LEAVES.len() { + tree.set(i, LEAVES[i]).unwrap(); assert_eq!(tree.root(), roots[i]); } - let mut tree = - OptimalMerkleTree::::new(2, TestFr([0; 32]), OptimalMerkleConfig::default()) - .unwrap(); + let mut tree = default_optimal_merkle_tree(); assert_eq!(tree.root(), default_tree_root); - for i in 0..leaves.len() { - tree.set(i, leaves[i]).unwrap(); + for i in 0..LEAVES.len() { + tree.set(i, LEAVES[i]).unwrap(); assert_eq!(tree.root(), roots[i]); } } #[test] fn test_proof() { - let leaves = [ - hex!("0000000000000000000000000000000000000000000000000000000000000001"), - hex!("0000000000000000000000000000000000000000000000000000000000000002"), - hex!("0000000000000000000000000000000000000000000000000000000000000003"), - hex!("0000000000000000000000000000000000000000000000000000000000000004"), - ] - .map(|x| TestFr(x)); - // We thest the FullMerkleTree implementation - let mut tree = - FullMerkleTree::::new(2, TestFr([0; 32]), FullMerkleConfig::default()) - .unwrap(); - for i in 0..leaves.len() { + let mut tree = default_full_merkle_tree(); + for i in 0..LEAVES.len() { // We set the leaves - tree.set(i, leaves[i]).unwrap(); + tree.set(i, LEAVES[i]).unwrap(); // We compute a merkle proof let proof = tree.proof(i).expect("index should be set"); @@ -113,24 +110,22 @@ pub mod test { assert_eq!(proof.leaf_index(), i); // We verify the proof - assert!(tree.verify(&leaves[i], &proof).unwrap()); + assert!(tree.verify(&LEAVES[i], &proof).unwrap()); // We ensure that the Merkle proof and the leaf generate the same root as the tree - assert_eq!(proof.compute_root_from(&leaves[i]), tree.root()); + assert_eq!(proof.compute_root_from(&LEAVES[i]), tree.root()); // We check that the proof is not valid for another leaf assert!(!tree - .verify(&leaves[(i + 1) % leaves.len()], &proof) + .verify(&LEAVES[(i + 1) % LEAVES.len()], &proof) .unwrap()); } // We test the OptimalMerkleTree implementation - let mut tree = - OptimalMerkleTree::::new(2, TestFr([0; 32]), OptimalMerkleConfig::default()) - .unwrap(); - for i in 0..leaves.len() { + let mut tree = default_optimal_merkle_tree(); + for i in 0..LEAVES.len() { // We set the leaves - tree.set(i, leaves[i]).unwrap(); + tree.set(i, LEAVES[i]).unwrap(); // We compute a merkle proof let proof = tree.proof(i).expect("index should be set"); @@ -139,40 +134,30 @@ pub mod test { assert_eq!(proof.leaf_index(), i); // We verify the proof - assert!(tree.verify(&leaves[i], &proof).unwrap()); + assert!(tree.verify(&LEAVES[i], &proof).unwrap()); // We ensure that the Merkle proof and the leaf generate the same root as the tree - assert_eq!(proof.compute_root_from(&leaves[i]), tree.root()); + assert_eq!(proof.compute_root_from(&LEAVES[i]), tree.root()); // We check that the proof is not valid for another leaf assert!(!tree - .verify(&leaves[(i + 1) % leaves.len()], &proof) + .verify(&LEAVES[(i + 1) % LEAVES.len()], &proof) .unwrap()); } } #[test] fn test_override_range() { - let initial_leaves = [ - hex!("0000000000000000000000000000000000000000000000000000000000000001"), - hex!("0000000000000000000000000000000000000000000000000000000000000002"), - hex!("0000000000000000000000000000000000000000000000000000000000000003"), - hex!("0000000000000000000000000000000000000000000000000000000000000004"), - ] - .map(|x| TestFr(x)); - - let mut tree = - OptimalMerkleTree::::new(2, TestFr([0; 32]), OptimalMerkleConfig::default()) - .unwrap(); + let mut tree = default_optimal_merkle_tree(); // We set the leaves - tree.set_range(0, initial_leaves.iter().cloned()).unwrap(); + tree.set_range(0, LEAVES.iter().cloned()).unwrap(); let new_leaves = [ hex!("0000000000000000000000000000000000000000000000000000000000000005"), hex!("0000000000000000000000000000000000000000000000000000000000000006"), ] - .map(|x| TestFr(x)); + .map(TestFr); let to_delete_indices: [usize; 2] = [0, 1]; @@ -185,8 +170,8 @@ pub mod test { .unwrap(); // ensure that the leaves are set correctly - for i in 0..new_leaves.len() { - assert_eq!(tree.get_leaf(i), new_leaves[i]); + for (i, &new_leaf) in new_leaves.iter().enumerate() { + assert_eq!(tree.get_leaf(i), new_leaf); } } } diff --git a/utils/tests/poseidon_constants.rs b/utils/tests/poseidon_constants.rs index 39654f2..4828b88 100644 --- a/utils/tests/poseidon_constants.rs +++ b/utils/tests/poseidon_constants.rs @@ -25,16 +25,10 @@ mod test { input_clean = input_clean.trim().to_string(); if radix == 10 { - BigUint::from_str_radix(&input_clean, radix) - .unwrap() - .try_into() - .unwrap() + BigUint::from_str_radix(&input_clean, radix).unwrap().into() } else { input_clean = input_clean.replace("0x", ""); - BigUint::from_str_radix(&input_clean, radix) - .unwrap() - .try_into() - .unwrap() + BigUint::from_str_radix(&input_clean, radix).unwrap().into() } } // The following constants were taken from https://github.com/arnaucube/poseidon-rs/blob/233027d6075a637c29ad84a8a44f5653b81f0410/src/constants.rs @@ -3500,21 +3494,21 @@ mod test { fn load_constants() -> (Vec>, Vec>>) { let (c_str, m_str) = constants(); let mut c: Vec> = Vec::new(); - for i in 0..c_str.len() { - let mut cci: Vec = Vec::new(); - for j in 0..c_str[i].len() { - let b: Fr = str_to_fr(c_str[i][j], 10); - cci.push(b); + for c_i in c_str { + let mut ci: Vec = Vec::new(); + for c_i_j in c_i { + let b: Fr = str_to_fr(c_i_j, 10); + ci.push(b); } - c.push(cci); + c.push(ci); } let mut m: Vec>> = Vec::new(); - for i in 0..m_str.len() { + for m_i in m_str { let mut mi: Vec> = Vec::new(); - for j in 0..m_str[i].len() { + for m_i_j in m_i { let mut mij: Vec = Vec::new(); - for k in 0..m_str[i][j].len() { - let b: Fr = str_to_fr(m_str[i][j][k], 10); + for m_i_j_k in m_i_j { + let b: Fr = str_to_fr(m_i_j_k, 10); mij.push(b); } mi.push(mij); @@ -3542,7 +3536,7 @@ mod test { assert_eq!(loaded_m[i], poseidon_parameters[i].m); } } else { - assert!(false); + unreachable!(); } } }