Include the ledger hash in BlockProducerWonSlot (#192)

* feat(block_producer) rework epoch ledger hash representation + add it to BlockProducerWonSlot

* refactor(block_producer): remove unnecessary clone

Author: adonagy

Cargo.lock

@@ -1,6 +1,9 @@
 use mina_signer::Keypair;
 use node::{
-    block_producer::{vrf_evaluator::VrfEvaluatorInput, BlockProducerEvent},
+    block_producer::{
+        vrf_evaluator::{VrfEvaluationOutputWithHash, VrfEvaluatorInput},
+        BlockProducerEvent,
+    },
     event_source::Event,
 };
 use openmina_core::channels::mpsc::{UnboundedReceiver, UnboundedSender};
@@ -15,14 +18,6 @@ pub fn vrf_evaluator(
     keypair: Keypair,
 ) {
     while let Some(vrf_evaluator_input) = vrf_evaluation_receiver.blocking_recv() {
-        // TODO(adonagy): check correctness of epoch bound calculations
-        // const SLOT_PER_EPOCH: u32 = 7140;
-        // let epoch_num = vrf_evaluator_input.start_at_slot / SLOT_PER_EPOCH;
-        // let end = epoch_num * SLOT_PER_EPOCH + SLOT_PER_EPOCH;
-
-        // println!("[vrf] evaluating: {} - {}", vrf_evaluator_input.start_at_slot, end);
-
-        // let mut batch: Vec<VrfEvaluationOutput> = Vec::new();
         let mut vrf_result = VrfEvaluationOutput::SlotLost(vrf_evaluator_input.global_slot);
 
         for (index, account) in vrf_evaluator_input.delegatee_table.iter() {
@@ -42,10 +37,16 @@ pub fn vrf_evaluator(
                 break;
             }
         }
+        let vrf_result_with_hash = VrfEvaluationOutputWithHash::new(
+            vrf_result,
+            vrf_evaluator_input.staking_ledger_hash.clone(),
+        );
         // send the result back to the state machine
         let _ = event_sender.send(
-            BlockProducerEvent::VrfEvaluator(BlockProducerVrfEvaluatorEvent::Evaluated(vrf_result))
-                .into(),
+            BlockProducerEvent::VrfEvaluator(BlockProducerVrfEvaluatorEvent::Evaluated(
+                vrf_result_with_hash,
+            ))
+            .into(),
         );
     }
 }

node/native/src/block_producer/vrf_evaluator.rs

@@ -90,22 +90,21 @@ pub fn block_producer_effects<S: crate::Service>(
 
 impl BlockProducerBestTipUpdateAction {
     pub fn effects<S: redux::Service>(self, _: &ActionMeta, store: &mut Store<S>) {
+        let best_tip_staking_ledger = self.best_tip.staking_epoch_ledger_hash();
         let protocol_state = &self.best_tip.block.header.protocol_state.body;
 
-        let vrf_evaluator_epoch = store.state().block_producer.with(None, |this| {
-            Some(&this.vrf_evaluator.current_epoch_data.ledger)
-        });
+        let vrf_evaluator_current_epoch_ledger = store
+            .state()
+            .block_producer
+            .vrf_evaluator()
+            .and_then(|vrf_evaluator| {
+                vrf_evaluator
+                    .current_epoch_data
+                    .as_ref()
+                    .map(|epoch_data| &epoch_data.ledger)
+            });
 
-        if vrf_evaluator_epoch.cloned()
-            != Some(
-                protocol_state
-                    .consensus_state
-                    .staking_epoch_data
-                    .ledger
-                    .hash
-                    .to_string(),
-            )
-        {
+        if vrf_evaluator_current_epoch_ledger != Some(best_tip_staking_ledger) {
             store.dispatch(BlockProducerVrfEvaluatorEpochDataUpdateAction {
                 new_epoch_number: protocol_state.consensus_state.epoch_count.as_u32(),
                 epoch_data: protocol_state.consensus_state.staking_epoch_data.clone(),

node/src/block_producer/block_producer_effects.rs

@@ -38,6 +38,8 @@ use vrf::VrfWonSlot;
 
 use crate::account::AccountPublicKey;
 
+use self::vrf_evaluator::VrfWonSlotWithHash;
+
 #[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
 pub struct BlockProducerWonSlot {
     pub slot_time: redux::Timestamp,
@@ -49,11 +51,19 @@ pub struct BlockProducerWonSlot {
     // calculated on spot from `vrf_output`? Maybe with `vrf_output.blake2b()`?
     pub vrf_hash: BigInt,
     // Staking ledger which was used during vrf evaluation.
-    // pub staking_ledger_hash: LedgerHash,
+    pub staking_ledger_hash: LedgerHash,
 }
 
 impl BlockProducerWonSlot {
-    pub fn from_vrf_won_slot(won_slot: VrfWonSlot, genesis_timestamp: redux::Timestamp) -> Self {
+    pub fn from_vrf_won_slot(
+        won_slot_with_hash: VrfWonSlotWithHash,
+        genesis_timestamp: redux::Timestamp,
+    ) -> Self {
+        let VrfWonSlotWithHash {
+            won_slot,
+            staking_ledger_hash,
+        } = won_slot_with_hash;
+
         let slot_time = Self::calculate_slot_time(genesis_timestamp, won_slot.global_slot);
 
         let winner_pub_key = AccountPublicKey::from(
@@ -78,6 +88,7 @@ impl BlockProducerWonSlot {
             global_slot_since_genesis,
             vrf_output,
             vrf_hash,
+            staking_ledger_hash,
         }
     }
 

node/src/block_producer/mod.rs

@@ -87,6 +87,7 @@ impl redux::EnablingCondition<crate::State> for BlockProducerVrfEvaluatorEvaluat
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct BlockProducerVrfEvaluatorEvaluationSuccessAction {
     pub vrf_output: VrfEvaluationOutput,
+    pub staking_ledger_hash: LedgerHash,
 }
 
 impl redux::EnablingCondition<crate::State> for BlockProducerVrfEvaluatorEvaluationSuccessAction {

node/src/block_producer/vrf_evaluator/block_producer_vrf_evaluator_actions.rs

@@ -53,29 +53,32 @@ impl BlockProducerVrfEvaluatorEvaluationSuccessAction {
             // TODO(adonagy): Can we get this from somewhere?
             const SLOTS_PER_EPOCH: u32 = 7140;
             // determine the epoch of the slot
-            if let Some(current_epoch) = vrf_evaluator_state.current_epoch {
+            if let (Some(current_epoch), Some(current_epoch_data), Some(next_epoch_data)) = (
+                &vrf_evaluator_state.current_epoch,
+                &vrf_evaluator_state.current_epoch_data,
+                &vrf_evaluator_state.next_epoch_data,
+            ) {
                 let current_epoch_end = current_epoch * SLOTS_PER_EPOCH + SLOTS_PER_EPOCH - 1;
                 let next_epoch_end = (current_epoch + 1) * SLOTS_PER_EPOCH + SLOTS_PER_EPOCH - 1;
 
                 // slot is in the current epoch
                 if next_slot <= current_epoch_end {
                     let vrf_input: VrfEvaluatorInput = VrfEvaluatorInput::new(
-                        vrf_evaluator_state.current_epoch_data.seed.clone(),
-                        vrf_evaluator_state
-                            .current_epoch_data
-                            .delegator_table
-                            .clone(),
+                        current_epoch_data.seed.clone(),
+                        current_epoch_data.delegator_table.clone(),
                         next_slot,
-                        vrf_evaluator_state.current_epoch_data.total_currency,
+                        current_epoch_data.total_currency,
+                        current_epoch_data.ledger.clone(),
                     );
                     store.dispatch(BlockProducerVrfEvaluatorEvaluateVrfAction { vrf_input });
                 // slot is in the next epoch
                 } else if next_slot > current_epoch_end && next_slot <= next_epoch_end {
                     let vrf_input = VrfEvaluatorInput::new(
-                        vrf_evaluator_state.next_epoch_data.seed.clone(),
-                        vrf_evaluator_state.next_epoch_data.delegator_table.clone(),
+                        next_epoch_data.seed.clone(),
+                        next_epoch_data.delegator_table.clone(),
                         next_slot,
-                        vrf_evaluator_state.next_epoch_data.total_currency,
+                        next_epoch_data.total_currency,
+                        next_epoch_data.ledger.clone(),
                     );
                     store.dispatch(BlockProducerVrfEvaluatorEvaluateVrfAction { vrf_input });
                 }
@@ -113,16 +116,16 @@ impl BlockProducerVrfEvaluatorUpdateProducerAndDelegatesSuccessAction {
         let vrf_evaluator_state = store.state().block_producer.vrf_evaluator();
 
         if let Some(vrf_evaluator_state) = vrf_evaluator_state {
-            let vrf_input: VrfEvaluatorInput = VrfEvaluatorInput::new(
-                vrf_evaluator_state.current_epoch_data.seed.clone(),
-                vrf_evaluator_state
-                    .current_epoch_data
-                    .delegator_table
-                    .clone(),
-                vrf_evaluator_state.current_best_tip_slot + 1,
-                vrf_evaluator_state.current_epoch_data.total_currency,
-            );
-            store.dispatch(BlockProducerVrfEvaluatorEvaluateVrfAction { vrf_input });
+            if let Some(current_epoch_data) = &vrf_evaluator_state.current_epoch_data {
+                let vrf_input: VrfEvaluatorInput = VrfEvaluatorInput::new(
+                    current_epoch_data.seed.clone(),
+                    current_epoch_data.delegator_table.clone(),
+                    vrf_evaluator_state.current_best_tip_slot + 1,
+                    current_epoch_data.total_currency,
+                    current_epoch_data.ledger.clone(),
+                );
+                store.dispatch(BlockProducerVrfEvaluatorEvaluateVrfAction { vrf_input });
+            }
         }
     }
 }

node/src/block_producer/vrf_evaluator/block_producer_vrf_evaluator_effects.rs

@@ -1,9 +1,11 @@
 use serde::{Deserialize, Serialize};
 use vrf::VrfEvaluationOutput;
 
+use super::VrfEvaluationOutputWithHash;
+
 #[derive(derive_more::From, Serialize, Deserialize, Debug, Clone)]
 pub enum BlockProducerVrfEvaluatorEvent {
-    Evaluated(VrfEvaluationOutput),
+    Evaluated(VrfEvaluationOutputWithHash),
 }
 
 impl std::fmt::Display for BlockProducerVrfEvaluatorEvent {