feat: implement epoch nonce calculation on epochs state

Author: golddydev

Cargo.lock

@@ -20,6 +20,18 @@ pub fn slot_to_epoch_with_shelley_params(
     }
 }
 
+pub fn epoch_to_first_slot_with_shelley_params(
+    epoch: u64,
+    shelley_epoch: u64,
+    shelley_epoch_len: u64,
+) -> u64 {
+    if epoch >= shelley_epoch {
+        shelley_epoch * BYRON_SLOTS_PER_EPOCH + (epoch - shelley_epoch) * shelley_epoch_len
+    } else {
+        epoch * BYRON_SLOTS_PER_EPOCH
+    }
+}
+
 pub fn slot_to_timestamp_with_params(slot: u64, byron_timestamp: u64, shelley_epoch: u64) -> u64 {
     let shelley_start_slot = shelley_epoch * BYRON_SLOTS_PER_EPOCH;
     if slot < shelley_start_slot {
@@ -42,6 +54,10 @@ mod tests {
         slot_to_epoch_with_shelley_params(slot, SHELLEY_START_EPOCH, SHELLEY_SLOTS_PER_EPOCH)
     }
 
+    fn epoch_to_first_slot(epoch: u64) -> u64 {
+        epoch_to_first_slot_with_shelley_params(epoch, SHELLEY_START_EPOCH, SHELLEY_SLOTS_PER_EPOCH)
+    }
+
     fn slot_to_timestamp(slot: u64) -> u64 {
         slot_to_timestamp_with_params(slot, BYRON_START_TIMESTAMP, SHELLEY_START_EPOCH)
     }
@@ -83,4 +99,12 @@ mod tests {
         assert_eq!(slot_to_epoch(98_272_003), (425, 35_203));
         assert_eq!(slot_to_timestamp(98_272_003), 1689838294);
     }
+
+    #[test]
+    fn epoch_to_first_slot_test() {
+        assert_eq!(slot_to_epoch(epoch_to_first_slot(208)), (208, 0));
+        assert_eq!(slot_to_epoch(epoch_to_first_slot(0)), (0, 0));
+        assert_eq!(slot_to_epoch(epoch_to_first_slot(209)), (209, 0));
+        assert_eq!(slot_to_epoch(epoch_to_first_slot(150)), (150, 0));
+    }
 }

common/src/calculations.rs

@@ -1,10 +1,16 @@
-use crate::calculations::{slot_to_epoch_with_shelley_params, slot_to_timestamp_with_params};
+use crate::calculations::{
+    epoch_to_first_slot_with_shelley_params, slot_to_epoch_with_shelley_params,
+    slot_to_timestamp_with_params,
+};
+const MAINNET_SHELLEY_GENESIS_HASH: &str =
+    "1a3be38bcbb7911969283716ad7aa550250226b76a61fc51cc9a9a35d9276d81";
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
 pub struct GenesisValues {
     pub byron_timestamp: u64,
     pub shelley_epoch: u64,
     pub shelley_epoch_len: u64,
+    pub shelley_genesis_hash: [u8; 32],
 }
 
 impl GenesisValues {
@@ -13,6 +19,7 @@ impl GenesisValues {
             byron_timestamp: 1506203091,
             shelley_epoch: 208,
             shelley_epoch_len: 432000,
+            shelley_genesis_hash: MAINNET_SHELLEY_GENESIS_HASH.as_bytes().try_into().unwrap(),
         }
     }
 
@@ -22,4 +29,8 @@ impl GenesisValues {
     pub fn slot_to_timestamp(&self, slot: u64) -> u64 {
         slot_to_timestamp_with_params(slot, self.byron_timestamp, self.shelley_epoch)
     }
+
+    pub fn epoch_to_first_slot(&self, epoch: u64) -> u64 {
+        epoch_to_first_slot_with_shelley_params(epoch, self.shelley_epoch, self.shelley_epoch_len)
+    }
 }

common/src/genesis_values.rs

@@ -5,7 +5,7 @@
 
 use crate::genesis_values::GenesisValues;
 use crate::ledger_state::SPOState;
-use crate::protocol_params::ProtocolParams;
+use crate::protocol_params::{Nonce, ProtocolParams};
 use crate::queries::parameters::{ParametersStateQuery, ParametersStateQueryResponse};
 use crate::queries::{
     accounts::{AccountsStateQuery, AccountsStateQueryResponse},
@@ -143,6 +143,9 @@ pub struct EpochActivityMessage {
     /// List of all VRF vkey hashes used on blocks (SPO indicator) and
     /// number of blocks produced
     pub vrf_vkey_hashes: Vec<(KeyHash, usize)>,
+
+    /// Nonce
+    pub nonce: Option<Nonce>,
 }
 
 #[derive(Debug, Default, Clone, serde::Serialize, serde::Deserialize)]

common/src/messages.rs

@@ -1,8 +1,11 @@
 use crate::{
+    genesis_values::GenesisValues,
     rational_number::{ChameleonFraction, RationalNumber},
-    BlockVersionData, Committee, Constitution, CostModel, DRepVotingThresholds, ExUnitPrices,
-    ExUnits, PoolVotingThresholds, ProtocolConsts,
+    BlockVersionData, Committee, Constitution, CostModel, DRepVotingThresholds, Era, ExUnitPrices,
+    ExUnits, NetworkId, PoolVotingThresholds, ProtocolConsts,
 };
+use anyhow::Result;
+use blake2::{digest::consts::U32, Blake2b, Digest};
 use chrono::{DateTime, Utc};
 use serde_with::serde_as;
 
@@ -95,12 +98,6 @@ pub struct ShelleyProtocolParams {
     pub pool_pledge_influence: RationalNumber,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
-pub enum NetworkId {
-    Testnet,
-    Mainnet,
-}
-
 #[serde_as]
 #[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
@@ -127,6 +124,55 @@ pub struct ShelleyParams {
     pub update_quorum: u32,
 }
 
+#[serde_as]
+#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PraosParams {
+    pub security_param: u32,
+    #[serde_as(as = "ChameleonFraction")]
+    pub active_slots_coeff: RationalNumber,
+    pub epoch_length: u32,
+    pub max_kes_evolutions: u32,
+    pub max_lovelace_supply: u64,
+    pub network_id: NetworkId,
+    pub slot_length: u32,
+    pub slots_per_kes_period: u32,
+
+    /// Relative slot from which data of the previous epoch can be considered stable.
+    /// This value is used for all TPraos eras AND Babbage Era from Praos
+    pub stability_window: u64,
+
+    /// Number of slots at the end of each epoch which do NOT contribute randomness to the candidate
+    /// nonce of the following epoch.
+    /// This value is used for all Praos eras except Babbage
+    pub randomness_stabilization_window: u64,
+}
+
+impl From<&ShelleyParams> for PraosParams {
+    fn from(params: &ShelleyParams) -> Self {
+        let active_slots_coeff = params.active_slots_coeff;
+        let security_param = params.security_param;
+        let stability_window =
+            (security_param as u64) * active_slots_coeff.denom() / active_slots_coeff.numer() * 3;
+        let randomness_stabilization_window =
+            (security_param as u64) * active_slots_coeff.denom() / active_slots_coeff.numer() * 4;
+
+        Self {
+            security_param: security_param,
+            active_slots_coeff: active_slots_coeff,
+            epoch_length: params.epoch_length,
+            max_kes_evolutions: params.max_kes_evolutions,
+            max_lovelace_supply: params.max_lovelace_supply,
+            network_id: params.network_id.clone(),
+            slot_length: params.slot_length,
+            slots_per_kes_period: params.slots_per_kes_period,
+
+            stability_window: stability_window,
+            randomness_stabilization_window: randomness_stabilization_window,
+        }
+    }
+}
+
 //
 // Babbage protocol parameters
 //
@@ -164,16 +210,133 @@ pub struct ProtocolVersion {
     pub major: u64,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[derive(
+    Default, Debug, Clone, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize,
+)]
 #[serde(rename_all = "PascalCase")]
 pub enum NonceVariant {
+    #[default]
     NeutralNonce,
     Nonce,
 }
 
-#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub type NonceHash = [u8; 32];
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Nonce {
     pub tag: NonceVariant,
-    pub hash: Option<Vec<u8>>,
+    pub hash: Option<NonceHash>,
+}
+
+impl Default for Nonce {
+    fn default() -> Self {
+        Self {
+            tag: NonceVariant::NeutralNonce,
+            hash: None,
+        }
+    }
+}
+
+impl From<NonceHash> for Nonce {
+    fn from(hash: NonceHash) -> Self {
+        Self {
+            tag: NonceVariant::Nonce,
+            hash: Some(hash),
+        }
+    }
+}
+
+#[derive(
+    Default, Debug, PartialEq, Eq, PartialOrd, Ord, Clone, serde::Serialize, serde::Deserialize,
+)]
+pub struct Nonces {
+    pub epoch: u64,
+    pub active: Nonce,
+    pub evolving: Nonce,
+    pub candidate: Nonce,
+    // Nonce constructed from the hash of the Last Applied Block
+    pub lab: Nonce,
+    // Nonce corresponding to the LAB nonce of the last block of the previous epoch
+    pub prev_lab: Nonce,
+}
+
+impl Nonces {
+    pub fn shelley_genesis_nonces(genesis: &GenesisValues) -> Nonces {
+        Nonces {
+            epoch: genesis.shelley_epoch,
+            active: genesis.shelley_genesis_hash.into(),
+            evolving: genesis.shelley_genesis_hash.into(),
+            candidate: genesis.shelley_genesis_hash.into(),
+            lab: Nonce::default(),
+            prev_lab: Nonce::default(),
+        }
+    }
+
+    pub fn from_candidate(candidate: &Nonce, prev_lab: &Nonce) -> Result<Nonce> {
+        let Some(candidate_hash) = candidate.hash.as_ref() else {
+            return Err(anyhow::anyhow!("Candidate hash is not set"));
+        };
+
+        // if prev_lab is Neutral then just return candidate
+        // this is for second shelley epoch boundary (from 208 to 209 in mainnet)
+        match prev_lab.tag {
+            NonceVariant::NeutralNonce => {
+                return Ok(candidate.clone());
+            }
+            NonceVariant::Nonce => {
+                let Some(prev_lab_hash) = prev_lab.hash.as_ref() else {
+                    return Err(anyhow::anyhow!("Prev lab hash is not set"));
+                };
+                let mut hasher = Blake2b::<U32>::new();
+                hasher.update(&[&candidate_hash.clone()[..], &prev_lab_hash.clone()[..]].concat());
+                let hash: NonceHash = hasher.finalize().into();
+                Ok(Nonce::from(hash))
+            }
+        }
+    }
+
+    /// Evolve the current nonce by combining it with the current rolling nonce and the
+    /// range-extended tagged leader VRF output.
+    ///
+    /// Specifically, we combine it with `η` (a.k.a eta), which is a blake2b-256 hash of the
+    /// tagged leader VRF output after a range extension. The range extension is, yet another
+    /// blake2b-256 hash.
+    pub fn evolve(current: &Nonce, nonce_vrf_output: &Vec<u8>,) -> Result<Nonce> {
+        // first hash nonce_vrf_output
+        let mut hasher = Blake2b::<U32>::new();
+        hasher.update(nonce_vrf_output.as_slice());
+        let nonce_vrf_output_hash: [u8; 32] = hasher.finalize().into();
+
+        match current.hash.as_ref() {
+            Some(nonce) => {
+                let mut hasher = Blake2b::<U32>::new();
+                hasher.update(&[&nonce.clone()[..], &nonce_vrf_output_hash[..]].concat());
+                let hash: NonceHash = hasher.finalize().into();
+                Ok(Nonce::from(hash))
+            }
+            _ => Err(anyhow::anyhow!("Current nonce is not set")),
+        }
+    }
+
+    pub fn randomness_stability_window(
+        era: Era,
+        slot: u64,
+        genesis: &GenesisValues,
+        params: &PraosParams,
+    ) -> bool {
+        let (epoch, _) = genesis.slot_to_epoch(slot);
+        let next_epoch_first_slot = genesis.epoch_to_first_slot(epoch + 1);
+
+        // For Praos in Babbage (just as in all TPraos eras) we use the
+        // smaller (3k/f vs 4k/f slots) stability window here for
+        // backwards-compatibility. See erratum 17.3 in the Shelley ledger
+        // specs for context
+        let window = match era {
+            Era::Conway => params.randomness_stabilization_window,
+            _ => params.stability_window,
+        };
+
+        slot + window < next_epoch_first_slot
+    }
 }

common/src/protocol_params.rs

@@ -18,6 +18,13 @@ use std::collections::{HashMap, HashSet};
 use std::fmt::{Display, Formatter};
 use std::ops::Neg;
 
+#[derive(Default, Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub enum NetworkId {
+    Testnet,
+    #[default]
+    Mainnet,
+}
+
 /// Protocol era
 #[derive(
     Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, serde::Serialize, serde::Deserialize,

common/src/types.rs

@@ -107,9 +107,10 @@ fn calculate_monetary_expansion(
 mod tests {
     use super::*;
     use acropolis_common::protocol_params::{
-        NetworkId, Nonce, NonceVariant, ProtocolVersion, ShelleyProtocolParams,
+        Nonce, NonceVariant, ProtocolVersion, ShelleyProtocolParams,
     };
     use acropolis_common::rational_number::rational_number_from_f32;
+    use acropolis_common::NetworkId;
     use chrono::{DateTime, Utc};
 
     // Known values at start of Shelley - from Java reference and DBSync

modules/accounts_state/src/monetary.rs

@@ -94,6 +94,7 @@ mod tests {
                 total_blocks: 1,
                 total_fees: 50,
                 vrf_vkey_hashes: vec![],
+                nonce: None,
             },
         );