diff --git a/crates/node/src/shell/finalize_block.rs b/crates/node/src/shell/finalize_block.rs
index 215ed23420..ee65f3b057 100644
--- a/crates/node/src/shell/finalize_block.rs
+++ b/crates/node/src/shell/finalize_block.rs
@@ -1351,11 +1351,7 @@ mod test_finalize_block {
                 .enumerate()
                 .find_map(
                     |(idx, tx_hash)| {
-                        if tx_hash == &hash {
-                            Some(idx)
-                        } else {
-                            None
-                        }
+                        if tx_hash == &hash { Some(idx) } else { None }
                     },
                 )
                 .unwrap();
@@ -2949,21 +2945,25 @@ mod test_finalize_block {
         assert_eq!(root_pre.0, root_post.0);
 
         // Check transaction's hash in storage
-        assert!(shell
-            .shell
-            .state
-            .write_log()
-            .has_replay_protection_entry(&wrapper_tx.raw_header_hash()));
+        assert!(
+            shell
+                .shell
+                .state
+                .write_log()
+                .has_replay_protection_entry(&wrapper_tx.raw_header_hash())
+        );
         // Check that the hash is not present in the merkle tree
         shell.state.commit_block().unwrap();
-        assert!(!shell
-            .shell
-            .state
-            .in_mem()
-            .block
-            .tree
-            .has_key(&wrapper_hash_key)
-            .unwrap());
+        assert!(
+            !shell
+                .shell
+                .state
+                .in_mem()
+                .block
+                .tree
+                .has_key(&wrapper_hash_key)
+                .unwrap()
+        );
 
         // test that a commitment to replay protection gets added.
         let reprot_key = replay_protection::commitment_key();
@@ -3010,22 +3010,26 @@ mod test_finalize_block {
         assert_eq!(root_pre.0, root_post.0);
         // Check that the hashes are present in the merkle tree
         shell.state.commit_block().unwrap();
-        assert!(shell
-            .shell
-            .state
-            .in_mem()
-            .block
-            .tree
-            .has_key(&convert_key)
-            .unwrap());
-        assert!(shell
-            .shell
-            .state
-            .in_mem()
-            .block
-            .tree
-            .has_key(&commitment_key)
-            .unwrap());
+        assert!(
+            shell
+                .shell
+                .state
+                .in_mem()
+                .block
+                .tree
+                .has_key(&convert_key)
+                .unwrap()
+        );
+        assert!(
+            shell
+                .shell
+                .state
+                .in_mem()
+                .block
+                .tree
+                .has_key(&commitment_key)
+                .unwrap()
+        );
     }
 
     /// Test that a tx that has already been applied in the same block
@@ -3103,26 +3107,34 @@ mod test_finalize_block {
         assert_eq!(code, ResultCode::WasmRuntimeError);
 
         for wrapper in [&wrapper, &new_wrapper] {
-            assert!(shell
-                .state
-                .write_log()
-                .has_replay_protection_entry(&wrapper.raw_header_hash()));
-            assert!(!shell
-                .state
-                .write_log()
-                .has_replay_protection_entry(&wrapper.header_hash()));
+            assert!(
+                shell
+                    .state
+                    .write_log()
+                    .has_replay_protection_entry(&wrapper.raw_header_hash())
+            );
+            assert!(
+                !shell
+                    .state
+                    .write_log()
+                    .has_replay_protection_entry(&wrapper.header_hash())
+            );
         }
         // Commit to check the hashes from storage
         shell.commit();
         for wrapper in [&wrapper, &new_wrapper] {
-            assert!(shell
-                .state
-                .has_replay_protection_entry(&wrapper.raw_header_hash())
-                .unwrap());
-            assert!(!shell
-                .state
-                .has_replay_protection_entry(&wrapper.header_hash())
-                .unwrap());
+            assert!(
+                shell
+                    .state
+                    .has_replay_protection_entry(&wrapper.raw_header_hash())
+                    .unwrap()
+            );
+            assert!(
+                !shell
+                    .state
+                    .has_replay_protection_entry(&wrapper.header_hash())
+                    .unwrap()
+            );
         }
     }
 
@@ -3405,23 +3417,29 @@ mod test_finalize_block {
             &unsigned_wrapper,
             &wrong_commitment_wrapper,
         ] {
-            assert!(!shell
-                .state
-                .write_log()
-                .has_replay_protection_entry(&valid_wrapper.raw_header_hash()));
-            assert!(shell
+            assert!(
+                !shell.state.write_log().has_replay_protection_entry(
+                    &valid_wrapper.raw_header_hash()
+                )
+            );
+            assert!(
+                shell
+                    .state
+                    .write_log()
+                    .has_replay_protection_entry(&valid_wrapper.header_hash())
+            );
+        }
+        assert!(
+            shell.state.write_log().has_replay_protection_entry(
+                &failing_wrapper.raw_header_hash()
+            )
+        );
+        assert!(
+            !shell
                 .state
                 .write_log()
-                .has_replay_protection_entry(&valid_wrapper.header_hash()));
-        }
-        assert!(shell
-            .state
-            .write_log()
-            .has_replay_protection_entry(&failing_wrapper.raw_header_hash()));
-        assert!(!shell
-            .state
-            .write_log()
-            .has_replay_protection_entry(&failing_wrapper.header_hash()));
+                .has_replay_protection_entry(&failing_wrapper.header_hash())
+        );
 
         // Commit to check the hashes from storage
         shell.commit();
@@ -3430,23 +3448,33 @@ mod test_finalize_block {
             unsigned_wrapper,
             wrong_commitment_wrapper,
         ] {
-            assert!(!shell
+            assert!(
+                !shell
+                    .state
+                    .has_replay_protection_entry(
+                        &valid_wrapper.raw_header_hash()
+                    )
+                    .unwrap()
+            );
+            assert!(
+                shell
+                    .state
+                    .has_replay_protection_entry(&valid_wrapper.header_hash())
+                    .unwrap()
+            );
+        }
+        assert!(
+            shell
                 .state
-                .has_replay_protection_entry(&valid_wrapper.raw_header_hash())
-                .unwrap());
-            assert!(shell
+                .has_replay_protection_entry(&failing_wrapper.raw_header_hash())
+                .unwrap()
+        );
+        assert!(
+            !shell
                 .state
-                .has_replay_protection_entry(&valid_wrapper.header_hash())
-                .unwrap());
-        }
-        assert!(shell
-            .state
-            .has_replay_protection_entry(&failing_wrapper.raw_header_hash())
-            .unwrap());
-        assert!(!shell
-            .state
-            .has_replay_protection_entry(&failing_wrapper.header_hash())
-            .unwrap());
+                .has_replay_protection_entry(&failing_wrapper.header_hash())
+                .unwrap()
+        );
     }
 
     #[test]
