trial

QuantumExplorer · QuantumExplorer · commit e0cd362204f4 · 2025-02-16T12:01:48.000+07:00
diff --git a/dash/src/sml/llmq_type/mod.rs b/dash/src/sml/llmq_type/mod.rs
@@ -1,4 +1,7 @@
 mod network;
+// pub mod rotation;
+// pub mod snapshot;
+// pub mod quorum_snapshot_skip_mode;
 
 use std::fmt::{Display, Formatter};
 use std::io;
diff --git a/dash/src/sml/llmq_type/quorum_snapshot_skip_mode.rs b/dash/src/sml/llmq_type/quorum_snapshot_skip_mode.rs
@@ -0,0 +1,60 @@
+use std::fmt::Formatter;
+
+#[derive(Clone, Debug, Eq, PartialEq, PartialOrd, Hash)]
+pub enum LLMQSnapshotSkipMode {
+    // No skipping. The skip list is empty.
+    NoSkipping = 0,
+    // Skip the first entry of the list.
+    // The following entries contain the relative position of subsequent skips.
+    // For example, if during the initialization phase you skip entries x, y and z of the models
+    // list, the skip list will contain x, y-x and z-y in this mode.
+    SkipFirst = 1,
+    // Contains the entries which were not skipped.
+    // This is better when there are many skips.
+    // Mode 2 is more efficient and should be used when 3/4*quorumSize ≥ 1/2*masternodeNb or
+    // quorumsize ≥ 2/3*masternodeNb
+    SkipExcept = 2,
+    // Every node was skipped. The skip list is empty. DKG sessions were not attempted.
+    SkipAll = 3,
+}
+impl std::fmt::Display for LLMQSnapshotSkipMode {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", match self {
+            LLMQSnapshotSkipMode::NoSkipping => "0_NoSkipping",
+            LLMQSnapshotSkipMode::SkipFirst => "1_SkipFirst",
+            LLMQSnapshotSkipMode::SkipExcept => "2_SkipExcept",
+            LLMQSnapshotSkipMode::SkipAll => "3_SkipAll"
+        })
+    }
+}
+impl From<u32> for LLMQSnapshotSkipMode {
+    fn from(orig: u32) -> Self {
+        match orig {
+            0 => LLMQSnapshotSkipMode::NoSkipping,
+            1 => LLMQSnapshotSkipMode::SkipFirst,
+            2 => LLMQSnapshotSkipMode::SkipExcept,
+            3 => LLMQSnapshotSkipMode::SkipAll,
+            _ => LLMQSnapshotSkipMode::NoSkipping,
+        }
+    }
+}
+impl From<LLMQSnapshotSkipMode> for u32 {
+    fn from(orig: LLMQSnapshotSkipMode) -> Self {
+        match orig {
+            LLMQSnapshotSkipMode::NoSkipping => 0,
+            LLMQSnapshotSkipMode::SkipFirst => 1,
+            LLMQSnapshotSkipMode::SkipExcept => 2,
+            LLMQSnapshotSkipMode::SkipAll => 3,
+        }
+    }
+}
+impl LLMQSnapshotSkipMode {
+    pub fn index(&self) -> u32 {
+        u32::from(self.clone())
+    }
+}
+
+
+pub fn from_index(index: u32) -> LLMQSnapshotSkipMode {
+    LLMQSnapshotSkipMode::from(index)
+}
diff --git a/dash/src/sml/llmq_type/rotation.rs b/dash/src/sml/llmq_type/rotation.rs
@@ -0,0 +1,23 @@
+use crate::sml::llmq_type::snapshot::LLMQSnapshot;
+use crate::sml::masternode_list_entry::MasternodeListEntry;
+
+pub enum LLMQQuarterType {
+    AtHeightMinus3Cycles,
+    AtHeightMinus2Cycles,
+    AtHeightMinusCycle,
+    New,
+}
+
+#[derive(Clone, Copy)]
+pub enum LLMQQuarterReconstructionType<'a> {
+    Snapshot,
+    New {
+        previous_quarters: [&'a Vec<Vec<MasternodeListEntry>>; 3],
+        skip_removed_masternodes: bool,
+    }
+}
+
+pub enum LLMQQuarterUsageType {
+    Snapshot(LLMQSnapshot),
+    New(Vec<Vec<MasternodeListEntry>>)
+}
diff --git a/dash/src/sml/llmq_type/snapshot.rs b/dash/src/sml/llmq_type/snapshot.rs
@@ -0,0 +1,62 @@
+use std::fmt::{Display, Formatter};
+use crate::sml::llmq_type::quorum_snapshot_skip_mode::LLMQSnapshotSkipMode;
+
+#[derive(Clone, Debug)]
+pub struct LLMQSnapshot {
+    // The bitset of nodes already in quarters at the start of cycle at height n
+    // (masternodeListSize + 7)/8
+    pub member_list: Vec<u8>,
+    // Skiplist at height n
+    pub skip_list: Vec<i32>,
+    //  Mode of the skip list
+    pub skip_list_mode: LLMQSnapshotSkipMode,
+}
+impl Default for LLMQSnapshot {
+    fn default() -> Self {
+        Self {
+            member_list: vec![],
+            skip_list: vec![],
+            skip_list_mode: LLMQSnapshotSkipMode::NoSkipping,
+        }
+    }
+}
+
+impl Display for LLMQSnapshot {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        let skip_list = self.skip_list.iter().fold(String::new(), |mut acc, i| {
+            acc.push_str(format!("{},", *i).as_str());
+            acc
+        });
+        write!(f, "members: {} {} {}", hex::encode(&self.member_list), self.skip_list_mode, skip_list)
+    }
+}
+
+impl<'a> std::fmt::Debug for LLMQSnapshot {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let member_list = hex::encode(&self.member_list);
+        f.debug_struct("LLMQSnapshot")
+            .field("member_list", &member_list)
+            .field("skip_list", &self.skip_list.iter())
+            .field("skip_list_mode", &self.skip_list_mode)
+            .finish()
+    }
+}
+
+impl LLMQSnapshot {
+    pub fn new(member_list: Vec<u8>, skip_list: Vec<i32>, skip_list_mode: LLMQSnapshotSkipMode) -> Self {
+        LLMQSnapshot {
+            member_list,
+            skip_list,
+            skip_list_mode
+        }
+    }
+
+    pub fn length(&self) -> usize {
+        self.member_list.len() + 1 + 2 + self.skip_list.len() * 2
+    }
+
+    pub fn member_is_true_at_index(&self, i: u32) -> bool {
+        self.member_list.as_slice().bit_is_true_at_le_index(i)
+    }
+}
+
diff --git a/dash/src/sml/masternode_list/mod.rs b/dash/src/sml/masternode_list/mod.rs
@@ -8,6 +8,7 @@ mod peer_addresses;
 pub mod from_diff;
 mod apply_diff;
 mod scores_for_quorum;
