test: Add partial integration test for mock miner replay

jbencin · jbencin · commit 29ee7ed425b2 · 2024-08-14T16:22:35.000-04:00
diff --git a/.github/workflows/bitcoin-tests.yml b/.github/workflows/bitcoin-tests.yml
@@ -72,6 +72,7 @@ jobs:
           - tests::neon_integrations::confirm_unparsed_ongoing_ops
           - tests::neon_integrations::min_txs
           - tests::neon_integrations::vote_for_aggregate_key_burn_op_test
+          - tests::neon_integrations::mock_miner_replay
           - tests::epoch_25::microblocks_disabled
           - tests::should_succeed_handling_malformed_and_valid_txs
           - tests::nakamoto_integrations::simple_neon_integration
diff --git a/stacks-common/src/types/chainstate.rs b/stacks-common/src/types/chainstate.rs
@@ -30,11 +30,11 @@ impl_byte_array_serde!(TrieHash);
 
 pub const TRIEHASH_ENCODED_SIZE: usize = 32;
 
-#[derive(Serialize, Deserialize)]
 pub struct BurnchainHeaderHash(pub [u8; 32]);
 impl_array_newtype!(BurnchainHeaderHash, u8, 32);
 impl_array_hexstring_fmt!(BurnchainHeaderHash);
 impl_byte_array_newtype!(BurnchainHeaderHash, u8, 32);
+impl_byte_array_serde!(BurnchainHeaderHash);
 
 pub struct BlockHeaderHash(pub [u8; 32]);
 impl_array_newtype!(BlockHeaderHash, u8, 32);
diff --git a/stackslib/src/chainstate/stacks/miner.rs b/stackslib/src/chainstate/stacks/miner.rs
@@ -76,9 +76,9 @@ pub struct AssembledAnchorBlock {
     /// Consensus hash this Stacks block
     pub consensus_hash: ConsensusHash,
     /// Burnchain tip's block hash when we finished mining
-    pub my_burn_hash: BurnchainHeaderHash,
+    pub burn_hash: BurnchainHeaderHash,
     /// Burnchain tip's block height when we finished mining
-    pub my_block_height: u64,
+    pub burn_block_height: u64,
     /// Burnchain tip's block hash when we started mining (could be different)
     pub orig_burn_hash: BurnchainHeaderHash,
     /// The block we produced
diff --git a/testnet/stacks-node/src/neon_node.rs b/testnet/stacks-node/src/neon_node.rs
@@ -140,7 +140,7 @@
 use std::cmp;
 use std::cmp::Ordering as CmpOrdering;
 use std::collections::{BTreeMap, HashMap, HashSet, VecDeque};
-use std::io::{Read, Write};
+use std::io::{ErrorKind, Read, Write};
 use std::net::SocketAddr;
 use std::sync::mpsc::{Receiver, TrySendError};
 use std::thread::JoinHandle;
@@ -1123,7 +1123,7 @@ impl BlockMinerThread {
     ) -> Vec<&AssembledAnchorBlock> {
         let mut ret = vec![];
         for (_, (assembled_block, _)) in last_mined_blocks.iter() {
-            if assembled_block.my_block_height >= burn_height {
+            if assembled_block.burn_block_height >= burn_height {
                 ret.push(assembled_block);
             }
         }
@@ -1633,7 +1633,7 @@ impl BlockMinerThread {
                     &prev_block.anchored_block.block_hash(),
                     &prev_block.parent_consensus_hash,
                     &prev_block.anchored_block.header.parent_block,
-                    &prev_block.my_burn_hash,
+                    &prev_block.burn_hash,
                     &prev_block.anchored_block.txs.len()
                 );
                 max_txs = cmp::max(max_txs, prev_block.anchored_block.txs.len());
@@ -1645,7 +1645,7 @@ impl BlockMinerThread {
                     continue;
                 }
                 if prev_block.parent_consensus_hash == *parent_consensus_hash
-                    && prev_block.my_burn_hash == self.burn_block.burn_header_hash
+                    && prev_block.burn_hash == self.burn_block.burn_header_hash
                     && prev_block.anchored_block.header.parent_block
                         == stacks_parent_header.anchored_header.block_hash()
                 {
@@ -1677,7 +1677,7 @@ impl BlockMinerThread {
                                 // already have.
                                 info!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, and no new microblocks ({} <= {} + 1)",
                                        &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
-                                       prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height, stream.len(), prev_block.anchored_block.header.parent_microblock_sequence);
+                                       prev_block.anchored_block.txs.len(), prev_block.burn_hash, parent_block_burn_height, stream.len(), prev_block.anchored_block.header.parent_microblock_sequence);
 
                                 return None;
                             }
@@ -1688,7 +1688,7 @@ impl BlockMinerThread {
                             // fee minus the old BTC fee
                             info!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, but there are new microblocks ({} > {} + 1)",
                                    &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
-                                   prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height, stream.len(), prev_block.anchored_block.header.parent_microblock_sequence);
+                                   prev_block.anchored_block.txs.len(), prev_block.burn_hash, parent_block_burn_height, stream.len(), prev_block.anchored_block.header.parent_microblock_sequence);
 
                             best_attempt = cmp::max(best_attempt, prev_block.attempt);
                         }
