Merge branch 'lowhung/introduce-combined-hash-file' into lowhung/unify-hash-types

# Conflicts:
#	codec/src/map_parameters.rs
#	common/src/hash.rs
#	common/src/snapshot/pool_params.rs
#	common/src/snapshot/streaming_snapshot.rs
#	common/src/types.rs
#	modules/chain_store/src/chain_store.rs
#	modules/chain_store/src/stores/fjall.rs
#	modules/chain_store/src/stores/mod.rs
#	modules/epochs_state/src/state.rs
#	modules/genesis_bootstrapper/src/genesis_bootstrapper.rs
#	modules/mithril_snapshot_fetcher/src/mithril_snapshot_fetcher.rs
#	modules/tx_unpacker/src/tx_unpacker.rs
#	modules/upstream_chain_fetcher/src/body_fetcher.rs

Author: lowhung

codec/src/map_parameters.rs

@@ -202,7 +202,7 @@ pub fn map_gov_action_id(pallas_action_id: &conway::GovActionId) -> Result<GovAc
     };
 
     Ok(GovActionId {
-        transaction_id: TxHash::new(*pallas_action_id.transaction_id),
+        transaction_id: TxHash::from(*pallas_action_id.transaction_id),
         action_index: act_idx_u8,
     })
 }

common/src/hash.rs

@@ -1,35 +1,13 @@
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use std::{fmt, ops::Deref, str::FromStr};
 
-/// Data that is a cryptographic hash of `BYTES` long.
-///
-/// This is a generic wrapper around a fixed-size byte array that provides:
-/// - Hexadecimal serialization/deserialization
-/// - CBOR encoding/decoding via minicbor
-/// - Type-safe conversions from various byte representations
-/// - Display and debug formatting
+/// data that is a cryptographic [`struct@Hash`] of `BYTES` long.
 ///
 /// # Common Hash Sizes in Cardano
 ///
 /// - **32 bytes**: Block hashes, transaction hashes
 /// - **28 bytes**: Script hashes, address key hashes
 ///
-/// # Examples
-///
-/// ```ignore
-/// use your_crate::Hash;
-///
-/// // Parse from hex string
-/// let hash: Hash<32> = "0d8d00cdd4657ac84d82f0a56067634a7adfdf43da41cb534bcaa45060973d21"
-///     .parse()
-///     .unwrap();
-///
-/// // Create from byte array
-/// let bytes = [0u8; 28];
-/// let hash = Hash::new(bytes);
-///
-/// // Convert to hex string
-/// let hex_string = hash.to_string();
 /// ```
 #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
 pub struct Hash<const BYTES: usize>([u8; BYTES]);
