more work on rotation

Author: QuantumExplorer

dash/src/network/message_qrinfo.rs

@@ -1,5 +1,6 @@
 use core::fmt::{Display, Formatter};
 use std::{fmt, io};
+use bincode::{Decode, Encode};
 use crate::BlockHash;
 use crate::consensus::{encode, Decodable, Encodable};
 use crate::consensus::encode::{read_compact_size, read_fixed_bitset, write_fixed_bitset};
@@ -149,6 +150,7 @@ impl Decodable for QRInfo {
 /// - `mn_skip_list_size`: A compact-size unsigned integer representing the number of skip list entries.
 /// - `mn_skip_list`: An array of 4-byte signed integers, one per skip list entry.
 #[derive(PartialEq, Eq, Clone, Debug)]
+#[cfg_attr(feature = "bincode", derive(Encode, Decode))]
 pub struct QuorumSnapshot {
     pub skip_list_mode: MNSkipListMode,
     pub active_quorum_members: Vec<bool>,   // Bitset, length = (active_quorum_members_count + 7) / 8
@@ -206,6 +208,7 @@ impl Decodable for QuorumSnapshot {
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 #[repr(u32)]
+#[cfg_attr(feature = "bincode", derive(Encode, Decode))]
 pub enum MNSkipListMode {
     /// Mode 0: No skipping – the skip list is empty.
     NoSkipping = 0,

dash/src/sml/llmq_type/llmq_indexed_hash.rs

@@ -0,0 +1,22 @@
+#[derive(Debug, Clone, Ord, PartialOrd, Eq, PartialEq)]
+pub struct LLMQIndexedHash {
+    pub index: u32,
+    pub hash: [u8; 32],
+}
+
+impl LLMQIndexedHash {
+    pub fn new(hash: [u8; 32], index: u32) -> Self {
+        LLMQIndexedHash { index, hash }
+    }
+}
+
+impl From<([u8; 32], usize)> for LLMQIndexedHash {
+    fn from(value: ([u8; 32], usize)) -> Self {
+        Self::new(value.0, value.1 as u32)
+    }
+}
+impl From<([u8; 32], u32)> for LLMQIndexedHash {
+    fn from(value: ([u8; 32], u32)) -> Self {
+        Self::new(value.0, value.1)
+    }
+}

dash/src/sml/llmq_type/mod.rs

@@ -1,5 +1,6 @@
 mod network;
 pub mod rotation;
+pub(crate) mod llmq_indexed_hash;
 
 use std::fmt::{Display, Formatter};
 use std::io;

dash/src/sml/llmq_type/rotation.rs

@@ -9,15 +9,15 @@ pub enum LLMQQuarterType {
 }
 
 #[derive(Clone, Copy)]
-pub enum LLMQQuarterReconstructionType<'a> {
+pub enum LLMQQuarterReconstructionType<'a: 'b, 'b> {
     Snapshot,
     New {
-        previous_quarters: [&'a Vec<Vec<QualifiedMasternodeListEntry>>; 3],
+        previous_quarters: [&'b Vec<Vec<&'a QualifiedMasternodeListEntry>>; 3],
         skip_removed_masternodes: bool,
     }
 }
 
-pub enum LLMQQuarterUsageType {
+pub enum LLMQQuarterUsageType<'a> {
     Snapshot(QuorumSnapshot),
-    New(Vec<Vec<QualifiedMasternodeListEntry>>)
+    New(Vec<Vec<&'a QualifiedMasternodeListEntry>>)
 }

dash/src/sml/masternode_list/mod.rs

@@ -9,6 +9,7 @@ pub mod from_diff;
 mod apply_diff;
 mod scores_for_quorum;
 mod rotation;
+mod valid_members_in_rotated_quorum;
 
 use std::collections::BTreeMap;
 #[cfg(feature = "bincode")]

dash/src/sml/masternode_list/rotated_quorums_info.rs

@@ -2,9 +2,9 @@ use crate::sml::masternode_list::MasternodeList;
 use crate::sml::masternode_list_entry::qualified_masternode_list_entry::QualifiedMasternodeListEntry;
 
 impl MasternodeList {
-    pub fn usage_info(&self, previous_quarters: [&Vec<Vec<QualifiedMasternodeListEntry>>; 3], skip_removed_masternodes: bool, quorum_count: usize) -> (Vec<QualifiedMasternodeListEntry>, Vec<QualifiedMasternodeListEntry>, Vec<Vec<QualifiedMasternodeListEntry>>) {
-        let mut used_at_h_masternodes = Vec::<QualifiedMasternodeListEntry>::new();
-        let mut used_at_h_indexed_masternodes = vec![Vec::<QualifiedMasternodeListEntry>::new(); quorum_count];
+    pub fn usage_info<'a>(&'a self, previous_quarters: [&Vec<Vec<&'a QualifiedMasternodeListEntry>>; 3], skip_removed_masternodes: bool, quorum_count: usize) -> (Vec<&'a QualifiedMasternodeListEntry>, Vec<&'a QualifiedMasternodeListEntry>, Vec<Vec<&'a QualifiedMasternodeListEntry>>) {
+        let mut used_at_h_masternodes = Vec::<&QualifiedMasternodeListEntry>::new();
+        let mut used_at_h_indexed_masternodes = vec![Vec::<&QualifiedMasternodeListEntry>::new(); quorum_count];
         for i in 0..quorum_count {
             // for quarters h - c, h -2c, h -3c
             for quarter in &previous_quarters {
@@ -14,10 +14,10 @@ impl MasternodeList {
                         if (!skip_removed_masternodes || self.has_masternode(&hash)) &&
                             self.has_valid_masternode(&hash) {
                             if !used_at_h_masternodes.iter().any(|m| m.masternode_list_entry.pro_reg_tx_hash == hash) {
-                                used_at_h_masternodes.push(node.clone());
+                                used_at_h_masternodes.push(node);
                             }
                             if !used_at_h_indexed_masternodes[i].iter().any(|m| m.masternode_list_entry.pro_reg_tx_hash == hash) {
-                                used_at_h_indexed_masternodes[i].push(node.clone());
+                                used_at_h_indexed_masternodes[i].push(node);
                             }
                         }
                     }
@@ -26,7 +26,6 @@ impl MasternodeList {
         }
         let unused_at_h_masternodes = self.masternodes.values()
             .filter(|mn| mn.masternode_list_entry.is_valid && !used_at_h_masternodes.iter().any(|node| mn.masternode_list_entry.pro_reg_tx_hash == node.masternode_list_entry.pro_reg_tx_hash))
-            .cloned()
             .collect();
         (used_at_h_masternodes, unused_at_h_masternodes, used_at_h_indexed_masternodes)
 

dash/src/sml/masternode_list/rotation.rs

@@ -1,102 +0,0 @@
-use std::collections::BTreeMap;
-use crate::BlockHash;
-use crate::prelude::CoreBlockHeight;
-use crate::sml::llmq_type::{LLMQParams, LLMQType};
-use crate::sml::llmq_type::rotation::LLMQQuarterReconstructionType;
-use crate::sml::masternode_list::MasternodeList;
-use crate::sml::masternode_list_entry::MasternodeListEntry;
-use crate::sml::quorum_validation_error::QuorumValidationError;
-
-impl MasternodeList {
-    fn rotate_members(
-        &self,
-        cycle_base_height: u32,
-        llmq_params: LLMQParams,
-        skip_removed_masternodes: bool,
-        // cache: &Arc<RwLock<MasternodeProcessorCache>>
-        // cached_mn_lists: &BTreeMap<UInt256, MasternodeList>,
-        // cached_llmq_snapshots: &BTreeMap<UInt256, LLMQSnapshot>,
-        // cached_cl_signatures: &BTreeMap<UInt256, UInt768>,
-        // unknown_mn_lists: &mut Vec<UInt256>,
-    ) -> Result<Vec<Vec<MasternodeListEntry>>, QuorumValidationError> {
-        let num_quorums = llmq_params.signing_active_quorum_count as usize;
-        let cycle_length = llmq_params.dkg_params.interval;
-        let work_block_height_for_index = |index: u32| (cycle_base_height - index * cycle_length) - 8;
-        // Reconstruct quorum members at h - 3c from snapshot
-        let q_h_m_3c = self.quorum_quarter_members_by_reconstruction_type(LLMQQuarterReconstructionType::Snapshot, &llmq_params, work_block_height_for_index(3))?;
-        // Reconstruct quorum members at h - 2c from snapshot
-        let q_h_m_2c = self.quorum_quarter_members_by_reconstruction_type(LLMQQuarterReconstructionType::Snapshot, &llmq_params, work_block_height_for_index(2))?;
-        // Reconstruct quorum members at h - c from snapshot
-        let q_h_m_c = self.quorum_quarter_members_by_reconstruction_type(LLMQQuarterReconstructionType::Snapshot, &llmq_params, work_block_height_for_index(1))?;
-        // Determine quorum members at new index
-        let reconstruction_type = LLMQQuarterReconstructionType::New { previous_quarters:  [&q_h_m_c, &q_h_m_2c, &q_h_m_3c], skip_removed_masternodes };
-        let quarter_new = self.quorum_quarter_members_by_reconstruction_type(reconstruction_type, &llmq_params, work_block_height_for_index(0))?;
-        let mut quorum_members =
-            Vec::<Vec<MasternodeListEntry>>::with_capacity(num_quorums);
-        (0..num_quorums).for_each(|index| {
-            add_quorum_members_from_quarter(&mut quorum_members, &q_h_m_3c, index);
-            add_quorum_members_from_quarter(&mut quorum_members, &q_h_m_2c, index);
-            add_quorum_members_from_quarter(&mut quorum_members, &q_h_m_c, index);
-            add_quorum_members_from_quarter(&mut quorum_members, &quarter_new, index);
-        });
-        Ok(quorum_members)
-    }
-
-    /// Determine masternodes which is responsible for signing at this quorum index
-    #[allow(clippy::too_many_arguments)]
-    pub fn get_rotated_masternodes_for_quorum(
-        &self,
-        llmq_type: LLMQType,
-        block_hash: BlockHash,
-        block_height: CoreBlockHeight,
-        skip_removed_masternodes: bool,
-    ) -> Result<Vec<MasternodeListEntry>, CoreProviderError> {
-        let mut llmq_members_lock = self.cache.llmq_members.write().unwrap();
-        let cached_members_of_llmq_type_opt = llmq_members_lock.get_mut(&llmq_type);
-        if cached_members_of_llmq_type_opt.is_some() {
-            if let Some(cached_members) = cached_members_of_llmq_type_opt.as_ref().unwrap().get(&block_hash).cloned() {
-                drop(llmq_members_lock);
-                return Ok(cached_members);
-            }
-        } else {
-            llmq_members_lock.insert(llmq_type.clone(), BTreeMap::new());
-        }
-
-        let cached_members_of_llmq_type = llmq_members_lock.get_mut(&llmq_type).unwrap();
-        let llmq_params = llmq_type.params();
-        let quorum_index = block_height % llmq_params.dkg_params.interval;
-        let cycle_base_height = block_height - quorum_index;
-        let cycle_base_hash = self.provider.lookup_block_hash_by_height(cycle_base_height);
-        let mut llmq_indexed_members_lock = self.cache.llmq_indexed_members.write().unwrap();
-        if let Some(map_by_type_indexed) = llmq_indexed_members_lock.get(&llmq_type) {
-            let indexed_hash = LLMQIndexedHash::from((cycle_base_hash, quorum_index));
-            if let Some(cached_members) = map_by_type_indexed.get(&indexed_hash).cloned() {
-                cached_members_of_llmq_type.insert(block_hash, cached_members.clone());
-                drop(llmq_members_lock);
-                drop(llmq_indexed_members_lock);
-                return Ok(cached_members);
-            }
-        } else {
-            llmq_indexed_members_lock.insert(llmq_type.clone(), BTreeMap::new());
-        }
-        drop(llmq_indexed_members_lock);
-        let rotated_members = self.rotate_members(cycle_base_height, llmq_params, skip_removed_masternodes)?;
-        let result = if let Some(rotated_members_at_index) = rotated_members.get(quorum_index as usize) {
-            cached_members_of_llmq_type.insert(block_hash, rotated_members_at_index.clone());
-            Ok(rotated_members_at_index.clone())
-        } else {
-            Err(CoreProviderError::NullResult(format!("No rotated_members for llmq index {} ({})", quorum_index, block_hash.to_hex())))
-        };
-        drop(llmq_members_lock);
-
-        self.cache.write_llmq_indexed_members(|lock| {
-            lock.get_mut(&llmq_type)
-                .unwrap()
-                .extend(rotated_members.into_iter()
-                    .enumerate()
-                    .map(|(index, members)|
-                        (LLMQIndexedHash::from((cycle_base_hash, index)), members)));
-        });
-        result
-    }
-}

dash/src/sml/masternode_list/scores_for_quorum.rs

@@ -1,39 +1,71 @@
 use std::collections::BTreeMap;
 use crate::hash_types::{QuorumModifierHash, ScoreHash};
 use crate::Network;
+use crate::network::message_qrinfo::QuorumSnapshot;
 use crate::sml::masternode_list::MasternodeList;
 use crate::sml::masternode_list_entry::MasternodeType;
 use crate::sml::masternode_list_entry::qualified_masternode_list_entry::QualifiedMasternodeListEntry;
 use crate::sml::quorum_entry::qualified_quorum_entry::QualifiedQuorumEntry;
 use crate::sml::quorum_entry::quorum_modifier_type::LLMQModifierType;
 
 impl MasternodeList {
-    pub fn valid_masternodes_for_quorum<T>(
-        &self,
+    pub fn valid_masternodes_for_quorum<'a, T>(
+        &'a self,
         quorum: &QualifiedQuorumEntry,
         quorum_modifier: LLMQModifierType,
         network: Network,
     ) -> T
-    where T: FromIterator<QualifiedMasternodeListEntry> {
+    where T: FromIterator<&'a QualifiedMasternodeListEntry> {
         let llmq_type = quorum.quorum_entry.llmq_type;
         let hpmn_only = llmq_type == network.platform_type();
         let quorum_modifier = quorum_modifier.build_llmq_hash();
         let score_dictionary = self.scores_for_quorum(quorum_modifier, hpmn_only);
         score_dictionary.into_values().rev().take(llmq_type.size() as usize).collect()
     }
 
-    pub fn scores_for_quorum(
-        &self,
+    pub fn used_and_unused_masternodes_for_quorum<'a>(
+        &'a self,
+        quorum: &QualifiedQuorumEntry,
+        quorum_modifier: LLMQModifierType,
+        quorum_snapshot: &QuorumSnapshot,
+        network: Network,
+    ) -> (Vec<&'a QualifiedMasternodeListEntry>, Vec<&'a QualifiedMasternodeListEntry>)
+     {
+        let llmq_type = quorum.quorum_entry.llmq_type;
+        let hpmn_only = llmq_type == network.platform_type();
+        let quorum_modifier = quorum_modifier.build_llmq_hash();
+        let score_dictionary = self.scores_for_quorum(quorum_modifier, hpmn_only);
+         let masternode_entry_list: Vec<&QualifiedMasternodeListEntry> = score_dictionary.into_values().rev().collect();
+         let mut i = 0;
+         masternode_entry_list.into_iter().partition(|(_)| {
+                let used = quorum_snapshot.active_quorum_members.get(i).copied().unwrap_or_default();
+             i += 1;
+                used
+            })
+    }
+
+    pub fn scores_for_quorum_for_masternodes<'a, T>(
+        entries: T,
         quorum_modifier: QuorumModifierHash,
         hpmn_only: bool,
-    ) -> BTreeMap<ScoreHash, QualifiedMasternodeListEntry> {
-        self.masternodes.values().filter_map(|entry| {
+    ) -> BTreeMap<ScoreHash, &'a QualifiedMasternodeListEntry>
+    where
+        T: IntoIterator<Item = &'a QualifiedMasternodeListEntry> {
+        entries.into_iter().filter_map(|entry| {
             if !hpmn_only || matches!(entry.masternode_list_entry.mn_type, MasternodeType::HighPerformance{..}) {
                 entry.score(quorum_modifier)
-                    .map(|score| (score, entry.clone()))
+                    .map(|score| (score, entry))
             } else {
                 None
             }
         }).collect()
     }
+
+    pub fn scores_for_quorum(
+        &self,
+        quorum_modifier: QuorumModifierHash,
+        hpmn_only: bool,
+    ) -> BTreeMap<ScoreHash, &QualifiedMasternodeListEntry> {
+        Self::scores_for_quorum_for_masternodes(self.masternodes.values(), quorum_modifier, hpmn_only)
+    }
 }

dash/src/sml/masternode_list/valid_members_in_rotated_quorum.rs

@@ -0,0 +1,13 @@
+use std::collections::BTreeMap;
+use crate::BlockHash;
+use crate::prelude::CoreBlockHeight;
+use crate::sml::llmq_type::llmq_indexed_hash::LLMQIndexedHash;
+use crate::sml::llmq_type::LLMQType;
+use crate::sml::masternode_list::MasternodeList;
+use crate::sml::masternode_list_entry::MasternodeListEntry;
+use crate::sml::masternode_list_entry::qualified_masternode_list_entry::QualifiedMasternodeListEntry;
+use crate::sml::quorum_validation_error::QuorumValidationError;
+
+impl MasternodeList {
+
+}

dash/src/sml/masternode_list_engine/mod.rs

@@ -1,6 +1,7 @@
 #[cfg(feature = "quorum_validation")]
 mod validation;
-mod rotation;
+mod rotated_quorum_construction;
+mod non_rotated_quorum_construction;
 
 use std::collections::{BTreeMap, BTreeSet};
 #[cfg(feature = "bincode")]
@@ -9,6 +10,7 @@ use bincode::{Decode, Encode};
 use serde::{Deserialize, Serialize};
 use crate::{BlockHash, Network, QuorumHash};
 use crate::bls_sig_utils::BLSSignature;
+use crate::network::message_qrinfo::QuorumSnapshot;
 use crate::network::message_sml::MnListDiff;
 use crate::prelude::CoreBlockHeight;
 use crate::sml::error::SmlError;
@@ -27,6 +29,7 @@ pub struct MasternodeListEngine {
     pub block_heights : BTreeMap<BlockHash, CoreBlockHeight>,
     pub masternode_lists : BTreeMap<CoreBlockHeight, MasternodeList>,
     pub known_chain_locks: BTreeMap<BlockHash, BLSSignature>,
+    pub known_snapshots: BTreeMap<BlockHash, QuorumSnapshot>,
     pub network: Network,
 }
 
@@ -40,6 +43,7 @@ impl MasternodeListEngine {
             block_heights: [(base_block_hash, 0), (block_hash, block_height)].into(),
             masternode_lists: [(block_height, masternode_list)].into(),
             known_chain_locks: Default::default(),
+            known_snapshots: Default::default(),
             network,
         })
     }
@@ -66,21 +70,6 @@ impl MasternodeListEngine {
             .unwrap_or_default()
     }
 
-    pub fn masternode_list_and_height_for_block_hash_8_blocks_ago(
-        &self,
-        block_hash: &BlockHash,
-    ) -> Result<(&MasternodeList, CoreBlockHeight), QuorumValidationError> {
-        if let Some(height) = self.block_heights.get(block_hash) {
-            if let Some(masternode_list) = self.masternode_lists.get(&(height.saturating_sub(8))) {
-                Ok((masternode_list, height.saturating_sub(8)))
-            } else {
-                Err(QuorumValidationError::RequiredMasternodeListNotPresent(height.saturating_sub(8)))
-            }
-        } else {
-            Err(QuorumValidationError::RequiredBlockNotPresent(*block_hash))
-        }
-    }
-
     pub fn masternode_list_for_block_hash(&self, block_hash: &BlockHash) -> Option<&MasternodeList> {
         self.block_heights.get(block_hash).and_then(|height| self.masternode_lists.get(height))
     }