@@ -1697,20 +1697,20 @@ impl BlockMinerThread {
                             // no microblock stream to confirm, and the stacks tip hasn't changed
                             info!("Relayer: Stacks tip is unchanged since we last tried to mine a block off of {}/{} at height {} with {} txs, in {} at burn height {}, and no microblocks present",
                                    &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block, prev_block.anchored_block.header.total_work.work,
-                                   prev_block.anchored_block.txs.len(), prev_block.my_burn_hash, parent_block_burn_height);
+                                   prev_block.anchored_block.txs.len(), prev_block.burn_hash, parent_block_burn_height);
 
                             return None;
                         }
                     }
                 } else {
-                    if self.burn_block.burn_header_hash == prev_block.my_burn_hash {
+                    if self.burn_block.burn_header_hash == prev_block.burn_hash {
                         // only try and re-mine if there was no sortition since the last chain tip
                         info!("Relayer: Stacks tip has changed to {}/{} since we last tried to mine a block in {} at burn height {}; attempt was {} (for Stacks tip {}/{})",
-                               parent_consensus_hash, stacks_parent_header.anchored_header.block_hash(), prev_block.my_burn_hash, parent_block_burn_height, prev_block.attempt, &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block);
+                               parent_consensus_hash, stacks_parent_header.anchored_header.block_hash(), prev_block.burn_hash, parent_block_burn_height, prev_block.attempt, &prev_block.parent_consensus_hash, &prev_block.anchored_block.header.parent_block);
                         best_attempt = cmp::max(best_attempt, prev_block.attempt);
                     } else {
                         info!("Relayer: Burn tip has changed to {} ({}) since we last tried to mine a block in {}",
-                               &self.burn_block.burn_header_hash, self.burn_block.block_height, &prev_block.my_burn_hash);
+                               &self.burn_block.burn_header_hash, self.burn_block.block_height, &prev_block.burn_hash);
                     }
                 }
             }
@@ -2554,34 +2554,48 @@ impl BlockMinerThread {
         } = self.config.get_node_config(false);
 
         let res = bitcoin_controller.submit_operation(target_epoch_id, op, &mut op_signer, attempt);
+        if res.is_none() {
+            self.failed_to_submit_last_attempt = true;
+            if !mock_mining {
+                warn!("Relayer: Failed to submit Bitcoin transaction");
+                return None;
+            }
+            debug!("Relayer: Mock-mining enabled; not sending Bitcoin transaction");
+        } else {
+            self.failed_to_submit_last_attempt = false;
+        }
+
         let assembled_block = AssembledAnchorBlock {
             parent_consensus_hash: parent_block_info.parent_consensus_hash,
             consensus_hash: cur_burn_chain_tip.consensus_hash,
-            my_burn_hash: cur_burn_chain_tip.burn_header_hash,
-            my_block_height: cur_burn_chain_tip.block_height,
+            burn_hash: cur_burn_chain_tip.burn_header_hash,
+            burn_block_height: cur_burn_chain_tip.block_height,
             orig_burn_hash: self.burn_block.burn_header_hash,
             anchored_block,
             attempt,
             tenure_begin,
         };
