fixed message deserialization

Author: QuantumExplorer

dash/src/network/message_sml.rs

@@ -1,10 +1,10 @@
-use hashes::sha256::Hash;
-use crate::{BlockHash, ProTxHash, Transaction};
 use crate::bls_sig_utils::BLSSignature;
 use crate::hash_types::MerkleRootMasternodeList;
 use crate::internal_macros::impl_consensus_encoding;
 use crate::sml::entry::MasternodeListEntry;
-use crate::transaction::special_transaction::quorum_commitment::{QuorumFinalizationCommitment};
+use crate::transaction::special_transaction::quorum_commitment::QuorumFinalizationCommitment;
+use crate::{BlockHash, ProTxHash, Transaction};
+use hashes::sha256::Hash;
 
 /// The getmnlistd message requests a mnlistdiff message that provides either:
 /// - A full masternode list (if baseBlockHash is all-zero)
@@ -39,7 +39,21 @@ pub struct MnListDiff {
     pub quorums_chainlock_signatures: Vec<BLSSignature>,
 }
 
-impl_consensus_encoding!(MnListDiff, version, base_block_hash, block_hash, total_transactions, merkle_hashes, merkle_flags, coinbase_tx, deleted_masternodes, new_masternodes, deleted_quorums, new_quorums, quorums_chainlock_signatures);
+impl_consensus_encoding!(
+    MnListDiff,
+    version,
+    base_block_hash,
+    block_hash,
+    total_transactions,
+    merkle_hashes,
+    merkle_flags,
+    coinbase_tx,
+    deleted_masternodes,
+    new_masternodes,
+    deleted_quorums,
+    new_quorums,
+    quorums_chainlock_signatures
+);
 
 #[derive(PartialEq, Eq, Clone, Debug)]
 pub struct DeletedQuorum {
@@ -52,3 +66,26 @@ impl_consensus_encoding!(DeletedQuorum, llmq_type, quorum_hash);
 
 // TODO: Add encoding tests with test vectors from Dash Core
 // TODO: Add documentation
+
+#[cfg(test)]
+mod tests {
+
+    use std::fs::File;
+    use std::io::{self, Read};
+    use crate::consensus::deserialize;
+    use crate::network::message::RawNetworkMessage;
+
+    fn read_binary_file(filename: &str) -> io::Result<Vec<u8>> {
+        let mut file = File::open(filename)?;
+        let mut buffer = Vec::new();
+        file.read_to_end(&mut buffer)?;
+        Ok(buffer)
+    }
+
+    #[test]
+    fn deserialize_mn_list_diff() {
+        let block_hex = include_str!("../../tests/data/test_DML_diffs/DML_0_2221605.hex");
+        let data = hex::decode(block_hex).expect("expected to decode hex");
+        let mn_list_diff: RawNetworkMessage = deserialize(&data).expect("Failed to deserialize MnListDiff");
+    }
+}

dash/src/sml/entry.rs

@@ -4,6 +4,7 @@ use std::io::{Read, Write};
 use blsful::{Bls12381G2Impl, PublicKey};
 use crate::internal_macros::impl_consensus_encoding;
 use crate::{ProTxHash, PubkeyHash};
+use crate::bls_sig_utils::BLSPublicKey;
 use crate::consensus::{Decodable, Encodable};
 use crate::consensus::encode::Error;
 use crate::hash_types::{ConfirmedHash, Sha256dHash};
@@ -41,7 +42,7 @@ impl Encodable for MasternodeType {
 impl Decodable for MasternodeType {
     fn consensus_decode<R: Read + ?Sized>(reader: &mut R) -> Result<Self, Error> {
         // First decode the variant tag.
-        let variant: u8 = Decodable::consensus_decode(reader)?;
+        let variant: u16 = Decodable::consensus_decode(reader)?;
         match variant {
             0 => Ok(MasternodeType::Regular),
             1 => {
@@ -71,16 +72,58 @@ impl_consensus_encoding!(OperatorPublicKey, data, version);
 
 #[derive(Clone, Eq, PartialEq, Debug)]
 pub struct MasternodeListEntry {
+    pub version: u16,
     pub pro_reg_tx_hash: ProTxHash,
     pub confirmed_hash: ConfirmedHash,
     pub service_address: ServiceAddress,
-    pub operator_public_key: OperatorPublicKey,
+    pub operator_public_key: BLSPublicKey,
     pub key_id_voting: PubkeyHash,
     pub is_valid: bool,
     pub mn_type: MasternodeType,
 }
 
-impl_consensus_encoding!(MasternodeListEntry, pro_reg_tx_hash, confirmed_hash, service_address, operator_public_key, key_id_voting, is_valid, mn_type);
+impl Encodable for MasternodeListEntry {
+    fn consensus_encode<W: Write + ?Sized>(&self, writer: &mut W) -> Result<usize, std::io::Error> {
+        let mut len = 0;
+        len += self.version.consensus_encode(writer)?;
+        len += self.pro_reg_tx_hash.consensus_encode(writer)?;
+        len += self.confirmed_hash.consensus_encode(writer)?;
+        len += self.service_address.consensus_encode(writer)?;
+        len += self.operator_public_key.consensus_encode(writer)?;
+        len += self.key_id_voting.consensus_encode(writer)?;
+        len += self.is_valid.consensus_encode(writer)?;
+        len += self.mn_type.consensus_encode(writer)?;
+        Ok(len)
+    }
+}
+
+impl Decodable for MasternodeListEntry {
+    fn consensus_decode<R: Read + ?Sized>(reader: &mut R) -> Result<Self, Error> {
+        let version: u16 = Decodable::consensus_decode(reader)?;
+        let pro_reg_tx_hash: ProTxHash = Decodable::consensus_decode(reader)?;
+        let confirmed_hash: ConfirmedHash = Decodable::consensus_decode(reader)?;
+        let service_address: ServiceAddress = Decodable::consensus_decode(reader)?;
+        let operator_public_key: BLSPublicKey = Decodable::consensus_decode(reader)?;
+        let key_id_voting: PubkeyHash = Decodable::consensus_decode(reader)?;
+        let is_valid: bool = Decodable::consensus_decode(reader)?;
+        let mn_type: MasternodeType = if version >= 2 {
+            Decodable::consensus_decode(reader)?
+        } else {
+            MasternodeType::Regular
+        };
+
+        Ok(MasternodeListEntry {
+            version,
+            pro_reg_tx_hash,
+            confirmed_hash,
+            service_address,
+            operator_public_key,
+            key_id_voting,
+            is_valid,
+            mn_type,
+        })
+    }
+}
 #[cfg(feature = "bls")]
 #[derive(Clone, Eq, PartialEq)]
 pub struct MasternodeListEntryInfo {