bincode serialization

Author: QuantumExplorer

dash/src/sml/masternode_list_entry/helpers.rs

@@ -0,0 +1,8 @@
+use crate::sml::masternode_list_entry::MasternodeListEntry;
+
+impl MasternodeListEntry {
+    pub fn use_legacy_bls_keys(&self) -> bool {
+        // Only version 1 used legacy bls keys
+        self.version == 1
+    }
+}

dash/src/sml/masternode_list_entry/mod.rs

@@ -1,6 +1,7 @@
 mod hash;
 pub mod qualified_masternode_list_entry;
 mod score;
+mod helpers;
 
 use std::collections::BTreeMap;
 use std::io::{Read, Write};

dash/src/sml/quorum_entry/validation.rs

@@ -1,5 +1,5 @@
 use std::collections::{BTreeMap, BTreeSet};
-use bls_signatures::{BasicSchemeMPL, G1Element, G2Element, Scheme};
+use bls_signatures::{BasicSchemeMPL, BlsError, G1Element, G2Element, Scheme};
 use blsful::{Bls12381G2Impl, MultiPublicKey, MultiSignature};
 use hashes::Hash;
 use crate::bls_sig_utils::BLSPublicKey;
@@ -10,15 +10,28 @@ use crate::sml::quorum_validation_error::QuorumValidationError;
 impl QualifiedQuorumEntry {
     pub fn verify_aggregated_commitment_signature<'a, I>(&self, operator_keys: I) -> Result<(), QuorumValidationError>
     where
-        I: IntoIterator<Item = &'a BLSPublicKey>,
+        I: IntoIterator<Item = &'a MasternodeListEntry>,
     {
         let mut message = self.commitment_hash.to_byte_array();
         // println!("quorum {}", self.quorum_entry.quorum_hash);
          println!("using message {}", hex::encode(message));
         let message = message.as_slice();
         let public_keys2 = operator_keys
             .into_iter()
-            .filter_map(|key| G1Element::from_bytes(key.as_ref()).ok())
+            .filter_map(|masternode_list_entry| {
+                let result = if masternode_list_entry.use_legacy_bls_keys() {
+                    G1Element::from_bytes_legacy(masternode_list_entry.operator_public_key.as_ref())
+                } else {
+                    G1Element::from_bytes(masternode_list_entry.operator_public_key.as_ref())
+                };
+                match result {
+                    Ok(public_key) => Some(public_key),
+                    Err(e) => {
+                        println!("error {} with key for masternode {}", e, masternode_list_entry.pro_reg_tx_hash);
+                        None
+                    }
+                }
+            })
             .collect::<Vec<_>>();
         let sig = G2Element::from_bytes(self.quorum_entry.all_commitment_aggregated_signature.as_bytes()).expect("expected sig");
         let verified = BasicSchemeMPL::new().verify_secure(public_keys2.iter(), message, &sig);
@@ -52,11 +65,7 @@ impl QualifiedQuorumEntry {
     where
         I: IntoIterator<Item = &'a MasternodeListEntry>,
     {
-        let operator_keys = valid_masternodes
-            .into_iter()
-            .map(|node| &node.operator_public_key);
-
-        self.verify_aggregated_commitment_signature(operator_keys)?;
+        self.verify_aggregated_commitment_signature(valid_masternodes)?;
         self.verify_quorum_signature()?;
 
         Ok(())