Merge pull request #66 from dashpay/small-fix

Fix: Allow Block hash of 0s to represent genesis.

Author: pankcuf

dash/src/bip32.rs

@@ -36,7 +36,13 @@ use serde;
 
 use crate::base58;
 use crate::crypto::key::{self, Keypair, PrivateKey, PublicKey};
-use crate::dip9::{COINJOIN_PATH_MAINNET, COINJOIN_PATH_TESTNET, DASH_BIP44_PATH_MAINNET, DASH_BIP44_PATH_TESTNET, IDENTITY_AUTHENTICATION_PATH_MAINNET, IDENTITY_AUTHENTICATION_PATH_TESTNET, IDENTITY_INVITATION_PATH_MAINNET, IDENTITY_INVITATION_PATH_TESTNET, IDENTITY_REGISTRATION_PATH_MAINNET, IDENTITY_REGISTRATION_PATH_TESTNET, IDENTITY_TOPUP_PATH_MAINNET, IDENTITY_TOPUP_PATH_TESTNET};
+use crate::dip9::{
+    COINJOIN_PATH_MAINNET, COINJOIN_PATH_TESTNET, DASH_BIP44_PATH_MAINNET, DASH_BIP44_PATH_TESTNET,
+    IDENTITY_AUTHENTICATION_PATH_MAINNET, IDENTITY_AUTHENTICATION_PATH_TESTNET,
+    IDENTITY_INVITATION_PATH_MAINNET, IDENTITY_INVITATION_PATH_TESTNET,
+    IDENTITY_REGISTRATION_PATH_MAINNET, IDENTITY_REGISTRATION_PATH_TESTNET,
+    IDENTITY_TOPUP_PATH_MAINNET, IDENTITY_TOPUP_PATH_TESTNET,
+};
 use crate::hash_types::XpubIdentifier;
 use crate::internal_macros::impl_bytes_newtype;
 use crate::io::Write;
@@ -489,16 +495,15 @@ impl DerivationPath {
         ]);
         root_derivation_path
     }
