Implement process_pushed_next_ready_block to enable calling process_next_nakamoto_block

Signed-off-by: Jacinta Ferrant <[email protected]>

Author: jferrant

stackslib/src/chainstate/nakamoto/mod.rs

@@ -2478,28 +2478,23 @@ impl NakamotoChainState {
         reward_set: &RewardSet,
         obtain_method: NakamotoBlockObtainMethod,
     ) -> Result<bool, ChainstateError> {
-        test_debug!("Consider Nakamoto block {}", &block.block_id());
+        let block_id = block.block_id();
+        test_debug!("Consider Nakamoto block {block_id}");
         // do nothing if we already have this block
-        if Self::get_block_header(headers_conn, &block.header.block_id())?.is_some() {
-            debug!("Already have block {}", &block.header.block_id());
+        if Self::get_block_header(headers_conn, &block_id)?.is_some() {
+            debug!("Already have block {block_id}");
             return Ok(false);
         }
 
         // if this is the first tenure block, then make sure it's well-formed
         block.is_wellformed_tenure_start_block().map_err(|_| {
-            warn!(
-                "Block {} is not a well-formed first tenure block",
-                &block.block_id()
-            );
+            warn!("Block {block_id} is not a well-formed first tenure block");
             ChainstateError::InvalidStacksBlock("Not a well-formed first-tenure block".into())
         })?;
 
         // if this is a tenure-extend block, then make sure it's well-formed
         block.is_wellformed_tenure_extend_block().map_err(|_| {
-            warn!(
-                "Block {} is not a well-formed tenure-extend block",
-                &block.block_id()
-            );
+            warn!("Block {block_id} is not a well-formed tenure-extend block");
             ChainstateError::InvalidStacksBlock("Not a well-formed tenure-extend block".into())
         })?;
 
@@ -2510,51 +2505,50 @@ impl NakamotoChainState {
         if block.is_shadow_block() {
             // this block is already present in the staging DB, so just perform some prefunctory
             // validation (since they're constructed a priori to be valid)
-            if let Err(e) = Self::validate_shadow_nakamoto_block_burnchain(
+            Self::validate_shadow_nakamoto_block_burnchain(
                 staging_db_tx.conn(),
                 db_handle,
                 expected_burn_opt,
                 block,
                 config.mainnet,
                 config.chain_id,
-            ) {
+            )
+            .unwrap_or_else(|e| {
                 error!("Unacceptable shadow Nakamoto block";
-                      "stacks_block_id" => %block.block_id(),
-                      "error" => ?e
+                    "stacks_block_id" => %block_id,
+                    "error" => ?e
                 );
                 panic!("Unacceptable shadow Nakamoto block");
-            }
-
+            });
             return Ok(false);
         }
 
         // this block must be consistent with its miner's leader-key and block-commit, and must
         // contain only transactions that are valid in this epoch.
-        if let Err(e) = Self::validate_normal_nakamoto_block_burnchain(
+        Self::validate_normal_nakamoto_block_burnchain(
             staging_db_tx.conn(),
             db_handle,
             expected_burn_opt,
             block,
             config.mainnet,
             config.chain_id,
-        ) {
+        )
+        .inspect_err(|e| {
             warn!("Unacceptable Nakamoto block; will not store";
-                  "stacks_block_id" => %block.block_id(),
-                  "error" => ?e
+                "stacks_block_id" => %block_id,
+                "error" => ?e
             );
-            return Ok(false);
-        };
+        })?;
 
-        let signing_weight = match block.header.verify_signer_signatures(reward_set) {
-            Ok(x) => x,
-            Err(e) => {
+        let signing_weight = block
+            .header
+            .verify_signer_signatures(reward_set)
+            .inspect_err(|e| {
                 warn!("Received block, but the signer signatures are invalid";
-                      "block_id" => %block.block_id(),
-                      "error" => ?e,
+                    "block_id" => %block_id,
+                    "error" => ?e,
                 );
-                return Err(e);
-            }
-        };
+            })?;
 
         // if we pass all the tests, then along the way, we will have verified (in
         // Self::validate_nakamoto_block_burnchain) that the consensus hash of this block is on the
@@ -2569,9 +2563,9 @@ impl NakamotoChainState {
             obtain_method,
         )?;
         if ret {
-            test_debug!("Stored Nakamoto block {}", &block.block_id());
+            test_debug!("Stored Nakamoto block {block_id}");
         } else {
-            test_debug!("Did NOT store Nakamoto block {}", &block.block_id());
+            test_debug!("Did NOT store Nakamoto block {block_id}");
         }
         Ok(ret)
     }

stackslib/src/chainstate/nakamoto/tests/node.rs

@@ -1060,6 +1060,105 @@ impl TestStacksNode {
         let cost = builder.tenure_finish(tenure_tx).unwrap();
         Ok((block, size, cost))
     }
+
+    /// Insert a staging Nakamoto block as a pushed block and
+    /// then process it as the next ready block
+    /// NOTE: Will panic if called with unprocessed staging
+    /// blocks already in the queue.
+    pub fn process_pushed_next_ready_block<'a>(
+        stacks_node: &mut TestStacksNode,
+        sortdb: &mut SortitionDB,
+        miner: &mut TestMiner,
+        tenure_id_consensus_hash: &ConsensusHash,
+        coord: &mut ChainsCoordinator<
+            'a,
+            TestEventObserver,
+            (),
+            OnChainRewardSetProvider<'a, TestEventObserver>,
+            (),
+            (),
+            BitcoinIndexer,
+        >,
+        nakamoto_block: NakamotoBlock,
+    ) -> Result<Option<StacksEpochReceipt>, ChainstateError> {
+        // Before processeding, make sure the caller did not accidentally construct a test with unprocessed blocks already in the queue
+        let nakamoto_blocks_db = stacks_node.chainstate.nakamoto_blocks_db();
+        assert!(nakamoto_blocks_db
+            .next_ready_nakamoto_block(stacks_node.chainstate.db())
+            .unwrap().is_none(), "process_pushed_next_ready_block can only be called if the staging blocks queue is empty");
+
+        let tenure_sn =
+            SortitionDB::get_block_snapshot_consensus(sortdb.conn(), tenure_id_consensus_hash)?
+                .ok_or_else(|| ChainstateError::NoSuchBlockError)?;
+
+        let cycle = sortdb
+            .pox_constants
+            .block_height_to_reward_cycle(sortdb.first_block_height, tenure_sn.block_height)
+            .unwrap();
+
+        // Get the reward set
+        let sort_tip_sn = SortitionDB::get_canonical_burn_chain_tip(sortdb.conn())?;
+        let reward_set = load_nakamoto_reward_set(
+            miner
+                .burnchain
+                .block_height_to_reward_cycle(sort_tip_sn.block_height)
+                .expect("FATAL: no reward cycle for sortition"),
+            &sort_tip_sn.sortition_id,
+            &miner.burnchain,
+            &mut stacks_node.chainstate,
+            &nakamoto_block.header.parent_block_id,
+            sortdb,
+            &OnChainRewardSetProvider::new(),
+        )
+        .expect("Failed to load reward set")
+        .expect("Expected a reward set")
+        .0
+        .known_selected_anchor_block_owned()
+        .expect("Unknown reward set");
+
+        let block_id = nakamoto_block.block_id();
+
+        debug!(
+            "Process Nakamoto block {block_id} ({:?}",
+            &nakamoto_block.header
+        );
+
+        let sort_tip = SortitionDB::get_canonical_sortition_tip(sortdb.conn())?;
+        let mut sort_handle = sortdb.index_handle(&sort_tip);
+
+        // Force the block to be added to the nakamoto_staging_blocks table
+        let config = stacks_node.chainstate.config();
+        let (headers_conn, staging_db_tx) =
+            stacks_node.chainstate.headers_conn_and_staging_tx_begin()?;
+        let accepted = NakamotoChainState::accept_block(
+            &config,
+            &nakamoto_block,
+            &mut sort_handle,
+            &staging_db_tx,
+            headers_conn,
+            &reward_set,
+            NakamotoBlockObtainMethod::Pushed,
+        )?;
+        staging_db_tx.commit()?;
+        debug!("Accepted Nakamoto block {}", &nakamoto_block.block_id());
+        // Actually attempt to process the accepted block added to nakamoto_staging_blocks
+        // Will attempt to execute the transactions via a call to append_block
+        let res = NakamotoChainState::process_next_nakamoto_block(
+            &mut coord.chain_state_db,
+            &mut coord.sortition_db,
+            &coord.canonical_sortition_tip.clone().expect(
+                "FAIL: processing a new Stacks block, but don't have a canonical sortition tip",
+            ),
+            coord.dispatcher,
+            coord.config.txindex,
+        )?;
+        if res.is_some() {
+            // If we successfully processed the block, make sure we append the block to our current tenure
+            // so subsequent blocks do not attempt to reorg it.
+            stacks_node.add_nakamoto_extended_blocks(vec![nakamoto_block]);
+        }
+        Ok(res)
+    }
 }
 
 /// Get the Nakamoto parent linkage data for building atop the last-produced tenure or