runtime: Add accessor for runtime state

.changelog/5915.feature.md

@@ -0,0 +1 @@
+runtime: Add accessor for runtime state

runtime/src/consensus/roothash/mod.rs

@@ -11,7 +11,7 @@ use crate::{
         crypto::{hash::Hash, signature::PublicKey},
         namespace::Namespace,
     },
-    consensus::state::StateError,
+    consensus::{registry::Runtime, scheduler::Committee, state::StateError},
 };
 
 // Modules.
@@ -111,6 +111,68 @@ impl MessageEvent {
     }
 }
 
+/// Per-runtime state.
+#[derive(Clone, Debug, Default, PartialEq, Eq, cbor::Encode, cbor::Decode)]
+#[cbor(allow_unknown)]
+pub struct RuntimeState {
+    /// Latest per-epoch runtime descriptor.
+    pub runtime: Runtime,
+    /// Flag indicating whether the runtime is currently suspended.
+    #[cbor(optional)]
+    pub suspended: bool,
+
+    // Runtime's first block.
+    pub genesis_block: Block,
+
+    /// Runtime's most recently finalized block.
+    pub last_block: Block,
+    /// Height at which the runtime's most recent block was finalized.
+    pub last_block_height: i64,
+
+    /// Runtime round which was normally processed by the runtime. This is also the round that
+    /// contains the message results for the last processed runtime messages.
+    pub last_normal_round: u64,
+    /// Consensus block height corresponding to `last_normal_round`.
+    pub last_normal_height: i64,
+
+    /// Committee the executor pool is collecting commitments for.
+    #[cbor(optional)]
+    pub commitee: Option<Committee>,
+    // NOTE: Commitment pool deserialization is currently not supported.
+    /// Consensus height at which the round is scheduled for forced finalization.
+    #[cbor(optional)]
+    pub next_timeout: i64,
+
+    /// Liveness statistics for the current epoch.
+    pub liveness_stats: Option<LivenessStatistics>,
+}
+
+/// Per-epoch liveness statistics for nodes.
+#[derive(Clone, Debug, Default, PartialEq, Eq, cbor::Encode, cbor::Decode)]
+pub struct LivenessStatistics {
+    /// Total number of rounds in the last epoch, excluding any rounds generated by the roothash
+    /// service itself.
+    pub total_rounds: u64,
+
+    /// A list of counters, specified in committee order (e.g. counter at index i has the value for
+    /// node i in the committee).
+    pub good_rounds: Vec<u64>,
+
+    /// A list that records the number of finalized rounds when a node acted as a proposed with the
+    /// highest rank.
+    ///
+    /// The list is ordered according to the committee arrangement (i.e., the counter at index i
+    /// holds the value for the node at index i in the committee).
+    pub finalized_proposals: Vec<u64>,
+
+    /// A list that records the number of failed rounds when a node/ acted as a proposer with the
+    /// highest rank.
+    ///
+    /// The list is ordered according to the committee arrangement (i.e., the counter at index i
+    /// holds the value for the node at index i in the committee).
+    pub missed_proposals: Vec<u64>,
+}
+
 /// Information about how a particular round was executed by the consensus layer.
 #[derive(Clone, Debug, Default, PartialEq, Eq, cbor::Encode, cbor::Decode)]
 pub struct RoundResults {

runtime/src/consensus/scheduler.rs

@@ -22,6 +22,7 @@ pub enum Role {
 }
 
 /// A node participating in a committee.
+#[derive(Clone, Debug, Default, PartialEq, Eq, cbor::Encode, cbor::Decode)]
 pub struct CommitteeNode {
     /// The node's role in a committee.
     pub role: Role,
@@ -44,6 +45,7 @@ pub enum CommitteeKind {
 }
 
 /// A per-runtime (instance) committee.
+#[derive(Clone, Debug, Default, PartialEq, Eq, cbor::Encode, cbor::Decode)]
 pub struct Committee {
     /// The functionality a committee exists to provide.
     pub kind: CommitteeKind,

runtime/src/consensus/state/roothash.rs

@@ -10,7 +10,7 @@ use crate::{
         namespace::Namespace,
     },
     consensus::{
-        roothash::{Error, RoundResults, RoundRoots},
+        roothash::{Error, RoundResults, RoundRoots, RuntimeState},
         state::StateError,
     },
     key_format,
@@ -29,11 +29,25 @@ impl<'a, T: ImmutableMKVS> ImmutableState<'a, T> {
     }
 }
 
+key_format!(RuntimeKeyFmt, 0x20, Hash);
 key_format!(StateRootKeyFmt, 0x25, Hash);
 key_format!(LastRoundResultsKeyFmt, 0x27, Hash);
 key_format!(PastRootsKeyFmt, 0x2a, (Hash, u64));
 
 impl<'a, T: ImmutableMKVS> ImmutableState<'a, T> {
+    /// Returns the latest runtime state.
+    pub fn runtime_state(&self, id: Namespace) -> Result<RuntimeState, Error> {
+        match self
+            .mkvs
+            .get(&RuntimeKeyFmt(Hash::digest_bytes(id.as_ref())).encode())
+        {
+            Ok(Some(b)) => cbor::from_slice_non_strict(&b)
+                .map_err(|err| StateError::Unavailable(anyhow!(err)).into()),
+            Ok(None) => Err(Error::InvalidRuntime(id)),
+            Err(err) => Err(StateError::Unavailable(anyhow!(err)).into()),
+        }
+    }
+
     /// Returns the state root for a specific runtime.
     pub fn state_root(&self, id: Namespace) -> Result<Hash, Error> {
         match self
@@ -132,6 +146,35 @@ mod test {
         let runtime_id =
             Namespace::from("8000000000000000000000000000000000000000000000000000000000000010");
 
+        // Test fetching runtime state.
+        let runtime_state = state
+            .runtime_state(runtime_id)
+            .expect("runtime state query should work");
+        println!("{:?}", runtime_state);
+        assert_eq!(runtime_state.runtime.id, runtime_id);
+        assert_eq!(runtime_state.suspended, false);
+        assert_eq!(runtime_state.genesis_block.header.round, 1);
+        assert_eq!(
+            runtime_state.genesis_block.header.io_root,
+            Hash::digest_bytes(format!("genesis").as_bytes())
+        );
+        assert_eq!(
+            runtime_state.genesis_block.header.state_root,
+            Hash::digest_bytes(format!("genesis").as_bytes())
+        );
+        assert_eq!(runtime_state.last_block.header.round, 10);
+        assert_eq!(
+            runtime_state.last_block.header.io_root,
+            Hash::digest_bytes(format!("io 10").as_bytes())
+        );
+        assert_eq!(
+            runtime_state.last_block.header.state_root,
+            Hash::digest_bytes(format!("state 10").as_bytes())
+        );
+        assert_eq!(runtime_state.last_block_height, 90);
+        assert_eq!(runtime_state.last_normal_round, 10);
+        assert_eq!(runtime_state.last_normal_height, 90);
+
         // Test fetching past round roots.
         let past_round_roots = state
             .past_round_roots(runtime_id)