feat(transition_frontier): avoid proving genesis until we have to, two minutes before the won slot

Author: binier

node/src/action_kind.rs

@@ -615,6 +615,7 @@ pub enum ActionKind {
     TransactionPoolVerifyError,
     TransactionPoolEffectfulFetchAccounts,
     TransitionFrontierGenesisInject,
+    TransitionFrontierGenesisProvenInject,
     TransitionFrontierSyncFailed,
     TransitionFrontierSynced,
     TransitionFrontierGenesisLedgerLoadInit,
@@ -704,7 +705,7 @@ pub enum ActionKind {
 }
 
 impl ActionKind {
-    pub const COUNT: u16 = 589;
+    pub const COUNT: u16 = 590;
 }
 
 impl std::fmt::Display for ActionKind {
@@ -858,6 +859,7 @@ impl ActionKindGet for TransitionFrontierAction {
             Self::GenesisEffect(a) => a.kind(),
             Self::Sync(a) => a.kind(),
             Self::GenesisInject => ActionKind::TransitionFrontierGenesisInject,
+            Self::GenesisProvenInject => ActionKind::TransitionFrontierGenesisProvenInject,
             Self::Synced { .. } => ActionKind::TransitionFrontierSynced,
             Self::SyncFailed { .. } => ActionKind::TransitionFrontierSyncFailed,
         }

node/src/block_producer/block_producer_actions.rs

@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use ledger::scan_state::transaction_logic::valid;
 use mina_p2p_messages::v2::MinaBaseProofStableV2;
 use openmina_core::block::ArcBlockWithHash;
@@ -100,9 +102,18 @@ impl redux::EnablingCondition<crate::State> for BlockProducerAction {
             BlockProducerAction::WonSlotWait => state
                 .block_producer
                 .with(false, |this| this.current.won_slot_should_wait(time)),
-            BlockProducerAction::WonSlotProduceInit { .. } => state
-                .block_producer
-                .with(false, |this| this.current.won_slot_should_produce(time)),
+            BlockProducerAction::WonSlotProduceInit { .. } => {
+                state.block_producer.with(false, |this| {
+                    let has_genesis_proven_if_needed = || {
+                        state.transition_frontier.best_tip().map_or(false, |tip| {
+                            let proven_block = state.transition_frontier.genesis.proven_block();
+                            !tip.is_genesis()
+                                || proven_block.map_or(false, |b| Arc::ptr_eq(&b.block, &tip.block))
+                        })
+                    };
+                    this.current.won_slot_should_produce(time) && has_genesis_proven_if_needed()
+                })
+            }
             BlockProducerAction::WonSlotTransactionsGet => {
                 state.block_producer.with(false, |this| {
                     matches!(

node/src/block_producer/block_producer_reducer.rs

@@ -104,6 +104,29 @@ impl BlockProducerEnabled {
                     };
                 }
             }
+            BlockProducerAction::WonSlotProduceInit => {
+                if let Some(won_slot) = state.current.won_slot() {
+                    if let Some(chain) = best_chain.last().map(|best_tip| {
+                        if best_tip.global_slot() == won_slot.global_slot() {
+                            best_chain
+                                .get(..best_chain.len().saturating_sub(1))
+                                .unwrap_or(&[])
+                                .to_vec()
+                        } else {
+                            best_chain.to_vec()
+                        }
+                    }) {
+                        state.current = BlockProducerCurrentState::WonSlotProduceInit {
+                            time: meta.time(),
+                            won_slot: won_slot.clone(),
+                            chain,
+                        };
+                    };
+                }
+
+                let dispatcher = state_context.into_dispatcher();
+                dispatcher.push(BlockProducerAction::WonSlotTransactionsGet);
+            }
             BlockProducerAction::WonSlotTransactionsGet => {
                 let BlockProducerCurrentState::WonSlotProduceInit {
                     won_slot, chain, ..
@@ -141,29 +164,6 @@ impl BlockProducerEnabled {
                 let dispatcher = state_context.into_dispatcher();
                 dispatcher.push(BlockProducerAction::StagedLedgerDiffCreateInit);
             }
-            BlockProducerAction::WonSlotProduceInit => {
-                if let Some(won_slot) = state.current.won_slot() {
-                    if let Some(chain) = best_chain.last().map(|best_tip| {
-                        if best_tip.global_slot() == won_slot.global_slot() {
-                            best_chain
-                                .get(..best_chain.len().saturating_sub(1))
-                                .unwrap_or(&[])
-                                .to_vec()
-                        } else {
-                            best_chain.to_vec()
-                        }
-                    }) {
-                        state.current = BlockProducerCurrentState::WonSlotProduceInit {
-                            time: meta.time(),
-                            won_slot: won_slot.clone(),
-                            chain,
-                        };
-                    };
-                }
-
-                let dispatcher = state_context.into_dispatcher();
-                dispatcher.push(BlockProducerAction::WonSlotTransactionsGet);
-            }
             BlockProducerAction::StagedLedgerDiffCreateInit => {
                 let dispatcher = state_context.into_dispatcher();
                 dispatcher.push(BlockProducerEffectfulAction::StagedLedgerDiffCreateInit);

node/src/block_producer/block_producer_state.rs

@@ -296,7 +296,7 @@ impl BlockProducerCurrentState {
         #[cfg(not(target_arch = "wasm32"))]
         const BLOCK_PRODUCTION_ESTIMATE: u64 = Duration::from_secs(5).as_nanos() as u64;
         #[cfg(target_arch = "wasm32")]
-        const BLOCK_PRODUCTION_ESTIMATE: u64 = Duration::from_secs(20).as_nanos() as u64;
+        const BLOCK_PRODUCTION_ESTIMATE: u64 = Duration::from_secs(18).as_nanos() as u64;
 
         let slot_interval = Duration::from_secs(3 * 60).as_nanos() as u64;
         match self {

node/src/effects.rs

@@ -37,6 +37,8 @@ pub fn effects<S: Service>(store: &mut Store<S>, action: ActionWithMeta) {
             store.dispatch(TransitionFrontierGenesisAction::LedgerLoadInit);
             store.dispatch(ExternalSnarkWorkerAction::Start);
 
+            store.dispatch(TransitionFrontierGenesisAction::ProveInit);
+
             if store.state().p2p.ready().is_some() {
                 p2p_request_best_tip_if_needed(store);
                 p2p_request_transactions_if_needed(store);

node/src/state.rs

@@ -1,4 +1,5 @@
 use std::sync::Arc;
+use std::time::Duration;
 
 use mina_p2p_messages::v2::{MinaBaseUserCommandStableV2, MinaBlockBlockStableV2};
 use rand::prelude::*;
@@ -333,17 +334,19 @@ impl State {
         )
     }
 
-    pub fn should_produce_blocks_after_genesis(&self) -> bool {
-        self.block_producer.is_enabled()
-            && self.genesis_block().map_or(false, |b| {
-                let slot = &b.consensus_state().curr_global_slot_since_hard_fork;
-                let epoch = slot
-                    .slot_number
-                    .as_u32()
-                    .checked_div(slot.slots_per_epoch.as_u32())
-                    .expect("division by 0");
-                self.current_epoch() <= Some(epoch)
-            })
+    pub fn producing_block_after_genesis(&self) -> bool {
+        let two_mins_in_future = self.time() + Duration::from_secs(2 * 60);
+        self.block_producer.with(false, |bp| {
+            bp.current.won_slot_should_produce(two_mins_in_future)
+        }) && self.genesis_block().map_or(false, |b| {
+            let slot = &b.consensus_state().curr_global_slot_since_hard_fork;
+            let epoch = slot
+                .slot_number
+                .as_u32()
+                .checked_div(slot.slots_per_epoch.as_u32())
+                .expect("division by 0");
+            self.current_epoch() <= Some(epoch)
+        })
     }
 
     pub fn should_log_node_id(&self) -> bool {

node/src/transition_frontier/genesis/transition_frontier_genesis_actions.rs

@@ -51,7 +51,7 @@ impl redux::EnablingCondition<crate::State> for TransitionFrontierGenesisAction
                 TransitionFrontierGenesisState::LedgerLoadSuccess { .. }
             ),
             TransitionFrontierGenesisAction::ProveInit => {
-                state.should_produce_blocks_after_genesis()
+                state.producing_block_after_genesis()
                     && matches!(
                         genesis_state,
                         TransitionFrontierGenesisState::Produced { .. }

node/src/transition_frontier/transition_frontier_actions.rs

@@ -1,4 +1,5 @@
 use std::collections::BTreeSet;
+use std::sync::Arc;
 
 use mina_p2p_messages::v2::StateHash;
 use openmina_core::block::ArcBlockWithHash;
@@ -25,6 +26,8 @@ pub enum TransitionFrontierAction {
     /// block, otherwise we don't need it so we use dummy proof instead.
     #[action_event(level = info)]
     GenesisInject,
+    #[action_event(level = info)]
+    GenesisProvenInject,
 
     Sync(TransitionFrontierSyncAction),
     /// Transition frontier synced.
@@ -44,15 +47,20 @@ impl redux::EnablingCondition<crate::State> for TransitionFrontierAction {
             TransitionFrontierAction::Genesis(a) => a.is_enabled(state, time),
             TransitionFrontierAction::GenesisEffect(a) => a.is_enabled(state, time),
             TransitionFrontierAction::GenesisInject => {
-                if state.transition_frontier.best_tip().is_some() {
+                state.transition_frontier.root().is_none()
+                    && state
+                        .transition_frontier
+                        .genesis
+                        .block_with_real_or_dummy_proof()
+                        .is_some()
+            }
+            TransitionFrontierAction::GenesisProvenInject => {
+                let Some(genesis) = state.transition_frontier.genesis.proven_block() else {
                     return false;
-                }
-                let genesis_state = &state.transition_frontier.genesis;
-                if state.should_produce_blocks_after_genesis() {
-                    genesis_state.proven_block().is_some()
-                } else {
-                    genesis_state.block_with_dummy_proof().is_some()
-                }
+                };
+                state.transition_frontier.root().map_or(true, |b| {
+                    b.is_genesis() && !Arc::ptr_eq(&genesis.block, &b.block)
+                })
             }
             TransitionFrontierAction::Sync(a) => a.is_enabled(state, time),
             TransitionFrontierAction::Synced { .. } => matches!(

node/src/transition_frontier/transition_frontier_effects.rs

@@ -34,10 +34,12 @@ pub fn transition_frontier_effects<S: crate::Service>(
             // TODO(refactor): this should be handled by a callback and removed from here
             // whenever any of these is going to happen, genesisinject must happen first
             match &a {
-                TransitionFrontierGenesisAction::Produce
-                | TransitionFrontierGenesisAction::ProveSuccess { .. } => {
+                TransitionFrontierGenesisAction::Produce => {
                     store.dispatch(TransitionFrontierAction::GenesisInject);
                 }
+                TransitionFrontierGenesisAction::ProveSuccess { .. } => {
+                    store.dispatch(TransitionFrontierAction::GenesisProvenInject);
+                }
                 _ => {}
             }
         }
@@ -47,6 +49,11 @@ pub fn transition_frontier_effects<S: crate::Service>(
         TransitionFrontierAction::GenesisInject => {
             synced_effects(&meta, store);
         }
+        TransitionFrontierAction::GenesisProvenInject => {
+            if store.state().transition_frontier.sync.is_synced() {
+                synced_effects(&meta, store);
+            }
+        }
         TransitionFrontierAction::Sync(a) => {
             match a {
                 TransitionFrontierSyncAction::Init {

node/src/transition_frontier/transition_frontier_reducer.rs

@@ -34,9 +34,22 @@ impl TransitionFrontierState {
                     block: genesis,
                     just_emitted_a_proof: true,
                 };
-                let new_chain = vec![genesis];
-                state.chain_diff = state.maybe_make_chain_diff(&new_chain);
-                state.best_chain = new_chain;
+                state.best_chain = vec![genesis];
+                state.sync = TransitionFrontierSyncState::Synced { time: meta.time() };
+            }
+            TransitionFrontierAction::GenesisProvenInject => {
+                let Some(genesis) = state.genesis.proven_block() else {
+                    return;
+                };
+                if let Some(block) = state.best_chain.get_mut(0) {
+                    block.block = genesis.clone();
+                } else {
+                    let genesis = AppliedBlock {
+                        block: genesis.clone(),
+                        just_emitted_a_proof: true,
+                    };
+                    state.best_chain = vec![genesis];
+                }
                 if !state.sync.is_pending() {
                     state.sync = TransitionFrontierSyncState::Synced { time: meta.time() };
                 }