feat(configs): add serde for Alonzo genesis file (#436)

pallas-configs/Cargo.toml

@@ -15,9 +15,11 @@ hex = "0.4.3"
 pallas-addresses = { version = "=0.25.0", path = "../pallas-addresses" }
 pallas-crypto = { version = "=0.25.0", path = "../pallas-crypto" }
 pallas-codec = { version = "=0.25.0", path = "../pallas-codec" }
+pallas-primitives = { version = "=0.25.0", path = "../pallas-primitives" }
 serde = { version = "1.0.136", optional = true, features = ["derive"] }
 serde_json = { version = "1.0.79", optional = true }
 base64 = "0.22.0"
+serde_with = "3.7.0"
 
 [features]
 json = ["serde", "serde_json"]

pallas-configs/src/alonzo.rs

@@ -0,0 +1,132 @@
+use serde::Deserialize;
+use std::collections::HashMap;
+
+#[derive(Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct ExecutionPrices {
+    pub pr_steps: Fraction,
+    pub pr_mem: Fraction,
+}
+
+impl From<ExecutionPrices> for pallas_primitives::alonzo::ExUnitPrices {
+    fn from(value: ExecutionPrices) -> Self {
+        Self {
+            mem_price: value.pr_mem.into(),
+            step_price: value.pr_steps.into(),
+        }
+    }
+}
+
+#[derive(Deserialize, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct ExUnits {
+    pub ex_units_mem: u32,
+    pub ex_units_steps: u64,
+}
+
+impl From<ExUnits> for pallas_primitives::alonzo::ExUnits {
+    fn from(value: ExUnits) -> Self {
+        Self {
+            mem: value.ex_units_mem,
+            steps: value.ex_units_steps,
+        }
+    }
+}
+
+#[derive(Deserialize, Clone)]
+pub struct Fraction {
+    pub numerator: u64,
+    pub denominator: u64,
+}
+
+impl From<Fraction> for pallas_primitives::alonzo::RationalNumber {
+    fn from(value: Fraction) -> Self {
+        Self {
+            numerator: value.numerator,
+            denominator: value.denominator,
+        }
+    }
+}
+
+#[derive(Deserialize, PartialEq, Eq, Hash, Clone)]
+pub enum Language {
+    PlutusV1,
+}
+
+impl From<Language> for pallas_primitives::alonzo::Language {
+    fn from(value: Language) -> Self {
+        match value {
+            Language::PlutusV1 => Self::PlutusV1,
+        }
+    }
+}
+
+#[derive(Deserialize, Clone)]
+pub struct CostModel(HashMap<String, i64>);
+
+impl From<CostModel> for pallas_primitives::alonzo::CostModel {
+    fn from(value: CostModel) -> Self {
+        value.0.into_values().collect()
+    }
+}
+
+#[derive(Deserialize, Clone)]
+pub struct CostModelPerLanguage(HashMap<Language, CostModel>);
+
+impl From<CostModelPerLanguage> for pallas_primitives::alonzo::CostMdls {
+    fn from(value: CostModelPerLanguage) -> Self {
+        let inner = value
+            .0
+            .into_iter()
+            .map(|(k, v)| (k.into(), v.into()))
+            .collect();
+
+        Self::Def(inner)
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GenesisFile {
+    #[serde(rename = "lovelacePerUTxOWord")]
+    pub lovelace_per_utxo_word: u64,
+    pub execution_prices: ExecutionPrices,
+    pub max_tx_ex_units: ExUnits,
+    pub max_block_ex_units: ExUnits,
+    pub max_value_size: u32,
+    pub collateral_percentage: u32,
+    pub max_collateral_inputs: u32,
+    pub cost_models: CostModelPerLanguage,
+}
+
+pub fn from_file(path: &std::path::Path) -> Result<GenesisFile, std::io::Error> {
+    let file = std::fs::File::open(path)?;
+    let reader = std::io::BufReader::new(file);
+    let parsed: GenesisFile = serde_json::from_reader(reader)?;
+
+    Ok(parsed)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn load_test_data_config(network: &str) -> GenesisFile {
+        let path = std::path::PathBuf::from(std::env::var("CARGO_MANIFEST_DIR").unwrap())
+            .join("..")
+            .join("test_data")
+            .join(format!("{network}-alonzo-genesis.json"));
+
+        from_file(&path).unwrap()
+    }
+
+    #[test]
+    fn test_preview_json_loads() {
+        load_test_data_config("preview");
+    }
+
+    #[test]
+    fn test_mainnet_json_loads() {
+        load_test_data_config("mainnet");
+    }
+}

pallas-configs/src/byron.rs

@@ -3,6 +3,8 @@
 use pallas_addresses::ByronAddress;
 use pallas_crypto::hash::Hash;
 use serde::Deserialize;
+use serde_with::serde_as;
+use serde_with::DisplayFromStr;
 use std::collections::HashMap;
 
 #[derive(Debug, Deserialize)]
@@ -19,23 +21,47 @@ pub struct GenesisFile {
     pub vss_certs: Option<HashMap<String, VssCert>>,
 }
 
-#[derive(Debug, Deserialize)]
+#[serde_as]
+#[derive(Debug, Deserialize, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct BlockVersionData {
-    pub heavy_del_thd: String,
-    pub max_block_size: String,
-    pub max_header_size: String,
-    pub max_proposal_size: String,
-    pub max_tx_size: String,
-    pub mpc_thd: String,
-    pub script_version: u32,
-    pub slot_duration: String,
+    pub script_version: u16,
+
+    #[serde_as(as = "DisplayFromStr")]
+    pub heavy_del_thd: u64,
+
+    #[serde_as(as = "DisplayFromStr")]
+    pub max_block_size: u64,
+
+    #[serde_as(as = "DisplayFromStr")]
+    pub max_header_size: u64,
+
+    #[serde_as(as = "DisplayFromStr")]
+    pub max_proposal_size: u64,
+
+    #[serde_as(as = "DisplayFromStr")]
+    pub max_tx_size: u64,
+
+    #[serde_as(as = "DisplayFromStr")]
+    pub mpc_thd: u64,
+
+    #[serde_as(as = "DisplayFromStr")]
+    pub slot_duration: u64,
+
     pub softfork_rule: SoftForkRule,
     pub tx_fee_policy: TxFeePolicy,
-    pub unlock_stake_epoch: String,
-    pub update_implicit: String,
-    pub update_proposal_thd: String,
-    pub update_vote_thd: String,
+
+    #[serde_as(as = "DisplayFromStr")]
+    pub unlock_stake_epoch: u64,
+
+    #[serde_as(as = "DisplayFromStr")]
+    pub update_implicit: u64,
+
+    #[serde_as(as = "DisplayFromStr")]
+    pub update_proposal_thd: u64,
+
+    #[serde_as(as = "DisplayFromStr")]
+    pub update_vote_thd: u64,
 }
 
 #[derive(Debug, Deserialize)]
@@ -69,18 +95,34 @@ pub struct VssCert {
     pub signing_key: String,
 }
 
-#[derive(Debug, Deserialize)]
+#[serde_as]
+#[derive(Debug, Deserialize, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct SoftForkRule {
-    pub init_thd: String,
-    pub min_thd: String,
-    pub thd_decrement: String,
+    #[serde_as(as = "DisplayFromStr")]
+    pub init_thd: u64,
+
+    #[serde_as(as = "DisplayFromStr")]
+    pub min_thd: u64,
+
+    #[serde_as(as = "DisplayFromStr")]
+    pub thd_decrement: u64,
 }
 
