feat(sml): masternodes_by_voting_key lookup on MasternodeList

Adds a by-voting-key lookup (returns matching pro_reg_tx_hashes) so SDK
consumers can resolve which masternodes an imported voting key controls
without the legacy dashj masternode list — needed for contested-username
voting after the dashj engine is held post-cutover. Data was already
present on every entry (key_id_voting, pro_reg_tx_hash); this is the
missing index/helper plus a unit test covering multi-match, single-match
and no-match.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

Author: bfoss765

dash/src/sml/masternode_list/masternode_helpers.rs

@@ -1,9 +1,26 @@
 use std::net::IpAddr;
 
-use crate::ProTxHash;
 use crate::sml::masternode_list::MasternodeList;
+use crate::{ProTxHash, PubkeyHash};
 
 impl MasternodeList {
+    /// Every masternode in the list whose voting key hash matches
+    /// `voting_key_id`, returned as their registration proTxHashes.
+    ///
+    /// Mirrors dashj's `MasternodeList.getMasternodesByVotingKey(votingKeyId)`
+    /// — the lookup contested-username voting uses to resolve which
+    /// masternode(s) a given voting key is entitled to cast a vote for.
+    /// `key_id_voting` is the 20-byte hash160 of the voting public key; a
+    /// single voting key can back more than one masternode, so the result is
+    /// a `Vec` (empty when no entry matches).
+    pub fn masternodes_by_voting_key(&self, voting_key_id: &PubkeyHash) -> Vec<ProTxHash> {
+        self.masternodes
+            .values()
+            .filter(|node| node.masternode_list_entry.key_id_voting == *voting_key_id)
+            .map(|node| node.masternode_list_entry.pro_reg_tx_hash)
+            .collect()
+    }
+
     pub fn has_valid_masternode(&self, pro_reg_tx_hash: &ProTxHash) -> bool {
         self.masternodes
             .get(pro_reg_tx_hash)
@@ -46,3 +63,69 @@ pub fn reverse_cmp_sup(lhs: [u8; 32], rhs: [u8; 32]) -> bool {
     // equal
     false
 }
+
+#[cfg(test)]
+mod tests {
+    use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};
+
+    use hashes::Hash;
+
+    use crate::bls_sig_utils::BLSPublicKey;
+    use crate::sml::masternode_list::MasternodeList;
+    use crate::sml::masternode_list_entry::{
+        EntryMasternodeType, MasternodeListEntry, MasternodeNetInfo,
+    };
+    use crate::{BlockHash, ProTxHash, PubkeyHash};
+
+    /// Build a `MasternodeList` from `(proTxHash-seed, voting-key-id)` pairs so
+    /// each entry gets a distinct proTxHash and a caller-chosen voting key.
+    fn list_from(entries: Vec<(u8, [u8; 20])>) -> MasternodeList {
+        let masternodes = entries
+            .into_iter()
+            .map(|(seed, voting_key_id)| {
+                let mut hash_bytes = [0u8; 32];
+                hash_bytes[0] = seed;
+                let pro_tx_hash = ProTxHash::from_byte_array(hash_bytes);
+                let entry = MasternodeListEntry {
+                    version: 1,
+                    pro_reg_tx_hash: pro_tx_hash,
+                    confirmed_hash: None,
+                    service_address: MasternodeNetInfo::Legacy(SocketAddr::V4(SocketAddrV4::new(
+                        Ipv4Addr::new(10, 0, 0, seed),
+                        9999,
+                    ))),
+                    operator_public_key: BLSPublicKey::from([0u8; 48]),
+                    key_id_voting: PubkeyHash::from_byte_array(voting_key_id),
+                    is_valid: true,
+                    mn_type: EntryMasternodeType::Regular,
+                };
+                (pro_tx_hash, entry.into())
+            })
+            .collect();
+        MasternodeList::build(masternodes, Default::default(), BlockHash::from_byte_array([0u8; 32]), 0)
+            .build()
+    }
+
+    #[test]
+    fn masternodes_by_voting_key_filters_and_collects() {
+        let key_a = [0xAAu8; 20];
+        let key_b = [0xBBu8; 20];
+        // Two masternodes share voting key A, one uses key B.
+        let list = list_from(vec![(1, key_a), (2, key_b), (3, key_a)]);
+
+        let mut matched = list.masternodes_by_voting_key(&PubkeyHash::from_byte_array(key_a));
+        // Order is BTreeMap (proTxHash) order; sort the seed byte for a stable assert.
+        matched.sort_by_key(|h| h.to_byte_array()[0]);
+        assert_eq!(matched.len(), 2);
+        assert_eq!(matched[0].to_byte_array()[0], 1);
+        assert_eq!(matched[1].to_byte_array()[0], 3);
+
+        let single = list.masternodes_by_voting_key(&PubkeyHash::from_byte_array(key_b));
+        assert_eq!(single.len(), 1);
+        assert_eq!(single[0].to_byte_array()[0], 2);
+
+        // A voting key no masternode uses yields an empty vec.
+        let none = list.masternodes_by_voting_key(&PubkeyHash::from_byte_array([0xCCu8; 20]));
+        assert!(none.is_empty());
+    }
+}