bincode serialization

Author: QuantumExplorer

dash/src/hash_types.rs

@@ -147,29 +147,30 @@ use hashes::{sha256, sha256d, hash160, hash_newtype, Hash, hash_newtype_no_ord};
         pub struct QuorumCommitmentHash(sha256d::Hash);
 
         pub struct Sha256dHash(sha256d::Hash);
-    }
-
-        hash_newtype_no_ord! {
         pub struct ScoreHash(sha256d::Hash);
-        }
-
-impl Ord for ScoreHash {
-    fn cmp(&self, other: &Self) -> Ordering {
-        let mut self_bytes = self.0.to_byte_array();
-        let mut other_bytes = other.0.to_byte_array();
-
-        self_bytes.reverse();
-        other_bytes.reverse();
-
-        self_bytes.cmp(&other_bytes)
     }
-}
 
-impl PartialOrd for ScoreHash {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
+        // hash_newtype_no_ord! {
+        //
+        // }
+
+// impl Ord for ScoreHash {
+//     fn cmp(&self, other: &Self) -> Ordering {
+//         let mut self_bytes = self.0.to_byte_array();
+//         let mut other_bytes = other.0.to_byte_array();
+//
+//         self_bytes.reverse();
+//         other_bytes.reverse();
+//
+//         self_bytes.cmp(&other_bytes)
+//     }
+// }
+//
+// impl PartialOrd for ScoreHash {
+//     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+//         Some(self.cmp(other))
+//     }
+// }
 
 
     /// A hash used to identify a quorum
@@ -229,13 +230,6 @@ impl PartialOrd for ScoreHash {
         pub fn to_hex(&self) -> String {
             self.0.to_string()
         }
-
-        /// Returns a new `ProTxHash` with the bytes reversed.
-        pub fn reverse(&self) -> Self {
-            let mut reversed_bytes = self.0.to_byte_array();
-            reversed_bytes.reverse();
-            Self::from_byte_array(reversed_bytes)
-        }
     }
 
         impl ScoreHash {
@@ -249,19 +243,12 @@ impl PartialOrd for ScoreHash {
             self.0.to_string()
         }
 
-        /// Returns a new `ProTxHash` with the bytes reversed.
-        pub fn reverse(&self) -> Self {
-            let mut reversed_bytes = self.0.to_byte_array();
-            reversed_bytes.reverse();
-            Self::from_byte_array(reversed_bytes)
-        }
-
         pub fn create_score(confirmed_hash_hashed_with_pro_reg_tx: Option<ConfirmedHashHashedWithProRegTx>, modifier: QuorumModifierHash) -> Self {
             let mut bytes = vec![];
             if let Some(confirmed_hash_hashed_with_pro_reg_tx) = confirmed_hash_hashed_with_pro_reg_tx{
                 bytes.append(&mut confirmed_hash_hashed_with_pro_reg_tx.to_byte_array().to_vec());
-                bytes.append(&mut modifier.to_byte_array().to_vec());
             }
+            bytes.append(&mut modifier.to_byte_array().to_vec());
             Self::hash(bytes.as_slice())
         }
     }

dash/src/sml/masternode_list/scores_for_quorum.rs

@@ -5,6 +5,7 @@ use crate::Network;
 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::order_option::LLMQOrderOption;
 use crate::sml::quorum_entry::qualified_quorum_entry::QualifiedQuorumEntry;
 use crate::sml::quorum_entry::quorum_modifier_type::LLMQModifierType;
 
@@ -14,22 +15,46 @@ impl MasternodeList {
         quorum: &QualifiedQuorumEntry,
         quorum_modifier: LLMQModifierType,
         network: Network,
+        order_option: &LLMQOrderOption,
     ) -> T
     where T: FromIterator<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);
