Add GraphQL extension to provide current STF and CP versions

crates/fuel-core/src/graphql_api.rs

@@ -11,10 +11,10 @@ use std::{
 pub mod api_service;
 pub mod da_compression;
 pub mod database;
+pub(crate) mod extensions;
 pub(crate) mod indexation;
 pub(crate) mod metrics_extension;
 pub mod ports;
-pub(crate) mod required_fuel_block_height_extension;
 pub mod storage;
 pub(crate) mod validation_extension;
 pub(crate) mod view_extension;

crates/fuel-core/src/graphql_api/api_service.rs

@@ -17,7 +17,11 @@ use crate::{
     },
     graphql_api::{
         self,
-        required_fuel_block_height_extension::RequiredFuelBlockHeightExtension,
+        extensions::{
+            current_consensus_parameters_version::CurrentConsensusParametersVersionExtension,
+            current_stf_version::CurrentStfVersionExtension,
+            required_fuel_block_height::RequiredFuelBlockHeightExtension,
+        },
     },
     schema::{
         CoreSchema,
@@ -287,6 +291,8 @@ where
         // `RequiredFuelBlockHeightExtension` uses the view set by the ViewExtension.
         // Do not reorder this line before adding the `ViewExtension`.
         .extension(RequiredFuelBlockHeightExtension::new())
+        .extension(CurrentStfVersionExtension::new())
+        .extension(CurrentConsensusParametersVersionExtension::new())
         .finish();
 
     let graphql_endpoint = "/v1/graphql";

crates/fuel-core/src/graphql_api/extensions.rs

@@ -0,0 +1,3 @@
+pub(crate) mod current_consensus_parameters_version;
+pub(crate) mod current_stf_version;
+pub(crate) mod required_fuel_block_height;

crates/fuel-core/src/graphql_api/extensions/current_consensus_parameters_version.rs

@@ -0,0 +1,52 @@
+use std::sync::Arc;
+
+use crate::graphql_api::api_service::ConsensusProvider;
+use async_graphql::{
+    extensions::{
+        Extension,
+        ExtensionContext,
+        ExtensionFactory,
+        NextExecute,
+    },
+    Response,
+    Value,
+};
+
+const CURRENT_CONSENSUS_PARAMETERS_VERSION: &str = "current_consensus_parameters_version";
+
+/// The extension to attach the current STF version to all responses.
+#[derive(Debug, derive_more::Display, derive_more::From)]
+pub(crate) struct CurrentConsensusParametersVersionExtension;
+impl CurrentConsensusParametersVersionExtension {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl ExtensionFactory for CurrentConsensusParametersVersionExtension {
+    fn create(&self) -> Arc<dyn Extension> {
+        Arc::new(CurrentConsensusParametersVersionExtension::new())
+    }
+}
+
+#[async_trait::async_trait]
+impl Extension for CurrentConsensusParametersVersionExtension {
+    async fn execute(
+        &self,
+        ctx: &ExtensionContext<'_>,
+        operation_name: Option<&str>,
+        next: NextExecute<'_>,
+    ) -> Response {
+        let consensus_parameters_provider = ctx.data_unchecked::<ConsensusProvider>();
+
+        let current_consensus_parameters_version =
+            consensus_parameters_provider.latest_consensus_parameters_version();
+
+        let mut response = next.run(ctx, operation_name).await;
+        response.extensions.insert(
+            CURRENT_CONSENSUS_PARAMETERS_VERSION.to_string(),
+            Value::Number(current_consensus_parameters_version.into()),
+        );
+        response
+    }
+}

crates/fuel-core/src/graphql_api/extensions/current_stf_version.rs

@@ -0,0 +1,57 @@
+use std::sync::Arc;
+
+use async_graphql::{
+    extensions::{
+        Extension,
+        ExtensionContext,
+        ExtensionFactory,
+        NextExecute,
+    },
+    Response,
+    Value,
+};
+
+use crate::graphql_api::database::ReadDatabase;
+
+const CURRENT_STF_VERSION: &str = "current_stf_version";
+
+/// The extension to attach the current STF version to all responses.
+#[derive(Debug, derive_more::Display, derive_more::From)]
+pub(crate) struct CurrentStfVersionExtension;
+impl CurrentStfVersionExtension {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl ExtensionFactory for CurrentStfVersionExtension {
+    fn create(&self) -> Arc<dyn Extension> {
+        Arc::new(CurrentStfVersionExtension::new())
+    }
+}
+
+#[async_trait::async_trait]
+impl Extension for CurrentStfVersionExtension {
+    async fn execute(
+        &self,
+        ctx: &ExtensionContext<'_>,
+        operation_name: Option<&str>,
+        next: NextExecute<'_>,
+    ) -> Response {
+        let db = ctx.data_unchecked::<ReadDatabase>();
+
+        let mut response = next.run(ctx, operation_name).await;
+        if let Ok(view) = db.view() {
+            if let Ok(latest_block) = view.latest_block() {
+                let current_stf_version =
+                    latest_block.header().state_transition_bytecode_version();
+                response.extensions.insert(
+                    CURRENT_STF_VERSION.to_string(),
+                    Value::Number(current_stf_version.into()),
+                );
+            }
+        }
+
+        response
+    }
+}

crates/fuel-core/src/graphql_api/required_fuel_block_height_extension.rs → crates/fuel-core/src/graphql_api/extensions/required_fuel_block_height.rs

@@ -1,6 +1,7 @@
-use super::database::ReadView;
-
-use crate::fuel_core_graphql_api::database::ReadDatabase;
+use crate::{
+    fuel_core_graphql_api::database::ReadDatabase,
+    graphql_api::database::ReadView,
+};
 use async_graphql::{
     extensions::{
         Extension,

crates/fuel-core/src/graphql_api/ports.rs

@@ -454,6 +454,9 @@ pub trait ConsensusProvider: Send + Sync {
     /// Returns latest consensus parameters.
     fn latest_consensus_params(&self) -> Arc<ConsensusParameters>;
 
+    /// Returns latest consensus parameters version.
+    fn latest_consensus_parameters_version(&self) -> ConsensusParametersVersion;
+
     fn consensus_params_at_version(
         &self,
         version: &ConsensusParametersVersion,

crates/fuel-core/src/service/adapters/consensus_parameters_provider.rs

@@ -100,10 +100,14 @@ impl SharedState {
         self.latest_consensus_parameters_with_version().1
     }
 
+    pub fn latest_consensus_parameters_version(&self) -> ConsensusParametersVersion {
+        *self.latest_consensus_parameters_version.lock()
+    }
+
     pub fn latest_consensus_parameters_with_version(
         &self,
     ) -> (ConsensusParametersVersion, Arc<ConsensusParameters>) {
-        let version = *self.latest_consensus_parameters_version.lock();
+        let version = self.latest_consensus_parameters_version();
         let params = self.get_consensus_parameters(&version)
             .expect("The latest consensus parameters always are available unless this function was called before regenesis.");
         (version, params)

crates/fuel-core/src/service/adapters/graphql_api.rs

@@ -192,6 +192,10 @@ impl ConsensusProvider for ConsensusParametersProvider {
         self.shared_state.latest_consensus_parameters()
     }
 
+    fn latest_consensus_parameters_version(&self) -> ConsensusParametersVersion {
+        self.shared_state.latest_consensus_parameters_version()
+    }
+
     fn consensus_params_at_version(
         &self,
         version: &ConsensusParametersVersion,

tests/tests/graphql_extensions.rs

@@ -0,0 +1,42 @@
+use fuel_core::service::Config;
+use fuel_core_bin::FuelService;
+use serde_json::Value;
+use test_helpers::send_graph_ql_query;
+
+// TODO[RC]: Provide more detailed tests to verify that the correct STF and CP versions
+// are returned.
+
+#[tokio::test]
+async fn extension_fields_are_present() {
+    const REQUIRED_FIELDS: [&str; 3] = [
+        "current_stf_version",
+        "current_fuel_block_height",
+        "current_consensus_parameters_version",
+    ];
+
+    let node = FuelService::new_node(Config::local_node()).await.unwrap();
+    let url = format!("http://{}/v1/graphql", node.bound_address);
+
+    // Given
+    const QUERY: &str = r#"
+        query {
+          nodeInfo {
+            nodeVersion
+          }
+        }
+    "#;
+
+    // When
+    let response = send_graph_ql_query(&url, QUERY).await;
+
+    // Then
+    let json_value: Value =
+        serde_json::from_str(&response).expect("should be valid json");
+    let extensions = json_value
+        .get("extensions")
+        .expect("should have extensions");
+    for field in REQUIRED_FIELDS.iter() {
+        let is_field_present = extensions.get(field).is_some();
+        assert!(is_field_present)
+    }
+}

tests/tests/lib.rs

@@ -30,6 +30,8 @@ mod fee_collection_contract;
 #[cfg(not(feature = "only-p2p"))]
 mod gas_price;
 #[cfg(not(feature = "only-p2p"))]
+mod graphql_extensions;
+#[cfg(not(feature = "only-p2p"))]
 mod health;
 #[cfg(not(feature = "only-p2p"))]
 mod helpers;