-        if res.is_none() {
-            self.failed_to_submit_last_attempt = true;
-            if mock_mining {
-                debug!("Relayer: Mock-mining enabled; not sending Bitcoin transaction");
-                if let Some(dir) = mock_mining_output_dir {
-                    let stacks_block_height = assembled_block.anchored_block.header.total_work.work;
-                    let filename = format!("{stacks_block_height}.json");
-                    let filepath = dir.join(filename);
-                    assembled_block
-                        .serialize_to_file(&filepath)
-                        .unwrap_or_else(|e| panic!("Failed to write to file '{filepath:?}': {e}"));
-                }
-            } else {
-                warn!("Relayer: Failed to submit Bitcoin transaction");
-                return None;
+
+        if mock_mining {
+            let stacks_block_height = assembled_block.anchored_block.header.total_work.work;
+            info!("Mock mined Stacks block {stacks_block_height}");
+            if let Some(dir) = mock_mining_output_dir {
+                info!("Writing mock mined Stacks block {stacks_block_height} to file");
+                fs::create_dir_all(&dir).unwrap_or_else(|e| match e.kind() {
+                    ErrorKind::AlreadyExists => { /* This is fine */ }
+                    _ => error!("Failed to create directory '{dir:?}': {e}"),
+                });
+                let filename = format!("{stacks_block_height}.json");
+                let filepath = dir.join(filename);
+                assembled_block
+                    .serialize_to_file(&filepath)
+                    .unwrap_or_else(|e| match e.kind() {
+                        ErrorKind::AlreadyExists => {
+                            error!("Failed to overwrite file '{filepath:?}'")
+                        }
+                        _ => error!("Failed to write to file '{filepath:?}': {e}"),
+                    });
             }
-        } else {
-            self.failed_to_submit_last_attempt = false;
         }
 
         Some(MinerThreadResult::Block(
@@ -3010,7 +3024,7 @@ impl RelayerThread {
             let AssembledAnchorBlock {
                 parent_consensus_hash,
                 anchored_block: mined_block,
-                my_burn_hash: mined_burn_hash,
+                burn_hash: mined_burn_hash,
                 attempt: _,
                 ..
             } = last_mined_block_data;
@@ -3423,16 +3437,16 @@ impl RelayerThread {
     fn clear_stale_mined_blocks(burn_height: u64, last_mined_blocks: MinedBlocks) -> MinedBlocks {
         let mut ret = HashMap::new();
         for (stacks_bhh, (assembled_block, microblock_privkey)) in last_mined_blocks.into_iter() {
-            if assembled_block.my_block_height < burn_height {
+            if assembled_block.burn_block_height < burn_height {
                 debug!(
                     "Stale mined block: {} (as of {},{})",
-                    &stacks_bhh, &assembled_block.my_burn_hash, assembled_block.my_block_height
+                    &stacks_bhh, &assembled_block.burn_hash, assembled_block.burn_block_height
                 );
                 continue;
             }
             debug!(
                 "Mined block in-flight: {} (as of {},{})",
-                &stacks_bhh, &assembled_block.my_burn_hash, assembled_block.my_block_height
+                &stacks_bhh, &assembled_block.burn_hash, assembled_block.burn_block_height
             );
             ret.insert(stacks_bhh, (assembled_block, microblock_privkey));
         }
@@ -3760,7 +3774,7 @@ impl RelayerThread {
                 ) => {
                     // finished mining a block
                     if BlockMinerThread::find_inflight_mined_blocks(
-                        last_mined_block.my_block_height,
+                        last_mined_block.burn_block_height,
                         &self.last_mined_blocks,
                     )
                     .len()
@@ -3769,7 +3783,7 @@ impl RelayerThread {
                         // first time we've mined a block in this burnchain block
                         debug!(
                             "Bump block processed for burnchain block {}",
-                            &last_mined_block.my_block_height
+                            &last_mined_block.burn_block_height
                         );
                         self.globals.counters.bump_blocks_processed();
                     }
@@ -3779,7 +3793,7 @@ impl RelayerThread {
                         &last_mined_block.anchored_block.block_hash()
                     );
 
-                    let bhh = last_mined_block.my_burn_hash.clone();
+                    let bhh = last_mined_block.burn_hash.clone();
                     let orig_bhh = last_mined_block.orig_burn_hash.clone();
                     let tenure_begin = last_mined_block.tenure_begin;
 
diff --git a/testnet/stacks-node/src/tests/neon_integrations.rs b/testnet/stacks-node/src/tests/neon_integrations.rs
