fix(test): Account for merge bit in more tests

src/models/blockchain/block/mod.rs

@@ -1030,7 +1030,6 @@ mod block_tests {
     use crate::config_models::network::Network;
     use crate::database::storage::storage_schema::SimpleRustyStorage;
     use crate::database::NeptuneLevelDb;
-    use crate::mine_loop::mine_loop_tests::make_coinbase_transaction_from_state;
     use crate::models::blockchain::transaction::lock_script::LockScriptAndWitness;
     use crate::models::state::tx_proving_capability::TxProvingCapability;
     use crate::models::state::wallet::transaction_output::TxOutput;
@@ -1226,41 +1225,21 @@ mod block_tests {
     }
 
     mod block_is_valid {
+        use rand::rngs::StdRng;
+        use rand::SeedableRng;
+
         use super::*;
-        use crate::config_models::cli_args;
-        use crate::job_queue::triton_vm::TritonVmJobPriority;
+        use crate::tests::shared::valid_successor_for_tests;
 
         #[traced_test]
         #[tokio::test]
         async fn block_with_far_future_timestamp_is_invalid() {
             let network = Network::Main;
             let genesis_block = Block::genesis_block(network);
             let mut now = genesis_block.kernel.header.timestamp + Timestamp::hours(2);
-            let wallet = WalletSecret::devnet_wallet();
-            let genesis_state =
-                mock_genesis_global_state(network, 0, wallet, cli_args::Args::default()).await;
-
-            let guesser_fraction = 0f64;
-            let (block_tx, _expected_utxo) = make_coinbase_transaction_from_state(
-                &genesis_block,
-                &genesis_state,
-                guesser_fraction,
-                now,
-                TxProvingCapability::SingleProof,
-            )
-            .await
-            .unwrap();
-            let mut block1 = Block::make_block_template_with_valid_proof(
-                &genesis_block,
-                block_tx,
-                now,
-                Digest::default(),
-                None,
-                &TritonVmJobQueue::dummy(),
-                TritonVmJobPriority::default().into(),
-            )
-            .await
-            .unwrap();
+            let mut rng: StdRng = SeedableRng::seed_from_u64(2225550001);
+
+            let mut block1 = valid_successor_for_tests(&genesis_block, now, rng.gen()).await;
 
             // Set block timestamp 1 hour in the future.  (is valid)
             let future_time1 = now + Timestamp::hours(1);

src/models/state/mod.rs

@@ -1511,6 +1511,7 @@ mod global_state_tests {
     use crate::models::blockchain::block::Block;
     use crate::tests::shared::make_mock_block;
     use crate::tests::shared::mock_genesis_global_state;
+    use crate::tests::shared::valid_successor_for_tests;
 
     async fn wallet_state_has_all_valid_mps_for(
         wallet_state: &WalletState,
@@ -2558,29 +2559,9 @@ mod global_state_tests {
         let genesis_block = Block::genesis_block(network);
         let now = genesis_block.kernel.header.timestamp + Timestamp::hours(1);
 
-        let guesser_fraction = 0f64;
-        let (cb, _) = make_coinbase_transaction_from_state(
-            &genesis_block,
-            &global_state_lock,
-            guesser_fraction,
-            now,
-            TxProvingCapability::SingleProof,
-        )
-        .await
-        .unwrap();
-        let block_1 = Block::compose(
-            &genesis_block,
-            cb,
-            now,
-            Digest::default(),
-            None,
-            &TritonVmJobQueue::dummy(),
-            TritonVmJobPriority::default().into(),
-        )
-        .await
-        .unwrap();
+        let block1 = valid_successor_for_tests(&genesis_block, now, Default::default()).await;
 
-        global_state_lock.set_new_tip(block_1).await.unwrap();
+        global_state_lock.set_new_tip(block1).await.unwrap();
 
         assert!(
             global_state_lock
@@ -3027,6 +3008,7 @@ mod global_state_tests {
     /// and comparing onchain vs offchain notification methods.
     mod restore_wallet {
         use super::*;
+        use crate::mine_loop::create_block_transaction_stateless;
 
         /// test scenario: onchain/symmetric.
         /// pass outcome: no funds loss
@@ -3162,6 +3144,8 @@ mod global_state_tests {
             };
 
             // in alice wallet: send pre-mined funds to bob
+            let coinbase_spending_key =
+                GenerationReceivingAddress::derive_from_seed(rng.gen()).into();
             let block_1 = {
                 let vm_job_queue = alice_state_lock.vm_job_queue().clone();
                 let mut alice_state_mut = alice_state_lock.lock_guard_mut().await;
@@ -3216,9 +3200,21 @@ mod global_state_tests {
                     .await;
 
                 // the block gets mined.
+                let (block_1_tx, _) = create_block_transaction_stateless(
+                    &genesis_block,
+                    coinbase_spending_key,
+                    rng.gen(),
+                    rng.gen(),
+                    seven_months_post_launch,
+                    0.5,
+                    &TritonVmJobQueue::dummy(),
+                    vec![alice_to_bob_tx],
+                )
+                .await
+                .unwrap();
                 let block_1 = Block::compose(
                     &genesis_block,
-                    alice_to_bob_tx,
+                    block_1_tx,
                     seven_months_post_launch,
                     Digest::default(),
                     None,

src/peer_loop.rs

@@ -1799,8 +1799,7 @@ mod peer_loop_tests {
         let genesis_block: Block = Block::genesis_block(network);
 
         let now = genesis_block.header().timestamp + Timestamp::hours(1);
-        let block_1 =
-            valid_block_for_tests(&alice, now, StdRng::seed_from_u64(5550001).gen(), 0.0).await;
+        let block_1 = valid_block_for_tests(&alice, StdRng::seed_from_u64(5550001).gen()).await;
         assert!(
             block_1.is_valid(&genesis_block, now),
             "Block must be valid for this test to make sense"
@@ -2079,17 +2078,8 @@ mod peer_loop_tests {
         let (_peer_broadcast_tx, from_main_rx_clone, to_main_tx, mut to_main_rx1, state_lock, hsd) =
             get_test_genesis_setup(network, 0).await?;
         let peer_address = get_dummy_socket_address(0);
-        let genesis_block: Block = state_lock
-            .lock_guard()
-            .await
-            .chain
-            .archival_state()
-            .get_tip()
-            .await;
-
-        let now = genesis_block.header().timestamp + Timestamp::hours(2);
-        let block_1 = valid_block_for_tests(&state_lock, now, rng.gen(), 0.0).await;
 
+        let block_1 = valid_block_for_tests(&state_lock, rng.gen()).await;
         let mock = Mock::new(vec![
             Action::Read(PeerMessage::Block(Box::new(
                 block_1.clone().try_into().unwrap(),
@@ -2901,13 +2891,9 @@ mod peer_loop_tests {
                 to_main_tx,
                 genesis_block,
             } = genesis_setup(Network::Main).await;
-            let now = genesis_block.header().timestamp + Timestamp::hours(1);
-            let guesser_fraction = 0.5;
             let block1 = valid_block_for_tests(
                 &peer_loop_handler.global_state_lock,
-                now,
                 StdRng::seed_from_u64(5550001).gen(),
-                guesser_fraction,
             )
             .await;
 
@@ -2944,15 +2930,11 @@ mod peer_loop_tests {
                 from_main_rx,
                 mut peer_state,
                 to_main_tx,
-                genesis_block,
+                ..
             } = genesis_setup(Network::Main).await;
-            let now = genesis_block.header().timestamp + Timestamp::hours(1);
-            let guesser_fraction = 0.5;
             let block1 = valid_block_for_tests(
                 &peer_loop_handler.global_state_lock,
-                now,
                 StdRng::seed_from_u64(5550001).gen(),
-                guesser_fraction,
             )
             .await;
 

src/tests/shared.rs

@@ -50,7 +50,6 @@ use crate::database::NeptuneLevelDb;
 use crate::job_queue::triton_vm::TritonVmJobPriority;
 use crate::job_queue::triton_vm::TritonVmJobQueue;
 use crate::mine_loop::create_block_transaction_stateless;
-use crate::mine_loop::mine_loop_tests::make_coinbase_transaction_from_state;
 use crate::mine_loop::mine_loop_tests::mine_iteration_for_tests;
 use crate::models::blockchain::block::block_appendix::BlockAppendix;
 use crate::models::blockchain::block::block_body::BlockBody;
@@ -86,7 +85,6 @@ use crate::models::state::blockchain_state::BlockchainState;
 use crate::models::state::light_state::LightState;
 use crate::models::state::mempool::Mempool;
 use crate::models::state::networking_state::NetworkingState;
-use crate::models::state::tx_proving_capability::TxProvingCapability;
 use crate::models::state::wallet::address::generation_address;
 use crate::models::state::wallet::address::generation_address::GenerationReceivingAddress;
 use crate::models::state::wallet::expected_utxo::ExpectedUtxo;
@@ -867,23 +865,16 @@ pub(crate) async fn valid_successor_for_tests(
 ///
 /// The block will be valid both in terms of PoW and block proof and will pass
 /// the Block::is_valid() function.
-pub(crate) async fn valid_block_for_tests(
-    state_lock: &GlobalStateLock,
-    timestamp: Timestamp,
-    seed: [u8; 32],
-    guesser_fraction: f64,
-) -> Block {
+pub(crate) async fn valid_block_for_tests(state_lock: &GlobalStateLock, seed: [u8; 32]) -> Block {
     let current_tip = state_lock.lock_guard().await.chain.light_state().clone();
-    let (cb, _) = make_coinbase_transaction_from_state(
+    let block = valid_successor_for_tests(
         &current_tip,
-        state_lock,
-        guesser_fraction,
-        timestamp,
-        TxProvingCapability::SingleProof,
+        current_tip.header().timestamp + Timestamp::hours(1),
+        seed,
     )
-    .await
-    .unwrap();
-    valid_block_from_tx_for_tests(&current_tip, cb, seed).await
+    .await;
+
+    block
 }
 
 /// Create a deterministic sequence of valid blocks.