@@ -3506,14 +3534,18 @@ mod test_finalize_block {
         let code = event[0].read_attribute::<CodeAttr>().expect("Test failed");
         assert_eq!(code, ResultCode::InvalidTx);
 
-        assert!(shell
-            .state
-            .write_log()
-            .has_replay_protection_entry(&wrapper_hash));
-        assert!(!shell
-            .state
-            .write_log()
-            .has_replay_protection_entry(&wrapper.raw_header_hash()));
+        assert!(
+            shell
+                .state
+                .write_log()
+                .has_replay_protection_entry(&wrapper_hash)
+        );
+        assert!(
+            !shell
+                .state
+                .write_log()
+                .has_replay_protection_entry(&wrapper.raw_header_hash())
+        );
     }
 
     // Test that the fees are paid even if the inner transaction fails and its
@@ -3911,9 +3943,11 @@ mod test_finalize_block {
                 .unwrap(),
             Some(ValidatorState::Consensus)
         );
-        assert!(enqueued_slashes_handle()
-            .at(&Epoch::default())
-            .is_empty(&shell.state)?);
+        assert!(
+            enqueued_slashes_handle()
+                .at(&Epoch::default())
+                .is_empty(&shell.state)?
+        );
         assert_eq!(
             get_num_consensus_validators(&shell.state, Epoch::default())
                 .unwrap(),
@@ -3932,17 +3966,21 @@ mod test_finalize_block {
                     .unwrap(),
                 Some(ValidatorState::Jailed)
             );
-            assert!(enqueued_slashes_handle()
-                .at(&epoch)
-                .is_empty(&shell.state)?);
+            assert!(
+                enqueued_slashes_handle()
+                    .at(&epoch)
+                    .is_empty(&shell.state)?
+            );
             assert_eq!(
                 get_num_consensus_validators(&shell.state, epoch).unwrap(),
                 5_u64
             );
         }