-        if quorum.quorum_entry.quorum_hash.to_string() == "00000000000000048529d958e7cfa32f51f0ac0584f7037ac34d8448f8a2a684".to_string() {
-            println!("00000000000000048529d958e7cfa32f51f0ac0584f7037ac34d8448f8a2a684 info");
-            println!("quorum modifier {}", quorum_modifier);
-            for (score, list_entry) in score_dictionary.iter() {
-                println!("score_hash {} -> {}", score, list_entry.masternode_list_entry.pro_reg_tx_hash);
+        // if quorum.quorum_entry.quorum_hash.to_string() == "0000000000000010d1f1ab756f1f3223485fdc7bce1cbb0e7437383bf7600b06".to_string() {
+
+        // } else {
+        //     println!("trying {}", quorum.quorum_entry.quorum_hash)
+        // }
+            println!("quorum modifier {}", quorum_modifier.reverse());
+        if order_option.reverse_sort_scores {
+            let mut score_dictionary: Vec<_> = score_dictionary.into_iter().collect();
+            score_dictionary.sort_by(|(s1, _), (s2, _)| {
+
+                if order_option.reverse_sort_order {
+                    s2.reverse().cmp(&s1.reverse())
+                } else {
+                    s1.reverse().cmp(&s2.reverse())
+                }
+            });
+            for (score, list_entry) in score_dictionary.iter().take(5) {
+                println!("score_hash {} {} -> {}", if order_option.reverse_sort_order { 1 } else { 2}, score, list_entry.masternode_list_entry.pro_reg_tx_hash);
             }
+            score_dictionary.into_iter().take(llmq_type.size() as usize).map(|(a, b)| b).collect()
         } else {
-            println!("trying {}", quorum.quorum_entry.quorum_hash)
+            if order_option.reverse_sort_order {
+                for (score, list_entry) in score_dictionary.iter().rev().take(5) {
+                    println!("3 score_hash {} -> {}", score, list_entry.masternode_list_entry.pro_reg_tx_hash);
+                }
+                score_dictionary.into_values().rev().take(llmq_type.size() as usize).collect()
+            } else {
+                for (score, list_entry) in score_dictionary.iter().take(5) {
+                    println!("4 score_hash {} -> {}", score, list_entry.masternode_list_entry.pro_reg_tx_hash);
+                }
+                score_dictionary.into_values().take(llmq_type.size() as usize).collect()
+            }
         }
-        score_dictionary.into_values().take(llmq_type.size() as usize).collect()
     }
 
     pub fn scores_for_quorum(

dash/src/sml/masternode_list_engine/mod.rs

@@ -15,6 +15,7 @@ use crate::sml::error::SmlError::CorruptedCodeExecution;
 use crate::sml::llmq_type::LLMQType;
 use crate::sml::masternode_list::from_diff::TryIntoWithBlockHashLookup;
 use crate::sml::masternode_list::MasternodeList;
+use crate::sml::order_option::LLMQOrderOption;
 use crate::sml::quorum_validation_error::QuorumValidationError;
 
 #[derive(Clone, Eq, PartialEq)]
@@ -144,7 +145,7 @@ impl MasternodeListEngine {
             let mut inner = BTreeMap::new();
 
             for (quorum_hash, quorum_entry) in hash_to_quorum_entries.iter() {
-                inner.insert(*quorum_hash, self.validate_quorum(quorum_entry));
+                inner.insert(*quorum_hash, self.validate_quorum(quorum_entry, &LLMQOrderOption::default()));
             }
             results.insert(*quorum_type, inner);
         }
@@ -160,4 +161,58 @@ impl MasternodeListEngine {
         }
         Ok(())
     }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::QuorumHash;
+    use crate::sml::llmq_entry_verification::LLMQEntryVerificationStatus;
+    use crate::sml::llmq_type::LLMQType::{Llmqtype100_67, Llmqtype400_60, Llmqtype400_85, Llmqtype50_60};
+    use crate::sml::masternode_list_engine::MasternodeListEngine;
+    use std::str::FromStr;
+    use crate::sml::order_option::LLMQOrderOption;
+
+    #[test]
+    fn deserialize_mn_list_engine_and_validate_quorums() {
+        let block_hex = include_str!("../../../tests/data/test_DML_diffs/masternode_list_engine.hex");
+        let data = hex::decode(block_hex).expect("decode hex");
+        let mut mn_list_engine: MasternodeListEngine = bincode::decode_from_slice(&data, bincode::config::standard()).expect("expected to decode").0;
+
+        assert_eq!(mn_list_engine.masternode_lists.len(), 27);
+
+        let last_masternode_list_height = *mn_list_engine.masternode_lists.last_key_value().unwrap().0;
+
+        mn_list_engine.verify_masternode_list_quorums(last_masternode_list_height, &[Llmqtype50_60, Llmqtype400_85]).expect("expected to verify quorums");
+
+        let last_masternode_list = mn_list_engine.masternode_lists.last_key_value().unwrap().1;
+
+        for (quorum_type, quorum_entries) in last_masternode_list.quorums.iter() {
+            if *quorum_type == Llmqtype400_85 || *quorum_type == Llmqtype50_60 || *quorum_type == Llmqtype400_60 {
+                continue;
+            }
+            for (quorum_hash, quorum) in quorum_entries.iter() {
+                let (_, known_block_height) = mn_list_engine.masternode_list_and_height_for_block_hash_8_blocks_ago(&quorum.quorum_entry.quorum_hash).expect("expected to find validating masternode");
+                assert_eq!(quorum.verified, LLMQEntryVerificationStatus::Verified, "could not verify quorum {} of type {} with masternode list {}", quorum_hash, quorum.quorum_entry.llmq_type, known_block_height);
+            }
+        }
+    }
+
+    #[test]
+    fn deserialize_mn_list_engine_and_validate_single_quorum() {
+        let block_hex = include_str!("../../../tests/data/test_DML_diffs/masternode_list_engine2.hex");
+        let data = hex::decode(block_hex).expect("decode hex");
+        let mn_list_engine: MasternodeListEngine = bincode::decode_from_slice(&data, bincode::config::standard()).expect("expected to decode").0;
+
+        assert_eq!(mn_list_engine.masternode_lists.len(), 27);
+
+        let last_masternode_list_height = *mn_list_engine.masternode_lists.last_key_value().unwrap().0;
+
+        let last_masternode_list = mn_list_engine.masternode_lists.last_key_value().unwrap().1;
+
+        let quorum = last_masternode_list.quorum_entry_of_type_for_quorum_hash(Llmqtype100_67, QuorumHash::from_str("000000000000001d4ebc43dbf9b25d2af6421641a84a1e04dd58f65d07b7ecf7").expect("expected to get quorum hash")).expect("expected to find quorum");
+
+        for option in LLMQOrderOption::all_combinations() {
+            println!("using {:?} {:?}", option, mn_list_engine.validate_quorum(quorum, &option))
+        }
+    }
 }

