Refactor: Replace KeyHash::try_from with .try_into() for consistent hash conversion across modules

Author: lowhung

codec/src/map_parameters.rs

@@ -49,13 +49,6 @@ pub fn genesis_delegate_to_hash<const N: usize>(
     Hash::try_from(pallas_hash.as_ref()).unwrap()
 }
 
-/// Convert an optional Pallas Hash reference to an optional Acropolis Hash
-pub fn to_hash_opt<const N: usize>(
-    pallas_hash: Option<&pallas_primitives::Hash<N>>,
-) -> Option<Hash<N>> {
-    pallas_hash.map(|h| to_hash(h))
-}
-
 /// Convert a Pallas Hash<28> reference to an Acropolis PoolId
 pub fn to_pool_id(pallas_hash: &pallas_primitives::Hash<28>) -> PoolId {
     to_hash(pallas_hash).into()
@@ -66,15 +59,6 @@ pub fn to_vrf_key(pallas_hash: &pallas_primitives::Hash<32>) -> VrfKeyHash {
     VrfKeyHash::try_from(pallas_hash.as_ref()).unwrap()
 }
 
-/// Convert a Pallas Bytes reference to an Acropolis Hash<N>
-/// Useful for genesis hash fields that might be stored as Bytes
-pub fn bytes_to_hash<const N: usize>(bytes: &pallas_primitives::Bytes) -> Hash<N> {
-    let slice: &[u8] = bytes.as_ref();
-    let mut array = [0u8; N];
-    array.copy_from_slice(&slice[..N]);
-    array.into()
-}
-
 /// Derive our Address from a Pallas address
 // This is essentially a 1:1 mapping but makes the Message definitions independent
 // of Pallas

common/src/snapshot/streaming_snapshot.rs

@@ -66,7 +66,7 @@ impl<'b, C> minicbor::decode::Decode<'b, C> for StakeCredential {
             0 => {
                 // ScriptHash variant (first in enum) - decode bytes directly
                 let bytes = d.bytes()?;
-                let key_hash = KeyHash::try_from(bytes).map_err(|_| {
+                let key_hash = bytes.try_into().map_err(|_| {
                     minicbor::decode::Error::message(
                         "invalid length for ScriptHash in StakeCredential",
                     )
@@ -76,7 +76,7 @@ impl<'b, C> minicbor::decode::Decode<'b, C> for StakeCredential {
             1 => {
                 // AddrKeyHash variant (second in enum) - decodes bytes directly
                 let bytes = d.bytes()?;
-                let key_hash = KeyHash::try_from(bytes).map_err(|_| {
+                let key_hash = bytes.try_into().map_err(|_| {
                     minicbor::decode::Error::message(
                         "invalid length for AddrKeyHash in StakeCredential",
                     )
@@ -309,7 +309,7 @@ impl<'b, C> minicbor::Decode<'b, C> for Account {
 
 pub use crate::types::AddrKeyhash;
 pub use crate::types::ScriptHash;
-use crate::{KeyHash, PoolId};
+use crate::{PoolId};
 /// Alias minicbor as cbor for pool_params module
 pub use minicbor as cbor;
 

common/src/types.rs

@@ -653,8 +653,10 @@ impl Credential {
                 hex_str
             ))
         } else {
-            KeyHash::try_from(key_hash.as_slice())
-                .map_err(|_| anyhow!("Failed to convert to KeyHash"))
+            key_hash
+                .as_slice()
+                .try_into()
+                .map_err(|e| anyhow!("Failed to convert to KeyHash {}", e))
         }
     }
 
@@ -695,12 +697,7 @@ impl Credential {
             ));
         }
 
-        let hash = KeyHash::try_from(data).map_err(|v| {
-            anyhow!(
-                "Failed to convert to KeyHash: expected 28 bytes, got {}",
-                v.len()
-            )
-        })?;
+        let hash = data.try_into().expect("failed to convert to fixed-size array");
 
         match hrp.as_str() {
             "drep" => Ok(Credential::AddrKeyHash(hash)),

modules/accounts_state/src/state.rs

@@ -1009,7 +1009,7 @@ mod tests {
         full_hash[..hash.len().min(28)].copy_from_slice(&hash[..hash.len().min(28)]);
         StakeAddress {
             network: NetworkId::Mainnet,
-            credential: StakeCredential::AddrKeyHash(KeyHash::try_from(full_hash).unwrap()),
+            credential: StakeCredential::AddrKeyHash(full_hash.try_into().unwrap()),
         }
     }
 

modules/accounts_state/src/verifier.rs

@@ -166,7 +166,7 @@ impl Verifier {
                     continue;
                 };
 
-                expected_rewards.entry(KeyHash::try_from(spo).unwrap()).or_default().push(
+                expected_rewards.entry(spo.try_into().unwrap()).or_default().push(
                     RewardDetail {
                         account: stake_address,
                         rtype,

modules/chain_store/src/chain_store.rs

@@ -12,7 +12,7 @@ use acropolis_common::{
     },
     queries::misc::Order,
     state_history::{StateHistory, StateHistoryStore},
-    BechOrdAddress, BlockHash, GenesisDelegate, HeavyDelegate, TxHash, VrfKeyHash,
+    BechOrdAddress, BlockHash, GenesisDelegate, HeavyDelegate, TxHash,
 };
 use anyhow::{bail, Result};
 use caryatid_sdk::{module, Context, Module};
@@ -413,7 +413,7 @@ impl ChainStore {
                 tx_count: decoded.tx_count() as u64,
                 output,
                 fees,
-                block_vrf: header.vrf_vkey().map(|key| VrfKeyHash::try_from(key).ok().unwrap()),
+                block_vrf: header.vrf_vkey().map(|key| key.try_into().ok().unwrap()),
                 op_cert,
                 op_cert_counter,
                 previous_block: header.previous_hash().map(|h| BlockHash::from(*h)),

modules/parameters_state/src/genesis_params.rs

@@ -1,5 +1,4 @@
 use crate::alonzo_genesis;
-use acropolis_common::types::ScriptHash;
 use acropolis_common::{
     protocol_params::{AlonzoParams, BabbageParams, ByronParams, ConwayParams, ShelleyParams},
     rational_number::{rational_number_from_f32, RationalNumber},
@@ -109,7 +108,7 @@ pub fn map_constitution(constitution: &conway::Constitution) -> Result<Constitut
     Ok(Constitution {
         anchor: map_anchor(&constitution.anchor)?,
         guardrail_script: Some(
-            ScriptHash::try_from(decode_hex_string(&constitution.script, 28)?).unwrap(),
+            decode_hex_string(&constitution.script, 28)?.try_into().unwrap(),
         ),
     })
 }

modules/stake_delta_filter/src/utils.rs

@@ -430,15 +430,15 @@ mod test {
     }
 
     pub fn script_to_hash<const N: usize>(pallas_hash: ScriptHash) -> Hash<N> {
-        Hash::try_from(pallas_hash.as_ref()).unwrap()
+        pallas_hash.as_ref().try_into().unwrap()
     }
 
     pub fn stake_to_hash<const N: usize>(pallas_hash: StakeKeyHash) -> Hash<N> {
-        Hash::try_from(pallas_hash.as_ref()).unwrap()
+        pallas_hash.as_ref().try_into().unwrap()
     }
 
     pub fn payment_to_hash<const N: usize>(pallas_hash: PaymentKeyHash) -> Hash<N> {
-        Hash::try_from(pallas_hash.as_ref()).unwrap()
+        pallas_hash.as_ref().try_into().unwrap()
     }
 
     /// Derive our Address from a Pallas address