diff --git a/forester/src/send_transaction.rs b/forester/src/send_transaction.rs index 63ac5e4370..308c7d49d6 100644 --- a/forester/src/send_transaction.rs +++ b/forester/src/send_transaction.rs @@ -66,7 +66,7 @@ const TIMEOUT_CHECK_ENABLED: bool = false; /// /// Strategy: /// 1. Execute transaction batches until max number of batches is -/// reached or light slot ended (global timeout). +/// reached or light slot ended (global timeout). /// 2. Fetch queue items. /// 3. If work items is empty, await minimum batch time. /// 4. Fetch recent blockhash. diff --git a/program-libs/batched-merkle-tree/src/batch.rs b/program-libs/batched-merkle-tree/src/batch.rs index 3920560107..e5dbb787e3 100644 --- a/program-libs/batched-merkle-tree/src/batch.rs +++ b/program-libs/batched-merkle-tree/src/batch.rs @@ -316,7 +316,7 @@ mod tests { let mut root_index = 20; let root_history_length = 23; for i in 0..batch.get_num_zkp_batches() { - sequence_number += i as u64; + sequence_number += i; root_index += i as u32; batch .mark_as_inserted_in_merkle_tree(sequence_number, root_index, root_history_length) @@ -383,10 +383,7 @@ mod tests { assert_eq!(*value_store.get(i as usize).unwrap(), value); } let result = batch.store_and_hash_value(&[1u8; 32], &mut value_store, &mut hashchain_store); - assert_eq!( - result.unwrap_err(), - BatchedMerkleTreeError::BatchNotReady.into() - ); + assert_eq!(result.unwrap_err(), BatchedMerkleTreeError::BatchNotReady); assert_eq!(batch.get_state(), BatchState::Full); assert_eq!(batch.get_num_inserted(), 0); assert_eq!(batch.get_current_zkp_batch_index(), 5); @@ -541,33 +538,21 @@ mod tests { let highest_eligible_value = batch.start_index + batch.get_num_zkp_batches() * batch.zkp_batch_size - 1; // 1. Failing test lowest value in eligble range - 1 - assert_eq!( - batch - .value_is_inserted_in_batch(lowest_eligible_value - 1) - .unwrap(), - false - ); + assert!(!batch + .value_is_inserted_in_batch(lowest_eligible_value - 1) + .unwrap()); // 2. Functional test lowest value in eligble range - assert_eq!( - batch - .value_is_inserted_in_batch(lowest_eligible_value) - .unwrap(), - true - ); + assert!(batch + .value_is_inserted_in_batch(lowest_eligible_value) + .unwrap()); // 3. Functional test highest value in eligble range - assert_eq!( - batch - .value_is_inserted_in_batch(highest_eligible_value) - .unwrap(), - true - ); + assert!(batch + .value_is_inserted_in_batch(highest_eligible_value) + .unwrap()); // 4. Failing test eligble range + 1 - assert_eq!( - batch - .value_is_inserted_in_batch(highest_eligible_value + 1) - .unwrap(), - false - ); + assert!(!batch + .value_is_inserted_in_batch(highest_eligible_value + 1) + .unwrap()); } /// 1. Failing: empty batch @@ -578,7 +563,7 @@ mod tests { let mut batch = get_test_batch(); assert_eq!( batch.get_first_ready_zkp_batch(), - Err(BatchedMerkleTreeError::BatchNotReady.into()) + Err(BatchedMerkleTreeError::BatchNotReady) ); let mut value_store_bytes = vec![0u8; ZeroCopyVecU64::<[u8; 32]>::required_size_for_capacity(batch.batch_size)]; @@ -613,12 +598,12 @@ mod tests { } else if i >= batch.batch_size { assert_eq!( batch.get_first_ready_zkp_batch(), - Err(BatchedMerkleTreeError::BatchAlreadyInserted.into()) + Err(BatchedMerkleTreeError::BatchAlreadyInserted) ); } else { assert_eq!( batch.get_first_ready_zkp_batch(), - Err(BatchedMerkleTreeError::BatchNotReady.into()) + Err(BatchedMerkleTreeError::BatchNotReady) ); } } diff --git a/program-libs/batched-merkle-tree/src/merkle_tree.rs b/program-libs/batched-merkle-tree/src/merkle_tree.rs index c76a592ca8..bfed2b7713 100644 --- a/program-libs/batched-merkle-tree/src/merkle_tree.rs +++ b/program-libs/batched-merkle-tree/src/merkle_tree.rs @@ -667,7 +667,7 @@ impl<'a> BatchedMerkleTreeAccount<'a> { /// - value is committed to bloom_filter for non-inclusion proof /// - nullifier is Hash(value, tx_hash), committed to leaves hashchain /// - tx_hash is hash of all inputs and outputs - /// -> we can access the history of how commitments are spent in zkps for example fraud proofs + /// -> we can access the history of how commitments are spent in zkps for example fraud proofs pub fn insert_nullifier_into_current_batch( &mut self, compressed_account_hash: &[u8; 32], @@ -782,9 +782,9 @@ impl<'a> BatchedMerkleTreeAccount<'a> { /// 1. Previous batch must be inserted and bloom filter must not be wiped. /// 2. Current batch must be 50% full /// 3. if yes - /// 3.1 zero out bloom filter - /// 3.2 mark bloom filter as wiped - /// 3.3 zero out roots if needed + /// 3.1 zero out bloom filter + /// 3.2 mark bloom filter as wiped + /// 3.3 zero out roots if needed pub fn wipe_previous_batch_bloom_filter(&mut self) -> Result<(), BatchedMerkleTreeError> { let current_batch = self .get_metadata() diff --git a/program-libs/batched-merkle-tree/tests/initialize_address_tree.rs b/program-libs/batched-merkle-tree/tests/initialize_address_tree.rs index d6dcda133e..61afe03956 100644 --- a/program-libs/batched-merkle-tree/tests/initialize_address_tree.rs +++ b/program-libs/batched-merkle-tree/tests/initialize_address_tree.rs @@ -26,13 +26,8 @@ fn test_account_init() { let params = InitAddressTreeAccountsInstructionData::test_default(); let mt_params = CreateTreeParams::from_address_ix_params(params, owner); let ref_mt_account = BatchedMerkleTreeMetadata::new_address_tree(mt_params, merkle_tree_rent); - init_batched_address_merkle_tree_account( - owner.into(), - params.clone(), - &mut mt_account_data, - merkle_tree_rent, - ) - .unwrap(); + init_batched_address_merkle_tree_account(owner, params, &mut mt_account_data, merkle_tree_rent) + .unwrap(); assert_address_mt_zero_copy_inited( &mut mt_account_data, @@ -115,7 +110,7 @@ fn test_rnd_account_init() { init_batched_address_merkle_tree_account( owner, - params.clone(), + params, &mut mt_account_data, merkle_tree_rent, ) diff --git a/program-libs/batched-merkle-tree/tests/initialize_state_tree.rs b/program-libs/batched-merkle-tree/tests/initialize_state_tree.rs index eca381f03d..4145d3f628 100644 --- a/program-libs/batched-merkle-tree/tests/initialize_state_tree.rs +++ b/program-libs/batched-merkle-tree/tests/initialize_state_tree.rs @@ -52,7 +52,7 @@ fn test_different_parameters() { let additional_bytes_rent = 1000; init_batched_state_merkle_tree_accounts( owner, - params.clone(), + params, &mut output_queue_account_data, output_queue_pubkey, queue_rent, @@ -105,7 +105,7 @@ fn test_account_init() { let additional_bytes_rent = 1000; init_batched_state_merkle_tree_accounts( owner, - params.clone(), + params, &mut output_queue_account_data, output_queue_pubkey, queue_rent, @@ -252,7 +252,7 @@ fn test_rnd_account_init() { let additional_bytes_rent = rng.gen_range(0..10000000); init_batched_state_merkle_tree_accounts( owner, - params.clone(), + params, &mut output_queue_account_data, output_queue_pubkey, queue_rent, diff --git a/program-libs/batched-merkle-tree/tests/merkle_tree.rs b/program-libs/batched-merkle-tree/tests/merkle_tree.rs index 4a2b8b96af..5b6b7c17d1 100644 --- a/program-libs/batched-merkle-tree/tests/merkle_tree.rs +++ b/program-libs/batched-merkle-tree/tests/merkle_tree.rs @@ -40,6 +40,7 @@ use light_zero_copy::{slice_mut::ZeroCopySliceMutU64, vec::ZeroCopyVecU64}; use rand::{rngs::StdRng, Rng}; use serial_test::serial; +#[allow(clippy::too_many_arguments)] pub fn assert_nullifier_queue_insert( pre_account: BatchedMerkleTreeMetadata, pre_batches: ZeroCopySliceMutU64, @@ -76,7 +77,7 @@ pub fn assert_nullifier_queue_insert( /// Insert into input queue: /// 1. New value exists in the current batch bloom_filter /// 2. New value does not exist in the other batch bloom_filters -/// 3. +#[allow(clippy::too_many_arguments)] pub fn assert_input_queue_insert( mut pre_account: BatchedMerkleTreeMetadata, mut pre_batches: ZeroCopySliceMutU64, @@ -172,10 +173,9 @@ pub fn assert_input_queue_insert( "assert input queue batch update: insert_value: {:?}", insert_value ); - assert!(bloom_filter.contains(&insert_value)); - let mut pre_hashchain = pre_hashchains.get_mut(inserted_batch_index).unwrap(); - - expected_batch.add_to_hash_chain(&leaf_hashchain_insert_values[i], &mut pre_hashchain)?; + assert!(bloom_filter.contains(insert_value)); + let pre_hashchain = pre_hashchains.get_mut(inserted_batch_index).unwrap(); + expected_batch.add_to_hash_chain(&leaf_hashchain_insert_values[i], pre_hashchain)?; // New value does not exist in the other batch bloom_filters for (i, batch) in merkle_tree_account.batches.iter_mut().enumerate() { @@ -187,7 +187,7 @@ pub fn assert_input_queue_insert( merkle_tree_account.bloom_filter_stores[i].as_mut_slice(), ) .unwrap(); - assert!(!bloom_filter.contains(&insert_value)); + assert!(!bloom_filter.contains(insert_value)); } } // if the currently processing batch changed it should @@ -223,7 +223,7 @@ pub fn assert_input_queue_insert( "BatchedMerkleTreeMetadata changed." ); let inserted_batch_index = pre_account.queue_metadata.currently_processing_batch_index as usize; - let mut expected_batch = pre_batches[inserted_batch_index].clone(); + let mut expected_batch = pre_batches[inserted_batch_index]; if should_be_wiped { expected_batch.set_bloom_filter_is_wiped(); } @@ -282,17 +282,17 @@ pub fn assert_output_queue_insert( expected_batch.start_index = pre_account.next_index; } pre_account.next_index += 1; - expected_batch.store_and_hash_value(&insert_value, pre_value_store, pre_hashchain)?; + expected_batch.store_and_hash_value(insert_value, pre_value_store, pre_hashchain)?; let other_batch = if inserted_batch_index == 0 { 1 } else { 0 }; assert!(output_account.value_vecs[inserted_batch_index] .as_mut_slice() .to_vec() - .contains(&insert_value)); + .contains(insert_value)); assert!(!output_account.value_vecs[other_batch] .as_mut_slice() .to_vec() - .contains(&insert_value)); + .contains(insert_value)); if expected_batch.get_num_zkp_batches() == expected_batch.get_current_zkp_batch_index() { assert!( output_account.batches @@ -367,7 +367,9 @@ pub fn simulate_transaction( for input in instruction_data.inputs.iter() { // zkp inclusion in Merkle tree let inclusion = reference_merkle_tree.get_leaf_index(input); - let leaf_index = if inclusion.is_none() { + let leaf_index = if let Some(leaf_index) = inclusion { + leaf_index as u64 + } else { println!("simulate_transaction: inclusion is none"); let mut included = false; let mut leaf_index = 0; @@ -388,8 +390,6 @@ pub fn simulate_transaction( panic!("Value not included in any output queue or trees."); } leaf_index - } else { - inclusion.unwrap() as u64 }; println!( @@ -487,13 +487,12 @@ async fn test_simulate_transactions() { outputs.push(get_rnd_bytes(&mut rng)); } let number_of_inputs = if rng.gen_bool(0.5) { - let number_of_inputs = if !mock_indexer.active_leaves.is_empty() { + if !mock_indexer.active_leaves.is_empty() { let x = min(mock_indexer.active_leaves.len(), 5); rng.gen_range(0..x) } else { 0 - }; - number_of_inputs + } } else { 0 }; @@ -558,7 +557,7 @@ async fn test_simulate_transactions() { let pre_output_account = BatchedQueueAccount::output_queue_from_bytes_mut(&mut pre_account_bytes).unwrap(); - let pre_output_metadata = pre_output_account.get_metadata().clone(); + let pre_output_metadata = *pre_output_account.get_metadata(); let pre_output_batches = pre_output_account.batches; let mut pre_output_value_stores = pre_output_account.value_vecs; let pre_output_hashchains = pre_output_account.hashchain_store; @@ -567,7 +566,7 @@ async fn test_simulate_transactions() { let pre_merkle_tree_account = BatchedMerkleTreeAccount::state_tree_from_bytes_mut(&mut pre_mt_account_bytes) .unwrap(); - let pre_mt_account = pre_merkle_tree_account.get_metadata().clone(); + let pre_mt_account = *pre_merkle_tree_account.get_metadata(); let pre_batches = pre_merkle_tree_account.batches; // let pre_value_store = pre_merkle_tree_account.value_vecs; let pre_roots = pre_merkle_tree_account @@ -629,9 +628,9 @@ async fn test_simulate_transactions() { .input_queue_leaves .push((inputs[i], leaf_indices[i] as usize)); } - for i in 0..number_of_outputs { - mock_indexer.active_leaves.push(outputs[i]); - mock_indexer.output_queue_leaves.push(outputs[i]); + for output in outputs.iter() { + mock_indexer.active_leaves.push(*output); + mock_indexer.output_queue_leaves.push(*output); } num_output_values += number_of_outputs; @@ -823,7 +822,7 @@ async fn test_simulate_transactions() { new_root, &old_output_account, &old_account, - mt_pubkey.into(), + mt_pubkey, ); assert_merkle_tree_update( old_account, @@ -851,7 +850,7 @@ async fn test_simulate_transactions() { // Get random leaf that is not in the input queue. pub fn get_random_leaf(rng: &mut StdRng, active_leaves: &mut Vec<[u8; 32]>) -> (usize, [u8; 32]) { - if active_leaves.len() == 0 { + if active_leaves.is_empty() { return (0, [0u8; 32]); } let index = rng.gen_range(0..active_leaves.len()); @@ -898,7 +897,7 @@ async fn test_e2e() { let additional_bytes_rent = 1000; init_batched_state_merkle_tree_accounts( - owner.into(), + owner, params, &mut output_queue_account_data, output_queue_pubkey, @@ -932,7 +931,7 @@ async fn test_e2e() { let pre_output_account = BatchedQueueAccount::output_queue_from_bytes_mut(&mut pre_account_bytes) .unwrap(); - let pre_account = pre_output_account.get_metadata().clone(); + let pre_account = *pre_output_account.get_metadata(); let pre_batches = pre_output_account.batches; let pre_value_store = pre_output_account.value_vecs; let pre_hashchains = pre_output_account.hashchain_store; @@ -978,7 +977,7 @@ async fn test_e2e() { let pre_mt_account = BatchedMerkleTreeAccount::state_tree_from_bytes_mut(&mut pre_account_bytes) .unwrap(); - let pre_account = pre_mt_account.get_metadata().clone(); + let pre_account = *pre_mt_account.get_metadata(); let pre_batches = pre_mt_account.batches; let pre_hashchains = pre_mt_account.hashchain_store; let pre_roots = pre_mt_account.root_history.iter().cloned().collect(); @@ -1095,10 +1094,10 @@ async fn test_e2e() { .unwrap(); let start = batch.get_num_inserted_zkps() as usize * batch.zkp_batch_size as usize; let end = start + batch.zkp_batch_size as usize; - for i in start..end { + for leaf in &leaves[start..end] { // Storing the leaf in the output queue indexer so that it // can be inserted into the input queue later. - mock_indexer.active_leaves.push(leaves[i]); + mock_indexer.active_leaves.push(*leaf); } let instruction_data = InstructionDataBatchAppendInputs { @@ -1323,9 +1322,9 @@ fn assert_merkle_tree_update( queue_account: Option, root: [u8; 32], ) { - let mut expected_account = old_account.get_metadata().clone(); + let mut expected_account = *old_account.get_metadata(); expected_account.sequence_number += 1; - let actual_account = account.get_metadata().clone(); + let actual_account = *account.get_metadata(); let ( batches, @@ -1334,7 +1333,7 @@ fn assert_merkle_tree_update( expected_queue_account, mut next_full_batch_index, ) = if let Some(queue_account) = queue_account.as_ref() { - let expected_queue_account = old_queue_account.as_ref().unwrap().get_metadata().clone(); + let expected_queue_account = *old_queue_account.as_ref().unwrap().get_metadata(); let previous_processing = if queue_account .get_metadata() @@ -1479,12 +1478,12 @@ async fn test_fill_queues_completely() { let owner = Pubkey::new_unique(); - let queue_account_size = get_output_queue_account_size_from_params(params.clone()); + let queue_account_size = get_output_queue_account_size_from_params(params); let mut output_queue_account_data = vec![0; queue_account_size]; let output_queue_pubkey = Pubkey::new_unique(); - let mt_account_size = get_state_merkle_tree_account_size_from_params(params.clone()); + let mt_account_size = get_state_merkle_tree_account_size_from_params(params); let mut mt_account_data = vec![0; mt_account_size]; let mt_pubkey = Pubkey::new_unique(); @@ -1493,8 +1492,8 @@ async fn test_fill_queues_completely() { let additional_bytes_rent = 1000; init_batched_state_merkle_tree_accounts( - owner.into(), - params.clone(), + owner, + params, &mut output_queue_account_data, output_queue_pubkey, queue_rent, @@ -1518,7 +1517,7 @@ async fn test_fill_queues_completely() { &mut pre_output_queue_account_data, ) .unwrap(); - let pre_account = pre_output_account.get_metadata().clone(); + let pre_account = *pre_output_account.get_metadata(); let pre_batches = pre_output_account.batches.to_vec(); let pre_value_store = pre_output_account.value_vecs; let pre_hashchains = pre_output_account.hashchain_store; @@ -1550,10 +1549,7 @@ async fn test_fill_queues_completely() { .unwrap(); let result = output_account.insert_into_current_batch(&rnd_bytes); - assert_eq!( - result.unwrap_err(), - BatchedMerkleTreeError::BatchNotReady.into() - ); + assert_eq!(result.unwrap_err(), BatchedMerkleTreeError::BatchNotReady); output_account .batches @@ -1602,10 +1598,10 @@ async fn test_fill_queues_completely() { .unwrap(); let start = batch.get_num_inserted_zkps() as usize * batch.zkp_batch_size as usize; let end = start + batch.zkp_batch_size as usize; - for i in start..end { + for leaf in &leaves[start..end] { // Storing the leaf in the output queue indexer so that it // can be inserted into the input queue later. - mock_indexer.active_leaves.push(leaves[i]); + mock_indexer.active_leaves.push(*leaf); } let instruction_data = InstructionDataBatchAppendInputs { @@ -1648,7 +1644,7 @@ async fn test_fill_queues_completely() { let pre_merkle_tree_account = BatchedMerkleTreeAccount::state_tree_from_bytes_mut(&mut pre_mt_account_data) .unwrap(); - let pre_account = pre_merkle_tree_account.get_metadata().clone(); + let pre_account = *pre_merkle_tree_account.get_metadata(); let pre_batches = pre_merkle_tree_account.batches; let pre_roots = pre_merkle_tree_account .root_history @@ -1740,10 +1736,7 @@ async fn test_fill_queues_completely() { let tx_hash = get_rnd_bytes(&mut rng); let result = merkle_tree_account.insert_nullifier_into_current_batch(&rnd_bytes, 0, &tx_hash); - assert_eq!( - result.unwrap_err(), - BatchedMerkleTreeError::BatchNotReady.into() - ); + assert_eq!(result.unwrap_err(), BatchedMerkleTreeError::BatchNotReady); } // Root of the final batch of first input queue batch let mut first_input_batch_update_root_value = [0u8; 32]; @@ -1797,7 +1790,7 @@ async fn test_fill_queues_completely() { let merkle_tree_account = &mut BatchedMerkleTreeAccount::state_tree_from_bytes_mut(&mut mt_account_data) .unwrap(); - let pre_batch_zero = merkle_tree_account.batches.get(0).unwrap().clone(); + let pre_batch_zero = *merkle_tree_account.batches.get(0).unwrap(); let value = &get_rnd_bytes(&mut rng); let tx_hash = &get_rnd_bytes(&mut rng); @@ -1805,7 +1798,7 @@ async fn test_fill_queues_completely() { .insert_nullifier_into_current_batch(value, 0, tx_hash) .unwrap(); { - let post_batch = merkle_tree_account.batches.get(0).unwrap().clone(); + let post_batch = *merkle_tree_account.batches.get(0).unwrap(); assert_eq!(post_batch.get_state(), BatchState::CanBeFilled); assert_eq!(post_batch.get_num_inserted(), 1); let bloom_filter_store = @@ -1883,7 +1876,7 @@ async fn test_fill_address_tree_completely() { let merkle_tree_rent = 1_000_000_000; init_batched_address_merkle_tree_account( - owner.into(), + owner, params, &mut mt_account_data, merkle_tree_rent, @@ -1903,7 +1896,7 @@ async fn test_fill_address_tree_completely() { let pre_merkle_tree_account = BatchedMerkleTreeAccount::address_tree_from_bytes_mut(&mut pre_account_data) .unwrap(); - let pre_account = pre_merkle_tree_account.get_metadata().clone(); + let pre_account = *pre_merkle_tree_account.get_metadata(); let pre_batches = pre_merkle_tree_account.batches; let pre_roots = pre_merkle_tree_account .root_history @@ -1973,10 +1966,7 @@ async fn test_fill_address_tree_completely() { .unwrap(); let rnd_bytes = get_rnd_bytes(&mut rng); let result = merkle_tree_account.insert_address_into_current_batch(&rnd_bytes); - assert_eq!( - result.unwrap_err(), - BatchedMerkleTreeError::BatchNotReady.into() - ); + assert_eq!(result.unwrap_err(), BatchedMerkleTreeError::BatchNotReady); } // Root of the final batch of first input queue batch let mut first_input_batch_update_root_value = [0u8; 32]; @@ -2021,7 +2011,7 @@ async fn test_fill_address_tree_completely() { &mut BatchedMerkleTreeAccount::address_tree_from_bytes_mut(&mut mt_account_data) .unwrap(); println!("root history {:?}", merkle_tree_account.root_history); - let pre_batch_zero = merkle_tree_account.batches.get(0).unwrap().clone(); + let pre_batch_zero = *merkle_tree_account.batches.get(0).unwrap(); // let mut address = get_rnd_bytes(&mut rng); // address[0] = 0; diff --git a/program-libs/batched-merkle-tree/tests/queue.rs b/program-libs/batched-merkle-tree/tests/queue.rs index b44de27e16..33acb3347f 100644 --- a/program-libs/batched-merkle-tree/tests/queue.rs +++ b/program-libs/batched-merkle-tree/tests/queue.rs @@ -28,11 +28,11 @@ pub fn get_test_account_and_account_data( }; let account = BatchedQueueMetadata { - metadata: metadata.clone(), + metadata, next_index: 0, batch_metadata: BatchMetadata { - batch_size: batch_size as u64, - num_batches: num_batches as u64, + batch_size, + num_batches, currently_processing_batch_index: 0, next_full_batch_index: 0, bloom_filter_capacity, @@ -51,7 +51,8 @@ fn test_output_queue_account() { let num_batches = 2; let bloom_filter_capacity = 0; let bloom_filter_num_iters = 0; - for queue_type in vec![QueueType::Output] { + { + let queue_type = QueueType::Output; let (ref_account, mut account_data) = get_test_account_and_account_data( batch_size, num_batches, @@ -85,16 +86,8 @@ fn test_output_queue_account() { fn test_value_exists_in_value_vec_present() { let (account, mut account_data) = get_test_account_and_account_data(100, 2, QueueType::Output, 0); - let mut account = BatchedQueueAccount::init( - &mut account_data, - account.metadata.clone(), - 2, - 100, - 10, - 0, - 0, - ) - .unwrap(); + let mut account = + BatchedQueueAccount::init(&mut account_data, account.metadata, 2, 100, 10, 0, 0).unwrap(); let value = [1u8; 32]; let value2 = [2u8; 32]; @@ -116,12 +109,9 @@ fn test_value_exists_in_value_vec_present() { ); assert!(account.prove_inclusion_by_index(0, &value).is_ok()); // prove inclusion for value out of range returns false - assert_eq!( - account - .prove_inclusion_by_index(100000, &[0u8; 32]) - .unwrap(), - false - ); + assert!(!account + .prove_inclusion_by_index(100000, &[0u8; 32]) + .unwrap()); assert!(account .prove_inclusion_by_index_and_zero_out_leaf(0, &value) .is_ok()); diff --git a/program-libs/batched-merkle-tree/tests/rollover_address_tree.rs b/program-libs/batched-merkle-tree/tests/rollover_address_tree.rs index c19abd8625..2cfe8a26f5 100644 --- a/program-libs/batched-merkle-tree/tests/rollover_address_tree.rs +++ b/program-libs/batched-merkle-tree/tests/rollover_address_tree.rs @@ -33,13 +33,8 @@ fn test_rollover() { let merkle_tree_rent = 1_000_000_000; // create first merkle tree - init_batched_address_merkle_tree_account( - owner, - params.clone(), - &mut mt_account_data, - merkle_tree_rent, - ) - .unwrap(); + init_batched_address_merkle_tree_account(owner, params, &mut mt_account_data, merkle_tree_rent) + .unwrap(); let create_tree_params = CreateTreeParams::from_address_ix_params(params, owner); @@ -108,9 +103,9 @@ fn test_rollover() { params.network_fee, ) .unwrap(); - let new_ref_mt_account = ref_mt_account.clone(); + let new_ref_mt_account = ref_mt_account; - let mut ref_rolledover_mt = ref_mt_account.clone(); + let mut ref_rolledover_mt = ref_mt_account; ref_rolledover_mt.next_index = 1 << ref_rolledover_mt.height; assert_address_mt_roll_over( mt_account_data.to_vec(), @@ -219,7 +214,7 @@ fn test_rnd_rollover() { init_batched_address_merkle_tree_account( owner, - params.clone(), + params, &mut mt_account_data, merkle_tree_rent, ) @@ -248,8 +243,8 @@ fn test_rnd_rollover() { network_fee, ) .unwrap(); - let new_ref_mt_account = ref_mt_account.clone(); - let mut ref_rolled_over_account = ref_mt_account.clone(); + let new_ref_mt_account = ref_mt_account; + let mut ref_rolled_over_account = ref_mt_account; ref_rolled_over_account.next_index = 1 << params.height; assert_address_mt_roll_over( diff --git a/program-libs/batched-merkle-tree/tests/rollover_state_tree.rs b/program-libs/batched-merkle-tree/tests/rollover_state_tree.rs index 93f4756edc..d4200159b6 100644 --- a/program-libs/batched-merkle-tree/tests/rollover_state_tree.rs +++ b/program-libs/batched-merkle-tree/tests/rollover_state_tree.rs @@ -54,7 +54,7 @@ fn test_rollover() { init_batched_state_merkle_tree_accounts( owner, - params.clone(), + params, &mut queue_account_data, queue_pubkey, queue_rent, @@ -100,7 +100,7 @@ fn test_rollover() { old_mt_pubkey: mt_pubkey, new_mt_data: &mut new_mt_account_data, new_mt_rent: merkle_tree_rent, - new_mt_pubkey: new_mt_pubkey, + new_mt_pubkey, old_output_queue: &mut BatchedQueueAccount::output_queue_from_bytes_mut( &mut queue_account_data, ) @@ -108,7 +108,7 @@ fn test_rollover() { old_queue_pubkey: queue_pubkey, new_output_queue_data: &mut new_queue_account_data, new_output_queue_rent: queue_rent, - new_output_queue_pubkey: new_output_queue_pubkey, + new_output_queue_pubkey, additional_bytes_rent, additional_bytes, network_fee: params.network_fee, @@ -140,7 +140,7 @@ fn test_rollover() { old_mt_pubkey: mt_pubkey, new_mt_data: &mut new_mt_account_data, new_mt_rent: merkle_tree_rent, - new_mt_pubkey: new_mt_pubkey, + new_mt_pubkey, old_output_queue: &mut BatchedQueueAccount::output_queue_from_bytes_mut( &mut queue_account_data, ) @@ -148,7 +148,7 @@ fn test_rollover() { old_queue_pubkey: queue_pubkey, new_output_queue_data: &mut new_queue_account_data, new_output_queue_rent: queue_rent, - new_output_queue_pubkey: new_output_queue_pubkey, + new_output_queue_pubkey, additional_bytes_rent, additional_bytes, network_fee: params.network_fee, @@ -252,15 +252,15 @@ fn test_rollover() { }; rollover_batched_state_tree(rollover_batch_state_tree_params).unwrap(); - let mut ref_rolledover_mt = ref_mt_account.clone(); + let mut ref_rolledover_mt = ref_mt_account; ref_rolledover_mt.next_index = 1 << height; - let mut new_ref_output_queue_account = ref_output_queue_account.clone(); + let mut new_ref_output_queue_account = ref_output_queue_account; new_ref_output_queue_account .metadata .rollover_metadata .additional_bytes = additional_bytes; new_ref_output_queue_account.metadata.associated_merkle_tree = new_mt_pubkey; - let mut new_ref_merkle_tree_account = ref_mt_account.clone(); + let mut new_ref_merkle_tree_account = ref_mt_account; new_ref_merkle_tree_account.metadata.associated_queue = new_output_queue_pubkey; let assert_state_mt_roll_over_params = StateMtRollOverAssertParams { mt_account_data: mt_account_data.to_vec(), @@ -297,7 +297,7 @@ fn test_rollover() { old_mt_pubkey: mt_pubkey, new_mt_data: &mut new_mt_account_data, new_mt_rent: merkle_tree_rent, - new_mt_pubkey: new_mt_pubkey, + new_mt_pubkey, old_output_queue: &mut BatchedQueueAccount::output_queue_from_bytes_mut( &mut queue_account_data, ) @@ -305,7 +305,7 @@ fn test_rollover() { old_queue_pubkey: queue_pubkey, new_output_queue_data: &mut new_queue_account_data, new_output_queue_rent: queue_rent, - new_output_queue_pubkey: new_output_queue_pubkey, + new_output_queue_pubkey, additional_bytes_rent, additional_bytes, network_fee: params.network_fee, @@ -337,7 +337,7 @@ fn test_rollover() { init_batched_state_merkle_tree_accounts( owner, - params.clone(), + params, &mut queue_account_data, queue_pubkey, queue_rent, @@ -379,10 +379,7 @@ fn test_rollover() { network_fee: Some(1), }; let result = rollover_batched_state_tree(params); - assert_eq!( - result, - Err(BatchedMerkleTreeError::InvalidNetworkFee.into()) - ); + assert_eq!(result, Err(BatchedMerkleTreeError::InvalidNetworkFee)); } let mut new_mt_account_data = vec![0; mt_account_size]; let mut new_queue_account_data = vec![0; queue_account_size]; @@ -434,15 +431,15 @@ fn test_rollover() { }; rollover_batched_state_tree(rollover_batch_state_tree_params).unwrap(); - let mut ref_rolledover_mt = ref_mt_account.clone(); + let mut ref_rolledover_mt = ref_mt_account; ref_rolledover_mt.next_index = 1 << height; - let mut new_ref_output_queue_account = ref_output_queue_account.clone(); + let mut new_ref_output_queue_account = ref_output_queue_account; new_ref_output_queue_account .metadata .rollover_metadata .additional_bytes = additional_bytes; new_ref_output_queue_account.metadata.associated_merkle_tree = new_mt_pubkey; - let mut new_ref_merkle_tree_account = ref_mt_account.clone(); + let mut new_ref_merkle_tree_account = ref_mt_account; new_ref_merkle_tree_account.metadata.associated_queue = new_output_queue_pubkey; let assert_state_mt_roll_over_params = StateMtRollOverAssertParams { @@ -541,7 +538,7 @@ fn test_rnd_rollover() { let additional_bytes = rng.gen_range(0..1000); init_batched_state_merkle_tree_accounts( owner, - params.clone(), + params, &mut output_queue_account_data, output_queue_pubkey, queue_rent, @@ -603,15 +600,15 @@ fn test_rnd_rollover() { }; rollover_batched_state_tree(rollover_batch_state_tree_params).unwrap(); - let mut ref_rolledover_mt = ref_mt_account.clone(); + let mut ref_rolledover_mt = ref_mt_account; ref_rolledover_mt.next_index = 1 << height; - let mut new_ref_output_queue_account = ref_output_queue_account.clone(); + let mut new_ref_output_queue_account = ref_output_queue_account; new_ref_output_queue_account .metadata .rollover_metadata .additional_bytes = additional_bytes; new_ref_output_queue_account.metadata.associated_merkle_tree = new_mt_pubkey; - let mut new_ref_merkle_tree_account = ref_mt_account.clone(); + let mut new_ref_merkle_tree_account = ref_mt_account; new_ref_merkle_tree_account.metadata.associated_queue = new_output_queue_pubkey; let assert_state_mt_roll_over_params = StateMtRollOverAssertParams { diff --git a/program-libs/batched-merkle-tree/tests/zero_copy.rs b/program-libs/batched-merkle-tree/tests/zero_copy.rs index 19b9978d7e..867c686fdd 100644 --- a/program-libs/batched-merkle-tree/tests/zero_copy.rs +++ b/program-libs/batched-merkle-tree/tests/zero_copy.rs @@ -32,7 +32,7 @@ impl TestAccount { } } - pub fn get_account_info<'a>(&'a mut self) -> AccountInfo<'a> { + pub fn get_account_info(&mut self) -> AccountInfo<'_> { AccountInfo { key: &self.key, is_signer: false, @@ -65,7 +65,7 @@ fn address_from_account_info() { // Test 1 functional init_batched_address_merkle_tree_from_account_info { let result = init_batched_address_merkle_tree_from_account_info( - params.clone(), + params, owner.into(), &account.get_account_info(), ); @@ -74,7 +74,7 @@ fn address_from_account_info() { // Test 2 already initialized { let result = init_batched_address_merkle_tree_from_account_info( - params.clone(), + params, owner.into(), &account.get_account_info(), ); @@ -89,7 +89,7 @@ fn address_from_account_info() { // Test 4 failing invalid owner { let mut account = account.clone(); - account.owner = Pubkey::new_unique().into(); + account.owner = Pubkey::new_unique(); let account_info = account.get_account_info(); let result = BatchedMerkleTreeAccount::address_tree_from_account_info_mut(&account_info); assert!(matches!(result, @@ -117,13 +117,12 @@ fn address_from_account_info() { /// 8. failing invalid discriminator (output queue) #[test] fn state_from_account_info() { - let key = Pubkey::new_unique().into(); - let owner = ACCOUNT_COMPRESSION_PROGRAM_ID.into(); + let key = Pubkey::new_unique(); + let owner = ACCOUNT_COMPRESSION_PROGRAM_ID; let mt_account_size = get_merkle_tree_account_size_default(); let output_queue_size = get_output_queue_account_size_default(); let mut merkle_tree_account = TestAccount::new(key, owner, mt_account_size); - let mut output_queue_account = - TestAccount::new(Pubkey::new_unique().into(), owner, output_queue_size); + let mut output_queue_account = TestAccount::new(Pubkey::new_unique(), owner, output_queue_size); let params = InitStateTreeAccountsInstructionData::test_default(); let merkle_tree_rent = 1_000_000_000; @@ -138,7 +137,7 @@ fn state_from_account_info() { let merkle_tree_account_info = merkle_tree_account.get_account_info(); let result = init_batched_state_merkle_tree_from_account_info( - params.clone(), + params, owner, &merkle_tree_account_info, &output_queue_account_info, @@ -152,7 +151,7 @@ fn state_from_account_info() { let merkle_tree_account_info = merkle_tree_account.get_account_info(); let result = init_batched_state_merkle_tree_from_account_info( - params.clone(), + params, owner, &merkle_tree_account_info, &output_queue_account_info, @@ -170,7 +169,7 @@ fn state_from_account_info() { // Test 4 failing invalid owner { let mut account = merkle_tree_account.clone(); - account.owner = Pubkey::new_unique().into(); + account.owner = Pubkey::new_unique(); let account_info = account.get_account_info(); let result = BatchedMerkleTreeAccount::state_tree_from_account_info_mut(&account_info); @@ -196,7 +195,7 @@ fn state_from_account_info() { // Test 7 failing invalid owner { let mut output_queue_account = output_queue_account.clone(); - output_queue_account.owner = Pubkey::new_unique().into(); + output_queue_account.owner = Pubkey::new_unique(); let account_info = output_queue_account.get_account_info(); let result = BatchedQueueAccount::output_queue_from_account_info_mut(&account_info); assert!(matches!(result, diff --git a/program-libs/concurrent-merkle-tree/tests/tests.rs b/program-libs/concurrent-merkle-tree/tests/tests.rs index a08c3c897a..b2e7bff2f1 100644 --- a/program-libs/concurrent-merkle-tree/tests/tests.rs +++ b/program-libs/concurrent-merkle-tree/tests/tests.rs @@ -290,7 +290,7 @@ fn invalid_updates( let res = merkle_tree.update( changelog_index, &invalid_old_leaf, - &new_leaf, + new_leaf, 0, &mut proof_clone, ); @@ -393,9 +393,9 @@ where ]; let mut expected_canopy = Vec::new(); - for canopy_level in 0..CANOPY { - println!("canopy_level: {canopy_level}"); - expected_canopy.extend_from_slice(&canopy_levels[canopy_level]); + for canopy_level in canopy_levels.iter().take(CANOPY) { + println!("canopy_level: {:?}", canopy_level); + expected_canopy.extend_from_slice(canopy_level); } assert_eq!(merkle_tree.changelog_index(), 4 % CHANGELOG); @@ -469,8 +469,8 @@ where ][..], ]; let mut expected_canopy = Vec::new(); - for canopy_level in 0..CANOPY { - expected_canopy.extend_from_slice(&canopy_levels[canopy_level]); + for canopy_level in canopy_levels.iter().take(CANOPY) { + expected_canopy.extend_from_slice(canopy_level); } assert_eq!(merkle_tree.changelog_index(), 5 % CHANGELOG); @@ -543,8 +543,8 @@ where ][..], ]; let mut expected_canopy = Vec::new(); - for canopy_level in 0..CANOPY { - expected_canopy.extend_from_slice(&canopy_levels[canopy_level]); + for canopy_level in canopy_levels.iter().take(CANOPY) { + expected_canopy.extend_from_slice(canopy_level); } assert_eq!(merkle_tree.changelog_index(), 6 % CHANGELOG); @@ -616,8 +616,8 @@ where ][..], ]; let mut expected_canopy = Vec::new(); - for canopy_level in 0..CANOPY { - expected_canopy.extend_from_slice(&canopy_levels[canopy_level]); + for canopy_level in canopy_levels.iter().take(CANOPY) { + expected_canopy.extend_from_slice(canopy_level); } assert_eq!(merkle_tree.changelog_index(), 7 % CHANGELOG); @@ -689,8 +689,8 @@ where ][..], ]; let mut expected_canopy = Vec::new(); - for canopy_level in 0..CANOPY { - expected_canopy.extend_from_slice(&canopy_levels[canopy_level]); + for canopy_level in canopy_levels.iter().take(CANOPY) { + expected_canopy.extend_from_slice(canopy_level); } assert_eq!(merkle_tree.changelog_index(), 8 % CHANGELOG); @@ -1396,7 +1396,7 @@ async fn test_spl_compat() { .update(changelog_index, &old_leaf, &new_leaf, 0, &mut proof) .unwrap(); spl_concurrent_mt - .set_leaf(root, old_leaf, new_leaf, proof.as_slice(), 0 as u32) + .set_leaf(root, old_leaf, new_leaf, proof.as_slice(), 0_u32) .unwrap(); reference_tree.update(&new_leaf, 0).unwrap(); @@ -2171,8 +2171,7 @@ pub fn test_100_nullify_mt() { let leaf_cell = queue.get_unmarked_bucket(queue_index).unwrap().unwrap(); let leaf_index = crank_merkle_tree .get_leaf_index(&leaf_cell.value_bytes()) - .unwrap() - .clone(); + .unwrap(); let mut proof = crank_merkle_tree .get_proof_of_leaf(leaf_index, false) @@ -2398,7 +2397,7 @@ fn test_subtree_updates() { spl_concurrent_mt.initialize().unwrap(); con_mt.init().unwrap(); assert_eq!(ref_mt.root(), con_mt.root()); - for (_, leaf) in LEAVES_WITH_NULLIFICATIONS.iter().enumerate() { + for leaf in LEAVES_WITH_NULLIFICATIONS.iter() { match leaf.1 { Some(index) => { let change_log_index = con_mt.changelog_index(); @@ -3378,7 +3377,7 @@ where tree.append(&leaf_0).unwrap(); tree.append(&leaf_1).unwrap(); tree.append(&leaf_2).unwrap(); - let old_canopy = tree.canopy.as_slice()[0].clone(); + let old_canopy = tree.canopy.as_slice()[0]; let new_leaf_0 = [1; 32]; let mut leaf_0_proof = BoundedVec::with_capacity(2); @@ -3391,7 +3390,7 @@ where &mut leaf_0_proof, ) .unwrap(); - let new_canopy = tree.canopy.as_slice()[0].clone(); + let new_canopy = tree.canopy.as_slice()[0]; assert_ne!(old_canopy, new_canopy); diff --git a/program-libs/hash-set/src/lib.rs b/program-libs/hash-set/src/lib.rs index 500de57899..1013552a22 100644 --- a/program-libs/hash-set/src/lib.rs +++ b/program-libs/hash-set/src/lib.rs @@ -598,10 +598,10 @@ mod test { sequence_number: None, }; // It should be always valid, no matter the sequence number. - assert_eq!(cell.is_valid(0), true); + assert!(cell.is_valid(0)); for _ in 0..100 { let seq: usize = rng.gen(); - assert_eq!(cell.is_valid(seq), true); + assert!(cell.is_valid(seq)); } let cell = HashSetCell { @@ -610,10 +610,10 @@ mod test { }; // Sequence numbers up to 2400 should succeed. for i in 0..2400 { - assert_eq!(cell.is_valid(i), true); + assert!(cell.is_valid(i)); } for i in 2400..10000 { - assert_eq!(cell.is_valid(i), false); + assert!(!cell.is_valid(i)); } } @@ -630,7 +630,7 @@ mod test { hs.mark_with_sequence_number(index_1_1, 1).unwrap(); // Check if element exists in the set. - assert_eq!(hs.contains(&element_1_1, Some(1)).unwrap(), true); + assert!(hs.contains(&element_1_1, Some(1)).unwrap()); // Try inserting the same element, even though we didn't reach the // threshold. assert!(matches!( @@ -649,10 +649,10 @@ mod test { let index_2_6 = hs.insert(&element_2_6, 1).unwrap(); let index_2_8 = hs.insert(&element_2_8, 1).unwrap(); let index_2_9 = hs.insert(&element_2_9, 1).unwrap(); - assert_eq!(hs.contains(&element_2_3, Some(2)).unwrap(), true); - assert_eq!(hs.contains(&element_2_6, Some(2)).unwrap(), true); - assert_eq!(hs.contains(&element_2_8, Some(2)).unwrap(), true); - assert_eq!(hs.contains(&element_2_9, Some(2)).unwrap(), true); + assert!(hs.contains(&element_2_3, Some(2)).unwrap()); + assert!(hs.contains(&element_2_6, Some(2)).unwrap()); + assert!(hs.contains(&element_2_8, Some(2)).unwrap()); + assert!(hs.contains(&element_2_9, Some(2)).unwrap()); hs.mark_with_sequence_number(index_2_3, 2).unwrap(); hs.mark_with_sequence_number(index_2_6, 2).unwrap(); hs.mark_with_sequence_number(index_2_8, 2).unwrap(); @@ -682,10 +682,10 @@ mod test { let index_3_13 = hs.insert(&element_3_13, 2).unwrap(); let index_3_21 = hs.insert(&element_3_21, 2).unwrap(); let index_3_29 = hs.insert(&element_3_29, 2).unwrap(); - assert_eq!(hs.contains(&element_3_11, Some(3)).unwrap(), true); - assert_eq!(hs.contains(&element_3_13, Some(3)).unwrap(), true); - assert_eq!(hs.contains(&element_3_21, Some(3)).unwrap(), true); - assert_eq!(hs.contains(&element_3_29, Some(3)).unwrap(), true); + assert!(hs.contains(&element_3_11, Some(3)).unwrap()); + assert!(hs.contains(&element_3_13, Some(3)).unwrap()); + assert!(hs.contains(&element_3_21, Some(3)).unwrap()); + assert!(hs.contains(&element_3_29, Some(3)).unwrap()); hs.mark_with_sequence_number(index_3_11, 3).unwrap(); hs.mark_with_sequence_number(index_3_13, 3).unwrap(); hs.mark_with_sequence_number(index_3_21, 3).unwrap(); @@ -715,10 +715,10 @@ mod test { let index_4_65 = hs.insert(&element_4_65, 3).unwrap(); let index_4_72 = hs.insert(&element_4_72, 3).unwrap(); let index_4_15 = hs.insert(&element_4_15, 3).unwrap(); - assert_eq!(hs.contains(&element_4_93, Some(4)).unwrap(), true); - assert_eq!(hs.contains(&element_4_65, Some(4)).unwrap(), true); - assert_eq!(hs.contains(&element_4_72, Some(4)).unwrap(), true); - assert_eq!(hs.contains(&element_4_15, Some(4)).unwrap(), true); + assert!(hs.contains(&element_4_93, Some(4)).unwrap()); + assert!(hs.contains(&element_4_65, Some(4)).unwrap()); + assert!(hs.contains(&element_4_72, Some(4)).unwrap()); + assert!(hs.contains(&element_4_15, Some(4)).unwrap()); hs.mark_with_sequence_number(index_4_93, 4).unwrap(); hs.mark_with_sequence_number(index_4_65, 4).unwrap(); hs.mark_with_sequence_number(index_4_72, 4).unwrap(); @@ -770,22 +770,17 @@ mod test { std::array::from_fn(|_| BigUint::from(Fr::rand(&mut rng))); for nf_chunk in nullifiers.chunks(2400) { for nullifier in nf_chunk.iter() { - assert_eq!(hs.contains(&nullifier, Some(seq)).unwrap(), false); - let index = hs.insert(&nullifier, seq as usize).unwrap(); - assert_eq!(hs.contains(&nullifier, Some(seq)).unwrap(), true); + assert!(!hs.contains(nullifier, Some(seq)).unwrap()); + let index = hs.insert(nullifier, seq).unwrap(); + assert!(hs.contains(nullifier, Some(seq)).unwrap()); - let nullifier_bytes = bigint_to_be_bytes_array(&nullifier).unwrap(); + let nullifier_bytes = bigint_to_be_bytes_array(nullifier).unwrap(); - let element = hs - .find_element(&nullifier, Some(seq)) - .unwrap() - .unwrap() - .0 - .clone(); + let element = *hs.find_element(nullifier, Some(seq)).unwrap().unwrap().0; assert_eq!( element, HashSetCell { - value: bigint_to_be_bytes_array(&nullifier).unwrap(), + value: bigint_to_be_bytes_array(nullifier).unwrap(), sequence_number: None, } ); @@ -796,12 +791,7 @@ mod test { assert!(element.is_valid(seq)); hs.mark_with_sequence_number(index, seq).unwrap(); - let element = hs - .find_element(&nullifier, Some(seq)) - .unwrap() - .unwrap() - .0 - .clone(); + let element = *hs.find_element(nullifier, Some(seq)).unwrap().unwrap().0; assert_eq!( element, @@ -819,7 +809,7 @@ mod test { // Trying to insert the same nullifier, before reaching the // sequence threshold, should fail. assert!(matches!( - hs.insert(&nullifier, seq as usize + 2399), + hs.insert(nullifier, seq + 2399), Err(HashSetError::ElementAlreadyExists), )); seq += 1; @@ -1023,7 +1013,7 @@ mod test { std::array::from_fn(|_| BigUint::from(Fr::rand(&mut rng))); for nullifier in nullifiers.iter() { - hs.insert(&nullifier, 0).unwrap(); + hs.insert(nullifier, 0).unwrap(); } let mut sorted_nullifiers = nullifiers.iter().collect::>(); diff --git a/program-libs/hash-set/src/zero_copy.rs b/program-libs/hash-set/src/zero_copy.rs index d558cef1e7..e4e35d6da8 100644 --- a/program-libs/hash-set/src/zero_copy.rs +++ b/program-libs/hash-set/src/zero_copy.rs @@ -190,7 +190,7 @@ mod test { } for (seq, nullifier) in nullifiers.iter().enumerate() { - let index = hs.insert(&nullifier, seq).unwrap(); + let index = hs.insert(nullifier, seq).unwrap(); hs.mark_with_sequence_number(index, seq).unwrap(); } } @@ -201,11 +201,11 @@ mod test { unsafe { HashSetZeroCopy::from_bytes_zero_copy_mut(bytes.as_mut_slice()).unwrap() }; for (seq, nullifier) in nullifiers.iter().enumerate() { - assert_eq!(hs.contains(nullifier, Some(seq)).unwrap(), true); + assert!(hs.contains(nullifier, Some(seq)).unwrap()); } for (seq, nullifier) in nullifiers.iter().enumerate() { - hs.insert(&nullifier, 2400 + seq as usize).unwrap(); + hs.insert(nullifier, 2400 + seq).unwrap(); } drop(hs); } @@ -215,10 +215,7 @@ mod test { let hs = unsafe { HashSet::from_bytes_copy(bytes.as_mut_slice()).unwrap() }; for (seq, nullifier) in nullifiers.iter().enumerate() { - assert_eq!( - hs.contains(nullifier, Some(2400 + seq as usize)).unwrap(), - true - ); + assert!(hs.contains(nullifier, Some(2400 + seq)).unwrap()); } } } diff --git a/program-libs/indexed-merkle-tree/tests/tests.rs b/program-libs/indexed-merkle-tree/tests/tests.rs index 596220176f..2e4e1dbff0 100644 --- a/program-libs/indexed-merkle-tree/tests/tests.rs +++ b/program-libs/indexed-merkle-tree/tests/tests.rs @@ -42,8 +42,8 @@ fn program_insert( where H: Hasher, { - for i in 0..NR_NULLIFIERS { - let nullifier = BigUint::from_be_bytes(nullifiers[i].as_slice()); + for nullifier_bytes in &nullifiers { + let nullifier = BigUint::from_be_bytes(nullifier_bytes.as_slice()); queue.insert(&nullifier, merkle_tree.sequence_number())?; } Ok(()) @@ -57,6 +57,7 @@ enum RelayerUpdateError { /// A mock function which imitates a Merkle tree program instruction for /// inserting nullifiers from the queue to the tree. +#[allow(clippy::too_many_arguments)] fn program_update( // PDAs queue: &mut RefMut<'_, HashSet>, @@ -132,7 +133,7 @@ where ) .unwrap(); let mut low_nullifier_proof = relayer_merkle_tree - .get_proof_of_leaf(usize::from(old_low_nullifier.index), false) + .get_proof_of_leaf(old_low_nullifier.index, false) .unwrap(); // Update on-chain tree. @@ -487,7 +488,7 @@ where // (Invalid) low nullifier. let low_nullifier = local_indexed_array.get(1).cloned().unwrap(); let low_nullifier_next_value = local_indexed_array - .get(usize::from(low_nullifier.next_index)) + .get(low_nullifier.next_index) .cloned() .unwrap() .value; @@ -524,7 +525,7 @@ where // (Invalid) low nullifier. let low_nullifier = local_indexed_array.get(0).cloned().unwrap(); let low_nullifier_next_value = local_indexed_array - .get(usize::from(low_nullifier.next_index)) + .get(low_nullifier.next_index) .cloned() .unwrap() .value; @@ -1110,7 +1111,7 @@ fn perform_change_log_test< for (i, (address, indexed_array)) in addresses.iter().zip(indexed_arrays.iter_mut()).enumerate() { let (old_low_address, old_low_address_next_value) = indexed_array - .find_low_element_for_nonexistent(&address) + .find_low_element_for_nonexistent(address) .unwrap(); let address_bundle = indexed_array .new_element_with_low_element_index(old_low_address.index, address) diff --git a/program-libs/merkle-tree-metadata/src/rollover.rs b/program-libs/merkle-tree-metadata/src/rollover.rs index 2c875e28aa..7ec63162f0 100644 --- a/program-libs/merkle-tree-metadata/src/rollover.rs +++ b/program-libs/merkle-tree-metadata/src/rollover.rs @@ -132,7 +132,7 @@ mod tests { assert_eq!( metadata.rollover(), - Err(MerkleTreeMetadataError::RolloverNotConfigured.into()) + Err(MerkleTreeMetadataError::RolloverNotConfigured) ); let mut metadata = RolloverMetadata::new(0, 0, Some(95), 0, None, None); assert_eq!(metadata.close_threshold, u64::MAX); @@ -144,7 +144,7 @@ mod tests { assert_eq!( metadata.rollover(), - Err(MerkleTreeMetadataError::MerkleTreeAlreadyRolledOver.into()) + Err(MerkleTreeMetadataError::MerkleTreeAlreadyRolledOver) ); } } diff --git a/program-libs/utils/src/account.rs b/program-libs/utils/src/account.rs index c23c9e51a8..1a22939227 100644 --- a/program-libs/utils/src/account.rs +++ b/program-libs/utils/src/account.rs @@ -196,7 +196,7 @@ mod check_account_tests { } } - pub fn get_account_info<'a>(&'a mut self) -> AccountInfo<'a> { + pub fn get_account_info(&mut self) -> AccountInfo<'_> { AccountInfo { key: &self.key, is_signer: false, diff --git a/program-libs/utils/src/prime.rs b/program-libs/utils/src/prime.rs index fa40f299ad..338bd601e6 100644 --- a/program-libs/utils/src/prime.rs +++ b/program-libs/utils/src/prime.rs @@ -129,11 +129,11 @@ mod test { #[test] fn test_is_prime() { - assert_eq!(is_prime(1), false); - assert_eq!(is_prime(2), true); - assert_eq!(is_prime(3), true); - assert_eq!(is_prime(4), false); - assert_eq!(is_prime(17), true); - assert_eq!(is_prime(19), true); + assert!(!is_prime(1)); + assert!(is_prime(2)); + assert!(is_prime(3)); + assert!(!is_prime(4)); + assert!(is_prime(17)); + assert!(is_prime(19)); } } diff --git a/program-libs/verifier/tests/test.rs b/program-libs/verifier/tests/test.rs index 57fdece3d6..9daed8ddee 100644 --- a/program-libs/verifier/tests/test.rs +++ b/program-libs/verifier/tests/test.rs @@ -89,7 +89,7 @@ mod test { let inputs = inclusion_inputs_string(*number_of_compressed_accounts); let response_result = client - .post(&format!("{}{}", SERVER_ADDRESS, PROVE_PATH)) + .post(format!("{}{}", SERVER_ADDRESS, PROVE_PATH)) .header("Content-Type", "text/plain; charset=utf-8") .body(inputs) .send() diff --git a/program-libs/zero-copy/tests/slice_mut_test.rs b/program-libs/zero-copy/tests/slice_mut_test.rs index 920118e338..431845722a 100644 --- a/program-libs/zero-copy/tests/slice_mut_test.rs +++ b/program-libs/zero-copy/tests/slice_mut_test.rs @@ -21,7 +21,7 @@ where let mut rng = thread_rng(); let mut data = vec![0; ZeroCopySliceMut::::required_size_for_capacity(length)]; ZeroCopySliceMut::::new(length, &mut data).unwrap(); - let usize_len: usize = u64::try_from(length).unwrap() as usize; + let usize_len: usize = u64::from(length) as usize; // Test from_bytes with a zeroed slice { @@ -50,7 +50,7 @@ where } assert_eq!(length_bytes, (u64::from(length).to_le_bytes()).to_vec()); - let padding_start = metadata_size.clone(); + let padding_start = metadata_size; add_padding::(&mut metadata_size); let padding_end = metadata_size; let data = data[padding_start..padding_end].to_vec(); @@ -99,7 +99,7 @@ where // 7. Mutate elements via iter_mut for (index, element) in slice.iter_mut().enumerate() { let new_element = rng.gen(); - *element = new_element.clone(); + *element = new_element; reference_vec[index] = new_element; } @@ -149,7 +149,7 @@ fn test_zero_copy_unaligned_type_for_len() { } } - test_zero_copy_slice_mut_new::(u8::MAX as u8); + test_zero_copy_slice_mut_new::(u8::MAX); test_zero_copy_slice_mut_new::((u8::MAX as u16).into()); test_zero_copy_slice_mut_new::((u8::MAX as u32).into()); test_zero_copy_slice_mut_new::((u8::MAX as u64).into()); @@ -239,9 +239,8 @@ fn test_zero_copy_u8_struct_vec() { fn test_empty() { let length = 0; let mut data = vec![0; ZeroCopySliceMut::::required_size_for_capacity(length)]; - let mut zero_copy_slice = - ZeroCopySliceMut::::new(u8::try_from(length).unwrap(), &mut data).unwrap(); - let usize_len: usize = u64::try_from(length).unwrap() as usize; + let mut zero_copy_slice = ZeroCopySliceMut::::new(length, &mut data).unwrap(); + let usize_len: usize = length as usize; assert_eq!(zero_copy_slice.len(), usize_len); assert!(zero_copy_slice.is_empty()); @@ -251,9 +250,10 @@ fn test_empty() { assert_eq!(zero_copy_slice.get_mut(0), None); assert_eq!(zero_copy_slice.as_slice(), &[]); assert_eq!(zero_copy_slice.iter().cloned().collect::>(), vec![]); - for element in zero_copy_slice.iter_mut() { - panic!("Expected no elements, found {:?}", element); - } + assert!( + zero_copy_slice.iter_mut().next().is_none(), + "Expected no elements" + ); assert_eq!(zero_copy_slice.as_mut_slice(), &[]); assert_eq!(zero_copy_slice.to_vec(), vec![]); } @@ -263,9 +263,8 @@ fn test_empty() { fn test_index_out_of_bounds() { let length = 1; let mut data = vec![0; ZeroCopySliceMut::::required_size_for_capacity(length)]; - let zero_copy_slice = - ZeroCopySliceMut::::new(u8::try_from(length).unwrap(), &mut data).unwrap(); - zero_copy_slice[length as usize]; + let zero_copy_slice = ZeroCopySliceMut::::new(length, &mut data).unwrap(); + let _ = zero_copy_slice[length as usize]; } /// Test that metadata size is aligned to T. @@ -430,7 +429,7 @@ fn test_new_at_and_from_bytes_at_multiple() { fn test_new_at_multiple() { let mut account_data = vec![0u8; 128]; let capacity = 4usize; - let mut reference_vecs = vec![vec![], vec![]]; + let mut reference_vecs = [vec![], vec![]]; { let (mut initialized_vecs, remaining_bytes) = diff --git a/program-libs/zero-copy/tests/vec_tests.rs b/program-libs/zero-copy/tests/vec_tests.rs index c7ea9bee2d..728a2407c6 100644 --- a/program-libs/zero-copy/tests/vec_tests.rs +++ b/program-libs/zero-copy/tests/vec_tests.rs @@ -129,7 +129,7 @@ where assert_eq!(length, vec![0; metadata_size]); - let padding_start = metadata_size.clone(); + let padding_start = metadata_size; add_padding::(&mut metadata_size); let padding_end = metadata_size; let data = data[padding_start..padding_end].to_vec(); @@ -137,9 +137,7 @@ where assert_eq!(data, vec![0; padding_end - padding_start]); } } - let capacity_usize: usize = (u64::try_from(capacity) - .map_err(|_| ZeroCopyError::InvalidConversion) - .unwrap()) as usize; + let capacity_usize: usize = (u64::from(capacity)) as usize; let mut reference_vec = vec![]; // fill vector completely and assert: { @@ -215,7 +213,7 @@ where } assert_eq!(length, ((i as u64 + 1).to_ne_bytes().as_ref().to_vec())); - let padding_start = metadata_size.clone(); + let padding_start = metadata_size; add_padding::(&mut metadata_size); let padding_end = metadata_size; let cloned_data = cloned_data[padding_start..padding_end].to_vec(); @@ -263,15 +261,10 @@ where } assert_eq!( length, - (u64::try_from(ref_length) - .map_err(|_| ZeroCopyError::InvalidConversion) - .unwrap()) - .to_le_bytes() - .as_ref() - .to_vec() + u64::from(ref_length).to_le_bytes().as_ref().to_vec() ); - let padding_start = metadata_size.clone(); + let padding_start = metadata_size; add_padding::(&mut metadata_size); let padding_end = metadata_size; let data = data[padding_start..padding_end].to_vec(); @@ -294,7 +287,7 @@ fn assert_full_vec( u64: From + TryInto, { // 1. vector capacity is correct - assert_eq!(vec.capacity() as u64, capacity.try_into().unwrap()); + assert_eq!(vec.capacity() as u64, capacity.into()); // 2. vector length is correct assert_eq!(vec.len(), capacity_usize); // 3. vector is not empty @@ -355,26 +348,22 @@ fn assert_empty_vec( // 12. vector to_vec returns correct vector assert_eq!(vec.to_vec(), reference_vec); // 13. (iter) iterating over vector returns correct elements - for (index, element) in vec.iter().enumerate() { - panic!( - "Should not iterate over empty vector: index={}, element={:?}", - index, element - ); - } + assert!( + vec.iter().next().is_none(), + "Should not iterate over empty vector" + ); // 14. (iter_mut) iterating over vector mutably returns correct elements - for (index, element) in vec.iter_mut().enumerate() { - panic!( - "Should not iterate over empty vector: index={}, element={:?}", - index, element - ); - } + assert!( + vec.iter_mut().next().is_none(), + "Should not iterate over empty vector" + ); } #[test] fn test_zero_copy_vec_to_array() { let capacity = 16; let mut data = vec![0; ZeroCopyVecU64::::required_size_for_capacity(capacity)]; - let mut vec = ZeroCopyVecU64::::new(capacity as u64, &mut data).unwrap(); + let mut vec = ZeroCopyVecU64::::new(capacity, &mut data).unwrap(); vec.extend_from_slice(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]); let arr: [u32; 16] = vec.try_into_array().unwrap(); @@ -394,7 +383,7 @@ fn test_zero_copy_vec_to_array() { fn test_zero_copy_vec_into_iter() { let capacity = 1000; let mut data = vec![0; ZeroCopyVecU64::::required_size_for_capacity(capacity)]; - let mut vec = ZeroCopyVecU64::::new(capacity as u64, &mut data).unwrap(); + let mut vec = ZeroCopyVecU64::::new(capacity, &mut data).unwrap(); for i in 0..1000 { vec.push(i).unwrap(); @@ -457,7 +446,7 @@ fn test_init_multiple_pass() { assert_eq!(initialized_vecs[1].capacity(), capacity); assert_eq!(initialized_vecs[0].len(), 0); assert_eq!(initialized_vecs[1].len(), 0); - let mut reference_vecs = vec![vec![], vec![]]; + let mut reference_vecs = [vec![], vec![]]; for i in 0..capacity { for (j, vec) in initialized_vecs.iter_mut().enumerate() { assert!(vec.get(i).is_none()); @@ -472,7 +461,7 @@ fn test_init_multiple_pass() { assert_full_vec( capacity as u64, &mut rng, - capacity as usize, + capacity, &mut reference_vecs[i], vec, ); diff --git a/program-tests/utils/src/assert_token_tx.rs b/program-tests/utils/src/assert_token_tx.rs index 69c6596ff4..879a73c6dc 100644 --- a/program-tests/utils/src/assert_token_tx.rs +++ b/program-tests/utils/src/assert_token_tx.rs @@ -20,7 +20,7 @@ use crate::assert_compressed_tx::{ /// 4. Merkle tree was updated correctly /// 5. TODO: Fees have been paid (after fee refactor) /// 6. Check compression amount was transferred (outside of this function) -/// No addresses in token transactions +/// No addresses in token transactions #[allow(clippy::too_many_arguments)] pub async fn assert_transfer + TestIndexerExtensions>( context: &mut R, diff --git a/program-tests/utils/src/lib.rs b/program-tests/utils/src/lib.rs index 77620f619a..0d561fd465 100644 --- a/program-tests/utils/src/lib.rs +++ b/program-tests/utils/src/lib.rs @@ -165,6 +165,7 @@ pub async fn create_address_merkle_tree_and_queue_account_with_assert, error_code: u32, diff --git a/programs/account-compression/src/instructions/migrate_state.rs b/programs/account-compression/src/instructions/migrate_state.rs index 8063f76cb2..220fe01c83 100644 --- a/programs/account-compression/src/instructions/migrate_state.rs +++ b/programs/account-compression/src/instructions/migrate_state.rs @@ -156,7 +156,7 @@ mod migrate_state_test { }; let account = BatchedQueueMetadata { - metadata: metadata.clone(), + metadata, next_index: 0, batch_metadata: BatchMetadata { batch_size: 1000, @@ -178,7 +178,7 @@ mod migrate_state_test { }; let data = unsafe { std::slice::from_raw_parts_mut( - mock_account.account_data.as_mut_ptr() as *mut u8, + mock_account.account_data.as_mut_ptr(), mock_account.account_data.len(), ) }; @@ -248,7 +248,7 @@ mod migrate_state_test { { let input = MigrateLeafParams { change_log_index: concurrent_mt_with_canopy.changelog_index() as u64, - leaf: leaves[0].clone(), + leaf: leaves[0], leaf_index: 0, proof: ref_merkle_tree .get_proof_of_leaf(0, false) @@ -278,7 +278,7 @@ mod migrate_state_test { { let input = MigrateLeafParams { change_log_index: concurrent_mt_with_canopy.changelog_index() as u64, - leaf: leaves[1].clone(), + leaf: leaves[1], leaf_index: 1, proof: ref_merkle_tree .get_proof_of_leaf(1, false) @@ -305,7 +305,7 @@ mod migrate_state_test { } let input = MigrateLeafParams { change_log_index: concurrent_mt_with_canopy.changelog_index() as u64, - leaf: leaves[2].clone(), + leaf: leaves[2], leaf_index: 2, proof: ref_merkle_tree .get_proof_of_leaf(2, false) @@ -435,7 +435,7 @@ mod migrate_state_test { let leaf_index = ref_merkle_tree.get_leaf_index(&leaf).unwrap(); let input = MigrateLeafParams { change_log_index: concurrent_mt_with_canopy.changelog_index() as u64, - leaf: leaf.clone(), + leaf, leaf_index: leaf_index as u64, proof: ref_merkle_tree .get_proof_of_leaf(leaf_index, false) diff --git a/programs/compressed-token/src/freeze.rs b/programs/compressed-token/src/freeze.rs index 8ecae003ed..daeefd1555 100644 --- a/programs/compressed-token/src/freeze.rs +++ b/programs/compressed-token/src/freeze.rs @@ -541,7 +541,7 @@ pub mod test_freeze { vec } pub fn create_expected_input_accounts( - input_token_data_with_context: &Vec, + input_token_data_with_context: &[InputTokenDataWithContext], mint: &Pubkey, owner: &Pubkey, remaining_accounts: &[Pubkey], @@ -550,11 +550,9 @@ pub mod test_freeze { input_token_data_with_context .iter() .map(|x| { - let delegate = if let Some(index) = x.delegate_index { - Some(remaining_accounts[index as usize]) - } else { - None - }; + let delegate = x + .delegate_index + .map(|index| remaining_accounts[index as usize]); let token_data = TokenData { mint: *mint, owner: *owner, diff --git a/programs/compressed-token/src/process_mint.rs b/programs/compressed-token/src/process_mint.rs index 682972fe6a..d09ba80018 100644 --- a/programs/compressed-token/src/process_mint.rs +++ b/programs/compressed-token/src/process_mint.rs @@ -486,7 +486,6 @@ pub mod mint_sdk { } #[cfg(test)] - mod test { use light_hasher::Poseidon; use light_system_program::{ @@ -502,8 +501,8 @@ mod test { #[test] fn test_manual_ix_data_serialization_borsh_compat() { - let pubkeys = vec![Pubkey::new_unique(), Pubkey::new_unique()]; - let amounts = vec![1, 2]; + let pubkeys = [Pubkey::new_unique(), Pubkey::new_unique()]; + let amounts = [1, 2]; let mint_pubkey = Pubkey::new_unique(); let mut output_compressed_accounts = vec![OutputCompressedAccountWithPackedContext::default(); pubkeys.len()]; @@ -568,8 +567,8 @@ mod test { for _ in 0..10000 { let mut rng = rand::thread_rng(); - let pubkeys = vec![Pubkey::new_unique(), Pubkey::new_unique()]; - let amounts = vec![rng.gen_range(0..1_000_000_000_000), rng.gen_range(1..100)]; + let pubkeys = [Pubkey::new_unique(), Pubkey::new_unique()]; + let amounts = [rng.gen_range(0..1_000_000_000_000), rng.gen_range(1..100)]; let mint_pubkey = Pubkey::new_unique(); let mut output_compressed_accounts = vec![OutputCompressedAccountWithPackedContext::default(); pubkeys.len()]; @@ -624,7 +623,7 @@ mod test { inputs_struct.serialize(&mut reference).unwrap(); assert_eq!(inputs.len(), reference.len()); - for (_, i) in inputs.iter().zip(reference.iter()).enumerate() { + for i in inputs.iter().zip(reference.iter()) { assert_eq!(i.0, i.1); } assert_eq!(inputs, reference); diff --git a/programs/compressed-token/src/process_transfer.rs b/programs/compressed-token/src/process_transfer.rs index 124fd9cf82..0ea6d474f7 100644 --- a/programs/compressed-token/src/process_transfer.rs +++ b/programs/compressed-token/src/process_transfer.rs @@ -1042,7 +1042,7 @@ mod test { }; sum_check( inputs.as_slice(), - &output_amounts, + output_amounts, compress_or_decompress_amount, is_compress, ) diff --git a/programs/compressed-token/src/token_data.rs b/programs/compressed-token/src/token_data.rs index e476e2b995..dcf0977f15 100644 --- a/programs/compressed-token/src/token_data.rs +++ b/programs/compressed-token/src/token_data.rs @@ -363,8 +363,8 @@ pub mod test { assert_to_previous_hashes(hash4, &mut vec_previous_hashes); // different delegate - let delegate = Some(Pubkey::new_unique()); - let hashed_delegate = hash_to_bn254_field_size_be(delegate.unwrap().to_bytes().as_slice()) + let delegate = Pubkey::new_unique(); + let hashed_delegate = hash_to_bn254_field_size_be(delegate.to_bytes().as_slice()) .unwrap() .0; let hash7 = TokenData::hash_with_hashed_values::( @@ -382,7 +382,7 @@ pub mod test { let hash9 = token_data.hash::().unwrap(); assert_to_previous_hashes(hash9, &mut vec_previous_hashes); // different account state with delegate - token_data.delegate = delegate; + token_data.delegate = Some(delegate); let hash10 = token_data.hash::().unwrap(); assert_to_previous_hashes(hash10, &mut vec_previous_hashes); } diff --git a/programs/registry/src/protocol_config/state.rs b/programs/registry/src/protocol_config/state.rs index b4c441aa10..24a6eca469 100644 --- a/programs/registry/src/protocol_config/state.rs +++ b/programs/registry/src/protocol_config/state.rs @@ -96,16 +96,16 @@ pub enum EpochState { /// /// To get the latest registry epoch: /// - slot = 0; -/// let current_registry_epoch = (slot - genesis) / active_phase_length; -/// current_registry_epoch = (0 - 0) / 1000 = 0; -/// first active phase starts at genesis + registration_phase_length +/// let current_registry_epoch = (slot - genesis) / active_phase_length; +/// current_registry_epoch = (0 - 0) / 1000 = 0; +/// first active phase starts at genesis + registration_phase_length /// = 0 + 100 = 100; /// /// To get the current active epoch: /// - slot = 100; -/// let current_active_epoch = +/// let current_active_epoch = /// (slot - genesis - registration_phase_length) / active_phase_length; -/// current_active_epoch = (100 - 0 - 100) / 1000 = 0; +/// current_active_epoch = (100 - 0 - 100) / 1000 = 0; /// /// Epoch 0: /// - Registration 0: 0 - 100 diff --git a/programs/system/src/invoke/processor.rs b/programs/system/src/invoke/processor.rs index f19f78772b..ff483d01da 100644 --- a/programs/system/src/invoke/processor.rs +++ b/programs/system/src/invoke/processor.rs @@ -415,7 +415,7 @@ fn filter_for_accounts_not_proven_by_index( /// Network fee distribution: /// - if any account is created or modified -> transfer network fee (5000 lamports) -/// (Previously we didn't charge for appends now we have to since values go into a queue.) +/// (Previously we didn't charge for appends now we have to since values go into a queue.) /// - if an address is created -> transfer an additional network fee (5000 lamports) /// /// Examples: diff --git a/programs/system/src/invoke/verify_signer.rs b/programs/system/src/invoke/verify_signer.rs index 28c6eef412..b4ac2e6237 100644 --- a/programs/system/src/invoke/verify_signer.rs +++ b/programs/system/src/invoke/verify_signer.rs @@ -54,7 +54,7 @@ mod test { assert_eq!( input_compressed_accounts_signer_check( - &vec![compressed_account_with_context.clone()], + &[compressed_account_with_context.clone()], &authority ), Ok(()) diff --git a/programs/system/src/invoke/verify_state_proof.rs b/programs/system/src/invoke/verify_state_proof.rs index d20364fec2..2392f9950a 100644 --- a/programs/system/src/invoke/verify_state_proof.rs +++ b/programs/system/src/invoke/verify_state_proof.rs @@ -246,7 +246,7 @@ fn fetch_root( /// For each read-only account /// 1. prove inclusion by index in the output queue if leaf index should exist in the output queue. -/// 1.1. if inclusion was proven by index, return Ok. +/// 1.1. if inclusion was proven by index, return Ok. /// 2. prove non-inclusion in the bloom filters /// 2.1. skip wiped batches. /// 2.2. prove non-inclusion in the bloom filters for each batch. diff --git a/programs/system/src/sdk/invoke.rs b/programs/system/src/sdk/invoke.rs index 418cc3de43..9c52c05531 100644 --- a/programs/system/src/sdk/invoke.rs +++ b/programs/system/src/sdk/invoke.rs @@ -264,7 +264,7 @@ mod test { data: None, }, ]; - let merkle_tree_indices = vec![0, 2]; + let merkle_tree_indices = [0, 2]; let merkle_tree_pubkey = Keypair::new().pubkey(); let merkle_tree_pubkey_1 = Keypair::new().pubkey(); @@ -364,7 +364,7 @@ mod test { .unwrap(), 100 ); - assert_eq!(deserialized_instruction_data.is_compress, true); + assert!(deserialized_instruction_data.is_compress); let ref_account_meta = AccountMeta::new(payer, true); assert_eq!(instruction.accounts[0], ref_account_meta); assert_eq!( diff --git a/prover/client/src/indexed_changelog.rs b/prover/client/src/indexed_changelog.rs index 2fdff8abb8..4bcd760eb8 100644 --- a/prover/client/src/indexed_changelog.rs +++ b/prover/client/src/indexed_changelog.rs @@ -7,7 +7,7 @@ use num_bigint::BigUint; /// Patch the indexed changelogs. /// 1. find changelog entries of the same index /// 2. iterate over entries -/// 2.1 if next_value < new_element.value patch element +/// 2.1 if next_value < new_element.value patch element /// 3. #[inline(never)] pub fn patch_indexed_changelogs( @@ -239,7 +239,7 @@ mod tests { println!("indexed_changelog {:?}", indexed_changelog); for address in addresses.iter() { indexed_merkle_tree - .append(&address, &mut indexed_array) + .append(address, &mut indexed_array) .unwrap(); } println!("man_indexed_array {:?}", man_indexed_array); @@ -353,7 +353,7 @@ mod tests { println!("indexed_changelog {:?}", indexed_changelog); for address in addresses.iter() { indexed_merkle_tree - .append(&address, &mut indexed_array) + .append(address, &mut indexed_array) .unwrap(); } println!("man_indexed_array {:?}", man_indexed_array); diff --git a/prover/client/tests/gnark.rs b/prover/client/tests/gnark.rs index 52562dd3a8..2475387540 100644 --- a/prover/client/tests/gnark.rs +++ b/prover/client/tests/gnark.rs @@ -43,7 +43,7 @@ async fn prove_inclusion() { for number_of_utxos in &[1, 2, 3, 4, 8] { let inputs = inclusion_inputs_string(*number_of_utxos as usize); let response_result = client - .post(&format!("{}{}", SERVER_ADDRESS, PROVE_PATH)) + .post(format!("{}{}", SERVER_ADDRESS, PROVE_PATH)) .header("Content-Type", "text/plain; charset=utf-8") .body(inputs) .send() @@ -58,7 +58,7 @@ async fn prove_inclusion() { let inputs = inclusion_json_formatter_legacy::inclusion_inputs_string(*number_of_utxos as usize); let response_result = client - .post(&format!("{}{}", SERVER_ADDRESS, PROVE_PATH)) + .post(format!("{}{}", SERVER_ADDRESS, PROVE_PATH)) .header("Content-Type", "text/plain; charset=utf-8") .body(inputs) .send() @@ -87,7 +87,7 @@ async fn prove_combined() { for non_i in 1..=2 { let inputs = combined_inputs_string_legacy(i, non_i); let response_result = client - .post(&format!("{}{}", SERVER_ADDRESS, PROVE_PATH)) + .post(format!("{}{}", SERVER_ADDRESS, PROVE_PATH)) .header("Content-Type", "text/plain; charset=utf-8") .body(inputs) .send() @@ -102,7 +102,7 @@ async fn prove_combined() { for non_i in 1..=2 { let inputs = combined_inputs_string(i, non_i); let response_result = client - .post(&format!("{}{}", SERVER_ADDRESS, PROVE_PATH)) + .post(format!("{}{}", SERVER_ADDRESS, PROVE_PATH)) .header("Content-Type", "text/plain; charset=utf-8") .body(inputs) .send() @@ -133,7 +133,7 @@ async fn prove_non_inclusion() { let (inputs, _) = non_inclusion_inputs_string(i); let response_result = client - .post(&format!("{}{}", SERVER_ADDRESS, PROVE_PATH)) + .post(format!("{}{}", SERVER_ADDRESS, PROVE_PATH)) .header("Content-Type", "text/plain; charset=utf-8") .body(inputs) .send() @@ -151,7 +151,7 @@ async fn prove_non_inclusion() { ); let response_result = client - .post(&format!("{}{}", SERVER_ADDRESS, PROVE_PATH)) + .post(format!("{}{}", SERVER_ADDRESS, PROVE_PATH)) .header("Content-Type", "text/plain; charset=utf-8") .body(inputs) .send() @@ -193,6 +193,7 @@ async fn prove_batch_update() { old_leaves.push(leaf); merkle_tree.append(&leaf).unwrap(); + #[allow(clippy::unnecessary_cast)] let nullifier = Poseidon::hashv(&[&leaf, &(i as usize).to_be_bytes(), &tx_hash]).unwrap(); nullifiers.push(nullifier); @@ -221,7 +222,7 @@ async fn prove_batch_update() { let client = Client::new(); let inputs = update_inputs_string(&inputs); let response_result = client - .post(&format!("{}{}", SERVER_ADDRESS, PROVE_PATH)) + .post(format!("{}{}", SERVER_ADDRESS, PROVE_PATH)) .header("Content-Type", "text/plain; charset=utf-8") .body(inputs) .send() @@ -310,7 +311,7 @@ async fn prove_batch_append_with_proofs() { let inputs_json = BatchAppendWithProofsInputsJson::from_inputs(&inputs).to_string(); // Send proof request to server let response_result = client - .post(&format!("{}{}", SERVER_ADDRESS, PROVE_PATH)) + .post(format!("{}{}", SERVER_ADDRESS, PROVE_PATH)) .header("Content-Type", "text/plain; charset=utf-8") .body(inputs_json) .send() @@ -429,7 +430,7 @@ async fn prove_batch_address_append() { // Send proof request to server let client = Client::new(); let response_result = client - .post(&format!("{}{}", SERVER_ADDRESS, PROVE_PATH)) + .post(format!("{}{}", SERVER_ADDRESS, PROVE_PATH)) .header("Content-Type", "text/plain; charset=utf-8") .body(inputs_json) .send() diff --git a/scripts/lint.sh b/scripts/lint.sh index f0d2223b13..d0793aac87 100755 --- a/scripts/lint.sh +++ b/scripts/lint.sh @@ -5,12 +5,4 @@ npx nx run-many --target=format:check --all npx nx run-many --target=lint --all cargo +nightly fmt --all -- --check -cargo clippy \ - --workspace \ - --exclude photon-api \ - --exclude name-service \ - -- -A clippy::result_large_err \ - -A clippy::empty-docs \ - -A clippy::to-string-trait-impl \ - -A clippy::doc_lazy_continuation \ - -D warnings +cargo clippy --workspace --all-targets -- -D warnings \ No newline at end of file diff --git a/sdk-libs/client/src/rpc/errors.rs b/sdk-libs/client/src/rpc/errors.rs index 6ca9524ec5..338c4c19b1 100644 --- a/sdk-libs/client/src/rpc/errors.rs +++ b/sdk-libs/client/src/rpc/errors.rs @@ -31,6 +31,7 @@ pub enum RpcError { InvalidWarpSlot, } +#[allow(clippy::result_large_err)] pub fn assert_rpc_error( result: Result, i: u8, diff --git a/sdk-libs/client/src/rpc/solana_rpc.rs b/sdk-libs/client/src/rpc/solana_rpc.rs index a98091a0b4..2c3cc6b632 100644 --- a/sdk-libs/client/src/rpc/solana_rpc.rs +++ b/sdk-libs/client/src/rpc/solana_rpc.rs @@ -132,6 +132,7 @@ impl SolanaRpcConnection { } impl SolanaRpcConnection { + #[allow(clippy::result_large_err)] fn parse_inner_instructions( &self, signature: Signature, diff --git a/sdk-libs/macros/src/hasher.rs b/sdk-libs/macros/src/hasher.rs index 94df7b7813..bf26fb3e1c 100644 --- a/sdk-libs/macros/src/hasher.rs +++ b/sdk-libs/macros/src/hasher.rs @@ -265,7 +265,7 @@ impl ::light_hasher::DataHasher for OuterStruct { } }"#; - assert_eq!(formatted_output.contains(expected_output), true); + assert!(formatted_output.contains(expected_output)); } #[test] fn test_option_handling() { diff --git a/sdk-libs/macros/tests/hasher.rs b/sdk-libs/macros/tests/hasher.rs index 47cb2f32bd..9b118176fb 100644 --- a/sdk-libs/macros/tests/hasher.rs +++ b/sdk-libs/macros/tests/hasher.rs @@ -39,7 +39,7 @@ mod tests { /// - test_zero_values: assert_eq! zero-value field hash matches manual hash /// /// 2. Attribute Behavior: - /// a. Truncate (Success): + /// a. Truncate (Success): /// - test_array_truncation: assert_ne! between different array hashes /// - test_truncation_longer_array: assert_ne! between different long string hashes /// - test_multiple_truncates: assert_ne! between multiple truncated field hashes @@ -299,7 +299,7 @@ mod tests { let manual_hash = Poseidon::hashv(&[ &test_struct.inner.hash::().unwrap(), - &light_utils::hash_to_bn254_field_size_be(&test_struct.data.as_bytes()) + &light_utils::hash_to_bn254_field_size_be(test_struct.data.as_bytes()) .unwrap() .0, ]) diff --git a/sdk-libs/photon-api/src/models/account_state.rs b/sdk-libs/photon-api/src/models/account_state.rs index 3dae0c673c..0d41b8cc6f 100644 --- a/sdk-libs/photon-api/src/models/account_state.rs +++ b/sdk-libs/photon-api/src/models/account_state.rs @@ -10,7 +10,6 @@ use crate::models; -/// #[derive(Clone, Copy, Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Serialize, Deserialize)] pub enum AccountState { #[serde(rename = "initialized")] @@ -19,11 +18,11 @@ pub enum AccountState { Frozen, } -impl ToString for AccountState { - fn to_string(&self) -> String { +impl std::fmt::Display for AccountState { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { - Self::Initialized => String::from("initialized"), - Self::Frozen => String::from("frozen"), + Self::Initialized => write!(f, "initialized"), + Self::Frozen => write!(f, "frozen"), } } } diff --git a/sdk-libs/sdk/src/transfer.rs b/sdk-libs/sdk/src/transfer.rs index 130e3dd37e..9b1f2042c8 100644 --- a/sdk-libs/sdk/src/transfer.rs +++ b/sdk-libs/sdk/src/transfer.rs @@ -42,7 +42,7 @@ mod tests { use crate::{account_info::LightInputAccountInfo, merkle_context::PackedMerkleContext}; /// Creates a mock account with the given input lamports. - fn mock_account<'a>(owner: &'a Pubkey, lamports: Option) -> LightAccountInfo<'a> { + fn mock_account(owner: &Pubkey, lamports: Option) -> LightAccountInfo<'_> { LightAccountInfo { input: Some(LightInputAccountInfo { lamports, @@ -72,7 +72,7 @@ mod tests { } /// Creates a mock account without input. - fn mock_account_without_input<'a>(owner: &'a Pubkey) -> LightAccountInfo<'a> { + fn mock_account_without_input(owner: &Pubkey) -> LightAccountInfo<'_> { LightAccountInfo { input: None, owner,