dash/src/sml/masternode_list_engine/validation.rs

@@ -6,6 +6,7 @@ use crate::sml::llmq_entry_verification::{LLMQEntryVerificationSkipStatus, LLMQE
 use crate::sml::masternode_list_engine::MasternodeListEngine;
 use crate::sml::masternode_list_entry::MasternodeListEntry;
 use crate::sml::masternode_list_entry::qualified_masternode_list_entry::QualifiedMasternodeListEntry;
+use crate::sml::order_option::LLMQOrderOption;
 use crate::sml::quorum_entry::qualified_quorum_entry::QualifiedQuorumEntry;
 use crate::sml::quorum_entry::quorum_modifier_type::LLMQModifierType;
 use crate::sml::quorum_validation_error::QuorumValidationError;
@@ -52,17 +53,18 @@ impl MasternodeListEngine {
     //     }
     // }
     pub fn validate_and_update_quorum_status(&self, quorum: &mut QualifiedQuorumEntry) {
-        quorum.update_quorum_status(self.validate_quorum(quorum));
+        quorum.update_quorum_status(self.validate_quorum(quorum, &LLMQOrderOption::default()));
     }
 
-    pub fn validate_quorum(&self, quorum: &QualifiedQuorumEntry) -> Result<(), QuorumValidationError> {
+    pub fn validate_quorum(&self, quorum: &QualifiedQuorumEntry, order_option: &LLMQOrderOption) -> Result<(), QuorumValidationError> {
         // first let's do basic structure validation
         quorum.quorum_entry.validate_structure()?;
 
         let llmq_block_hash = quorum.quorum_entry.quorum_hash;
         let (masternode_list, known_block_height) = self.masternode_list_and_height_for_block_hash_8_blocks_ago(&llmq_block_hash)?;
         let quorum_modifier_type = LLMQModifierType::new_quorum_modifier_type(quorum.quorum_entry.llmq_type, masternode_list.block_hash, known_block_height, &self.known_chain_locks, self.network)?;
-        let masternodes : Vec<_> = masternode_list.valid_masternodes_for_quorum(quorum, quorum_modifier_type, self.network);
+        // println!("quorum modifier is {} giving {}", quorum_modifier_type, quorum_modifier_type.build_llmq_hash(order_option));
+        let masternodes : Vec<_> = masternode_list.valid_masternodes_for_quorum(quorum, quorum_modifier_type, self.network, order_option);
         quorum.validate(masternodes.iter().map(|qualified_masternode_list_entry| &qualified_masternode_list_entry.masternode_list_entry))
     }
 }

dash/src/sml/masternode_list_entry/score.rs

@@ -4,9 +4,16 @@ use crate::sml::masternode_list_entry::qualified_masternode_list_entry::Qualifie
 impl QualifiedMasternodeListEntry {
     pub fn score(&self, modifier: QuorumModifierHash) -> Option<ScoreHash> {
         if !self.masternode_list_entry.is_valid ||
-            self.masternode_list_entry.confirmed_hash.is_none() {
+            self.confirmed_hash_hashed_with_pro_reg_tx.is_none() {
             return None;
         }
-        Some(ScoreHash::create_score(self.confirmed_hash_hashed_with_pro_reg_tx, modifier))
+        println!("creating score for {}({})\nconfirmed_hash_hashed_with_pro_reg_tx: {}({})\nmodifier {}({})", self.masternode_list_entry.pro_reg_tx_hash, self.masternode_list_entry.pro_reg_tx_hash.reverse(), if let Some(confirmed_hash_hashed_with_pro_reg_tx) = self.confirmed_hash_hashed_with_pro_reg_tx { confirmed_hash_hashed_with_pro_reg_tx.to_string() } else {
+            "None".to_string()
+        },  if let Some(confirmed_hash_hashed_with_pro_reg_tx) = self.confirmed_hash_hashed_with_pro_reg_tx { confirmed_hash_hashed_with_pro_reg_tx.reverse().to_string() } else {
+            "None".to_string()
+        }, modifier, modifier.reverse());
+        let score = ScoreHash::create_score(self.confirmed_hash_hashed_with_pro_reg_tx, modifier);
+        println!("score is {}",score);
+        Some(score)
     }
 }

dash/src/sml/mod.rs

@@ -7,3 +7,4 @@ pub mod llmq_entry_verification;
 pub mod error;
 pub mod quorum_validation_error;
 pub mod quorum_entry;
+mod order_option;

dash/src/sml/order_option.rs

@@ -0,0 +1,22 @@
+#[derive(Debug, PartialEq, Eq, Clone, Default)]
+pub struct LLMQOrderOption {
+    pub reverse_sort_scores: bool,
+    pub reverse_sort_order: bool,
+}
+
+impl LLMQOrderOption {
+    pub fn all_combinations() -> Vec<LLMQOrderOption> {
+        let mut combinations = Vec::with_capacity(8);
+
+        for reverse_sort_scores in [false, true] {
+            for reverse_sort_order in [false, true] {
+                combinations.push(LLMQOrderOption {
+                    reverse_sort_scores,
+                    reverse_sort_order,
+                });
+            }
+        }
+
+        combinations
+    }
+}

dash/src/sml/quorum_entry/quorum_modifier_type.rs

@@ -1,4 +1,5 @@
 use std::collections::BTreeMap;
+use std::fmt;
 use std::io::Write;
 use hashes::Hash;
 use crate::consensus::Encodable;
@@ -8,13 +9,27 @@ use crate::{BlockHash, Network};
 use crate::bls_sig_utils::BLSSignature;
 use crate::prelude::CoreBlockHeight;
 use crate::sml::llmq_type::LLMQType;
+use crate::sml::order_option::LLMQOrderOption;
 use crate::sml::quorum_validation_error::QuorumValidationError;
 
 pub enum LLMQModifierType {
     PreCoreV20(LLMQType, BlockHash),
     CoreV20(LLMQType, CoreBlockHeight, BLSSignature),
 }
 
+impl fmt::Display for LLMQModifierType {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            LLMQModifierType::PreCoreV20(llmq_type, block_hash) => {
+                write!(f, "PreCoreV20: Type: {}, BlockHash: {}", llmq_type, block_hash)
+            }
+            LLMQModifierType::CoreV20(llmq_type, height, signature) => {
+                write!(f, "CoreV20: Type: {}, Height: {}, Signature: {}", llmq_type, height, signature)
+            }
+        }
+    }
+}
+
 impl LLMQModifierType {
     pub fn build_llmq_hash(&self) -> QuorumModifierHash {
         let mut writer = vec![];
@@ -35,7 +50,6 @@ impl LLMQModifierType {
                 writer.write_all(cl_signature.as_bytes()).unwrap();
             }
         }
-
         QuorumModifierHash::hash(&writer)
     }
 

dash/src/sml/quorum_entry/validation.rs

@@ -12,13 +12,13 @@ impl QualifiedQuorumEntry {
     {
         let mut message = self.commitment_hash.to_byte_array();
         message.reverse();
-        println!("quorum {}", self.quorum_entry.quorum_hash);
-        println!("using message {}", hex::encode(message));
+        // println!("quorum {}", self.quorum_entry.quorum_hash);
+        // println!("using message {}", hex::encode(message));
         let message = message.as_slice();
         let public_keys : Vec<(blsful::PublicKey<Bls12381G2Impl>)> = operator_keys
             .into_iter().enumerate()
             .map(|(i, key)| {
-                println!("using operator key {}. {}", i, key);
+                // println!("using operator key {}. {}", i, key);
                 key.try_into()
             })
             .collect::<Result<Vec<(blsful::PublicKey<Bls12381G2Impl>)>, QuorumValidationError>>()?;