+// mod rotation;
 
 use std::collections::BTreeMap;
 use crate::hash_types::{MerkleRootMasternodeList, MerkleRootQuorums};
diff --git a/dash/src/sml/masternode_list/rotation.rs b/dash/src/sml/masternode_list/rotation.rs
@@ -0,0 +1,144 @@
+use std::collections::BTreeMap;
+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 quorum_quarter_members_by_reconstruction_type(
+        &self,
+        reconstruction_type: LLMQQuarterReconstructionType,
+        llmq_params: &LLMQParams,
+        work_block_height: u32,
+    ) -> Result<Vec<Vec<MasternodeListEntry>>, QuorumValidationError> {
+        let work_block_hash = self.provider.lookup_block_hash_by_height(work_block_height);
+        if work_block_hash.is_zero() {
+            warn!("quorum_quarter_members_by_reconstruction_type: empty work block hash for {work_block_height}")
+        }
+        let masternode_list = self.masternode_list_for_block_hash(work_block_hash)
+            .ok_or(QuorumValidationError::RequiredMasternodeListNotPresent(work_block_hash))?;
+        let llmq_type = llmq_params.r#type.clone();
+        let quorum_count = llmq_params.signing_active_quorum_count as usize;
+        let quorum_size = llmq_params.size as usize;
+        let quarter_size = quorum_size / 4;
+        let quorum_modifier_type = self.llmq_modifier_type_for(llmq_type, work_block_hash, work_block_height);
+        let quorum_modifier = quorum_modifier_type.build_llmq_hash();
+        match reconstruction_type {
+            LLMQQuarterReconstructionType::New { previous_quarters, skip_removed_masternodes } => {
+                let (used_at_h_masternodes, unused_at_h_masternodes, used_at_h_indexed_masternodes) =
+                    masternode_list.usage_info(previous_quarters, skip_removed_masternodes, quorum_count);
+                Ok(apply_skip_strategy_of_type(LLMQQuarterUsageType::New(used_at_h_indexed_masternodes), used_at_h_masternodes, unused_at_h_masternodes, work_block_height, quorum_modifier, quorum_count, quarter_size))
+            },
+            LLMQQuarterReconstructionType::Snapshot => {
+                if let Some(snapshot) = self.cache.maybe_snapshot(work_block_hash) {
+                    let (used_at_h_masternodes, unused_at_h_masternodes) =
+                        usage_info_from_snapshot(&masternode_list.masternodes, &snapshot, quorum_modifier, work_block_height);
+                    Ok(apply_skip_strategy_of_type(LLMQQuarterUsageType::Snapshot(snapshot), used_at_h_masternodes, unused_at_h_masternodes, work_block_height, quorum_modifier, quorum_count, quarter_size))
+                } else {
+                    Err(CoreProviderError::NoSnapshot)
+                }
+
+                // self.provider.find_snapshot(work_block_hash, &self.cache)
+                //     .map(|snapshot| {
+                //         let (used_at_h_masternodes, unused_at_h_masternodes) =
+                //             usage_info_from_snapshot(masternode_list, &snapshot, quorum_modifier, work_block_height);
+                //         apply_skip_strategy_of_type(LLMQQuarterUsageType::Snapshot(snapshot), used_at_h_masternodes, unused_at_h_masternodes, work_block_height, quorum_modifier, quorum_count, quarter_size)
+                //     })
+            }
+        }
+    }
+
+
+    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: [u8; 32],
+        block_height: u32,
+        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
+    }
+}
diff --git a/dash/src/sml/quorum_entry/validation.rs b/dash/src/sml/quorum_entry/validation.rs
@@ -10,7 +10,9 @@ impl QualifiedQuorumEntry {
     where
         I: IntoIterator<Item = &'a BLSPublicKey>,
     {
-        let message = self.commitment_hash.as_byte_array().as_slice();
+        let mut message = self.commitment_hash.as_byte_array();
+        message.reverse();
+        let message = message.as_slice();
         let public_keys : Vec<(blsful::PublicKey<Bls12381G2Impl>)> = operator_keys
             .into_iter()
             .map(|key| key.try_into())
