bincode serialization

QuantumExplorer · QuantumExplorer · commit a6f83a1d9c6b · 2025-02-16T20:42:27.000+07:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/dash/Cargo.toml b/dash/Cargo.toml
@@ -19,7 +19,7 @@ edition = "2021"
 
 # Please don't forget to add relevant features to docs.rs below
 [features]
-default = [ "std", "secp-recovery", "core-block-hash-use-x11", "quorum_validation" ]
+default = [ "std", "secp-recovery", "core-block-hash-use-x11", "quorum_validation", "bincode" ]
 base64 = [ "base64-compat" ]
 rand-std = ["secp256k1/rand"]
 rand = ["secp256k1/rand"]
@@ -31,6 +31,7 @@ core-block-hash-use-x11 = ["dashcore_hashes/x11"]
 bls = ["blsful"]
 eddsa = ["ed25519-dalek"]
 quorum_validation = ["bls"]
+bincode = [ "dep:bincode", "dashcore_hashes/bincode" ]
 
 # At least one of std, no-std must be enabled.
 #
diff --git a/dash/src/blockdata/transaction/special_transaction/quorum_commitment.rs b/dash/src/blockdata/transaction/special_transaction/quorum_commitment.rs
@@ -18,7 +18,8 @@
 //!
 
 use std::io::{Read, Write};
