feat(GraphQL): expand daemonStatus endpoint with consensus times

Author: Adrian Nagy

core/src/block/block_with_hash.rs

@@ -61,6 +61,10 @@ impl<T: AsRef<Block>> BlockWithHash<T> {
         global_slot(self.header())
     }
 
+    pub fn slot(&self) -> u32 {
+        slot(self.header())
+    }
+
     pub fn global_slot_since_genesis(&self) -> u32 {
         global_slot_since_genesis(self.header())
     }
@@ -180,6 +184,10 @@ impl<T: AsRef<BlockHeader>> BlockHeaderWithHash<T> {
         global_slot(self.header())
     }
 
+    pub fn slot(&self) -> u32 {
+        slot(self.header())
+    }
+
     pub fn global_slot_since_genesis(&self) -> u32 {
         global_slot_since_genesis(self.header())
     }
@@ -251,6 +259,15 @@ fn global_slot(header: &BlockHeader) -> u32 {
     consensus_state(header).global_slot()
 }
 
+fn slot(header: &BlockHeader) -> u32 {
+    let slot_struct = &consensus_state(header).curr_global_slot_since_hard_fork;
+    slot_struct
+        .slot_number
+        .as_u32()
+        .checked_rem(slot_struct.slots_per_epoch.as_u32())
+        .expect("division by zero")
+}
+
 fn global_slot_since_genesis(header: &BlockHeader) -> u32 {
     consensus_state(header).global_slot_since_genesis.as_u32()
 }

core/src/consensus.rs

@@ -2,6 +2,7 @@ use mina_p2p_messages::v2::{
     self, BlockTimeTimeStableV1,
     ConsensusProofOfStakeDataConsensusStateValueStableV2 as MinaConsensusState, StateHash,
 };
+use redux::Timestamp;
 use serde::{Deserialize, Serialize};
 use time::{macros::format_description, OffsetDateTime};
 
