feat: decode SML ProTx v3 entries

dash/src/network/message_qrinfo.rs

@@ -302,9 +302,12 @@ impl Decodable for MNSkipListMode {
 
 #[cfg(test)]
 mod tests {
-    use super::{MNSkipListMode, QuorumSnapshot};
+    use hashes::{Hash, sha256};
+
+    use super::{MNSkipListMode, QRInfo, QuorumSnapshot};
     use crate::consensus::{deserialize, serialize};
     use crate::network::message::{NetworkMessage, RawNetworkMessage};
+    use crate::sml::masternode_list_entry::{EntryMasternodeType, MasternodeNetInfo};
 
     #[test]
     fn quorum_snapshot_encode_decode_roundtrip() {
@@ -337,4 +340,65 @@ mod tests {
         };
         assert_eq!(magic, 3177909439);
     }
+
+    fn load_v3_qrinfo_bytes() -> Vec<u8> {
+        let hex = include_str!("../../tests/data/test_DML_diffs/qrinfo_core231_paloma.hex");
+        let data = hex::decode(hex.trim()).expect("decode hex");
+        assert_eq!(data.len(), 20064);
+        assert_eq!(
+            sha256::Hash::hash(&data).to_string(),
+            "2811689d4bca44b17a881fc799a563d9ac78c3b7a4b8395a67bb0d857eb61eec"
+        );
+        data
+    }
+
+    #[test]
+    fn deserialize_v3_qrinfo_extnetinfo() {
+        let data = load_v3_qrinfo_bytes();
+        let _qr_info: QRInfo = deserialize(&data).expect("deserialize v3 QRInfo");
+    }
+
+    #[test]
+    fn v3_qrinfo_wire_roundtrip() {
+        let data = load_v3_qrinfo_bytes();
+        let qr_info: QRInfo = deserialize(&data).expect("deserialize v3 QRInfo");
+        let reencoded = serialize(&qr_info);
+        assert_eq!(reencoded, data, "v3 QRInfo did not round-trip byte-exact");
+    }
+
+    #[test]
+    fn v3_evo_entry_sources_platform_port_from_extnetinfo() {
+        let data = load_v3_qrinfo_bytes();
+        let qr_info: QRInfo = deserialize(&data).expect("deserialize v3 QRInfo");
+
+        let mut saw_v3_evo = false;
+        let extra = qr_info.quorum_snapshot_and_mn_list_diff_at_h_minus_4c.as_ref().map(|(_, d)| d);
+        let mut all_diffs = vec![
+            &qr_info.mn_list_diff_tip,
+            &qr_info.mn_list_diff_h,
+            &qr_info.mn_list_diff_at_h_minus_c,
+            &qr_info.mn_list_diff_at_h_minus_2c,
+            &qr_info.mn_list_diff_at_h_minus_3c,
+        ];
+        all_diffs.extend(extra);
+        for diff in all_diffs {
+            for entry in &diff.new_masternodes {
+                if entry.version < 3 {
+                    continue;
+                }
+                let MasternodeNetInfo::Extended(info) = &entry.service_address else {
+                    panic!("v3 entry must carry an extended service address");
+                };
+                if let EntryMasternodeType::HighPerformance {
+                    platform_http_port,
+                    ..
+                } = &entry.mn_type
+                {
+                    saw_v3_evo = true;
+                    assert_eq!(Some(*platform_http_port), info.platform_https_port());
+                }
+            }
+        }
+        assert!(saw_v3_evo, "fixture should contain at least one v3 Evo entry");
+    }
 }

dash/src/sml/masternode_list/masternode_helpers.rs

@@ -12,16 +12,19 @@ impl MasternodeList {
 
     pub fn has_masternode_at_location(&self, address: [u8; 16], port: u16) -> bool {
         self.masternodes.values().any(|node| {
-            match node.masternode_list_entry.service_address.ip() {
+            let Some(service_address) =
+                node.masternode_list_entry.service_address.primary_service_address()
+            else {
+                return false;
+            };
+            match service_address.ip() {
                 IpAddr::V4(ipv4) => {
                     let ipv4_bytes = ipv4.octets();
-                    address[..4] == ipv4_bytes
-                        && node.masternode_list_entry.service_address.port() == port
+                    address[..4] == ipv4_bytes && service_address.port() == port
                 }
                 IpAddr::V6(ipv6) => {
                     let ipv6_bytes = ipv6.octets();
-                    address == ipv6_bytes
-                        && node.masternode_list_entry.service_address.port() == port
+                    address == ipv6_bytes && service_address.port() == port
                 }
             }
         })

dash/src/sml/masternode_list/peer_addresses.rs

@@ -53,10 +53,10 @@ impl MasternodeList {
             .take(max_count.min(self.masternodes.len()))
             .filter_map(|hash| {
                 self.masternodes.get(&hash).and_then(|entry| {
-                    entry
-                        .masternode_list_entry
-                        .is_valid
-                        .then_some(entry.masternode_list_entry.service_address)
+                    if !entry.masternode_list_entry.is_valid {
+                        return None;
+                    }
+                    entry.masternode_list_entry.service_address.primary_service_address()
                 })
             })
             .collect()