fix(configs): parse directly into rational numbers (#437)

pallas-configs/Cargo.toml

@@ -20,6 +20,7 @@ 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"
+num-rational = "0.4.1"
 
 [features]
 json = ["serde", "serde_json"]

pallas-configs/src/shelley.rs

@@ -1,5 +1,26 @@
-use serde::Deserialize;
+use num_rational::BigRational;
-use std::collections::HashMap;
+use pallas_crypto::hash::Hash;
+use pallas_primitives::conway::RationalNumber;
+use serde::{Deserialize, Deserializer};
+use std::{collections::HashMap, str::FromStr};
+
+fn deserialize_rational<'de, D>(
+    deserializer: D,
+) -> Result<pallas_primitives::alonzo::RationalNumber, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let s = f32::deserialize(deserializer)?;
+    let r = BigRational::from_float(s)
+        .ok_or(serde::de::Error::custom("can't turn float into rational"))?;
+
+    let r = pallas_primitives::alonzo::RationalNumber {
+        numerator: r.numer().try_into().map_err(serde::de::Error::custom)?,
+        denominator: r.denom().try_into().map_err(serde::de::Error::custom)?,
+    };
+
+    Ok(r)
+}
 
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -21,10 +42,37 @@ impl From<ProtocolVersion> for pallas_primitives::alonzo::ProtocolVersion {
     }
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Deserialize, Clone)]
+pub enum NonceVariant {
+    NeutralNonce,
+    Nonce,
+}
+
+impl From<NonceVariant> for pallas_primitives::alonzo::NonceVariant {
+    fn from(value: NonceVariant) -> Self {
+        match value {
+            NonceVariant::NeutralNonce => Self::NeutralNonce,
+            NonceVariant::Nonce => Self::Nonce,
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Clone)]
 #[serde(rename_all = "camelCase")]
 pub struct ExtraEntropy {
-    pub tag: Option<String>,
+    pub tag: NonceVariant,
+    pub hash: Option<String>,
+}
+
+impl From<ExtraEntropy> for pallas_primitives::alonzo::Nonce {
+    fn from(value: ExtraEntropy) -> Self {
+        Self {
+            variant: value.tag.into(),
+            hash: value
+                .hash
+                .map(|x| Hash::<32>::from_str(&x).expect("invalid nonce hash value")),
+        }
+    }
 }
 
 #[derive(Debug, Deserialize)]
@@ -42,13 +90,20 @@ pub struct ProtocolParams {
     pub pool_deposit: u64,
     pub n_opt: u32,
     pub min_pool_cost: u64,
+    pub e_max: u32,
+    pub extra_entropy: ExtraEntropy,
 
-    pub decentralisation_param: Option<u32>,
+    #[serde(deserialize_with = "deserialize_rational")]
-    pub e_max: Option<u32>,
+    pub decentralisation_param: RationalNumber,
-    pub extra_entropy: Option<ExtraEntropy>,
+
-    pub rho: Option<f32>,
+    #[serde(deserialize_with = "deserialize_rational")]
-    pub tau: Option<f32>,
+    pub rho: pallas_primitives::alonzo::RationalNumber,
-    pub a0: Option<f32>,
+
+    #[serde(deserialize_with = "deserialize_rational")]
+    pub tau: pallas_primitives::alonzo::RationalNumber,
+
+    #[serde(deserialize_with = "deserialize_rational")]
+    pub a0: pallas_primitives::alonzo::RationalNumber,
 }
 
 #[derive(Debug, Deserialize)]