@@ -30,6 +31,15 @@ pub enum ConsensusLongRangeForkDecisionReason {
     StateHash,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ConsensusTime {
+    pub start_time: Timestamp,
+    pub end_time: Timestamp,
+    pub epoch: u32,
+    pub global_slot: u32,
+    pub slot: u32,
+}
+
 // TODO(binier): do we need to verify constants? Probably they are verified
 // using block proof verification, but check just to be sure.
 pub fn is_short_range_fork(a: &MinaConsensusState, b: &MinaConsensusState) -> bool {

node/common/src/service/rpc/mod.rs

@@ -9,8 +9,8 @@ pub mod transition_frontier;
 
 use node::rpc::{
     RpcBestChainResponse, RpcBlockProducerStatsGetResponse, RpcConsensusConstantsGetResponse,
-    RpcDiscoveryBoostrapStatsResponse, RpcDiscoveryRoutingTableResponse, RpcGenesisBlockResponse,
-    RpcGetBlockResponse, RpcHealthCheckResponse, RpcHeartbeatGetResponse,
+    RpcConsensusTimeGetResponse, RpcDiscoveryBoostrapStatsResponse, RpcDiscoveryRoutingTableResponse,
+    RpcGenesisBlockResponse, RpcGetBlockResponse, RpcHealthCheckResponse, RpcHeartbeatGetResponse,
     RpcLedgerAccountsResponse, RpcLedgerSlimAccountsResponse, RpcMessageProgressResponse,
     RpcPeersGetResponse, RpcPooledUserCommandsResponse, RpcPooledZkappCommandsResponse,
     RpcReadinessCheckResponse, RpcRequest, RpcSnarkPoolCompletedJobsResponse,
@@ -325,6 +325,7 @@ impl node::rpc_effectful::RpcService for NodeService {
         RpcPooledZkappCommandsResponse
     );
     rpc_service_impl!(respond_genesis_block, RpcGenesisBlockResponse);
+    rpc_service_impl!(respond_consensus_time_get, RpcConsensusTimeGetResponse);
 }
 
 #[cfg(test)]

node/native/src/graphql/constants.rs

@@ -1,7 +1,120 @@
 use juniper::GraphQLObject;
-use openmina_core::{consensus::ConsensusConstants, constants::ConstraintConstants};
+use node::rpc::{
+    ConsensusTimeQuery, PeerConnectionStatus, RpcConsensusTimeGetResponse, RpcPeerInfo, RpcRequest,
+};
+use openmina_core::{
+    consensus::{ConsensusConstants, ConsensusTime},
+    constants::ConstraintConstants,
+};
 
-use super::ConversionError;
+use super::{Context, ConversionError, Error};
+
+#[derive(Clone, Debug, Copy)]
+pub(crate) struct GraphQLDaemonStatus;
+
+#[juniper::graphql_object(context = Context)]
+impl GraphQLDaemonStatus {
+    async fn consensus_configuration(
+        &self,
+        context: &Context,
+    ) -> juniper::FieldResult<GraphQLConsensusConfiguration> {
+        let consensus_constants: ConsensusConstants = context
+            .0
+            .oneshot_request(RpcRequest::ConsensusConstantsGet)
+            .await
+            .ok_or(Error::StateMachineEmptyResponse)?;
+        Ok(GraphQLConsensusConfiguration::from(consensus_constants))
+    }
+
+    async fn peers(&self, context: &Context) -> juniper::FieldResult<Vec<GraphQLRpcPeerInfo>> {
+        let peers: Vec<RpcPeerInfo> = context
+            .0
+            .oneshot_request(RpcRequest::PeersGet)
+            .await
+            .ok_or(Error::StateMachineEmptyResponse)?;
+
+        let connected_peers = peers
+            .iter()
+            .filter(|peer| matches!(peer.connection_status, PeerConnectionStatus::Connected))
+            .map(GraphQLRpcPeerInfo::from)
+            .collect();
+
+        Ok(connected_peers)
+    }
+
+    async fn consensus_time_now(
+        &self,
+        context: &Context,
+    ) -> juniper::FieldResult<GraphQLConsensusTime> {
+        let consensus_time: RpcConsensusTimeGetResponse = context
+            .0
+            .oneshot_request(RpcRequest::ConsensusTimeGet(ConsensusTimeQuery::Now))
+            .await
+            .ok_or(Error::StateMachineEmptyResponse)?;
+
+        match consensus_time {
+            Some(consensus_time) => Ok(GraphQLConsensusTime::from(consensus_time)),
+            None => Err(juniper::FieldError::new(
+                "No consensus time found",
+                juniper::Value::Null,
+            )),
+        }
+    }
+
+    async fn consensus_time_best_tip(
+        &self,
+        context: &Context,
+    ) -> juniper::FieldResult<GraphQLConsensusTime> {
+        let consensus_time_res: RpcConsensusTimeGetResponse = context
+            .0
+            .oneshot_request(RpcRequest::ConsensusTimeGet(ConsensusTimeQuery::BestTip))
+            .await
+            .ok_or(Error::StateMachineEmptyResponse)?;
+
+        match consensus_time_res {
+            Some(consensus_time) => Ok(GraphQLConsensusTime::from(consensus_time)),
+            None => Err(juniper::FieldError::new(
+                "No consensus time found",
+                juniper::Value::Null,
+            )),
+        }
+    }
+}
+
+#[derive(GraphQLObject, Clone, Debug)]
+pub struct GraphQLRpcPeerInfo {
+    pub peer_id: String,
+    pub best_tip: Option<String>,
+    pub best_tip_height: Option<String>,
+    pub best_tip_global_slot: Option<String>,
+    pub best_tip_timestamp: Option<String>,
+    pub connection_status: String,
+    pub connecting_details: Option<String>,
+    pub address: Option<String>,
+    pub incoming: bool,
+    pub is_libp2p: bool,
+    pub time: String,
+}
+
+impl From<&RpcPeerInfo> for GraphQLRpcPeerInfo {
+    fn from(peer: &RpcPeerInfo) -> Self {
+        Self {
+            peer_id: peer.peer_id.to_string(),
+            best_tip: peer.best_tip.as_ref().map(|hash| hash.to_string()),
+            best_tip_height: peer.best_tip_height.map(|height| height.to_string()),
+            best_tip_global_slot: peer.best_tip_global_slot.map(|slot| slot.to_string()),
+            best_tip_timestamp: peer
+                .best_tip_timestamp
+                .map(|timestamp| timestamp.to_string()),
+            connection_status: peer.connection_status.to_string(),
+            connecting_details: peer.connecting_details.clone(),
+            address: peer.address.clone(),
+            incoming: peer.incoming,
+            is_libp2p: peer.is_libp2p,
+            time: peer.time.to_string(),
+        }
+    }
+}
 
 #[derive(GraphQLObject, Debug)]
 pub struct GraphQLGenesisConstants {
@@ -25,11 +138,6 @@ impl GraphQLGenesisConstants {
     }
 }
 
-#[derive(GraphQLObject, Debug)]
-pub struct GraphQLDaemonStatus {
-    pub consensus_configuration: GraphQLConsensusConfiguration,
-}
-
 #[derive(GraphQLObject, Debug)]
 pub struct GraphQLConsensusConfiguration {
     pub epoch_duration: i32,
@@ -48,3 +156,30 @@ impl From<ConsensusConstants> for GraphQLConsensusConfiguration {
         }
     }
 }
+
+#[derive(GraphQLObject, Debug)]
+pub struct GraphQLConsensusTime {
+    pub start_time: String,
+    pub end_time: String,
+    pub epoch: String,
+    pub global_slot: String,
+    pub slot: String,
+}
+
+impl From<ConsensusTime> for GraphQLConsensusTime {
+    fn from(consensus_time: ConsensusTime) -> Self {
+        let start_time: u64 = consensus_time.start_time.into();
+        let end_time: u64 = consensus_time.end_time.into();
+
+        let start_time_ms = start_time.checked_div(1_000_000).expect("division by zero");
+        let end_time_ms = end_time.checked_div(1_000_000).expect("division by zero");
+
+        GraphQLConsensusTime {
+            start_time: start_time_ms.to_string(),
+            end_time: end_time_ms.to_string(),
+            epoch: consensus_time.epoch.to_string(),
+            global_slot: consensus_time.global_slot.to_string(),
+            slot: consensus_time.slot.to_string(),
+        }
+    }
+}

node/native/src/graphql/mod.rs

@@ -89,10 +89,20 @@ impl From<ConversionError> for Error {
     }
 }
 