-    pub fn coinjoin_path(
-        network: Network,
-        account: u32,
-    ) -> Self {
+    pub fn coinjoin_path(network: Network, account: u32) -> Self {
         let mut root_derivation_path: DerivationPath = match network {
             Network::Dash => COINJOIN_PATH_MAINNET,
             _ => COINJOIN_PATH_TESTNET,
         }
         .into();
-        root_derivation_path.0.extend(&[ChildNumber::Hardened { index: account }]);
+        root_derivation_path.0.extend(&[ChildNumber::Hardened {
+            index: account,
+        }]);
         root_derivation_path
     }
 

dash/src/dip9.rs

@@ -155,18 +155,30 @@ pub const DASH_BIP44_PATH_TESTNET: IndexConstPath<2> = IndexConstPath {
 
 pub const COINJOIN_PATH_MAINNET: IndexConstPath<3> = IndexConstPath {
     indexes: [
-        ChildNumber::Hardened { index: FEATURE_PURPOSE },
-        ChildNumber::Hardened { index: DASH_COIN_TYPE },
-        ChildNumber::Hardened { index: FEATURE_PURPOSE_COINJOIN },
+        ChildNumber::Hardened {
+            index: FEATURE_PURPOSE,
+        },
+        ChildNumber::Hardened {
+            index: DASH_COIN_TYPE,
+        },
+        ChildNumber::Hardened {
+            index: FEATURE_PURPOSE_COINJOIN,
+        },
     ],
     reference: DerivationPathReference::CoinJoin,
     path_type: DerivationPathType::ANONYMOUS_FUNDS,
 };
 pub const COINJOIN_PATH_TESTNET: IndexConstPath<3> = IndexConstPath {
     indexes: [
-        ChildNumber::Hardened { index: FEATURE_PURPOSE },
-        ChildNumber::Hardened { index: DASH_TESTNET_COIN_TYPE },
-        ChildNumber::Hardened { index: FEATURE_PURPOSE_COINJOIN },
+        ChildNumber::Hardened {
+            index: FEATURE_PURPOSE,
+        },
+        ChildNumber::Hardened {
+            index: DASH_TESTNET_COIN_TYPE,
+        },
+        ChildNumber::Hardened {
+            index: FEATURE_PURPOSE_COINJOIN,
+        },
     ],
     reference: DerivationPathReference::CoinJoin,
     path_type: DerivationPathType::ANONYMOUS_FUNDS,

dash/src/sml/masternode_list/from_diff.rs

@@ -1,5 +1,3 @@
-use std::collections::BTreeMap;
-
 use crate::bls_sig_utils::BLSSignature;
 use crate::network::message_sml::MnListDiff;
 use crate::sml::error::SmlError;
@@ -11,6 +9,8 @@ use crate::sml::quorum_entry::qualified_quorum_entry::{
     QualifiedQuorumEntry, VerifyingChainLockSignaturesType,
 };
 use crate::{BlockHash, Network};
+use hashes::Hash;
+use std::collections::BTreeMap;
 
 pub trait TryFromWithBlockHashLookup<T>: Sized {
     type Error;
@@ -67,7 +67,9 @@ impl TryFromWithBlockHashLookup<MnListDiff> for MasternodeList {
     {
         if let Some(genesis_block_hash) = network.known_genesis_block_hash() {
             // Check if the base block is the genesis block
-            if diff.base_block_hash != genesis_block_hash {
+            if diff.base_block_hash != genesis_block_hash
+                && diff.base_block_hash.as_byte_array() != &[0; 32]
+            {
                 return Err(SmlError::BaseBlockNotGenesis(diff.base_block_hash));
             }
         }

dash/src/sml/masternode_list_engine/mod.rs

@@ -8,11 +8,6 @@ mod validation;
 
 use std::collections::{BTreeMap, BTreeSet};
 
-#[cfg(feature = "bincode")]
-use bincode::{Decode, Encode};
-#[cfg(feature = "serde")]
-use serde::{Deserialize, Serialize};
-
 use crate::bls_sig_utils::{BLSPublicKey, BLSSignature};
 use crate::network::message_qrinfo::{QRInfo, QuorumSnapshot};
 use crate::network::message_sml::MnListDiff;
@@ -28,6 +23,11 @@ use crate::sml::quorum_entry::qualified_quorum_entry::{
 use crate::sml::quorum_validation_error::{ClientDataRetrievalError, QuorumValidationError};
 use crate::transaction::special_transaction::quorum_commitment::QuorumEntry;
 use crate::{BlockHash, Network, QuorumHash};
+#[cfg(feature = "bincode")]
+use bincode::{Decode, Encode};
+use hashes::Hash;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Eq, PartialEq, Default)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
@@ -66,10 +66,15 @@ impl From<MasternodeListEngineBTreeMapBlockContainer> for MasternodeListEngineBl
 }
 
 impl MasternodeListEngineBlockContainer {
-    pub fn get_height(&self, block: &BlockHash) -> Option<&CoreBlockHeight> {
-        match self {
-            MasternodeListEngineBlockContainer::BTreeMapContainer(map) => {
-                map.block_heights.get(block)
+    pub fn get_height(&self, block_hash: &BlockHash) -> Option<CoreBlockHeight> {
+        if block_hash.as_byte_array() == &[0; 32] {
+            // rep
+            Some(0)
+        } else {
+            match self {
+                MasternodeListEngineBlockContainer::BTreeMapContainer(map) => {
+                    map.block_heights.get(block_hash).copied()
+                }
             }
         }
     }
@@ -203,7 +208,7 @@ impl MasternodeListEngine {
                             else {
                                 return true;
                             };
-                            !self.masternode_lists.contains_key(block_height)
+                            !self.masternode_lists.contains_key(&block_height)
                         })
                         .collect()
                 } else {
@@ -230,7 +235,7 @@ impl MasternodeListEngine {
                             else {
                                 return true;
                             };
-                            !self.masternode_lists.contains_key(block_height)
+                            !self.masternode_lists.contains_key(&block_height)
                         })
                         .collect()
                 } else {
@@ -255,7 +260,7 @@ impl MasternodeListEngine {
     ) -> Option<&MasternodeList> {
         self.block_container
             .get_height(block_hash)
-            .and_then(|height| self.masternode_lists.get(height))
+            .and_then(|height| self.masternode_lists.get(&height))
     }
 
     pub fn feed_block_height(&mut self, height: CoreBlockHeight, block_hash: BlockHash) {
@@ -357,7 +362,7 @@ impl MasternodeListEngine {
         Ok(())
     }
 
-    pub fn feed_qr_info<FH, FS>(
+    pub fn feed_qr_info<FH>(
         &mut self,
         qr_info: QRInfo,
         verify_tip_non_rotated_quorums: bool,
@@ -366,7 +371,6 @@ impl MasternodeListEngine {
     ) -> Result<(), QuorumValidationError>
     where
         FH: Fn(&BlockHash) -> Result<u32, ClientDataRetrievalError>,
-        FS: Fn(&BlockHash) -> Result<Option<BLSSignature>, ClientDataRetrievalError>,
     {
         // Fetch and process block heights using the provided callback
         if let Some(fetch_height) = fetch_block_height {
@@ -397,15 +401,18 @@ impl MasternodeListEngine {
 
         let can_verify_previous = quorum_snapshot_and_mn_list_diff_at_h_minus_4c.is_some();
 
-        let h_height = self
-            .block_container
-            .get_height(&mn_list_diff_h.block_hash)
-            .copied()
-            .ok_or(QuorumValidationError::RequiredBlockNotPresent(mn_list_diff_h.block_hash))?;
-        let tip_height =
-            self.block_container.get_height(&mn_list_diff_tip.block_hash).copied().ok_or(
-                QuorumValidationError::RequiredBlockNotPresent(mn_list_diff_tip.block_hash),
-            )?;
+        let h_height = self.block_container.get_height(&mn_list_diff_h.block_hash).ok_or(
+            QuorumValidationError::RequiredBlockNotPresent(
+                mn_list_diff_h.block_hash,
+                "getting height at diff h".to_string(),
+            ),
+        )?;
+        let tip_height = self.block_container.get_height(&mn_list_diff_tip.block_hash).ok_or(
+            QuorumValidationError::RequiredBlockNotPresent(
+                mn_list_diff_tip.block_hash,
+                "getting height at diff tip".to_string(),
+            ),
+        )?;
         let rotation_quorum_type = last_commitment_per_index
             .first()
             .map(|quorum_entry| quorum_entry.llmq_type)
@@ -657,23 +664,22 @@ impl MasternodeListEngine {
             .known_genesis_block_hash()
             .or_else(|| self.block_container.get_hash(&0).cloned())
         {
-            if masternode_list_diff.base_block_hash == known_genesis_block_hash {
+            if masternode_list_diff.base_block_hash == known_genesis_block_hash
+                || masternode_list_diff.base_block_hash.as_byte_array() == &[0; 32]
+            {
                 // we are going from the start
                 let block_hash = masternode_list_diff.block_hash;
 
                 let masternode_list = masternode_list_diff.try_into_with_block_hash_lookup(
-                    |block_hash| {
-                        diff_end_height.or(self.block_container.get_height(block_hash).copied())
-                    },
+                    |block_hash| diff_end_height.or(self.block_container.get_height(block_hash)),
                     self.network,
                 )?;
 
                 let diff_end_height = match diff_end_height {
                     None => self
                         .block_container
                         .get_height(&block_hash)
-                        .ok_or(SmlError::BlockHashLookupFailed(block_hash))
-                        .cloned()?,
+                        .ok_or(SmlError::BlockHashLookupFailed(block_hash))?,
                     Some(diff_end_height) => {
                         self.block_container.feed_block_height(diff_end_height, block_hash);
                         diff_end_height
@@ -689,7 +695,7 @@ impl MasternodeListEngine {
         else {
             return Err(SmlError::BlockHashLookupFailed(masternode_list_diff.base_block_hash));
         };
-        let Some(base_masternode_list) = self.masternode_lists.get(base_height) else {
+        let Some(base_masternode_list) = self.masternode_lists.get(&base_height) else {
             return Err(SmlError::MissingStartMasternodeList(masternode_list_diff.base_block_hash));
         };
 
@@ -699,8 +705,7 @@ impl MasternodeListEngine {
             None => self
                 .block_container
                 .get_height(&block_hash)
-                .ok_or(SmlError::BlockHashLookupFailed(block_hash))
-                .cloned()?,
+                .ok_or(SmlError::BlockHashLookupFailed(block_hash))?,
             Some(diff_end_height) => diff_end_height,
         };
 
@@ -1107,11 +1112,8 @@ mod tests {
         }
 
         masternode_list_engine
-            .feed_qr_info::<fn(&BlockHash) -> Result<u32, ClientDataRetrievalError>, fn(&BlockHash) -> Result<Option<BLSSignature>, ClientDataRetrievalError>>(
-                qr_info,
-                true,
-                true,
-                None,
+            .feed_qr_info::<fn(&BlockHash) -> Result<u32, ClientDataRetrievalError>>(
+                qr_info, true, true, None,
             )
             .expect("expected to feed_qr_info");
 

dash/src/sml/masternode_list_engine/non_rotated_quorum_construction.rs

@@ -23,7 +23,10 @@ impl MasternodeListEngine {
                 ))
             }
         } else {
-            Err(QuorumValidationError::RequiredBlockNotPresent(*block_hash))
+            Err(QuorumValidationError::RequiredBlockNotPresent(
+                *block_hash,
+                "looking for masternode list and height for block hash 8 blocks ago".to_string(),
+            ))
         }
     }
 

dash/src/sml/masternode_list_engine/rotated_quorum_construction.rs

@@ -35,6 +35,7 @@ impl MasternodeListEngine {
         else {
             return Err(QuorumValidationError::RequiredBlockNotPresent(
                 quorum.quorum_entry.quorum_hash,
+                "getting height when finding rotated masternodes for quorum".to_string(),
             ));
         };
         let llmq_type = quorum.quorum_entry.llmq_type;
@@ -82,7 +83,7 @@ impl MasternodeListEngine {
                 self.block_container.get_height(&quorum.quorum_entry.quorum_hash)
             else {
                 return Err(QuorumValidationError::RequiredBlockNotPresent(
-                    quorum.quorum_entry.quorum_hash,
+                    quorum.quorum_entry.quorum_hash, "getting height for a quorum hash when trying to find rotated masternodes for quorums".to_string()
                 ));
             };
             let llmq_type = quorum.quorum_entry.llmq_type;
@@ -145,7 +146,10 @@ impl MasternodeListEngine {
         for quorum in &qr_info.last_commitment_per_index {
             let Some(quorum_block_height) = self.block_container.get_height(&quorum.quorum_hash)
             else {
-                return Err(QuorumValidationError::RequiredBlockNotPresent(quorum.quorum_hash));
+                return Err(QuorumValidationError::RequiredBlockNotPresent(
+                    quorum.quorum_hash,
+                    "getting required cl_sig heights".to_string(),
+                ));
             };
             let llmq_params = quorum.llmq_type.params();
             let quorum_index = quorum_block_height % llmq_params.dkg_params.interval;
@@ -164,6 +168,7 @@ impl MasternodeListEngine {
                     else {
                         return Err(QuorumValidationError::RequiredBlockNotPresent(
                             quorum.quorum_hash,
+                            "getting height for quorum hash for diff at h minus 4c".to_string(),
                         ));
                     };
                     let llmq_params = quorum.llmq_type.params();

dash/src/sml/quorum_entry/qualified_quorum_entry.rs

@@ -68,7 +68,7 @@ impl QualifiedQuorumEntry {
     /// * `result` - A `Result` containing either success (`Ok`) or a `QuorumValidationError`.
     pub fn update_quorum_status(&mut self, result: Result<(), QuorumValidationError>) {
         match result {
-            Err(QuorumValidationError::RequiredBlockNotPresent(block_hash)) => {
+            Err(QuorumValidationError::RequiredBlockNotPresent(block_hash, _)) => {
                 self.verified = LLMQEntryVerificationStatus::Skipped(
                     LLMQEntryVerificationSkipStatus::UnknownBlock(block_hash),
                 );

dash/src/sml/quorum_validation_error.rs

@@ -24,8 +24,8 @@ pub enum ClientDataRetrievalError {
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
 pub enum QuorumValidationError {
-    #[error("Required block not present: {0}")]
-    RequiredBlockNotPresent(BlockHash),
+    #[error("Required block not present: {0} ({1})")]
+    RequiredBlockNotPresent(BlockHash, String),
 
     #[error("Required block height not present: {0}")]
     RequiredBlockHeightNotPresent(CoreBlockHeight),