@@ -61,48 +39,16 @@ impl<'de, const BYTES: usize> Deserialize<'de> for Hash<BYTES> {
 }
 
 impl<const BYTES: usize> Hash<BYTES> {
-    /// Creates a new hash from a byte array.
-    ///
-    /// This is a const function, allowing hashes to be created at compile time.
-    ///
-    /// # Examples
-    ///
-    /// ```ignore
-    /// use your_crate::Hash;
-    ///
-    /// const MY_HASH: Hash<32> = Hash::new([0u8; 32]);
-    /// ```
     #[inline]
     pub const fn new(bytes: [u8; BYTES]) -> Self {
         Self(bytes)
     }
 
-    /// Converts the hash to a `Vec<u8>`.
-    ///
-    /// # Examples
-    ///
-    /// ```ignore
-    /// use your_crate::Hash;
-    ///
-    /// let hash = Hash::new([1u8; 28]);
-    /// let vec = hash.to_vec();
-    /// assert_eq!(vec.len(), 28);
-    /// ```
     #[inline]
     pub fn to_vec(&self) -> Vec<u8> {
         self.0.to_vec()
     }
 
-    /// Consumes the hash and returns the inner byte array.
-    ///
-    /// # Examples
-    ///
-    /// ```ignore
-    /// use your_crate::Hash;
-    ///
-    /// let hash = Hash::new([1u8; 28]);
-    /// let bytes: [u8; 28] = hash.into_inner();
-    /// ```
     #[inline]
     pub fn into_inner(self) -> [u8; BYTES] {
         self.0
@@ -119,11 +65,6 @@ impl<const BYTES: usize> From<[u8; BYTES]> for Hash<BYTES> {
 impl<const BYTES: usize> TryFrom<&[u8]> for Hash<BYTES> {
     type Error = std::array::TryFromSliceError;
 
-    /// Attempts to create a hash from a byte slice.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the slice length does not match `BYTES`.
     fn try_from(value: &[u8]) -> Result<Self, Self::Error> {
         let hash: [u8; BYTES] = value.try_into()?;
         Ok(Self::new(hash))
@@ -133,25 +74,19 @@ impl<const BYTES: usize> TryFrom<&[u8]> for Hash<BYTES> {
 impl<const BYTES: usize> TryFrom<Vec<u8>> for Hash<BYTES> {
     type Error = Vec<u8>;
 
-    /// Attempts to create a hash from a `Vec<u8>`.
-    ///
-    /// # Errors
-    ///
-    /// Returns the original vector if its length does not match `BYTES`.
     fn try_from(value: Vec<u8>) -> Result<Self, Self::Error> {
-        let hash: [u8; BYTES] = value.try_into()?;
-        Ok(Self::new(hash))
+        Self::try_from(value.as_slice()).map_err(|_| value)
     }
 }
 
-impl<const BYTES: usize> From<Hash<BYTES>> for Vec<u8> {
-    fn from(hash: Hash<BYTES>) -> Self {
+impl<const BYTES: usize> From<&Hash<BYTES>> for Vec<u8> {
+    fn from(hash: &Hash<BYTES>) -> Self {
         hash.0.to_vec()
     }
 }
 
-impl<const BYTES: usize> From<Hash<BYTES>> for [u8; BYTES] {
-    fn from(hash: Hash<BYTES>) -> Self {
+impl<const BYTES: usize> From<&Hash<BYTES>> for [u8; BYTES] {
+    fn from(hash: &Hash<BYTES>) -> Self {
         hash.0
     }
 }
@@ -185,7 +120,6 @@ impl<const BYTES: usize> fmt::Debug for Hash<BYTES> {
 }
 
 impl<const BYTES: usize> fmt::Display for Hash<BYTES> {
-    /// Formats the hash as a lowercase hexadecimal string.
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.write_str(&hex::encode(self))
     }
@@ -194,23 +128,6 @@ impl<const BYTES: usize> fmt::Display for Hash<BYTES> {
 impl<const BYTES: usize> FromStr for Hash<BYTES> {
     type Err = hex::FromHexError;
 
-    /// Parses a hash from a hexadecimal string.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if:
-    /// - The string is not valid hexadecimal
-    /// - The decoded bytes do not match the expected length `BYTES`
-    ///
-    /// # Examples
-    ///
-    /// ```ignore
-    /// use your_crate::Hash;
-    ///
-    /// let hash: Hash<28> = "276fd18711931e2c0e21430192dbeac0e458093cd9d1fcd7210f64b3"
-    ///     .parse()
-    ///     .unwrap();
-    /// ```
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         let mut bytes = [0; BYTES];
         hex::decode_to_slice(s, &mut bytes)?;
@@ -221,11 +138,6 @@ impl<const BYTES: usize> FromStr for Hash<BYTES> {
 impl<const BYTES: usize> hex::FromHex for Hash<BYTES> {
     type Error = hex::FromHexError;
 
-    /// Decodes a hash from hexadecimal bytes.
-    ///
-    /// # Errors
-    ///
-    /// Returns an error if the decoded length does not match `BYTES`.
     fn from_hex<T: AsRef<[u8]>>(hex: T) -> Result<Self, Self::Error> {
         match Self::try_from(Vec::<u8>::from_hex(hex)?) {
             Ok(h) => Ok(h),
@@ -262,14 +174,6 @@ impl<'a, C, const BYTES: usize> minicbor::Decode<'a, C> for Hash<BYTES> {
     }
 }
 
-/// Declares a type alias for a hash with optional documentation.
-///
-/// # Examples
-///
-/// ```ignore
-/// declare_hash_type!(BlockHash, 32);
-/// declare_hash_type!(TxHash, 32);
-/// ```
 #[macro_export]
 macro_rules! declare_hash_type {
     ($name:ident, $size:expr) => {
@@ -341,22 +245,26 @@ macro_rules! declare_hash_type_with_bech32 {
         }
 
         impl TryFrom<Vec<u8>> for $name {
-            type Error = Vec<u8>;
+            type Error = anyhow::Error;
             fn try_from(vec: Vec<u8>) -> Result<Self, Self::Error> {
-                Ok(Self(Hash::try_from(vec)?))
+                Ok(Self(
+                    Hash::try_from(vec).map_err(|e| anyhow::anyhow!("{}", hex::encode(e)))?,
+                ))
             }
         }
 
         impl TryFrom<&[u8]> for $name {
-            type Error = std::array::TryFromSliceError;
+            type Error = anyhow::Error;
             fn try_from(arr: &[u8]) -> Result<Self, Self::Error> {
-                Ok(Self(Hash::try_from(arr)?))
+                Ok(Self(
+                    Hash::try_from(arr).map_err(|e| anyhow::anyhow!("{}", e))?,
+                ))
             }
         }
 
         impl AsRef<[u8]> for $name {
             fn as_ref(&self) -> &[u8] {
-                self.0.as_ref()
+                &self.0.as_ref()
             }
         }
 
@@ -370,7 +278,7 @@ macro_rules! declare_hash_type_with_bech32 {
         impl std::str::FromStr for $name {
             type Err = hex::FromHexError;
             fn from_str(s: &str) -> Result<Self, Self::Err> {
-                Ok(Self(s.parse()?))
+                Ok(Self(s.parse::<Hash<$size>>()?))
             }
         }
 
@@ -402,14 +310,30 @@ macro_rules! declare_hash_type_with_bech32 {
         impl crate::serialization::Bech32Conversion for $name {
             fn to_bech32(&self) -> Result<String, anyhow::Error> {
                 use crate::serialization::Bech32WithHrp;
-                self.0.to_vec().to_bech32_with_hrp($hrp)
+                use anyhow::Context;
+
+                self.as_ref().to_bech32_with_hrp($hrp).with_context(|| {
+                    format!(
+                        "Failed to encode {} to bech32 with HRP '{}'",
+                        stringify!($name),
+                        $hrp
+                    )
+                })
             }
 
             fn from_bech32(s: &str) -> Result<Self, anyhow::Error> {
                 use crate::serialization::Bech32WithHrp;
-                let v = Vec::<u8>::from_bech32_with_hrp(s, $hrp)?;
+                use anyhow::Context;
+
+                let v = Vec::<u8>::from_bech32_with_hrp(s, $hrp).with_context(|| {
+                    format!("Failed to decode {} from bech32", stringify!($name))
+                })?;
+
                 Self::try_from(v).map_err(|_| {
-                    anyhow::Error::msg(format!("Bad vector input to {}", stringify!($name)))
+                    anyhow::anyhow!(
+                        "Failed to create {} from decoded bech32 data",
+                        stringify!($name)
+                    )
                 })
             }
         }
@@ -459,7 +383,7 @@ mod tests {
     fn into_vec() {
         let bytes = [0u8; 28];
         let hash = Hash::new(bytes);
-        let vec: Vec<u8> = hash.into();
+        let vec: Vec<u8> = hash.as_ref().into();
         assert_eq!(vec, bytes.to_vec());
     }
 

common/src/serialization.rs

@@ -115,3 +115,23 @@ impl Bech32WithHrp for Vec<u8> {
         Ok(data.to_vec())
     }
 }
+
+impl Bech32WithHrp for [u8] {
+    fn to_bech32_with_hrp(&self, hrp: &str) -> Result<String, anyhow::Error> {
+        let hrp = Hrp::parse(hrp).map_err(|e| anyhow!("Bech32 HRP parse error: {e}"))?;
+
+        bech32::encode::<Bech32>(hrp, self).map_err(|e| anyhow!("Bech32 encoding error: {e}"))
+    }
+
+    fn from_bech32_with_hrp(s: &str, expected_hrp: &str) -> Result<Vec<u8>, anyhow::Error> {
+        let (hrp, data) = bech32::decode(s).map_err(|e| anyhow!("Invalid Bech32 string: {e}"))?;
+
+        if hrp != Hrp::parse(expected_hrp)? {
+            return Err(anyhow!(
+                "Invalid HRP, expected '{expected_hrp}', got '{hrp}'"
+            ));
+        }
+
+        Ok(data.to_vec())
+    }
+}

modules/chain_store/src/chain_store.rs

@@ -400,7 +400,7 @@ impl ChainStore {
             block_info.push(BlockInfo {
                 timestamp: block.extra.timestamp,
                 number: header.number(),
-                hash: BlockHash::new(*header.hash()),
+                hash: BlockHash::from(*header.hash()),
                 slot: header.slot(),
                 epoch: block.extra.epoch,
                 epoch_slot: block.extra.epoch_slot,
@@ -416,8 +416,8 @@ impl ChainStore {
                 block_vrf: header.vrf_vkey().map(|key| VrfKeyHash::try_from(key).ok().unwrap()),
                 op_cert,
                 op_cert_counter,
-                previous_block: header.previous_hash().map(|h| BlockHash::new(*h)),
-                next_block: next_hash.map(|h| BlockHash::new(*h)),
+                previous_block: header.previous_hash().map(|h| BlockHash::from(*h)),
+                next_block: next_hash.map(|h| BlockHash::from(*h)),
                 confirmations: latest_number - header.number(),
             });
 

modules/chain_store/src/stores/fjall.rs

@@ -263,7 +263,7 @@ mod tests {
             status: acropolis_common::BlockStatus::Immutable,
             slot: block.slot(),
             number: block.number(),
-            hash: BlockHash::new(*block.hash()),
+            hash: BlockHash::from(*block.hash()),
             epoch,
             epoch_slot,
             new_epoch: false,

modules/chain_store/src/stores/mod.rs

@@ -34,5 +34,5 @@ pub struct ExtraBlockData {
 
 pub(crate) fn extract_tx_hashes(block: &[u8]) -> Result<Vec<TxHash>> {
     let block = pallas_traverse::MultiEraBlock::decode(block).context("could not decode block")?;
-    Ok(block.txs().into_iter().map(|tx| TxHash::new(*tx.hash())).collect())
+    Ok(block.txs().into_iter().map(|tx| TxHash::from(*tx.hash())).collect())
 }

modules/epochs_state/src/state.rs

@@ -134,7 +134,7 @@ impl State {
             let evolving = Nonces::evolve(&current_nonces.evolving, &nonce_vrf_output)?;
 
             // there must be parent hash
-            let Some(parent_hash) = header.previous_hash().map(|h| BlockHash::new(*h)) else {
+            let Some(parent_hash) = header.previous_hash().map(|h| BlockHash::from(*h)) else {
                 return Err(anyhow::anyhow!("Header Parent hash error"));
             };
 

modules/genesis_bootstrapper/src/genesis_bootstrapper.rs

@@ -141,7 +141,7 @@ impl GenesisBootstrapper {
                 let mut total_allocated: u64 = 0;
                 for (tx_index, (hash, address, amount)) in gen_utxos.iter().enumerate() {
                     let tx_identifier = TxIdentifier::new(0, tx_index as u16);
-                    let tx_ref = TxOutRef::new(TxHash::new(**hash), 0);
+                    let tx_ref = TxOutRef::new(TxHash::from(**hash), 0);
 
                     gen_utxo_identifiers.push((tx_ref, tx_identifier));
 

modules/mithril_snapshot_fetcher/src/mithril_snapshot_fetcher.rs

@@ -325,7 +325,7 @@ impl MithrilSnapshotFetcher {
                             status: BlockStatus::Immutable,
                             slot,
                             number,
-                            hash: BlockHash::new(*block.hash()),
+                            hash: BlockHash::from(*block.hash()),
                             epoch,
                             epoch_slot,
                             new_epoch,

modules/tx_unpacker/src/tx_unpacker.rs

@@ -183,7 +183,7 @@ impl TxUnpacker {
                                             for input in inputs {  // MultiEraInput
                                                 // Lookup and remove UTxOIdentifier from registry 
                                                 let oref = input.output_ref();
-                                                let tx_ref = TxOutRef::new(TxHash::new(**oref.hash()), oref.index() as u16);
+                                                let tx_ref = TxOutRef::new(TxHash::from(**oref.hash()), oref.index() as u16);
 
                                                 match utxo_registry.consume(&tx_ref) {
                                                     Ok(tx_identifier) => {
@@ -342,7 +342,7 @@ impl TxUnpacker {
                                         if publish_governance_procedures_topic.is_some() {
                                             if let Some(pp) = props {
                                                 // Nonempty set -- governance_message.proposal_procedures will not be empty
-                                                let mut proc_id = GovActionId { transaction_id: TxHash::new(*tx.hash()), action_index: 0 };
+                                                let mut proc_id = GovActionId { transaction_id: tx_hash, action_index: 0 };
                                                 for (action_index, pallas_governance_proposals) in pp.iter().enumerate() {
                                                     match proc_id.set_action_index(action_index)
                                                         .and_then (|proc_id| map_parameters::map_governance_proposals_procedures(proc_id, pallas_governance_proposals))
@@ -356,7 +356,7 @@ impl TxUnpacker {
                                             if let Some(pallas_vp) = votes {
                                                 // Nonempty set -- governance_message.voting_procedures will not be empty
                                                 match map_parameters::map_all_governance_voting_procedures(pallas_vp) {
-                                                    Ok(vp) => voting_procedures.push((TxHash::new(*tx.hash()), vp)),
+                                                    Ok(vp) => voting_procedures.push((tx_hash, vp)),
                                                     Err(e) => error!("Cannot decode governance voting procedures in slot {}: {e}", block.slot)
                                                 }
                                             }