Refactor: Replace VRFKey with VrfKeyHash across modules for consistency, update associated type aliases, imports, and serialization logic.

lowhung · lowhung · commit 727ffee86cc6 · 2025-10-28T16:10:41.000-07:00
diff --git a/codec/src/map_parameters.rs b/codec/src/map_parameters.rs
@@ -62,8 +62,8 @@ pub fn to_pool_id(pallas_hash: &pallas_primitives::Hash<28>) -> PoolId {
 }
 
 /// Convert a Pallas Hash<32> reference to an Acropolis VRFKey
-pub fn to_vrf_key(pallas_hash: &pallas_primitives::Hash<32>) -> VRFKey {
-    VRFKey::try_from(pallas_hash.as_ref()).unwrap()
+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>
@@ -89,20 +89,20 @@ pub fn map_address(address: &addresses::Address) -> Result<Address> {
 
             payment: match shelley_address.payment() {
                 addresses::ShelleyPaymentPart::Key(hash) => {
-                    ShelleyAddressPaymentPart::PaymentKeyHash(hash.to_vec().try_into().unwrap())
+                    ShelleyAddressPaymentPart::PaymentKeyHash(to_hash(hash))
                 }
                 addresses::ShelleyPaymentPart::Script(hash) => {
-                    ShelleyAddressPaymentPart::ScriptHash(hash.to_vec().try_into().unwrap())
+                    ShelleyAddressPaymentPart::ScriptHash(to_hash(hash))
                 }
             },
 
             delegation: match shelley_address.delegation() {
                 addresses::ShelleyDelegationPart::Null => ShelleyAddressDelegationPart::None,
                 addresses::ShelleyDelegationPart::Key(hash) => {
-                    ShelleyAddressDelegationPart::StakeKeyHash(hash.to_vec().try_into().unwrap())
+                    ShelleyAddressDelegationPart::StakeKeyHash(to_hash(hash))
                 }
                 addresses::ShelleyDelegationPart::Script(hash) => {
-                    ShelleyAddressDelegationPart::ScriptHash(hash.to_vec().try_into().unwrap())
+                    ShelleyAddressDelegationPart::ScriptHash(to_hash(hash))
                 }
                 addresses::ShelleyDelegationPart::Pointer(pointer) => {
                     ShelleyAddressDelegationPart::Pointer(ShelleyAddressPointer {
diff --git a/common/src/address.rs b/common/src/address.rs
@@ -211,25 +211,19 @@ impl ShelleyAddress {
 
             let header = *header;
 
+            let to_28_bytes = |slice: &[u8]| -> Result<KeyHash> {
+                slice.try_into().map_err(|_| anyhow!("Invalid hash"))
+            };
+
             let payment_part = match (header >> 4) & 0x01 {
-                0 => ShelleyAddressPaymentPart::PaymentKeyHash(
-                    data[1..29].try_into().map_err(|_| anyhow!("Invalid payment key hash size"))?,
-                ),
-                1 => ShelleyAddressPaymentPart::ScriptHash(
-                    data[1..29].try_into().map_err(|_| anyhow!("Invalid script hash size"))?,
-                ),
+                0 => ShelleyAddressPaymentPart::PaymentKeyHash(to_28_bytes(&data[1..29])?),
+                1 => ShelleyAddressPaymentPart::ScriptHash(to_28_bytes(&data[1..29])?),
                 _ => panic!(),
             };
 
             let delegation_part = match (header >> 5) & 0x03 {
-                0 => ShelleyAddressDelegationPart::StakeKeyHash(
-                    data[29..57].try_into().map_err(|_| anyhow!("Invalid stake key hash size"))?,
-                ),
-                1 => ShelleyAddressDelegationPart::ScriptHash(
-                    data[29..57]
-                        .try_into()
-                        .map_err(|_| anyhow!("Invalid delegation script hash size"))?,
-                ),
+                0 => ShelleyAddressDelegationPart::StakeKeyHash(to_28_bytes(&data[29..57])?),
+                1 => ShelleyAddressDelegationPart::ScriptHash(to_28_bytes(&data[29..57])?),
                 2 => {
                     let mut decoder = VarIntDecoder::new(&data[29..]);
                     let slot = decoder.read()?;
diff --git a/common/src/hash.rs b/common/src/hash.rs
@@ -262,13 +262,6 @@ impl<'a, C, const BYTES: usize> minicbor::Decode<'a, C> for Hash<BYTES> {
     }
 }
 
-// Type aliases for common hash sizes in Cardano
-/// A 28-byte hash used for scripts in Cardano addresses.
-pub type ScriptHash = Hash<28>;
-
-/// A 28-byte hash of an address key in Cardano.
-pub type AddrKeyhash = Hash<28>;
-
 /// Declares a type alias for a hash with optional documentation.
 ///
 /// # Examples
diff --git a/common/src/queries/blocks.rs b/common/src/queries/blocks.rs
@@ -1,7 +1,7 @@
 use crate::{
     queries::misc::Order,
     serialization::{Bech32Conversion, Bech32WithHrp},
-    Address, BlockHash, GenesisDelegate, HeavyDelegate, KeyHash, TxHash, TxIdentifier, VRFKey,
+    Address, BlockHash, GenesisDelegate, HeavyDelegate, KeyHash, TxHash, TxIdentifier, VrfKeyHash,
 };
 use cryptoxide::hashing::blake2b::Blake2b;
 use serde::ser::{Serialize, SerializeStruct, Serializer};
@@ -114,7 +114,7 @@ pub struct BlockInfo {
     pub tx_count: u64,
     pub output: Option<u64>,
     pub fees: Option<u64>,
-    pub block_vrf: Option<VRFKey>,
+    pub block_vrf: Option<VrfKeyHash>,
     pub op_cert: Option<KeyHash>,
     pub op_cert_counter: Option<u64>,
     pub previous_block: Option<BlockHash>,
diff --git a/common/src/snapshot/pool_params.rs b/common/src/snapshot/pool_params.rs
@@ -13,14 +13,15 @@
 // limitations under the License.
 
 use super::streaming_snapshot::{
-    cbor, AddrKeyhash, Coin, Nullable, PoolMetadata, Relay, RewardAccount, Set, UnitInterval,
+    cbor, Coin, Nullable, PoolMetadata, Relay, RewardAccount, Set, UnitInterval,
 };
-use crate::{PoolId, VRFKey};
+use crate::{PoolId, VrfKeyHash};
+use crate::types::AddrKeyhash;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub struct PoolParams {
     pub id: PoolId,
-    pub vrf: VRFKey,
+    pub vrf: VrfKeyHash,
     pub pledge: Coin,
     pub cost: Coin,
     pub margin: UnitInterval,
diff --git a/common/src/snapshot/streaming_snapshot.rs b/common/src/snapshot/streaming_snapshot.rs
@@ -29,7 +29,7 @@ use std::fs::File;
 use std::io::{Read, Seek, SeekFrom};
 use tracing::info;
 
-pub use crate::hash::{AddrKeyhash, Hash, ScriptHash};
+pub use crate::hash::Hash;
 pub use crate::stake_addresses::{AccountState, StakeAddressState};
 pub use crate::StakeCredential;
 
@@ -74,7 +74,7 @@ impl<'b, C> minicbor::decode::Decode<'b, C> for StakeCredential {
                 Ok(StakeCredential::ScriptHash(key_hash))
             }
             1 => {
-                // AddrKeyHash variant (second in enum) - decode bytes directly
+                // AddrKeyHash variant (second in enum) - decodes bytes directly
                 let bytes = d.bytes()?;
                 let key_hash = KeyHash::try_from(bytes).map_err(|_| {
                     minicbor::decode::Error::message(
@@ -307,6 +307,8 @@ impl<'b, C> minicbor::Decode<'b, C> for Account {
 // Type aliases for pool_params compatibility
 // -----------------------------------------------------------------------------
 
+pub use crate::types::AddrKeyhash;
+pub use crate::types::ScriptHash;
 use crate::{KeyHash, PoolId};
 /// Alias minicbor as cbor for pool_params module
 pub use minicbor as cbor;
@@ -1086,12 +1088,8 @@ impl StreamingSnapshotParser {
                 // Convert DRep delegation from StrictMaybe<DRep> to Option<DRepChoice>
                 let delegated_drep = match &account.drep {
                     StrictMaybe::Just(drep) => Some(match drep {
-                        DRep::Key(hash) => crate::DRepChoice::Key(
-                            KeyHash::try_from(hash.as_ref().to_vec()).unwrap(),
-                        ),
-                        DRep::Script(hash) => crate::DRepChoice::Script(
-                            KeyHash::try_from(hash.as_ref().to_vec()).unwrap(),
-                        ),
+                        DRep::Key(hash) => crate::DRepChoice::Key(*hash),
+                        DRep::Script(hash) => crate::DRepChoice::Script(*hash),
                         DRep::Abstain => crate::DRepChoice::Abstain,
                         DRep::NoConfidence => crate::DRepChoice::NoConfidence,
                     }),
@@ -1456,12 +1454,8 @@ impl StreamingSnapshotParser {
                 // Convert DRep delegation from StrictMaybe<DRep> to Option<DRepChoice>
                 let delegated_drep = match &account.drep {
                     StrictMaybe::Just(drep) => Some(match drep {
-                        DRep::Key(hash) => crate::DRepChoice::Key(
-                            KeyHash::try_from(hash.as_ref().to_vec()).unwrap(),
-                        ),
-                        DRep::Script(hash) => crate::DRepChoice::Script(
-                            KeyHash::try_from(hash.as_ref().to_vec()).unwrap(),
-                        ),
+                        DRep::Key(hash) => crate::DRepChoice::Key(*hash),
+                        DRep::Script(hash) => crate::DRepChoice::Script(*hash),
                         DRep::Abstain => crate::DRepChoice::Abstain,
                         DRep::NoConfidence => crate::DRepChoice::NoConfidence,
                     }),
diff --git a/common/src/types.rs b/common/src/types.rs
@@ -2,7 +2,7 @@
 // We don't use these types in the acropolis_common crate itself
 #![allow(dead_code)]
 
-use crate::hash::{AddrKeyhash, Hash, ScriptHash};
+use crate::hash::Hash;
 use crate::{
     address::{Address, ShelleyAddress, StakeAddress},
     declare_hash_newtype_with_bech32, declare_hash_type, declare_hash_type_with_bech32,
@@ -437,12 +437,15 @@ impl Default for UTXODelta {
 
 pub type KeyHash = Hash<28>;
 
+pub type ScriptHash = KeyHash;
+pub type AddrKeyhash = KeyHash;
+
 /// Script identifier
 pub type GenesisKeyhash = Vec<u8>;
 
 declare_hash_type!(BlockHash, 32);
 declare_hash_type!(TxHash, 32);
-declare_hash_newtype_with_bech32!(VRFKey, 32, "vrf_vk");
+declare_hash_newtype_with_bech32!(VrfKeyHash, 32, "vrf_vk");
 declare_hash_newtype_with_bech32!(PoolId, 28, "pool");
 declare_hash_newtype_with_bech32!(DrepKey, 28, "drep");
 declare_hash_type_with_bech32!(DrepScriptKey, 28, "drep_script");
@@ -844,7 +847,7 @@ pub struct PoolRegistration {
     /// VRF key hash
     #[serde_as(as = "Hex")]
     #[n(1)]
-    pub vrf_key_hash: VRFKey,
+    pub vrf_key_hash: VrfKeyHash,
 
     /// Pledged Ada
     #[n(2)]
@@ -989,7 +992,7 @@ pub struct GenesisKeyDelegation {
     pub genesis_delegate_hash: KeyHash,
 
     /// VRF key hash
-    pub vrf_key_hash: VRFKey,
+    pub vrf_key_hash: VrfKeyHash,
 }
 
 /// Source of a MIR
diff --git a/modules/accounts_state/src/spo_distribution_store.rs b/modules/accounts_state/src/spo_distribution_store.rs
@@ -1,6 +1,6 @@
 use std::collections::HashMap;
 
-use acropolis_common::hash::AddrKeyhash;
+use acropolis_common::types::AddrKeyhash;
 use acropolis_common::PoolId;
 use anyhow::Result;
 use fjall::{Config, Keyspace, PartitionCreateOptions};
@@ -224,7 +224,7 @@ impl SPDDStore {
 mod tests {
     use super::*;
     use acropolis_common::crypto::keyhash_224;
-    use acropolis_common::hash::AddrKeyhash;
+    use acropolis_common::types::AddrKeyhash;
     use acropolis_common::PoolId;
 
     const DB_PATH: &str = "spdd_db";
diff --git a/modules/accounts_state/src/state.rs b/modules/accounts_state/src/state.rs
@@ -996,7 +996,7 @@ mod tests {
         Anchor, Committee, Constitution, CostModel, DRepVotingThresholds, NetworkId,
         PoolVotingThresholds, Pot, PotDelta, Ratio, Registration, StakeAddress, StakeAddressDelta,
         StakeAndVoteDelegation, StakeCredential, StakeRegistrationAndStakeAndVoteDelegation,
-        StakeRegistrationAndVoteDelegation, VRFKey, VoteDelegation, Withdrawal,
+        StakeRegistrationAndVoteDelegation, VrfKeyHash, VoteDelegation, Withdrawal,
     };
 
     // Helper to create a StakeAddress from a byte slice
@@ -1017,8 +1017,8 @@ mod tests {
         keyhash_224(bytes)
     }
 
-    fn test_vrf_keyhash(byte: u8) -> VRFKey {
-        VRFKey::new(keyhash_256(&vec![byte]))
+    fn test_vrf_keyhash(byte: u8) -> VrfKeyHash {
+        VrfKeyHash::new(keyhash_256(&vec![byte]))
     }
 
     const STAKE_KEY_HASH: [u8; 3] = [0x99, 0x0f, 0x00];
diff --git a/modules/chain_store/src/chain_store.rs b/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, VRFKey,
+    BechOrdAddress, BlockHash, GenesisDelegate, HeavyDelegate, TxHash, VrfKeyHash,
 };
 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| VRFKey::try_from(key).ok().unwrap()),
+                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)),
diff --git a/modules/parameters_state/src/genesis_params.rs b/modules/parameters_state/src/genesis_params.rs
@@ -1,5 +1,5 @@
 use crate::alonzo_genesis;
-use acropolis_common::hash::ScriptHash;
+use acropolis_common::types::ScriptHash;
 use acropolis_common::{
     protocol_params::{AlonzoParams, BabbageParams, ByronParams, ConwayParams, ShelleyParams},
     rational_number::{rational_number_from_f32, RationalNumber},
diff --git a/modules/rest_blockfrost/src/handlers/epochs.rs b/modules/rest_blockfrost/src/handlers/epochs.rs
@@ -4,6 +4,7 @@ use crate::{
         EpochActivityRest, ProtocolParamsRest, SPDDByEpochAndPoolItemRest, SPDDByEpochItemRest,
     },
 };
+use acropolis_common::serialization::Bech32Conversion;
 use acropolis_common::{
     messages::{Message, RESTResponse, StateQuery, StateQueryResponse},
     queries::{
@@ -553,7 +554,7 @@ pub async fn handle_epoch_pool_stakes_blockfrost(
         }
     };
 
-    let Ok(pool_id) = Vec::<u8>::from_bech32_with_hrp(pool_id, "pool") else {
+    let Ok(pool_id) = PoolId::from_bech32(pool_id) else {
         return Ok(RESTResponse::with_text(
             400,
             &format!("Invalid Bech32 stake pool ID: {pool_id}"),
@@ -618,7 +619,7 @@ pub async fn handle_epoch_pool_stakes_blockfrost(
     let msg = Arc::new(Message::StateQuery(StateQuery::Accounts(
         AccountsStateQuery::GetSPDDByEpochAndPool {
             epoch: epoch_number,
-            pool_id: pool_id.try_into().unwrap(),
+            pool_id,
         },
     )));
     let spdd = query_state(
@@ -698,7 +699,7 @@ pub async fn handle_epoch_pool_blocks_blockfrost(
         }
     };
 
-    let Ok(spo) = Vec::<u8>::from_bech32_with_hrp(pool_id_param, "pool") else {
+    let Ok(spo) = PoolId::from_bech32(pool_id_param) else {
         return Ok(RESTResponse::with_text(
             400,
             &format!("Invalid Bech32 stake pool ID: {pool_id_param}"),
@@ -708,7 +709,7 @@ pub async fn handle_epoch_pool_blocks_blockfrost(
     // query Pool's Blocks by epoch from spo-state
     let msg = Arc::new(Message::StateQuery(StateQuery::Pools(
         PoolsStateQuery::GetBlocksByPoolAndEpoch {
-            pool_id: PoolId::try_from(spo.clone()).unwrap(),
+            pool_id: spo,
             epoch: epoch_number,
         },
     )));
diff --git a/modules/rest_blockfrost/src/types.rs b/modules/rest_blockfrost/src/types.rs
@@ -7,7 +7,7 @@ use acropolis_common::{
     rest_helper::ToCheckedF64,
     serialization::{DisplayFromBech32, PoolPrefix},
     AssetAddressEntry, AssetMetadataStandard, AssetMintRecord, KeyHash, PolicyAsset,
-    PoolEpochState, PoolUpdateAction, Relay, TxHash, VRFKey, Vote,
+    PoolEpochState, PoolUpdateAction, Relay, TxHash, VrfKeyHash, Vote,
 };
 use anyhow::Result;
 use num_traits::ToPrimitive;
@@ -432,7 +432,7 @@ pub struct PoolInfoRest {
     #[serde_as(as = "Hex")]
     pub hex: KeyHash,
     #[serde_as(as = "Hex")]
-    pub vrf_key: VRFKey,
+    pub vrf_key: VrfKeyHash,
     pub blocks_minted: u64,
     pub blocks_epoch: u64,
     #[serde_as(as = "DisplayFromStr")]
diff --git a/modules/spo_state/src/state.rs b/modules/spo_state/src/state.rs
@@ -682,7 +682,7 @@ mod tests {
     use acropolis_common::hash::Hash;
     use acropolis_common::{
         state_history::{StateHistory, StateHistoryStore},
-        PoolId, PoolRetirement, Ratio, StakeAddress, TxCertificate, TxHash, VRFKey,
+        PoolId, PoolRetirement, Ratio, StakeAddress, TxCertificate, TxHash, VrfKeyHash,
     };
     use tokio::sync::Mutex;
 
@@ -696,11 +696,11 @@ mod tests {
 
     fn default_pool_registration(
         operator: PoolId,
-        vrf_key_hash: Option<VRFKey>,
+        vrf_key_hash: Option<VrfKeyHash>,
     ) -> PoolRegistration {
         PoolRegistration {
             operator,
-            vrf_key_hash: vrf_key_hash.unwrap_or_else(|| VRFKey::default()),
+            vrf_key_hash: vrf_key_hash.unwrap_or_else(|| VrfKeyHash::default()),
             pledge: 0,
             cost: 0,
             margin: Ratio {
diff --git a/modules/upstream_chain_fetcher/src/body_fetcher.rs b/modules/upstream_chain_fetcher/src/body_fetcher.rs
@@ -1,7 +1,7 @@
 //! Acropolis Miniprotocols module for Caryatid
 //! Multi-connection, block body fetching part of the client (in separate thread).
 
-use acropolis_common::{messages::RawBlockMessage, BlockInfo, BlockStatus, Era};
+use acropolis_common::{messages::RawBlockMessage, BlockHash, BlockInfo, BlockStatus, Era};
 use anyhow::{bail, Result};
 use crossbeam::channel::{Receiver, TryRecvError};
 use pallas::{
@@ -117,7 +117,7 @@ impl BodyFetcher {
             }, // TODO vary with 'k'
             slot,
             number,
-            hash: hash.into(),
+            hash: BlockHash::new(hash),
             epoch,
             epoch_slot,
             new_epoch,

Original file line number	Diff line number	Diff line change
`@@ -62,8 +62,8 @@ pub fn to_pool_id(pallas_hash: &pallas_primitives::Hash<28>) -> PoolId {`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`/// Convert a Pallas Hash<32> reference to an Acropolis VRFKey`
`65`		`-pub fn to_vrf_key(pallas_hash: &pallas_primitives::Hash<32>) -> VRFKey {`
`66`		`- VRFKey::try_from(pallas_hash.as_ref()).unwrap()`
	`65`	`+pub fn to_vrf_key(pallas_hash: &pallas_primitives::Hash<32>) -> VrfKeyHash {`
	`66`	`+ VrfKeyHash::try_from(pallas_hash.as_ref()).unwrap()`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`/// Convert a Pallas Bytes reference to an Acropolis Hash<N>`
`@@ -89,20 +89,20 @@ pub fn map_address(address: &addresses::Address) -> Result<Address> {`
`89`	`89`
`90`	`90`	`payment: match shelley_address.payment() {`
`91`	`91`	`addresses::ShelleyPaymentPart::Key(hash) => {`
`92`		`- ShelleyAddressPaymentPart::PaymentKeyHash(hash.to_vec().try_into().unwrap())`
	`92`	`+ ShelleyAddressPaymentPart::PaymentKeyHash(to_hash(hash))`
`93`	`93`	`}`
`94`	`94`	`addresses::ShelleyPaymentPart::Script(hash) => {`
`95`		`- ShelleyAddressPaymentPart::ScriptHash(hash.to_vec().try_into().unwrap())`
	`95`	`+ ShelleyAddressPaymentPart::ScriptHash(to_hash(hash))`
`96`	`96`	`}`
`97`	`97`	`},`
`98`	`98`
`99`	`99`	`delegation: match shelley_address.delegation() {`
`100`	`100`	`addresses::ShelleyDelegationPart::Null => ShelleyAddressDelegationPart::None,`
`101`	`101`	`addresses::ShelleyDelegationPart::Key(hash) => {`
`102`		`- ShelleyAddressDelegationPart::StakeKeyHash(hash.to_vec().try_into().unwrap())`
	`102`	`+ ShelleyAddressDelegationPart::StakeKeyHash(to_hash(hash))`
`103`	`103`	`}`
`104`	`104`	`addresses::ShelleyDelegationPart::Script(hash) => {`
`105`		`- ShelleyAddressDelegationPart::ScriptHash(hash.to_vec().try_into().unwrap())`
	`105`	`+ ShelleyAddressDelegationPart::ScriptHash(to_hash(hash))`
`106`	`106`	`}`
`107`	`107`	`addresses::ShelleyDelegationPart::Pointer(pointer) => {`
`108`	`108`	`ShelleyAddressDelegationPart::Pointer(ShelleyAddressPointer {`
Original file line number	Diff line number	Diff line change
`@@ -262,13 +262,6 @@ impl<'a, C, const BYTES: usize> minicbor::Decode<'a, C> for Hash<BYTES> {`
`262`	`262`	`}`
`263`	`263`	`}`
`264`	`264`
`265`		`-// Type aliases for common hash sizes in Cardano`
`266`		`-/// A 28-byte hash used for scripts in Cardano addresses.`
`267`		`-pub type ScriptHash = Hash<28>;`
`268`		`-`
`269`		`-/// A 28-byte hash of an address key in Cardano.`
`270`		`-pub type AddrKeyhash = Hash<28>;`
`271`		`-`
`272`	`265`	`/// Declares a type alias for a hash with optional documentation.`
`273`	`266`	`///`
`274`	`267`	`/// # Examples`