-#[derive(Debug, Deserialize)]
+impl From<SoftForkRule> for (u64, u64, u64) {
+    fn from(value: SoftForkRule) -> Self {
+        (value.init_thd, value.min_thd, value.thd_decrement)
+    }
+}
+
+#[serde_as]
+#[derive(Debug, Deserialize, Clone)]
 pub struct TxFeePolicy {
-    pub multiplier: String,
-    pub summand: String,
+    #[serde_as(as = "DisplayFromStr")]
+    pub multiplier: u64,
+
+    #[serde_as(as = "DisplayFromStr")]
+    pub summand: u64,
 }
 
 pub fn from_file(path: &std::path::Path) -> Result<GenesisFile, std::io::Error> {

pallas-configs/src/lib.rs

@@ -1,4 +1,5 @@
 //! Genesis data structs and utilities
 
+pub mod alonzo;
 pub mod byron;
 pub mod shelley;

pallas-configs/src/shelley.rs

@@ -8,11 +8,17 @@ pub struct GenDelegs {
     pub vrf: Option<String>,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Deserialize, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct ProtocolVersion {
-    pub minor: Option<u32>,
-    pub major: Option<u32>,
+    pub minor: u64,
+    pub major: u64,
+}
+
+impl From<ProtocolVersion> for pallas_primitives::alonzo::ProtocolVersion {
+    fn from(value: ProtocolVersion) -> Self {
+        (value.major, value.minor)
+    }
 }
 
 #[derive(Debug, Deserialize)]
@@ -24,20 +30,22 @@ pub struct ExtraEntropy {
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct ProtocolParams {
-    pub protocol_version: Option<ProtocolVersion>,
+    pub protocol_version: ProtocolVersion,
+    pub max_tx_size: u32,
+    pub max_block_body_size: u32,
+    pub max_block_header_size: u32,
+    pub key_deposit: u64,
+    #[serde(rename = "minUTxOValue")]
+    pub min_utxo_value: u64,
+    pub min_fee_a: u32,
+    pub min_fee_b: u32,
+    pub pool_deposit: u64,
+    pub n_opt: u32,
+    pub min_pool_cost: u64,
+
     pub decentralisation_param: Option<u32>,
     pub e_max: Option<u32>,
     pub extra_entropy: Option<ExtraEntropy>,
-    pub max_tx_size: u64,
-    pub max_block_body_size: Option<u32>,
-    pub max_block_header_size: Option<u32>,
-    pub min_fee_a: u64,
-    pub min_fee_b: u64,
-    pub min_u_tx_o_value: u64,
-    pub pool_deposit: Option<u64>,
-    pub min_pool_cost: Option<u64>,
-    pub key_deposit: Option<u32>,
-    pub n_opt: Option<u32>,
     pub rho: Option<f32>,
     pub tau: Option<f32>,
     pub a0: Option<f32>,