-
+#[cfg(feature = "bincode")]
+use bincode::{Decode, Encode};
 use crate::bls_sig_utils::{BLSPublicKey, BLSSignature};
 use crate::consensus::encode::{
     compact_size_len, fixed_bitset_len, read_compact_size, read_fixed_bitset, write_compact_size,
@@ -37,6 +38,7 @@ use crate::sml::quorum_validation_error::QuorumValidationError;
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "bincode", derive(Encode, Decode))]
 pub struct QuorumEntry {
     pub version: u16,
     pub llmq_type: LLMQType,
diff --git a/dash/src/bls_sig_utils.rs b/dash/src/bls_sig_utils.rs
@@ -17,6 +17,8 @@
 //! and signature.
 //!
 
+#[cfg(feature = "bincode")]
+use bincode::{Decode, Encode};
 #[cfg(feature = "bls")]
 use blsful::{Bls12381G2Impl, Pairing};
 use hex::{FromHexError, ToHex};
@@ -29,6 +31,7 @@ use crate::sml::quorum_validation_error::QuorumValidationError;
 /// A BLS Public key is 48 bytes in the scheme used for Dash Core
 #[rustversion::attr(since(1.48), derive(PartialEq, Eq, Ord, PartialOrd, Hash))]
 #[derive(Clone, Copy, Debug)]
+#[cfg_attr(feature = "bincode", derive(Encode, Decode))]
 pub struct BLSPublicKey([u8; 48]);
 
 impl BLSPublicKey {
@@ -86,6 +89,7 @@ impl fmt::Display for BLSPublicKey {
 /// A BLS Signature is 96 bytes in the scheme used for Dash Core
 #[rustversion::attr(since(1.48), derive(PartialEq, Eq, Ord, PartialOrd, Hash))]
 #[derive(Clone, Copy)]
+#[cfg_attr(feature = "bincode", derive(Encode, Decode))]
 pub struct BLSSignature([u8; 96]);
 
 impl BLSSignature {
diff --git a/dash/src/network/constants.rs b/dash/src/network/constants.rs
@@ -44,6 +44,8 @@ use core::convert::From;
 use core::fmt::Display;
 use core::str::FromStr;
 use core::{fmt, ops};
+#[cfg(feature = "bincode")]
+use bincode::{Decode, Encode};
 use hashes::Hash;
 use internals::write_err;
 
@@ -76,6 +78,7 @@ pub const PROTOCOL_VERSION: u32 = 70220;
 #[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
 #[cfg_attr(feature = "serde", serde(rename_all = "lowercase"))]
 #[non_exhaustive]
+#[cfg_attr(feature = "bincode", derive(Encode, Decode))]
 pub enum Network {
     /// Classic Dash Core Payment Chain
     Dash,
diff --git a/dash/src/sml/llmq_entry_verification.rs b/dash/src/sml/llmq_entry_verification.rs
@@ -1,8 +1,11 @@
 use core::fmt::{Display, Formatter};
+#[cfg(feature = "bincode")]
+use bincode::{Decode, Encode};
 use crate::prelude::CoreBlockHeight;
 use crate::sml::quorum_validation_error::QuorumValidationError;
 
 #[derive(Clone, Ord, PartialOrd, PartialEq, Eq, Hash, Debug)]
+#[cfg_attr(feature = "bincode", derive(Encode, Decode))]
 pub enum LLMQEntryVerificationSkipStatus {
     NotMarkedForVerification,
     MissedList(CoreBlockHeight),
@@ -22,6 +25,7 @@ impl Display for LLMQEntryVerificationSkipStatus {
 }
 
 #[derive(Clone, Ord, PartialOrd, PartialEq, Eq, Hash, Debug)]
+#[cfg_attr(feature = "bincode", derive(Encode, Decode))]
 pub enum LLMQEntryVerificationStatus {
     Unknown,
     Verified,
diff --git a/dash/src/sml/llmq_type/mod.rs b/dash/src/sml/llmq_type/mod.rs
@@ -5,6 +5,8 @@ mod network;
 
 use std::fmt::{Display, Formatter};
 use std::io;
+#[cfg(feature = "bincode")]
+use bincode::{Decode, Encode};
 use crate::bip152::BlockTransactionsRequest;
 use crate::consensus::{Decodable, Encodable, encode};
 use crate::Network;
@@ -290,6 +292,7 @@ pub const LLMQ_DEV_PLATFORM: LLMQParams = LLMQParams {
 #[derive(Clone, Copy, Debug, Eq, PartialEq, PartialOrd, Hash, Ord)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "bincode", derive(Encode, Decode))]
 pub enum LLMQType {
     LlmqtypeUnknown = 0,    // other kind of
     Llmqtype50_60 = 1,      // 50 members,  30  (60%) threshold, 24 / day
diff --git a/dash/src/sml/masternode_list/mod.rs b/dash/src/sml/masternode_list/mod.rs
@@ -11,13 +11,16 @@ mod scores_for_quorum;
 // mod rotation;
 
 use std::collections::BTreeMap;
+#[cfg(feature = "bincode")]
+use bincode::{Decode, Encode};
 use crate::hash_types::{MerkleRootMasternodeList, MerkleRootQuorums};
 use crate::sml::llmq_type::LLMQType;
 use crate::{BlockHash, ProTxHash, QuorumHash};
 use crate::sml::masternode_list_entry::qualified_masternode_list_entry::QualifiedMasternodeListEntry;
 use crate::sml::quorum_entry::qualified_quorum_entry::QualifiedQuorumEntry;
 
 #[derive(Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "bincode", derive(Encode, Decode))]
 pub struct MasternodeList {
     pub block_hash: BlockHash,
     pub known_height: u32,
diff --git a/dash/src/sml/masternode_list_engine/mod.rs b/dash/src/sml/masternode_list_engine/mod.rs
@@ -2,6 +2,10 @@
 mod validation;
 
 use std::collections::{BTreeMap, BTreeSet};
+#[cfg(feature = "bincode")]
+use bincode::{Decode, Encode};
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
 use crate::{BlockHash, Network, QuorumHash};
 use crate::bls_sig_utils::BLSSignature;
 use crate::network::message_sml::MnListDiff;
@@ -14,6 +18,9 @@ use crate::sml::masternode_list::MasternodeList;
 use crate::sml::quorum_validation_error::QuorumValidationError;
 
 #[derive(Clone, Eq, PartialEq)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "bincode", derive(Encode, Decode))]
 pub struct MasternodeListEngine {
     pub block_hashes : BTreeMap<CoreBlockHeight, BlockHash>,
     pub block_heights : BTreeMap<BlockHash, CoreBlockHeight>,
diff --git a/dash/src/sml/masternode_list_entry/mod.rs b/dash/src/sml/masternode_list_entry/mod.rs
@@ -17,6 +17,7 @@ use crate::internal_macros::impl_consensus_encoding;
 use crate::{ProTxHash, PubkeyHash};
 
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Debug)]
+#[cfg_attr(feature = "bincode", derive(Encode, Decode))]
 pub enum MasternodeType {
     Regular,
     HighPerformance { platform_http_port: u16, platform_node_id: PubkeyHash },
@@ -72,6 +73,7 @@ pub struct OperatorPublicKey {
 impl_consensus_encoding!(OperatorPublicKey, data, version);
 
 #[derive(Clone, Eq, PartialEq, Debug)]
+#[cfg_attr(feature = "bincode", derive(Encode, Decode))]
 pub struct MasternodeListEntry {
     pub version: u16,
     pub pro_reg_tx_hash: ProTxHash,
@@ -84,6 +86,8 @@ pub struct MasternodeListEntry {
 }
 
 use std::cmp::Ordering;
+#[cfg(feature = "bincode")]
+use bincode::{Decode, Encode};
 use hashes::Hash;
 
 impl Ord for MasternodeListEntry {
diff --git a/dash/src/sml/masternode_list_entry/qualified_masternode_list_entry.rs b/dash/src/sml/masternode_list_entry/qualified_masternode_list_entry.rs
@@ -1,9 +1,12 @@
 use std::cmp::Ordering;
+#[cfg(feature = "bincode")]
+use bincode::{Decode, Encode};
 use hashes::Hash;
 use crate::hash_types::ConfirmedHashHashedWithProRegTx;
 use crate::sml::masternode_list_entry::MasternodeListEntry;
 
 #[derive(Clone, Eq, PartialEq, Debug)]
+#[cfg_attr(feature = "bincode", derive(Encode, Decode))]
 pub struct QualifiedMasternodeListEntry {
     pub masternode_list_entry: MasternodeListEntry,
     pub entry_hash: [u8;32],
diff --git a/dash/src/sml/quorum_entry/qualified_quorum_entry.rs b/dash/src/sml/quorum_entry/qualified_quorum_entry.rs
@@ -1,3 +1,5 @@
+#[cfg(feature = "bincode")]
+use bincode::{Decode, Encode};
 use hashes::Hash;
 use crate::hash_types::{QuorumCommitmentHash, QuorumEntryHash};
 use crate::sml::llmq_entry_verification::{LLMQEntryVerificationSkipStatus, LLMQEntryVerificationStatus};
@@ -7,6 +9,7 @@ use crate::transaction::special_transaction::quorum_commitment::QuorumEntry;
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "serde", serde(crate = "actual_serde"))]
+#[cfg_attr(feature = "bincode", derive(Encode, Decode))]
 pub struct QualifiedQuorumEntry {
     pub quorum_entry: QuorumEntry,
     pub verified: LLMQEntryVerificationStatus,
diff --git a/dash/src/sml/quorum_validation_error.rs b/dash/src/sml/quorum_validation_error.rs
@@ -1,8 +1,11 @@
+#[cfg(feature = "bincode")]
+use bincode::{Decode, Encode};
 use thiserror::Error;
 use crate::BlockHash;
 use crate::prelude::CoreBlockHeight;
 
 #[derive(Debug, Error, Clone, Ord, PartialOrd, PartialEq, Hash, Eq)]
+#[cfg_attr(feature = "bincode", derive(Encode, Decode))]
 pub enum QuorumValidationError {
     #[error("Required block not present: {0}")]
     RequiredBlockNotPresent(BlockHash),
diff --git a/hashes/Cargo.toml b/hashes/Cargo.toml
@@ -38,6 +38,7 @@ dyn-clone = { version = "<=1.0.7", default_features = false, optional = true }
 secp256k1 = { default-features = false, features = ["hashes"], version= "0.30.0" }
 
 rs-x11-hash = { version = "0.1.8", optional = true }
+bincode = { version= "2.0.0-rc.3", optional = true }
 
 [dev-dependencies]
 serde_test = "1.0"
diff --git a/hashes/src/bincode_macros.rs b/hashes/src/bincode_macros.rs
@@ -0,0 +1,45 @@
+#[macro_export]
+#[cfg(feature = "bincode")]
+macro_rules! bincode_impl {
+    ($t:ident, $len:expr $(, $gen:ident: $gent:ident)*) => {
+        impl<$($gen: $gent),*> bincode::Encode for $t<$($gen),*> {
+            fn encode<E: bincode::enc::Encoder>(&self, encoder: &mut E) -> Result<(), bincode::error::EncodeError> {
+                // Use the as_byte_array method so that we encode the inner byte array
+                self.as_byte_array().encode(encoder)
+            }
+        }
+
+        impl<$($gen: $gent),*> bincode::Decode for $t<$($gen),*> {
+            fn decode<D: bincode::de::Decoder>(decoder: &mut D) -> Result<Self, bincode::error::DecodeError> {
+                // Decode a fixed-length byte array and then reconstruct via from_byte_array
+                let bytes: [u8; $len] = <[u8; $len]>::decode(decoder)?;
+                Ok(Self::from_byte_array(bytes))
+            }
+        }
+
+        impl<'de, $($gen: $gent),*> bincode::BorrowDecode<'de> for $t<$($gen),*> {
+            fn borrow_decode<D: bincode::de::BorrowDecoder<'de>>(decoder: &mut D) -> Result<Self, bincode::error::DecodeError> {
+                // Decode a borrowed reference, then use from_bytes_ref (and clone, since our type is Copy)
+                use std::convert::TryInto;
+
+                // Decode a borrowed reference to a byte slice
+                let bytes: &[u8] = bincode::BorrowDecode::borrow_decode(decoder)?;
+
+                // Convert the slice into a fixed-size array
+                let bytes: [u8; $len] = bytes.try_into()
+                    .map_err(|_| bincode::error::DecodeError::Other("Incorrect byte length".into()))?;
+
+                // Construct the hash from the reference (cloned since the type is Copy)
+                Ok(Self::from_byte_array(bytes))
+            }
+        }
+    };
+}
+
+/// Does an "empty" serde implementation for the configuration without serde feature.
+#[macro_export]
+#[cfg(not(feature = "bincode"))]
+#[cfg_attr(docsrs, doc(cfg(not(feature = "bincode"))))]
+macro_rules! bincode_impl(
+        ($t:ident, $len:expr $(, $gen:ident: $gent:ident)*) => ()
+);
diff --git a/hashes/src/internal_macros.rs b/hashes/src/internal_macros.rs
@@ -138,6 +138,41 @@ macro_rules! hash_trait_impls {
             fn into(self) -> [u8; $bits / 8] { self.0 }
         }
 
+        #[cfg(feature = "bincode")]
+        impl<$($gen: $gent),*> bincode::Encode for Hash<$($gen),*> {
+            fn encode<E: bincode::enc::Encoder>(&self, encoder: &mut E) -> Result<(), bincode::error::EncodeError> {
+                use crate::Hash;
+                // Use as_byte_array so that we don’t have to consume self
+                self.as_byte_array().encode(encoder)
+            }
+        }
+
+        #[cfg(feature = "bincode")]
+        impl<$($gen: $gent),*> bincode::Decode for Hash<$($gen),*> {
+            fn decode<D: bincode::de::Decoder>(decoder: &mut D) -> Result<Self, bincode::error::DecodeError> {
+                use crate::Hash;
+                // Decode a fixed-length byte array and then create the Hash
+                let bytes: [u8; $bits / 8] = <[u8; $bits / 8]>::decode(decoder)?;
+                Ok(Self::from_byte_array(bytes))
+            }
+        }
+
+        #[cfg(feature = "bincode")]
+        impl<'de, $($gen: $gent),*> bincode::BorrowDecode<'de> for Hash<$($gen),*> {
+            fn borrow_decode<D: bincode::de::BorrowDecoder<'de>>(decoder: &mut D) -> Result<Self, bincode::error::DecodeError> {
+                use crate::Hash;
+                use std::convert::TryInto;
+                // Decode a borrowed reference to a byte slice
+                let bytes: &[u8] = bincode::BorrowDecode::borrow_decode(decoder)?;
+
+                // Convert the slice into a fixed-size array
+                let bytes: &[u8; $bits / 8] = bytes.try_into().map_err(|_| bincode::error::DecodeError::Other("Incorrect byte length".into()))?;
+
+                // Construct the hash from the reference
+                Ok(Self::from_bytes_ref(bytes).clone())
+            }
+        }
+
         impl<$($gen: $gent),*> crate::Hash for Hash<$($gen),*> {
             type Engine = HashEngine;
             type Bytes = [u8; $bits / 8];
diff --git a/hashes/src/lib.rs b/hashes/src/lib.rs
@@ -137,6 +137,7 @@ pub mod sha256t;
 pub mod sha512;
 pub mod sha512_256;
 pub mod siphash24;
+mod bincode_macros;
 
 use core::{borrow, fmt, hash, ops};
 
diff --git a/hashes/src/util.rs b/hashes/src/util.rs
@@ -202,6 +202,7 @@ macro_rules! hash_newtype {
 
         $crate::hex_fmt_impl!(<$newtype as $crate::Hash>::DISPLAY_BACKWARD, $newtype);
         $crate::serde_impl!($newtype, <$newtype as $crate::Hash>::LEN);
+        $crate::bincode_impl!($newtype, <$newtype as $crate::Hash>::LEN);
         $crate::borrow_slice_impl!($newtype);
 
         impl $newtype {
