feat: support multi-miner integration test

* test: add nakamoto_integration test with multiple miners (this test uses the blind signer test signing channel)

* fix: nakamoto miner communicates over the correct miner slot for their block election (rather than searching by pubkey)

* fix: neon miner does not submit block commits if the next burn block is in nakamoto

* feat: update `/v2/neighbors` to use qualified contract identifier's ToString and parse() for JSON serialization

* perf: nakamoto miner caches the reward set for their tenure

Author: kantai

stackslib/src/chainstate/nakamoto/mod.rs

@@ -455,6 +455,28 @@ impl MaturedMinerPaymentSchedules {
     }
 }
 
+pub struct MinersDBInformation {
+    signer_0_sortition: ConsensusHash,
+    signer_1_sortition: ConsensusHash,
+    latest_winner: u16,
+}
+
+impl MinersDBInformation {
+    pub fn get_signer_index(&self, sortition: &ConsensusHash) -> Option<u16> {
+        if sortition == &self.signer_0_sortition {
+            Some(0)
+        } else if sortition == &self.signer_1_sortition {
+            Some(1)
+        } else {
+            None
+        }
+    }
+
+    pub fn get_latest_winner_index(&self) -> u16 {
+        self.latest_winner
+    }
+}
+
 /// Calculated matured miner rewards, from scheduled rewards
 #[derive(Debug, Clone)]
 pub struct MaturedMinerRewards {
@@ -4039,7 +4061,7 @@ impl NakamotoChainState {
     pub fn make_miners_stackerdb_config(
         sortdb: &SortitionDB,
         tip: &BlockSnapshot,
-    ) -> Result<StackerDBConfig, ChainstateError> {
+    ) -> Result<(StackerDBConfig, MinersDBInformation), ChainstateError> {
         let ih = sortdb.index_handle(&tip.sortition_id);
         let last_winner_snapshot = ih.get_last_snapshot_with_sortition(tip.block_height)?;
         let parent_winner_snapshot = ih.get_last_snapshot_with_sortition(
@@ -4051,13 +4073,13 @@ impl NakamotoChainState {
         // go get their corresponding leader keys, but preserve the miner's relative position in
         // the stackerdb signer list -- if a miner was in slot 0, then it should stay in slot 0
         // after a sortition (and vice versa for 1)
-        let sns = if last_winner_snapshot.num_sortitions % 2 == 0 {
-            [last_winner_snapshot, parent_winner_snapshot]
+        let (latest_winner_idx, sns) = if last_winner_snapshot.num_sortitions % 2 == 0 {
+            (0, [last_winner_snapshot, parent_winner_snapshot])
         } else {
-            [parent_winner_snapshot, last_winner_snapshot]
+            (1, [parent_winner_snapshot, last_winner_snapshot])
         };
 
-        for sn in sns {
+        for sn in sns.iter() {
             // find the commit
             let Some(block_commit) =
                 ih.get_block_commit_by_txid(&sn.sortition_id, &sn.winning_block_txid)?
@@ -4088,6 +4110,12 @@ impl NakamotoChainState {
             );
         }
 
+        let miners_db_info = MinersDBInformation {
+            signer_0_sortition: sns[0].consensus_hash,
+            signer_1_sortition: sns[1].consensus_hash,
+            latest_winner: latest_winner_idx,
+        };
+
         let signers = miner_key_hash160s
             .into_iter()
             .map(|hash160|
@@ -4101,14 +4129,17 @@ impl NakamotoChainState {
                 ))
             .collect();
 
-        Ok(StackerDBConfig {
-            chunk_size: MAX_PAYLOAD_LEN.into(),
-            signers,
-            write_freq: 0,
-            max_writes: u32::MAX,  // no limit on number of writes
-            max_neighbors: 200, // TODO: const -- just has to be equal to or greater than the number of signers
-            hint_replicas: vec![], // TODO: is there a way to get the IP addresses of stackers' preferred nodes?
-        })
+        Ok((
+            StackerDBConfig {
+                chunk_size: MAX_PAYLOAD_LEN.into(),
+                signers,
+                write_freq: 0,
+                max_writes: u32::MAX,  // no limit on number of writes
+                max_neighbors: 200, // TODO: const -- just has to be equal to or greater than the number of signers
+                hint_replicas: vec![], // TODO: is there a way to get the IP addresses of stackers' preferred nodes?
+            },
+            miners_db_info,
+        ))
     }
 
     /// Get the slot range for the given miner's public key.
@@ -4119,33 +4150,29 @@ impl NakamotoChainState {
     pub fn get_miner_slot(
         sortdb: &SortitionDB,
         tip: &BlockSnapshot,
-        miner_pubkey: &StacksPublicKey,
+        election_sortition: &ConsensusHash,
     ) -> Result<Option<Range<u32>>, ChainstateError> {
-        let miner_hash160 = Hash160::from_node_public_key(&miner_pubkey);
-        let stackerdb_config = Self::make_miners_stackerdb_config(sortdb, &tip)?;
+        let (stackerdb_config, miners_info) = Self::make_miners_stackerdb_config(sortdb, &tip)?;
 
         // find out which slot we're in
-        let mut slot_index = 0;
-        let mut slot_id_result = None;
-        for (addr, slot_count) in stackerdb_config.signers.iter() {
-            if addr.bytes == miner_hash160 {
-                slot_id_result = Some(Range {
-                    start: slot_index,
-                    end: slot_index + slot_count,
-                });
-                break;
-            }
-            slot_index += slot_count;
-        }
-
-        let Some(slot_id_range) = slot_id_result else {
-            // miner key does not match any slot
+        let Some(signer_ix) = miners_info
+            .get_signer_index(election_sortition)
+            .map(usize::from)
+        else {
             warn!("Miner is not in the miners StackerDB config";
-                  "miner" => %miner_hash160,
                   "stackerdb_slots" => format!("{:?}", &stackerdb_config.signers));
-
             return Ok(None);
         };
+        let mut signer_ranges = stackerdb_config.signer_ranges();
+        if signer_ix >= signer_ranges.len() {
+            // should be unreachable, but always good to be careful
+            warn!("Miner is not in the miners StackerDB config";
+                  "stackerdb_slots" => format!("{:?}", &stackerdb_config.signers));
+
+            return Ok(None);
+        }
+        let slot_id_range = signer_ranges.swap_remove(signer_ix);
+
         Ok(Some(slot_id_range))
     }
 

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

@@ -2049,8 +2049,9 @@ fn test_make_miners_stackerdb_config() {
 
         let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
         // check the stackerdb config as of this chain tip
-        let stackerdb_config =
-            NakamotoChainState::make_miners_stackerdb_config(sort_db, &tip).unwrap();
+        let stackerdb_config = NakamotoChainState::make_miners_stackerdb_config(sort_db, &tip)
+            .unwrap()
+            .0;
         eprintln!(
             "stackerdb_config at i = {} (sorition? {}): {:?}",
             &i, sortition, &stackerdb_config
@@ -2079,8 +2080,9 @@ fn test_make_miners_stackerdb_config() {
         let tip = SortitionDB::get_canonical_burn_chain_tip(sort_db.conn()).unwrap();
         let miner_privkey = &miner_keys[i];
         let miner_pubkey = StacksPublicKey::from_private(miner_privkey);
-        let slot_id = NakamotoChainState::get_miner_slot(&sort_db, &tip, &miner_pubkey)
-            .expect("Failed to get miner slot");
+        let slot_id =
+            NakamotoChainState::get_miner_slot(&sort_db, &tip, &block.header.consensus_hash)
+                .expect("Failed to get miner slot");
         if sortition {
             let slot_id = slot_id.expect("No miner slot exists for this miner").start;
             let slot_version = stackerdbs

stackslib/src/net/api/getneighbors.rs

@@ -51,9 +51,43 @@ pub struct RPCNeighbor {
     pub public_key_hash: Hash160,
     pub authenticated: bool,
     #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(with = "serde_opt_vec_qci")]
     pub stackerdbs: Option<Vec<QualifiedContractIdentifier>>,
 }
 
+/// Serialize and deserialize `Option<Vec<QualifiedContractIdentifier>>`
+///  using the `to_string()` and `parse()` implementations of `QualifiedContractIdentifier`.
+mod serde_opt_vec_qci {
+    use clarity::vm::types::QualifiedContractIdentifier;
+    use serde::{Deserialize, Serialize};
+
+    pub fn serialize<S: serde::Serializer>(
+        opt: &Option<Vec<QualifiedContractIdentifier>>,
+        serializer: S,
+    ) -> Result<S::Ok, S::Error> {
+        let serialize_as: Option<Vec<_>> = opt
+            .as_ref()
+            .map(|vec_qci| vec_qci.iter().map(ToString::to_string).collect());
+        serialize_as.serialize(serializer)
+    }
+
+    pub fn deserialize<'de, D>(de: D) -> Result<Option<Vec<QualifiedContractIdentifier>>, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        let from_str: Option<Vec<String>> = Deserialize::deserialize(de)?;
+        let Some(vec_str) = from_str else {
+            return Ok(None);
+        };
+        let parse_opt: Result<Vec<QualifiedContractIdentifier>, _> = vec_str
+            .into_iter()
+            .map(|x| QualifiedContractIdentifier::parse(&x).map_err(serde::de::Error::custom))
+            .collect();
+        let out_vec = parse_opt?;
+        Ok(Some(out_vec))
+    }
+}
+
 impl RPCNeighbor {
     pub fn from_neighbor_key_and_pubkh(
         nk: NeighborKey,

stackslib/src/net/rpc.rs

@@ -554,12 +554,12 @@ impl ConversationHttp {
                     )?;
 
                     info!("Handled StacksHTTPRequest";
-                           "verb" => %verb,
-                           "path" => %request_path,
-                           "processing_time_ms" => start_time.elapsed().as_millis(),
-                           "latency_ms" => latency,
-                           "conn_id" => self.conn_id,
-                           "peer_addr" => &self.peer_addr);
+                          "verb" => %verb,
+                          "path" => %request_path,
+                          "processing_time_ms" => start_time.elapsed().as_millis(),
+                          "latency_ms" => latency,
+                          "conn_id" => self.conn_id,
+                          "peer_addr" => &self.peer_addr);
 
                     if let Some(msg) = msg_opt {
                         ret.push(msg);

stackslib/src/net/stackerdb/config.rs

@@ -555,10 +555,17 @@ impl StackerDBConfig {
                 reason,
             ));
         } else if let Some(Err(e)) = res {
-            warn!(
-                "Could not use contract {} for StackerDB: {:?}",
-                contract_id, &e
-            );
+            if contract_id.is_boot() {
+                debug!(
+                    "Could not use contract {} for StackerDB: {:?}",
+                    contract_id, &e
+                );
+            } else {
+                warn!(
+                    "Could not use contract {} for StackerDB: {:?}",
+                    contract_id, &e
+                );
+            }
             return Err(e);
         }
 

stackslib/src/net/stackerdb/mod.rs

@@ -119,6 +119,7 @@ pub mod db;
 pub mod sync;
 
 use std::collections::{HashMap, HashSet};
+use std::ops::Range;
 
 use clarity::vm::types::QualifiedContractIdentifier;
 use libstackerdb::{SlotMetadata, STACKERDB_MAX_CHUNK_SIZE};
@@ -205,6 +206,22 @@ impl StackerDBConfig {
     pub fn num_slots(&self) -> u32 {
         self.signers.iter().fold(0, |acc, s| acc + s.1)
     }
+
+    /// What are the slot index ranges for each signer?
+    /// Returns the ranges in the same ordering as `self.signers`
+    pub fn signer_ranges(&self) -> Vec<Range<u32>> {
+        let mut slot_index = 0;
+        let mut result = Vec::with_capacity(self.signers.len());
+        for (_, slot_count) in self.signers.iter() {
+            let end = slot_index + *slot_count;
+            result.push(Range {
+                start: slot_index,
+                end,
+            });
+            slot_index = end;
+        }
+        result
+    }
 }
 
 /// This is the set of replicated chunks in all stacker DBs that this node subscribes to.
@@ -280,14 +297,16 @@ impl StackerDBs {
                 == boot_code_id(MINERS_NAME, chainstate.mainnet)
             {
                 // .miners contract -- directly generate the config
-                NakamotoChainState::make_miners_stackerdb_config(sortdb, &tip).unwrap_or_else(|e| {
-                    warn!(
-                        "Failed to generate .miners StackerDB config";
-                        "contract" => %stackerdb_contract_id,
-                        "err" => ?e,
-                    );
-                    StackerDBConfig::noop()
-                })
+                NakamotoChainState::make_miners_stackerdb_config(sortdb, &tip)
+                    .map(|(config, _)| config)
+                    .unwrap_or_else(|e| {
+                        warn!(
+                            "Failed to generate .miners StackerDB config";
+                            "contract" => %stackerdb_contract_id,
+                            "err" => ?e,
+                        );
+                        StackerDBConfig::noop()
+                    })
             } else {
                 // attempt to load the config from the contract itself
                 StackerDBConfig::from_smart_contract(
@@ -297,11 +316,20 @@ impl StackerDBs {
                     num_neighbors,
                 )
                 .unwrap_or_else(|e| {
-                    warn!(
-                        "Failed to load StackerDB config";
-                        "contract" => %stackerdb_contract_id,
-                        "err" => ?e,
-                    );
+                    if matches!(e, net_error::NoSuchStackerDB(_)) && stackerdb_contract_id.is_boot()
+                    {
+                        debug!(
+                            "Failed to load StackerDB config";
+                            "contract" => %stackerdb_contract_id,
+                            "err" => ?e,
+                        );
+                    } else {
+                        warn!(
+                            "Failed to load StackerDB config";
+                            "contract" => %stackerdb_contract_id,
+                            "err" => ?e,
+                        );
+                    }
                     StackerDBConfig::noop()
                 })
             };

stackslib/src/net/stackerdb/sync.rs

@@ -1096,9 +1096,6 @@ impl<NC: NeighborComms> StackerDBSync<NC> {
             // next-prioritized chunk
             cur_priority = (cur_priority + 1) % self.chunk_push_priorities.len();
         }
-        if pushed == 0 {
-            return Err(net_error::PeerNotConnected);
-        }
         self.next_chunk_push_priority = cur_priority;
         Ok(self
             .chunk_push_priorities