-        assert!(!enqueued_slashes_handle()
-            .at(&processing_epoch)
-            .is_empty(&shell.state)?);
+        assert!(
+            !enqueued_slashes_handle()
+                .at(&processing_epoch)
+                .is_empty(&shell.state)?
+        );
 
         // Advance to the processing epoch
         loop {
@@ -3965,9 +4003,11 @@ mod test_finalize_block {
                 // println!("Reached processing epoch");
                 break;
             } else {
-                assert!(enqueued_slashes_handle()
-                    .at(&shell.state.in_mem().block.epoch)
-                    .is_empty(&shell.state)?);
+                assert!(
+                    enqueued_slashes_handle()
+                        .at(&shell.state.in_mem().block.epoch)
+                        .is_empty(&shell.state)?
+                );
                 let stake1 = read_validator_stake(
                     &shell.state,
                     &params,
@@ -4451,11 +4491,13 @@ mod test_finalize_block {
             )
             .unwrap();
         assert_eq!(last_slash, Some(misbehavior_epoch));
-        assert!(namada_proof_of_stake::storage::validator_slashes_handle(
-            &val1.address
-        )
-        .is_empty(&shell.state)
-        .unwrap());
+        assert!(
+            namada_proof_of_stake::storage::validator_slashes_handle(
+                &val1.address
+            )
+            .is_empty(&shell.state)
+            .unwrap()
+        );
 
         tracing::debug!("Advancing to epoch 7");
 
@@ -4520,18 +4562,22 @@ mod test_finalize_block {
             )
             .unwrap();
         assert_eq!(last_slash, Some(Epoch(4)));
-        assert!(namada_proof_of_stake::is_validator_frozen(
-            &shell.state,
-            &val1.address,
-            current_epoch,
-            &params
-        )
-        .unwrap());
-        assert!(namada_proof_of_stake::storage::validator_slashes_handle(
-            &val1.address
-        )
-        .is_empty(&shell.state)
-        .unwrap());
+        assert!(
+            namada_proof_of_stake::is_validator_frozen(
+                &shell.state,
+                &val1.address,
+                current_epoch,
+                &params
+            )
+            .unwrap()
+        );
+        assert!(
+            namada_proof_of_stake::storage::validator_slashes_handle(
+                &val1.address
+            )
+            .is_empty(&shell.state)
+            .unwrap()
+        );
 
         let pre_stake_10 =
             namada_proof_of_stake::storage::read_validator_stake(
@@ -5409,9 +5455,11 @@ mod test_finalize_block {
             shell.vp_wasm_cache.clone(),
         );
         let parameters = ParametersVp { ctx };
-        assert!(parameters
-            .validate_tx(&batched_tx, &keys_changed, &verifiers)
-            .is_ok());
+        assert!(
+            parameters
+                .validate_tx(&batched_tx, &keys_changed, &verifiers)
+                .is_ok()
+        );
 
         // we advance forward to the next epoch
         let mut req = FinalizeBlock::default();
@@ -5484,11 +5532,13 @@ mod test_finalize_block {
         let inner_results = inner_tx_result.batch_results.0;
 
         for cmt in batch.commitments() {
-            assert!(inner_results
-                .get(&cmt.get_hash())
-                .unwrap()
-                .clone()
-                .is_ok_and(|res| res.is_accepted()));
+            assert!(
+                inner_results
+                    .get(&cmt.get_hash())
+                    .unwrap()
+                    .clone()
+                    .is_ok_and(|res| res.is_accepted())
+            );
         }
 
         // Check storage modifications
@@ -5526,18 +5576,24 @@ mod test_finalize_block {
         let inner_tx_result = event[0].read_attribute::<Batch<'_>>().unwrap();
         let inner_results = inner_tx_result.batch_results.0;
 
-        assert!(inner_results
-            .get(&batch.commitments()[0].get_hash())
-            .unwrap()
-            .clone()
-            .is_ok_and(|res| res.is_accepted()));
-        assert!(inner_results
-            .get(&batch.commitments()[1].get_hash())
-            .unwrap()
-            .clone()
-            .is_err());
+        assert!(
+            inner_results
+                .get(&batch.commitments()[0].get_hash())
+                .unwrap()
+                .clone()
+                .is_ok_and(|res| res.is_accepted())
+        );
+        assert!(
+            inner_results
+                .get(&batch.commitments()[1].get_hash())
+                .unwrap()
+                .clone()
+                .is_err()
+        );
         // Assert that the last tx didn't run
-        assert!(!inner_results.contains_key(&batch.commitments()[2].get_hash()));
+        assert!(
+            !inner_results.contains_key(&batch.commitments()[2].get_hash())
+        );
 
         // Check storage modifications are missing
         for key in ["random_key_1", "random_key_2", "random_key_3"] {
@@ -5568,21 +5624,27 @@ mod test_finalize_block {
         let inner_tx_result = event[0].read_attribute::<Batch<'_>>().unwrap();
         let inner_results = inner_tx_result.batch_results.0;
 
-        assert!(inner_results
-            .get(&batch.commitments()[0].get_hash())
-            .unwrap()
-            .clone()
-            .is_ok_and(|res| res.is_accepted()));
-        assert!(inner_results
-            .get(&batch.commitments()[1].get_hash())
-            .unwrap()
-            .clone()
-            .is_err());
-        assert!(inner_results
-            .get(&batch.commitments()[2].get_hash())
-            .unwrap()
-            .clone()
-            .is_ok_and(|res| res.is_accepted()));
+        assert!(
+            inner_results
+                .get(&batch.commitments()[0].get_hash())
+                .unwrap()
+                .clone()
+                .is_ok_and(|res| res.is_accepted())
+        );
+        assert!(
+            inner_results
+                .get(&batch.commitments()[1].get_hash())
+                .unwrap()
+                .clone()
+                .is_err()
+        );
+        assert!(
+            inner_results
+                .get(&batch.commitments()[2].get_hash())
+                .unwrap()
+                .clone()
+                .is_ok_and(|res| res.is_accepted())
+        );
 
         // Check storage modifications
         assert_eq!(
@@ -5593,10 +5655,12 @@ mod test_finalize_block {
                 .unwrap(),
             STORAGE_VALUE
         );
-        assert!(!shell
-            .state
-            .has_key(&"random_key_2".parse().unwrap())
-            .unwrap());
+        assert!(
+            !shell
+                .state
+                .has_key(&"random_key_2".parse().unwrap())
+                .unwrap()
+        );
         assert_eq!(
             shell
                 .state
@@ -5628,18 +5692,24 @@ mod test_finalize_block {
         let inner_tx_result = event[0].read_attribute::<Batch<'_>>().unwrap();
         let inner_results = inner_tx_result.batch_results.0;
 
-        assert!(inner_results
-            .get(&batch.commitments()[0].get_hash())
-            .unwrap()
-            .clone()
-            .is_ok_and(|res| res.is_accepted()));
-        assert!(inner_results
-            .get(&batch.commitments()[1].get_hash())
-            .unwrap()
-            .clone()
-            .is_err());
+        assert!(
+            inner_results
+                .get(&batch.commitments()[0].get_hash())
+                .unwrap()
+                .clone()
+                .is_ok_and(|res| res.is_accepted())
+        );
+        assert!(
+            inner_results
+                .get(&batch.commitments()[1].get_hash())
+                .unwrap()
+                .clone()
+                .is_err()
+        );
         // Assert that the last tx didn't run
-        assert!(!inner_results.contains_key(&batch.commitments()[2].get_hash()));
+        assert!(
+            !inner_results.contains_key(&batch.commitments()[2].get_hash())
+        );
 
         // Check storage modifications are missing
         for key in ["random_key_1", "random_key_2", "random_key_3"] {
@@ -5669,18 +5739,24 @@ mod test_finalize_block {
         let inner_tx_result = event[0].read_attribute::<Batch<'_>>().unwrap();
         let inner_results = inner_tx_result.batch_results.0;
 
-        assert!(inner_results
-            .get(&batch.commitments()[0].get_hash())
-            .unwrap()
-            .clone()
-            .is_ok_and(|res| res.is_accepted()));
-        assert!(inner_results
-            .get(&batch.commitments()[1].get_hash())
-            .unwrap()
-            .clone()
-            .is_err());
+        assert!(
+            inner_results
+                .get(&batch.commitments()[0].get_hash())
+                .unwrap()
+                .clone()
+                .is_ok_and(|res| res.is_accepted())
+        );
+        assert!(
+            inner_results
+                .get(&batch.commitments()[1].get_hash())
+                .unwrap()
+                .clone()
+                .is_err()
+        );
         // Assert that the last tx didn't run
-        assert!(!inner_results.contains_key(&batch.commitments()[2].get_hash()));
+        assert!(
+            !inner_results.contains_key(&batch.commitments()[2].get_hash())
+        );
 
         // Check storage modifications
         assert_eq!(