Connect vrf and block producer (#184)

* WIP: connect vrf and block producer

* Add slot time calculation for won slot

* chore: cargo fmt

Author: adonagy

Cargo.lock

@@ -69,6 +69,10 @@ impl<T: AsRef<Block>> BlockWithHash<T> {
         timestamp(self.header())
     }
 
+    pub fn genesis_timestamp(&self) -> Timestamp {
+        genesis_timestamp(self.header())
+    }
+
     pub fn constants(&self) -> &MinaBaseProtocolConstantsCheckedValueStableV1 {
         constants(self.header())
     }
@@ -191,6 +195,10 @@ impl<T: AsRef<BlockHeader>> BlockHeaderWithHash<T> {
         timestamp(self.header())
     }
 
+    pub fn genesis_timestamp(&self) -> Timestamp {
+        genesis_timestamp(self.header())
+    }
+
     pub fn constants(&self) -> &MinaBaseProtocolConstantsCheckedValueStableV1 {
         constants(self.header())
     }
@@ -241,6 +249,11 @@ fn timestamp(header: &BlockHeader) -> Timestamp {
     Timestamp::new(time_ms * 1_000_000)
 }
 
+fn genesis_timestamp(header: &BlockHeader) -> Timestamp {
+    let genesis_timestamp = constants(header).genesis_state_timestamp.0.as_u64();
+    Timestamp::new(genesis_timestamp * 1_000_000)
+}
+
 fn constants(header: &BlockHeader) -> &MinaBaseProtocolConstantsCheckedValueStableV1 {
     &header.protocol_state.body.constants
 }

core/src/block.rs

@@ -1,12 +1,10 @@
 mod vrf_evaluator;
 
 use mina_signer::Keypair;
-use node::core::channels::mpsc;
+use node::{core::channels::mpsc, block_producer::vrf_evaluator::VrfEvaluatorInput};
 
 use crate::NodeService;
 
-use vrf::VrfEvaluatorInput;
-
 pub struct BlockProducerService {
     vrf_evaluation_sender: mpsc::UnboundedSender<VrfEvaluatorInput>,
 }

node/native/src/block_producer/mod.rs

@@ -1,7 +1,7 @@
 use mina_signer::Keypair;
-use node::{block_producer::BlockProducerEvent, event_source::Event};
+use node::{block_producer::{BlockProducerEvent, vrf_evaluator::VrfEvaluatorInput}, event_source::Event};
 use openmina_core::channels::mpsc::{UnboundedReceiver, UnboundedSender};
-use vrf::{VrfEvaluationInput, VrfEvaluationOutput, VrfEvaluatorInput};
+use vrf::{VrfEvaluationInput, VrfEvaluationOutput};
 
 use crate::NodeService;
 use node::block_producer::BlockProducerVrfEvaluatorEvent;
@@ -26,9 +26,9 @@ pub fn vrf_evaluator(
             let vrf_input = VrfEvaluationInput::new(
                 keypair.clone(),
                 vrf_evaluator_input.epoch_seed.clone(),
-                account.0.clone(),
+                account.0.to_string(),
                 vrf_evaluator_input.global_slot,
-                index.as_u64(),
+                index.clone(),
                 account.1.into(),
                 vrf_evaluator_input.total_currency.into(),
             );

node/native/src/block_producer/vrf_evaluator.rs

@@ -12,9 +12,10 @@ use super::{
     BlockProducerBlockProducedAction, BlockProducerBlockUnprovenBuildAction, BlockProducerService,
     BlockProducerStagedLedgerDiffCreateInitAction,
     BlockProducerStagedLedgerDiffCreatePendingAction,
-    BlockProducerStagedLedgerDiffCreateSuccessAction, BlockProducerWonSlotAction,
-    BlockProducerWonSlotDiscardAction, BlockProducerWonSlotProduceInitAction,
-    BlockProducerWonSlotSearchAction, BlockProducerWonSlotWaitAction,
+    BlockProducerStagedLedgerDiffCreateSuccessAction, BlockProducerWonSlot,
+    BlockProducerWonSlotAction, BlockProducerWonSlotDiscardAction,
+    BlockProducerWonSlotProduceInitAction, BlockProducerWonSlotSearchAction,
+    BlockProducerWonSlotWaitAction,
 };
 
 pub fn block_producer_effects<S: crate::Service>(
@@ -120,11 +121,23 @@ impl BlockProducerBestTipUpdateAction {
 
 impl BlockProducerWonSlotSearchAction {
     pub fn effects<S: redux::Service>(self, _: &ActionMeta, store: &mut Store<S>) {
-        // TODO(adonagy): find next slot in `won_slots`, for which global
-        // slot is higher then current best tip. It can be in the future,
-        // doesn't have to be next slot.
-        //
-        // store.dispatch(BlockProducerWonSlotAction { won_slot });
+        let vrf_evaluator_state = store.state().block_producer.vrf_evaluator();
+
+        if let Some(vrf_evaluator_state) = vrf_evaluator_state {
+            if let Some((_, won_slot)) = vrf_evaluator_state
+                .won_slots
+                .range(vrf_evaluator_state.current_best_tip_slot + 1..)
+                .next()
+            {
+                let genesis_timestamp = vrf_evaluator_state.genesis_timestamp;
+                store.dispatch(BlockProducerWonSlotAction {
+                    won_slot: BlockProducerWonSlot::from_vrf_won_slot(
+                        won_slot.clone(),
+                        genesis_timestamp,
+                    ),
+                });
+            }
+        }
     }
 }
 

node/src/block_producer/block_producer_effects.rs

@@ -57,6 +57,12 @@ impl BlockProducerEnabled {
                     .curr_global_slot
                     .slot_number
                     .as_u32();
+
+                // set the genesis timestamp on the first best tip update
+                // TODO: move/remove once we can generate the genesis block
+                if self.vrf_evaluator.genesis_timestamp == redux::Timestamp::ZERO {
+                    self.vrf_evaluator.genesis_timestamp = action.best_tip.genesis_timestamp();
+                }
             }
             BlockProducerAction::WonSlotSearch(_) => {}
             BlockProducerAction::WonSlot(action) => {

node/src/block_producer/block_producer_reducer.rs

@@ -26,12 +26,17 @@ use mina_p2p_messages::{
     bigint::BigInt,
     v2::{
         BlockTimeTimeStableV1, ConsensusGlobalSlotStableV1, ConsensusVrfOutputTruncatedStableV1,
-        LedgerHash, MinaNumbersGlobalSlotSinceGenesisMStableV1, NonZeroCurvePoint,
+        LedgerHash, MinaNumbersGlobalSlotSinceGenesisMStableV1,
+        MinaNumbersGlobalSlotSinceHardForkMStableV1, NonZeroCurvePoint,
         UnsignedExtendedUInt64Int64ForVersionTagsStableV1,
     },
 };
+use mina_signer::CompressedPubKey;
 use openmina_core::block::ArcBlockWithHash;
 use serde::{Deserialize, Serialize};
+use vrf::VrfWonSlot;
+
+use crate::account::AccountPublicKey;
 
 #[derive(Serialize, Deserialize, Debug, PartialEq, Clone)]
 pub struct BlockProducerWonSlot {
@@ -43,11 +48,45 @@ pub struct BlockProducerWonSlot {
     // TODO(adonagy): maybe instead of passing it here, it can be
     // 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,
+    // Staking ledger which was used during vrf evaluation.
+    // pub staking_ledger_hash: LedgerHash,
 }
 
 impl BlockProducerWonSlot {
+    pub fn from_vrf_won_slot(won_slot: VrfWonSlot, genesis_timestamp: redux::Timestamp) -> Self {
+        let slot_time = Self::calculate_slot_time(genesis_timestamp, won_slot.global_slot);
+
+        let winner_pub_key = AccountPublicKey::from(
+            CompressedPubKey::from_address(&won_slot.winner_account).unwrap(),
+        );
+        let delegator = (winner_pub_key.into(), won_slot.account_index.clone());
+        let global_slot = ConsensusGlobalSlotStableV1 {
+            slot_number: MinaNumbersGlobalSlotSinceHardForkMStableV1::SinceHardFork(
+                won_slot.global_slot.into(),
+            ),
+            slots_per_epoch: 7140.into(), // TODO
+        };
+        let global_slot_since_genesis =
+            MinaNumbersGlobalSlotSinceGenesisMStableV1::SinceGenesis(won_slot.global_slot.into());
+
+        let vrf_output = ConsensusVrfOutputTruncatedStableV1(won_slot.vrf_output_bytes.into());
+        let vrf_hash = won_slot.vrf_hash;
+        Self {
+            slot_time,
+            delegator,
+            global_slot,
+            global_slot_since_genesis,
+            vrf_output,
+            vrf_hash,
+        }
+    }
+
+    fn calculate_slot_time(genesis_timestamp: redux::Timestamp, slot: u32) -> redux::Timestamp {
+        // FIXME: this calculation must use values from the protocol constants,
+        // now it assumes 3 minutes blocks.
+        genesis_timestamp + (slot as u64) * 3 * 60 * 1_000_000_000_u64
+    }
+
     pub fn timestamp(&self) -> BlockTimeTimeStableV1 {
         let ms = u64::from(self.slot_time) / 1_000_000;
         BlockTimeTimeStableV1(UnsignedExtendedUInt64Int64ForVersionTagsStableV1(ms.into()))