-struct Context(RpcSender);
+pub(crate) struct Context(RpcSender);
 
 impl juniper::Context for Context {}
 
+// impl Context {
+//     pub(crate) async fn get_or_fetch_status(&self) -> RpcStatusGetResponse {
+//         let result: RpcStatusGetResponse = self
+//             .0
+//             .oneshot_request(RpcRequest::StatusGet)
+//             .await
+//             .flatten();
+//     }
+// }
+
 #[derive(Clone, Copy, Debug, GraphQLEnum)]
 #[allow(clippy::upper_case_acronyms)]
 enum SyncStatus {
@@ -227,16 +237,9 @@ impl Query {
     }
 
     async fn daemon_status(
-        context: &Context,
+        _context: &Context,
     ) -> juniper::FieldResult<constants::GraphQLDaemonStatus> {
-        let consensus_constants: ConsensusConstants = context
-            .0
-            .oneshot_request(RpcRequest::ConsensusConstantsGet)
-            .await
-            .ok_or(Error::StateMachineEmptyResponse)?;
-        Ok(constants::GraphQLDaemonStatus {
-            consensus_configuration: consensus_constants.into(),
-        })
+        Ok(constants::GraphQLDaemonStatus)
     }
 
     async fn genesis_constants(

node/src/action_kind.rs

@@ -473,6 +473,7 @@ pub enum ActionKind {
     RpcBlockGet,
     RpcBlockProducerStatsGet,
     RpcConsensusConstantsGet,
+    RpcConsensusTimeGet,
     RpcDiscoveryBoostrapStats,
     RpcDiscoveryRoutingTable,
     RpcFinish,
@@ -525,6 +526,7 @@ pub enum ActionKind {
     RpcEffectfulBlockGet,
     RpcEffectfulBlockProducerStatsGet,
     RpcEffectfulConsensusConstantsGet,
+    RpcEffectfulConsensusTimeGet,
     RpcEffectfulDiscoveryBoostrapStats,
     RpcEffectfulDiscoveryRoutingTable,
     RpcEffectfulGenesisBlock,
@@ -728,7 +730,7 @@ pub enum ActionKind {
 }
 
 impl ActionKind {
-    pub const COUNT: u16 = 618;
+    pub const COUNT: u16 = 620;
 }
 
 impl std::fmt::Display for ActionKind {
@@ -1100,6 +1102,7 @@ impl ActionKindGet for RpcAction {
             Self::ConsensusConstantsGet { .. } => ActionKind::RpcConsensusConstantsGet,
             Self::TransactionStatusGet { .. } => ActionKind::RpcTransactionStatusGet,
             Self::BlockGet { .. } => ActionKind::RpcBlockGet,
+            Self::ConsensusTimeGet { .. } => ActionKind::RpcConsensusTimeGet,
             Self::PooledUserCommands { .. } => ActionKind::RpcPooledUserCommands,
             Self::PooledZkappCommands { .. } => ActionKind::RpcPooledZkappCommands,
             Self::GenesisBlock { .. } => ActionKind::RpcGenesisBlock,
@@ -1176,6 +1179,7 @@ impl ActionKindGet for RpcEffectfulAction {
             Self::PooledUserCommands { .. } => ActionKind::RpcEffectfulPooledUserCommands,
             Self::PooledZkappCommands { .. } => ActionKind::RpcEffectfulPooledZkappCommands,
             Self::GenesisBlock { .. } => ActionKind::RpcEffectfulGenesisBlock,
+            Self::ConsensusTimeGet { .. } => ActionKind::RpcEffectfulConsensusTimeGet,
         }
     }
 }

node/src/event_source/event.rs

@@ -78,6 +78,7 @@ impl std::fmt::Display for Event {
                     RpcRequest::PooledUserCommands(..) => write!(f, "PooledUserCommands"),
                     RpcRequest::PooledZkappCommands(..) => write!(f, "PooledZkappCommands"),
                     RpcRequest::GenesisBlockGet => write!(f, "GenesisBlock"),
+                    RpcRequest::ConsensusTimeGet(..) => write!(f, "ConsensusTimeGet"),
                 }
             }
             Self::ExternalSnarkWorker(event) => {

node/src/event_source/event_source_effects.rs

@@ -402,6 +402,8 @@ pub fn event_source_effects<S: Service>(store: &mut Store<S>, action: EventSourc
                 }
                 RpcRequest::PooledZkappCommands(query) => {
                     store.dispatch(RpcAction::PooledZkappCommands { rpc_id, query });
+                RpcRequest::ConsensusTimeGet(query) => {
+                    store.dispatch(RpcAction::ConsensusTimeGet { rpc_id, query });
                 }
                 RpcRequest::GenesisBlockGet => {
                     store.dispatch(RpcAction::GenesisBlock { rpc_id });

node/src/rpc/mod.rs

@@ -17,7 +17,7 @@ use mina_p2p_messages::v2::{
     TransactionSnarkWorkTStableV2,
 };
 use openmina_core::block::{AppliedBlock, ArcBlockWithHash};
-use openmina_core::consensus::ConsensusConstants;
+use openmina_core::consensus::{ConsensusConstants, ConsensusTime};
 use openmina_node_account::AccountPublicKey;
 use p2p::bootstrap::P2pNetworkKadBootstrapStats;
 pub use rpc_state::*;
@@ -94,6 +94,13 @@ pub enum RpcRequest {
     PooledUserCommands(PooledUserCommandsQuery),
     PooledZkappCommands(PooledZkappsCommandsQuery),
     GenesisBlockGet,
+    ConsensusTimeGet(ConsensusTimeQuery),
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub enum ConsensusTimeQuery {
+    Now,
+    BestTip,
 }
 
 pub type MaxLength = u32;
@@ -166,7 +173,7 @@ pub enum ActionStatsResponse {
     ForBlock(ActionStatsForBlock),
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone, strum_macros::Display)]
 pub enum PeerConnectionStatus {
     Disconnecting,
     Disconnected,
@@ -379,6 +386,7 @@ pub type RpcTransactionStatusGetResponse = TransactionStatus;
 pub type RpcPooledUserCommandsResponse = Vec<MinaBaseSignedCommandStableV2>;
 pub type RpcPooledZkappCommandsResponse = Vec<MinaBaseZkappCommandTStableV1WireStableV1>;
 pub type RpcGenesisBlockResponse = Option<ArcBlockWithHash>;
+pub type RpcConsensusTimeGetResponse = Option<ConsensusTime>;
 
 #[derive(Serialize, Deserialize, Debug, Clone, strum_macros::Display)]
 #[strum(serialize_all = "SCREAMING_SNAKE_CASE")]