Merge remote-tracking branch 'origin/develop' into feat/add-version-to-block-proposal

Author: hstove

CHANGELOG.md

@@ -10,9 +10,12 @@ and this project adheres to the versioning scheme outlined in the [README.md](RE
 ### Added
 
 - The `BlockProposal` StackerDB message serialization struct now includes a `server_version` string, which represents the version of the node that the miner is using. ([#5803](https://github.com/stacks-network/stacks-core/pull/5803))
+- Add `vrf_seed` to the `/v3/sortitions` rpc endpoint
 
 ### Changed
 
+- Miner will stop waiting for signatures on a block if the Stacks tip advances (causing the block it had proposed to be invalid).
+
 ### Fixed
 
 - Error responses to /v2/transactions/fees are once again expressed as JSON ([#4145](https://github.com/stacks-network/stacks-core/issues/4145)).

contrib/tools/block-replay.sh

@@ -10,6 +10,7 @@
     "miner_pk_hash160": "0x6bc51b33e9f3626944eb879147e18111581f8f9b",
     "stacks_parent_ch": "0x697357c72da55b759b1d6b721676c92c69f0b490",
     "last_sortition_ch": "0x697357c72da55b759b1d6b721676c92c69f0b490",
-    "committed_block_hash": "0xeea47d6d639c565027110e192e308fb11656183d5c077bcd718d830652800183"
+    "committed_block_hash": "0xeea47d6d639c565027110e192e308fb11656183d5c077bcd718d830652800183",
+    "vrf_seed": "0x48b754acc291a5bfad1354ee19bbc471f14af2b21dc7eccc0f929bd16798defe"
   }
 ]

docs/rpc/api/core-node/get_sortitions.example.json

@@ -559,6 +559,7 @@ fn check_proposal_refresh() {
             stacks_parent_ch: Some(view.cur_sortition.parent_tenure_id),
             last_sortition_ch: Some(view.cur_sortition.parent_tenure_id),
             committed_block_hash: None,
+            vrf_seed: None,
         },
         SortitionInfo {
             burn_block_hash: BurnchainHeaderHash([128; 32]),
@@ -572,6 +573,7 @@ fn check_proposal_refresh() {
             stacks_parent_ch: Some(view.cur_sortition.parent_tenure_id),
             last_sortition_ch: Some(view.cur_sortition.parent_tenure_id),
             committed_block_hash: None,
+            vrf_seed: None,
         },
     ];
 

stacks-signer/src/tests/chainstate.rs

@@ -207,6 +207,10 @@ impl SignerTrait<SignerMessage> for Signer {
                                 "block_height" => b.header.chain_length,
                                 "signer_sighash" => %b.header.signer_signature_hash(),
                             );
+                            #[cfg(any(test, feature = "testing"))]
+                            if self.test_skip_block_broadcast(b) {
+                                return;
+                            }
                             stacks_client.post_block_until_ok(self, b);
                         }
                         SignerMessage::MockProposal(mock_proposal) => {

stacks-signer/src/v0/signer.rs

@@ -234,10 +234,7 @@ impl BitcoinIndexer {
             true,
             false,
         )
-        .expect(&format!(
-            "Failed to open {:?}",
-            working_dir_path.to_str().unwrap()
-        ));
+        .unwrap_or_else(|_| panic!("Failed to open {working_dir_path:?}"));
 
         BitcoinIndexer {
             config: BitcoinIndexerConfig::default_regtest(

stackslib/src/burnchains/bitcoin/indexer.rs

@@ -439,10 +439,7 @@ impl TestBurnchainBlock {
             // prove on the last-ever sortition's hash to produce the new seed
             let proof = miner
                 .make_proof(&leader_key.public_key, &last_snapshot.sortition_hash)
-                .expect(&format!(
-                    "FATAL: no private key for {}",
-                    leader_key.public_key.to_hex()
-                ));
+                .unwrap_or_else(|| panic!("FATAL: no private key for {:?}", leader_key.public_key));
 
             VRFSeed::from_proof(&proof)
         });
@@ -655,10 +652,12 @@ impl TestBurnchainBlock {
         let parent_hdr = indexer
             .read_burnchain_header(self.block_height.saturating_sub(1))
             .unwrap()
-            .expect(&format!(
-                "BUG: could not read block at height {}",
-                self.block_height.saturating_sub(1)
-            ));
+            .unwrap_or_else(|| {
+                panic!(
+                    "BUG: could not read block at height {}",
+                    self.block_height.saturating_sub(1)
+                )
+            });
 
         let now = BURNCHAIN_TEST_BLOCK_TIME;
         let block_hash = BurnchainHeaderHash::from_bitcoin_hash(

stackslib/src/burnchains/tests/mod.rs

@@ -1344,7 +1344,7 @@ impl TestPeer<'_> {
                 );
             }
             Err(e) => {
-                panic!("Failure fetching recipient set: {:?}", e);
+                panic!("Failure fetching recipient set: {e:?}");
             }
         };
 
@@ -1368,16 +1368,11 @@ impl TestPeer<'_> {
         let proof = self
             .miner
             .make_proof(&miner_key.public_key, &tip.sortition_hash)
-            .expect(&format!(
-                "FATAL: no private key for {}",
-                miner_key.public_key.to_hex()
-            ));
+            .unwrap_or_else(|| panic!("FATAL: no private key for {:?}", miner_key.public_key));
         self.sortdb = Some(sortdb);
         debug!(
-            "VRF proof made from {} over {}: {}",
-            &miner_key.public_key.to_hex(),
-            &tip.sortition_hash,
-            &proof.to_hex()
+            "VRF proof made from {:?} over {}: {proof:?}",
+            miner_key.public_key, &tip.sortition_hash
         );
         proof
     }

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

@@ -334,10 +334,7 @@ pub fn check_stacking_state_invariants(
     .burn_header_height;
 
     let stacking_state_entry = get_stacking_state_pox(peer, tip, stacker, active_pox_contract)
-        .expect(&format!(
-            "Invariant violated: reward-cycle entry has stacker field set, but not present in stacker-state (pox_contract = {})",
-            active_pox_contract,
-        ))
+        .unwrap_or_else(|| panic!("Invariant violated: reward-cycle entry has stacker field set, but not present in stacker-state (pox_contract = {active_pox_contract})"))
         .expect_tuple().unwrap();
     let first_cycle = stacking_state_entry
         .get("first-reward-cycle")

stackslib/src/chainstate/stacks/boot/pox_2_tests.rs

@@ -8353,9 +8353,9 @@ fn test_scenario_three(use_nakamoto: bool) {
     assert_eq!(amount_locked_actual, amount_locked_expected);
 
     // Check Bob signer key
-    let signer_key_expected = Value::buff_from(bob.public_key.to_bytes_compressed());
+    let signer_key_expected = Value::buff_from(bob.public_key.to_bytes_compressed()).unwrap();
     let signer_key_actual = bob_stack_tx_ok.data_map.get("signer-key").unwrap().clone();
-    assert_eq!(signer_key_actual, signer_key_actual);
+    assert_eq!(signer_key_actual, signer_key_expected);
 
     // 5. Check that David can't delegate-stack-stx Eve if delegation expires during lock period
     let eve_delegate_stx_to_david_err = receipts
@@ -10262,7 +10262,7 @@ fn test_scenario_five(use_nakamoto: bool) {
     for (idx, (stacker, stacker_lock_period)) in davids_stackers.iter().enumerate() {
         let (pox_address, first_reward_cycle, lock_period, _indices) =
             get_stacker_info_pox_4(&mut peer, &stacker.principal)
-                .expect(format!("Failed to find stacker {}", idx).as_str());
+                .unwrap_or_else(|| panic!("Failed to find stacker {idx}"));
         assert_eq!(first_reward_cycle, reward_cycle);
         assert_eq!(pox_address, david.pox_address);
         assert_eq!(lock_period, *stacker_lock_period);
@@ -10271,7 +10271,7 @@ fn test_scenario_five(use_nakamoto: bool) {
     for (idx, (stacker, stacker_lock_period)) in eves_stackers.iter().enumerate() {
         let (pox_address, first_reward_cycle, lock_period, _indices) =
             get_stacker_info_pox_4(&mut peer, &stacker.principal)
-                .expect(format!("Failed to find stacker {}", idx).as_str());
+                .unwrap_or_else(|| panic!("Failed to find stacker {idx}"));
         assert_eq!(first_reward_cycle, reward_cycle);
         assert_eq!(pox_address, eve.pox_address);
         assert_eq!(lock_period, *stacker_lock_period);