diff --git a/api-server/stack-test-suite/tests/v2/orders.rs b/api-server/stack-test-suite/tests/v2/orders.rs
index 07aa08322..d13fa0e61 100644
--- a/api-server/stack-test-suite/tests/v2/orders.rs
+++ b/api-server/stack-test-suite/tests/v2/orders.rs
@@ -21,10 +21,9 @@ use common::chain::{
 use super::*;
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 #[tokio::test]
 async fn create_fill_conclude_order(#[case] seed: Seed, #[case] version: OrdersVersion) {
     use common::chain::config::create_unit_test_config_builder;
diff --git a/chainstate/constraints-value-accumulator/src/tests/orders_constraints.rs b/chainstate/constraints-value-accumulator/src/tests/orders_constraints.rs
index eb739aab4..3e644af2a 100644
--- a/chainstate/constraints-value-accumulator/src/tests/orders_constraints.rs
+++ b/chainstate/constraints-value-accumulator/src/tests/orders_constraints.rs
@@ -254,10 +254,9 @@ fn create_order_constraints(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn fill_order_constraints(#[case] seed: Seed, #[case] version: OrdersVersion) {
     let mut rng = make_seedable_rng(seed);
 
@@ -608,10 +607,9 @@ fn fill_order_constraints(#[case] seed: Seed, #[case] version: OrdersVersion) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn conclude_order_constraints(#[case] seed: Seed, #[case] version: OrdersVersion) {
     let mut rng = make_seedable_rng(seed);
 
diff --git a/chainstate/test-suite/src/tests/data_deposit.rs b/chainstate/test-suite/src/tests/data_deposit.rs
index e6977fcde..9b7ce8f33 100644
--- a/chainstate/test-suite/src/tests/data_deposit.rs
+++ b/chainstate/test-suite/src/tests/data_deposit.rs
@@ -29,10 +29,9 @@ use test_utils::random::{Seed, make_seedable_rng};
 use tx_verifier::CheckTransactionError;
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), true)]
-#[trace]
 #[case(Seed::from_entropy(), false)]
+#[trace]
 fn data_deposited_too_large(#[case] seed: Seed, #[case] expect_success: bool) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -84,14 +83,11 @@ fn data_deposited_too_large(#[case] seed: Seed, #[case] expect_success: bool) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), true, 1)]
-#[trace]
 #[case(Seed::from_entropy(), false, 1)]
-#[trace]
 #[case(Seed::from_entropy(), true, 2)]
-#[trace]
 #[case(Seed::from_entropy(), false, 2)]
+#[trace]
 fn data_deposit_insufficient_fee(
     #[case] seed: Seed,
     #[case] expect_success: bool,
diff --git a/chainstate/test-suite/src/tests/fungible_tokens_v1.rs b/chainstate/test-suite/src/tests/fungible_tokens_v1.rs
index 93b33cae3..a2736b4ae 100644
--- a/chainstate/test-suite/src/tests/fungible_tokens_v1.rs
+++ b/chainstate/test-suite/src/tests/fungible_tokens_v1.rs
@@ -2575,10 +2575,9 @@ fn check_lockable_supply(#[case] seed: Seed) {
 // Issue a token.
 // Check that Unlimited and Fixed supplies cannot be locked.
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), TokenTotalSupply::Unlimited)]
-#[trace]
 #[case(Seed::from_entropy(), TokenTotalSupply::Fixed(Amount::from_atoms(1)))]
+#[trace]
 fn try_lock_not_lockable_supply(#[case] seed: Seed, #[case] supply: TokenTotalSupply) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
diff --git a/chainstate/test-suite/src/tests/input_commitments.rs b/chainstate/test-suite/src/tests/input_commitments.rs
index fb77c2e02..83b231f2d 100644
--- a/chainstate/test-suite/src/tests/input_commitments.rs
+++ b/chainstate/test-suite/src/tests/input_commitments.rs
@@ -298,10 +298,9 @@ fn pool_decommissioning(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn order_fill(#[case] seed: Seed, #[case] orders_version: OrdersVersion) {
     let mut rng = make_seedable_rng(seed);
 
@@ -585,10 +584,9 @@ fn order_fill(#[case] seed: Seed, #[case] orders_version: OrdersVersion) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn order_conclude(#[case] seed: Seed, #[case] orders_version: OrdersVersion) {
     let mut rng = make_seedable_rng(seed);
 
diff --git a/chainstate/test-suite/src/tests/orders_tests.rs b/chainstate/test-suite/src/tests/orders_tests.rs
index 0dc99f5e6..b2d98e701 100644
--- a/chainstate/test-suite/src/tests/orders_tests.rs
+++ b/chainstate/test-suite/src/tests/orders_tests.rs
@@ -732,10 +732,9 @@ fn create_order_tokens_for_tokens(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn conclude_order_check_storage(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -822,10 +821,9 @@ fn conclude_order_check_storage(#[case] seed: Seed, #[case] version: OrdersVersi
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn conclude_order_multiple_txs(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -921,10 +919,9 @@ fn conclude_order_multiple_txs(#[case] seed: Seed, #[case] version: OrdersVersio
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn fill_order_check_storage(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -1061,10 +1058,9 @@ fn fill_order_check_storage(#[case] seed: Seed, #[case] version: OrdersVersion)
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn fill_then_conclude(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -1283,10 +1279,9 @@ fn fill_then_conclude(#[case] seed: Seed, #[case] version: OrdersVersion) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn try_overbid_order_in_multiple_txs(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -1396,10 +1391,9 @@ fn try_overbid_order_in_multiple_txs(#[case] seed: Seed, #[case] version: Orders
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn fill_completely_then_conclude(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -1585,10 +1579,9 @@ fn fill_completely_then_conclude(#[case] seed: Seed, #[case] version: OrdersVers
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn conclude_order_check_signature(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -1720,10 +1713,9 @@ fn conclude_order_check_signature(#[case] seed: Seed, #[case] version: OrdersVer
 // Create a chain with an order which is filled partially.
 // Reorg from a point before the order was created, so that after reorg storage has no information on the order
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn reorg_before_create(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -1819,10 +1811,9 @@ fn reorg_before_create(#[case] seed: Seed, #[case] version: OrdersVersion) {
 // Create a chain with an order which is filled partially or completely and then concluded.
 // Reorg from a point after the order was created, so that after reorg storage has original information on the order
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn reorg_after_create(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -2025,10 +2016,9 @@ fn test_activation(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn create_order_with_nft(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -2469,10 +2459,9 @@ fn partially_fill_order_with_nft_v1(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn fill_order_with_zero(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -2554,10 +2543,9 @@ fn fill_order_with_zero(#[case] seed: Seed, #[case] version: OrdersVersion) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn fill_order_underbid(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         use orders_accounting::calculate_filled_amount;
@@ -3064,10 +3052,9 @@ fn create_order_fill_activate_fork_fill_conclude(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn freeze_order_check_storage(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -3497,10 +3484,9 @@ fn fill_freeze_conclude_order(#[case] seed: Seed) {
 
 // Orders with zero values are not allowed.
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn order_with_zero_value(#[case] seed: Seed, #[case] version: OrdersVersion) {
     utils::concurrency::model(move || {
         let mut rng = make_seedable_rng(seed);
@@ -3943,10 +3929,9 @@ fn fill_order_v1_must_not_be_signed(#[case] seed: Seed) {
 // it creates a block with 2 identical inputs among its transactions (which would normally be
 // rejected with the DuplicateInputInBlock error, but v1 FillOrder inputs are an exception).
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn fill_order_twice_in_same_block(
     #[case] seed: Seed,
     #[case] version: OrdersVersion,
diff --git a/chainstate/test-suite/src/tests/pos_accounting_reorg.rs b/chainstate/test-suite/src/tests/pos_accounting_reorg.rs
index 9629db8dc..a50862895 100644
--- a/chainstate/test-suite/src/tests/pos_accounting_reorg.rs
+++ b/chainstate/test-suite/src/tests/pos_accounting_reorg.rs
@@ -49,7 +49,6 @@ use test_utils::random::{Seed, make_seedable_rng};
 // Block `a` and block `c` have stake pool operation.
 // Check that after reorg all accounting data from block `a` was removed and from block `c` added to storage.
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), NonZeroU64::new(1).unwrap(), 0)]
 #[case(Seed::from_entropy(), NonZeroU64::new(1).unwrap(), 1)]
 #[case(Seed::from_entropy(), NonZeroU64::new(1).unwrap(), 2)]
@@ -59,6 +58,7 @@ use test_utils::random::{Seed, make_seedable_rng};
 #[case(Seed::from_entropy(), NonZeroU64::new(3).unwrap(), 0)]
 #[case(Seed::from_entropy(), NonZeroU64::new(3).unwrap(), 1)]
 #[case(Seed::from_entropy(), NonZeroU64::new(3).unwrap(), 2)]
+#[trace]
 fn stake_pool_reorg(
     #[case] seed: Seed,
     #[case] epoch_length: NonZeroU64,
diff --git a/chainstate/test-suite/src/tests/signature_tests.rs b/chainstate/test-suite/src/tests/signature_tests.rs
index c2e0dfa2a..f73cbd5ae 100644
--- a/chainstate/test-suite/src/tests/signature_tests.rs
+++ b/chainstate/test-suite/src/tests/signature_tests.rs
@@ -499,9 +499,9 @@ fn signed_classical_multisig_tx_missing_sigs(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), true)]
 #[case(Seed::from_entropy(), false)]
+#[trace]
 fn too_large_no_sig_data(#[case] seed: Seed, #[case] valid_size: bool) {
     utils::concurrency::model(move || {
         let mut rng = test_utils::random::make_seedable_rng(seed);
@@ -567,11 +567,11 @@ fn too_large_no_sig_data(#[case] seed: Seed, #[case] valid_size: bool) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), true, true)]
 #[case(Seed::from_entropy(), true, false)]
 #[case(Seed::from_entropy(), false, true)]
 #[case(Seed::from_entropy(), false, false)]
+#[trace]
 fn no_sig_data_not_allowed(
     #[case] seed: Seed,
     #[case] data_allowed: bool,
diff --git a/chainstate/tx-verifier/src/transaction_verifier/reward_distribution.rs b/chainstate/tx-verifier/src/transaction_verifier/reward_distribution.rs
index ee58cb335..00e1a964d 100644
--- a/chainstate/tx-verifier/src/transaction_verifier/reward_distribution.rs
+++ b/chainstate/tx-verifier/src/transaction_verifier/reward_distribution.rs
@@ -647,9 +647,9 @@ mod tests {
     // and that pool_b and its delegations were not affected.
     // Then undo everything and check that original state was restored.
     #[rstest]
-    #[trace]
     #[case(Seed::from_entropy(), RewardDistributionVersion::V0)]
     #[case(Seed::from_entropy(), RewardDistributionVersion::V1)]
+    #[trace]
     fn distribution_basic(#[case] seed: Seed, #[case] version: RewardDistributionVersion) {
         let mut rng = make_seedable_rng(seed);
         let block_id = Id::new(H256::random_using(&mut rng));
@@ -810,9 +810,9 @@ mod tests {
     // Create a pool with 2 delegations and random balances and reward.
     // Check distribution properties.
     #[rstest]
-    #[trace]
     #[case(Seed::from_entropy(), RewardDistributionVersion::V0)]
     #[case(Seed::from_entropy(), RewardDistributionVersion::V1)]
+    #[trace]
     fn distribution_properties(#[case] seed: Seed, #[case] version: RewardDistributionVersion) {
         let mut rng = make_seedable_rng(seed);
         let block_id = Id::new(H256::random_using(&mut rng));
@@ -959,9 +959,9 @@ mod tests {
 
     // Check that if delegation is present but its balance is 0 then all the reward goes to staker
     #[rstest]
-    #[trace]
     #[case(Seed::from_entropy(), RewardDistributionVersion::V0)]
     #[case(Seed::from_entropy(), RewardDistributionVersion::V1)]
+    #[trace]
     fn total_delegations_balance_zero(
         #[case] seed: Seed,
         #[case] version: RewardDistributionVersion,
@@ -1034,9 +1034,9 @@ mod tests {
 
     // Check that staker can set its reward to 100% and the reward goes entirely to the staker
     #[rstest]
-    #[trace]
     #[case(Seed::from_entropy(), RewardDistributionVersion::V0)]
     #[case(Seed::from_entropy(), RewardDistributionVersion::V1)]
+    #[trace]
     fn total_delegations_reward_zero(
         #[case] seed: Seed,
         #[case] version: RewardDistributionVersion,
@@ -1109,9 +1109,9 @@ mod tests {
 
     // Check that if there are no delegations then the whole reward goes to the staker
     #[rstest]
-    #[trace]
     #[case(Seed::from_entropy(), RewardDistributionVersion::V0)]
     #[case(Seed::from_entropy(), RewardDistributionVersion::V1)]
+    #[trace]
     fn no_delegations(#[case] seed: Seed, #[case] version: RewardDistributionVersion) {
         let mut rng = make_seedable_rng(seed);
         let block_id = Id::new(H256::random_using(&mut rng));
diff --git a/consensus/src/pos/effective_pool_balance.rs b/consensus/src/pos/effective_pool_balance.rs
index dd1017cf0..2e4ba7fb0 100644
--- a/consensus/src/pos/effective_pool_balance.rs
+++ b/consensus/src/pos/effective_pool_balance.rs
@@ -333,10 +333,9 @@ mod tests {
     }
 
     #[rstest]
-    #[trace]
     #[case(Seed::from_entropy(), Amount::from_atoms(600_000))]
-    #[trace]
     #[case(Seed::from_entropy(), CoinUnit::from_coins(600_000_000).to_amount_atoms())]
+    #[trace]
     fn calculate_effective_pool_balance_not_saturated(
         #[case] seed: Seed,
         #[case] final_supply: Amount,
@@ -358,10 +357,9 @@ mod tests {
     }
 
     #[rstest]
-    #[trace]
     #[case(Seed::from_entropy(), Amount::from_atoms(600_000))]
-    #[trace]
     #[case(Seed::from_entropy(), CoinUnit::from_coins(600_000_000).to_amount_atoms())]
+    #[trace]
     fn calculate_effective_balance_capped(#[case] seed: Seed, #[case] final_supply: Amount) {
         let mut rng = make_seedable_rng(seed);
 
diff --git a/mempool/src/pool/tests/orphans.rs b/mempool/src/pool/tests/orphans.rs
index 9d7a36102..1b1f4dcbf 100644
--- a/mempool/src/pool/tests/orphans.rs
+++ b/mempool/src/pool/tests/orphans.rs
@@ -19,20 +19,19 @@ use common::primitives::id::hash_encoded;
 use super::*;
 
 #[rstest]
-#[trace]
 #[case::success(
     Seed::from_entropy(),
     Amount::from_atoms(100_000_000),
     Amount::from_atoms(90_000_000),
     true
 )]
-#[trace]
 #[case::failure(
     Seed::from_entropy(),
     Amount::from_atoms(90_000_000),
     Amount::from_atoms(100_000_000),
     false
 )]
+#[trace]
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn two_transactions_in_sequence(
     #[case] seed: Seed,
@@ -110,26 +109,23 @@ async fn two_transactions_in_sequence(
 // This is a simple diamond transaction graph but it covers many interesting cases.
 //
 #[rstest]
-#[trace]
 #[case::topological_order(
     Seed::from_entropy(),
     vec![(0, 0b0001, 0b0000), (1, 0b0011, 0b0000), (2, 0b0111, 0b0000), (3, 0b1111, 0b0000)],
 )]
-#[trace]
 #[case::op_branch_released_first(
     Seed::from_entropy(),
     vec![(1, 0b0000, 0b0010), (3, 0b0000, 0b1010), (0, 0b0011, 0b1000), (2, 0b1111, 0b0000)],
 )]
-#[trace]
 #[case::one_orphan_then_mempool(
     Seed::from_entropy(),
     vec![(1, 0b0000, 0b0010), (0, 0b0011, 0b0000), (2, 0b0111, 0b0000), (3, 0b1111, 0b0000)],
 )]
-#[trace]
 #[case::reverse_topological_order(
     Seed::from_entropy(),
     vec![(3, 0b0000, 0b1000), (2, 0b0000, 0b1100), (1, 0b0000, 0b1110), (0, 0b1111, 0b0000)],
 )]
+#[trace]
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn diamond_graph(#[case] seed: Seed, #[case] insertion_plan: Vec<(usize, usize, usize)>) {
     let mut rng = make_seedable_rng(seed);
@@ -279,12 +275,10 @@ async fn transaction_graph_subset_permutation(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
 #[case::p2p(Seed::from_entropy(), LocalTxOrigin::P2p)]
-#[trace]
 #[case::mempool(Seed::from_entropy(), LocalTxOrigin::Mempool)]
-#[trace]
 #[case::block(Seed::from_entropy(), LocalTxOrigin::PastBlock)]
+#[trace]
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn local_origins_rejected(#[case] seed: Seed, #[case] origin: LocalTxOrigin) {
     let mut rng = make_seedable_rng(seed);
diff --git a/mempool/src/pool/tx_pool/tests/accumulator.rs b/mempool/src/pool/tx_pool/tests/accumulator.rs
index c5ff8896a..0160c9418 100644
--- a/mempool/src/pool/tx_pool/tests/accumulator.rs
+++ b/mempool/src/pool/tx_pool/tests/accumulator.rs
@@ -298,42 +298,25 @@ fn timelock_secs_after_genesis(n: u64) -> OutputTimeLock {
 }
 
 #[rstest]
-#[trace]
 #[case::until_blk1(Seed::from_entropy(), OutputTimeLock::UntilHeight(1.into()), 0b1111)]
-#[trace]
 #[case::until_blk2(Seed::from_entropy(), OutputTimeLock::UntilHeight(2.into()), 0b1011)]
-#[trace]
 #[case::until_blk4(Seed::from_entropy(), OutputTimeLock::UntilHeight(4.into()), 0b1010)]
-#[trace]
 #[case::until_blk20(Seed::from_entropy(), OutputTimeLock::UntilHeight(20.into()), 0b0000)]
-#[trace]
 #[case::for_1blk(Seed::from_entropy(), OutputTimeLock::ForBlockCount(1), 0b0011)]
-#[trace]
 #[case::for_2blk(Seed::from_entropy(), OutputTimeLock::ForBlockCount(2), 0b0010)]
-#[trace]
 #[case::for_20blk(Seed::from_entropy(), OutputTimeLock::ForBlockCount(20), 0b0000)]
-#[trace]
 #[case::until_5s(Seed::from_entropy(), timelock_secs_after_genesis(5), 0b1111)]
-#[trace]
 #[case::until_10s(Seed::from_entropy(), timelock_secs_after_genesis(10), 0b1111)]
-#[trace]
 #[case::until_11s(Seed::from_entropy(), timelock_secs_after_genesis(11), 0b1011)]
-#[trace]
 #[case::until_30s(Seed::from_entropy(), timelock_secs_after_genesis(30), 0b1011)]
-#[trace]
 #[case::until_31s(Seed::from_entropy(), timelock_secs_after_genesis(31), 0b1010)]
-#[trace]
 #[case::until_500s(Seed::from_entropy(), timelock_secs_after_genesis(500), 0b0000)]
-#[trace]
 #[case::for_1s(Seed::from_entropy(), OutputTimeLock::ForSeconds(1), 0b0011)]
-#[trace]
 #[case::for_10s(Seed::from_entropy(), OutputTimeLock::ForSeconds(10), 0b0011)]
-#[trace]
 #[case::for_20s(Seed::from_entropy(), OutputTimeLock::ForSeconds(20), 0b0011)]
-#[trace]
 #[case::for_21s(Seed::from_entropy(), OutputTimeLock::ForSeconds(21), 0b0010)]
-#[trace]
 #[case::for_500s(Seed::from_entropy(), OutputTimeLock::ForSeconds(500), 0b0000)]
+#[trace]
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn timelocked(#[case] seed: Seed, #[case] timelock: OutputTimeLock, #[case] expected: u32) {
     // Unpack expected results:
@@ -435,42 +418,25 @@ async fn timelocked(#[case] seed: Seed, #[case] timelock: OutputTimeLock, #[case
 }
 
 #[rstest]
-#[trace]
 #[case::until_blk1(Seed::from_entropy(), OutputTimeLock::UntilHeight(1.into()), 0b1111)]
-#[trace]
 #[case::until_blk2(Seed::from_entropy(), OutputTimeLock::UntilHeight(2.into()), 0b1011)]
-#[trace]
 #[case::until_blk4(Seed::from_entropy(), OutputTimeLock::UntilHeight(4.into()), 0b1010)]
-#[trace]
 #[case::until_blk20(Seed::from_entropy(), OutputTimeLock::UntilHeight(20.into()), 0b0000)]
-#[trace]
 #[case::for_1blk(Seed::from_entropy(), OutputTimeLock::ForBlockCount(1), 0b0011)]
-#[trace]
 #[case::for_2blk(Seed::from_entropy(), OutputTimeLock::ForBlockCount(2), 0b0010)]
-#[trace]
 #[case::for_20blk(Seed::from_entropy(), OutputTimeLock::ForBlockCount(20), 0b0000)]
-#[trace]
 #[case::until_5s(Seed::from_entropy(), timelock_secs_after_genesis(5), 0b1111)]
-#[trace]
 #[case::until_10s(Seed::from_entropy(), timelock_secs_after_genesis(10), 0b1111)]
-#[trace]
 #[case::until_11s(Seed::from_entropy(), timelock_secs_after_genesis(11), 0b1011)]
-#[trace]
 #[case::until_30s(Seed::from_entropy(), timelock_secs_after_genesis(30), 0b1011)]
-#[trace]
 #[case::until_31s(Seed::from_entropy(), timelock_secs_after_genesis(31), 0b1010)]
-#[trace]
 #[case::until_500s(Seed::from_entropy(), timelock_secs_after_genesis(500), 0b0000)]
-#[trace]
 #[case::for_1s(Seed::from_entropy(), OutputTimeLock::ForSeconds(1), 0b0011)]
-#[trace]
 #[case::for_10s(Seed::from_entropy(), OutputTimeLock::ForSeconds(10), 0b0011)]
-#[trace]
 #[case::for_20s(Seed::from_entropy(), OutputTimeLock::ForSeconds(20), 0b0011)]
-#[trace]
 #[case::for_21s(Seed::from_entropy(), OutputTimeLock::ForSeconds(21), 0b0010)]
-#[trace]
 #[case::for_500s(Seed::from_entropy(), OutputTimeLock::ForSeconds(500), 0b0000)]
+#[trace]
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn timelocked_htlc_refund(
     #[case] seed: Seed,
diff --git a/mempool/src/pool/tx_pool/tests/basic.rs b/mempool/src/pool/tx_pool/tests/basic.rs
index f986da2fc..839335252 100644
--- a/mempool/src/pool/tx_pool/tests/basic.rs
+++ b/mempool/src/pool/tx_pool/tests/basic.rs
@@ -1266,9 +1266,9 @@ async fn mempool_full_mock(#[case] seed: Seed) -> anyhow::Result<()> {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy())]
 #[case::fail(Seed(1))]
+#[trace]
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn mempool_full_real(#[case] seed: Seed) {
     let mut rng = make_seedable_rng(seed);
@@ -1396,7 +1396,6 @@ async fn no_empty_bags_in_indices(#[case] seed: Seed) -> anyhow::Result<()> {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), 300, true)]
 #[case(Seed::from_entropy(), 1_000, true)]
 #[case(Seed::from_entropy(), 10_000, true)]
@@ -1408,6 +1407,7 @@ async fn no_empty_bags_in_indices(#[case] seed: Seed) -> anyhow::Result<()> {
 #[case::just_above(Seed::from_entropy(), 1_047_577, false)]
 #[case::one_below_block_limit(Seed::from_entropy(), 1_048_575, false)]
 #[case::at_block_limit(Seed::from_entropy(), 1_048_576, false)]
+#[trace]
 #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
 async fn accepted_tx_size(#[case] seed: Seed, #[case] tx_size: usize, #[case] accept: bool) {
     let mut rng = make_seedable_rng(seed);
diff --git a/mintscript/src/tests/checkers.rs b/mintscript/src/tests/checkers.rs
index 24160330d..a56e33a2d 100644
--- a/mintscript/src/tests/checkers.rs
+++ b/mintscript/src/tests/checkers.rs
@@ -147,7 +147,6 @@ fn check_timelocks(
 }
 
 #[rstest::rstest]
-#[trace]
 #[case(Seed::from_entropy(), tl_until_height(1), (0, 1, 8, 15), true)]
 #[case(Seed::from_entropy(), tl_until_height(2), (0, 1, 3, 19), false)]
 #[case(Seed::from_entropy(), tl_until_height(2), (0, 2, 3, 19), true)]
@@ -178,6 +177,7 @@ fn check_timelocks(
 #[case(Seed::from_entropy(), tl_for_secs(100), (1, 2, 12, 111), false)]
 #[case(Seed::from_entropy(), tl_for_secs(100), (3, 5, 25, 125), true)]
 #[case(Seed::from_entropy(), tl_for_secs(100), (1, 2, 41, 142), true)]
+#[trace]
 fn check_timelocks_corner_cases(
     #[case] seed: Seed,
     #[case] timelock: OutputTimeLock,
diff --git a/mintscript/src/tests/hashlock_checker.rs b/mintscript/src/tests/hashlock_checker.rs
index d9efa538c..2cc2ccf01 100644
--- a/mintscript/src/tests/hashlock_checker.rs
+++ b/mintscript/src/tests/hashlock_checker.rs
@@ -85,6 +85,7 @@ fn check_hashlock_160_ok(#[case] preimage: &str, #[case] hash: &str) {
 
 #[rstest::rstest]
 #[case(Seed::from_entropy())]
+#[trace]
 fn check_hashlock_160_random_values_mismatch(#[case] seed: Seed) {
     let mut rng = make_seedable_rng(seed);
 
diff --git a/mintscript/src/tests/script.rs b/mintscript/src/tests/script.rs
index f47a278d0..77be96445 100644
--- a/mintscript/src/tests/script.rs
+++ b/mintscript/src/tests/script.rs
@@ -58,8 +58,8 @@ fn generate_conds(rng: &mut impl Rng, n_sat: usize, n_dissat: usize) -> Vec<Scri
 #[case(Seed::from_entropy(), 0..=0, 1..=1)]
 #[case(Seed::from_entropy(), 1..=1, 0..=0)]
 #[case(Seed::from_entropy(), 1..=1, 1..=1)]
-#[trace]
 #[case(Seed::from_entropy(), 2..=100, 2..=100)]
+#[trace]
 fn threshold_collect_satisfied(
     #[case] seed: Seed,
     #[case] sat_range: RangeInclusive<usize>,
@@ -94,10 +94,10 @@ fn threshold_collect_satisfied(
 }
 
 #[rstest::rstest]
-#[trace]
 #[case::zero(Seed::from_entropy(), 0..=0)]
 #[case::unit(Seed::from_entropy(), 1..=1)]
 #[case::rand(Seed::from_entropy(), 2..=100)]
+#[trace]
 fn conjunction_matches_explicit(#[case] seed: Seed, #[case] size_range: RangeInclusive<usize>) {
     let mut rng = make_seedable_rng(seed);
     let n = rng.random_range(size_range);
diff --git a/orders-accounting/src/tests/operations.rs b/orders-accounting/src/tests/operations.rs
index c693e2ac7..e1da163d1 100644
--- a/orders-accounting/src/tests/operations.rs
+++ b/orders-accounting/src/tests/operations.rs
@@ -254,9 +254,9 @@ fn conclude_order_and_undo(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn fill_entire_order_and_flush(#[case] seed: Seed, #[case] version: OrdersVersion) {
     let mut rng = make_seedable_rng(seed);
 
@@ -308,9 +308,9 @@ fn fill_entire_order_and_flush(#[case] seed: Seed, #[case] version: OrdersVersio
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn fill_order_partially_and_flush(#[case] seed: Seed, #[case] version: OrdersVersion) {
     let mut rng = make_seedable_rng(seed);
 
@@ -391,9 +391,9 @@ fn fill_order_partially_and_flush(#[case] seed: Seed, #[case] version: OrdersVer
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn fill_order_partially_and_undo(#[case] seed: Seed, #[case] version: OrdersVersion) {
     let mut rng = make_seedable_rng(seed);
 
@@ -485,9 +485,9 @@ fn fill_order_partially_and_undo(#[case] seed: Seed, #[case] version: OrdersVers
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn fill_order_partially_and_conclude(#[case] seed: Seed, #[case] version: OrdersVersion) {
     let mut rng = make_seedable_rng(seed);
 
@@ -534,10 +534,9 @@ fn fill_order_partially_and_conclude(#[case] seed: Seed, #[case] version: Orders
 // For V0 implementation there should not be any change left.
 // For V1 it is allowed for some dust to be left in the give balance.
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn fill_order_must_converge(#[case] seed: Seed, #[case] version: OrdersVersion) {
     let mut rng = make_seedable_rng(seed);
 
@@ -644,10 +643,9 @@ fn fill_order_commutativity(#[case] seed: Seed, #[case] fills: Vec<u128>) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), OrdersVersion::V1)]
+#[trace]
 fn fill_order_underbid(#[case] seed: Seed, #[case] version: OrdersVersion) {
     let mut rng = make_seedable_rng(seed);
 
diff --git a/utxo/src/tests/mod.rs b/utxo/src/tests/mod.rs
index 0f058ac6d..1606ee23a 100644
--- a/utxo/src/tests/mod.rs
+++ b/utxo/src/tests/mod.rs
@@ -630,10 +630,10 @@ fn check_tx_spend_undo_spend(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), make_burn_output())]
 #[case(Seed::from_entropy(), make_create_delegation_output())]
 #[case(Seed::from_entropy(), make_delegate_staking_output())]
+#[trace]
 fn check_burn_spend_undo_spend(#[case] seed: Seed, #[case] output: TxOutput) {
     let mut rng = make_seedable_rng(seed);
     let test_view = empty_test_utxos_view(H256::zero().into());
diff --git a/wallet/src/signer/software_signer/tests.rs b/wallet/src/signer/software_signer/tests.rs
index ecee83516..08f730fbc 100644
--- a/wallet/src/signer/software_signer/tests.rs
+++ b/wallet/src/signer/software_signer/tests.rs
@@ -57,10 +57,9 @@ async fn test_sign_transaction_intent(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), SighashInputCommitmentVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), SighashInputCommitmentVersion::V1)]
+#[trace]
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
 async fn test_sign_transaction(
     #[case] seed: Seed,
@@ -89,10 +88,9 @@ async fn test_fixed_signatures(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), SighashInputCommitmentVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), SighashInputCommitmentVersion::V1)]
+#[trace]
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
 async fn test_fixed_signatures2(
     #[case] seed: Seed,
@@ -119,10 +117,9 @@ async fn test_fixed_signatures_no_legacy(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), SighashInputCommitmentVersion::V0)]
-#[trace]
 #[case(Seed::from_entropy(), SighashInputCommitmentVersion::V1)]
+#[trace]
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
 async fn test_fixed_signatures_htlc_refunding(
     #[case] seed: Seed,
diff --git a/wallet/src/signer/trezor_signer/tests.rs b/wallet/src/signer/trezor_signer/tests.rs
index 0255e3689..111513cf2 100644
--- a/wallet/src/signer/trezor_signer/tests.rs
+++ b/wallet/src/signer/trezor_signer/tests.rs
@@ -110,12 +110,10 @@ async fn test_sign_transaction_intent(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
-#[serial]
 #[case(Seed::from_entropy(), SighashInputCommitmentVersion::V0)]
+#[case(Seed::from_entropy(), SighashInputCommitmentVersion::V1)]
 #[trace]
 #[serial]
-#[case(Seed::from_entropy(), SighashInputCommitmentVersion::V1)]
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
 async fn test_sign_transaction(
     #[case] seed: Seed,
@@ -155,12 +153,10 @@ async fn test_fixed_signatures(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
-#[serial]
 #[case(Seed::from_entropy(), SighashInputCommitmentVersion::V0)]
+#[case(Seed::from_entropy(), SighashInputCommitmentVersion::V1)]
 #[trace]
 #[serial]
-#[case(Seed::from_entropy(), SighashInputCommitmentVersion::V1)]
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
 async fn test_fixed_signatures2(
     #[case] seed: Seed,
@@ -193,12 +189,10 @@ async fn test_fixed_signatures_no_legacy(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
-#[serial]
 #[case(Seed::from_entropy(), SighashInputCommitmentVersion::V0)]
+#[case(Seed::from_entropy(), SighashInputCommitmentVersion::V1)]
 #[trace]
 #[serial]
-#[case(Seed::from_entropy(), SighashInputCommitmentVersion::V1)]
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
 async fn test_fixed_signatures_htlc_refunding(
     #[case] seed: Seed,
@@ -262,12 +256,10 @@ async fn test_sign_transaction_intent_sig_consistency(#[case] seed: Seed) {
 }
 
 #[rstest]
-#[trace]
-#[serial]
 #[case(Seed::from_entropy(), SighashInputCommitmentVersion::V0)]
+#[case(Seed::from_entropy(), SighashInputCommitmentVersion::V1)]
 #[trace]
 #[serial]
-#[case(Seed::from_entropy(), SighashInputCommitmentVersion::V1)]
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
 async fn test_sign_transaction_sig_consistency(
     #[case] seed: Seed,
diff --git a/wallet/wallet-cli-lib/tests/basic.rs b/wallet/wallet-cli-lib/tests/basic.rs
index ae3435098..4494f56e7 100644
--- a/wallet/wallet-cli-lib/tests/basic.rs
+++ b/wallet/wallet-cli-lib/tests/basic.rs
@@ -26,6 +26,7 @@ use crate::cli_test_framework::CliTestFramework;
 
 #[rstest]
 #[case(test_utils::random::Seed::from_entropy())]
+#[trace]
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
 async fn wallet_cli_basic(#[case] seed: Seed) {
     let mut rng = make_seedable_rng(seed);
@@ -42,6 +43,7 @@ async fn wallet_cli_basic(#[case] seed: Seed) {
 
 #[rstest]
 #[case(test_utils::random::Seed::from_entropy())]
+#[trace]
 #[tokio::test(flavor = "multi_thread", worker_threads = 1)]
 async fn wallet_cli_file(#[case] seed: Seed) {
     let mut rng = make_seedable_rng(seed);
@@ -76,6 +78,7 @@ async fn wallet_cli_file(#[case] seed: Seed) {
 
 #[rstest]
 #[case(test_utils::random::Seed::from_entropy())]
+#[trace]
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 async fn produce_blocks(#[case] seed: Seed) {
     let mut rng = make_seedable_rng(seed);
@@ -92,6 +95,7 @@ async fn produce_blocks(#[case] seed: Seed) {
 
 #[rstest]
 #[case(test_utils::random::Seed::from_entropy())]
+#[trace]
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 async fn produce_blocks_decommission_genesis_pool(#[case] seed: Seed) {
     let mut rng = make_seedable_rng(seed);
diff --git a/wallet/wallet-cli-lib/tests/staking.rs b/wallet/wallet-cli-lib/tests/staking.rs
index 9f6323001..4ec1ced1b 100644
--- a/wallet/wallet-cli-lib/tests/staking.rs
+++ b/wallet/wallet-cli-lib/tests/staking.rs
@@ -22,6 +22,7 @@ use crate::cli_test_framework::CliTestFramework;
 
 #[rstest]
 #[case(test_utils::random::Seed::from_entropy())]
+#[trace]
 #[tokio::test(flavor = "multi_thread", worker_threads = 4)]
 async fn staking_locked_wallet(#[case] seed: Seed) {
     let mut rng = make_seedable_rng(seed);
diff --git a/wallet/wallet-controller/src/tests/compose_transaction_tests.rs b/wallet/wallet-controller/src/tests/compose_transaction_tests.rs
index 9152b3ec3..5abaaeab4 100644
--- a/wallet/wallet-controller/src/tests/compose_transaction_tests.rs
+++ b/wallet/wallet-controller/src/tests/compose_transaction_tests.rs
@@ -58,10 +58,9 @@ use crate::{
 };
 
 #[rstest]
-#[trace]
 #[case(Seed::from_entropy(), false)]
-#[trace]
 #[case(Seed::from_entropy(), true)]
+#[trace]
 #[tokio::test]
 async fn general_test(#[case] seed: Seed, #[case] use_htlc_secret: bool) {
     let mut rng = make_seedable_rng(seed);