Add GraphQL extension to provide current STF and CP versions (#2715)

## Linked Issues/PRs
Closes #2596 

## Description
This PR adds new GraphQL extensions to provide:
- current STF version
- current consensus parameters version

Example response:
```
{
  "data": {
    "nodeInfo": {
      "nodeVersion": "0.41.6"
    }
  },
  "extensions": {
    "current_consensus_parameters_version": 0,
    "current_fuel_block_height": 0,
    "current_stf_version": 21
  }
}
```

### Additional housekeeping changes:
- all graphql extensions have been moved into a subdirectory


## TODO
- [x] Add tests to check that correct versions are returned when STF or
CP are bumped
- [x] Rework how we retrieve the current STF version

## Checklist
- [x] Breaking changes are clearly marked as such in the PR description
and changelog
- [x] New behavior is reflected in tests

### Before requesting review
- [x] I have reviewed the code myself
- [ ] I have created follow-up issues caused by this PR and linked them
here

### After merging, notify other teams

- [X] [Rust SDK](https://github.com/FuelLabs/fuels-rs/)

---------

Co-authored-by: green <[email protected]>

Author: rafal-ch

.changes/changed/2715.md

@@ -0,0 +1 @@
+Each GraphQL response contains `current_consensus_parameters_version` and `current_stf_version` in the `extensions` section.

Cargo.lock

@@ -47,8 +47,8 @@ codegen-units = 1
 lto = "fat"
 # The difference in performance for "fat" and "thin" is small,
 # but "thin" LTO is much faster to compile.
-# If you play with benchamrks or flamegraph, it is better to use "thin"
-# To speedup iterations between compialtion.
+# If you play with benchmarks or flamegraphs, it is better to use "thin"
+# To speedup iterations between compilation.
 #lto = "thin"
 panic = "unwind"
 

Cargo.toml

@@ -52,6 +52,10 @@ use cynic::{
     QueryBuilder,
 };
 use fuel_core_types::{
+    blockchain::header::{
+        ConsensusParametersVersion,
+        StateTransitionBytecodeVersion,
+    },
     fuel_asm::{
         Instruction,
         Word,
@@ -210,13 +214,36 @@ impl Clone for ConsistencyPolicy {
     }
 }
 
+#[derive(Debug, Default)]
+struct ChainStateInfo {
+    current_stf_version: Arc<Mutex<Option<StateTransitionBytecodeVersion>>>,
+    current_consensus_parameters_version: Arc<Mutex<Option<ConsensusParametersVersion>>>,
+}
+
+impl Clone for ChainStateInfo {
+    fn clone(&self) -> Self {
+        Self {
+            current_stf_version: Arc::new(Mutex::new(
+                self.current_stf_version.lock().ok().and_then(|v| *v),
+            )),
+            current_consensus_parameters_version: Arc::new(Mutex::new(
+                self.current_consensus_parameters_version
+                    .lock()
+                    .ok()
+                    .and_then(|v| *v),
+            )),
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct FuelClient {
     client: reqwest::Client,
     #[cfg(feature = "subscriptions")]
     cookie: std::sync::Arc<reqwest::cookie::Jar>,
     url: reqwest::Url,
     require_height: ConsistencyPolicy,
+    chain_state_info: ChainStateInfo,
 }
 
 impl FromStr for FuelClient {
@@ -247,6 +274,7 @@ impl FromStr for FuelClient {
                 require_height: ConsistencyPolicy::Auto {
                     height: Arc::new(Mutex::new(None)),
                 },
+                chain_state_info: Default::default(),
             })
         }
 
@@ -259,6 +287,7 @@ impl FromStr for FuelClient {
                 require_height: ConsistencyPolicy::Auto {
                     height: Arc::new(Mutex::new(None)),
                 },
+                chain_state_info: Default::default(),
             })
         }
     }
@@ -322,6 +351,51 @@ impl FuelClient {
         }
     }
 
+    fn update_chain_state_info<R, E>(&self, response: &FuelGraphQlResponse<R, E>) {
+        if let Some(current_sft_version) = response
+            .extensions
+            .as_ref()
+            .and_then(|e| e.current_stf_version)
+        {
+            if let Ok(mut c) = self.chain_state_info.current_stf_version.lock() {
+                *c = Some(current_sft_version);
+            }
+        }
+
+        if let Some(current_consensus_parameters_version) = response
+            .extensions
+            .as_ref()
+            .and_then(|e| e.current_consensus_parameters_version)
+        {
+            if let Ok(mut c) = self
+                .chain_state_info
+                .current_consensus_parameters_version
+                .lock()
+            {
+                *c = Some(current_consensus_parameters_version);
+            }
+        }
+
+        let inner_required_height = match &self.require_height {
+            ConsistencyPolicy::Auto { height } => Some(height.clone()),
+            ConsistencyPolicy::Manual { .. } => None,
+        };
+
+        if let Some(inner_required_height) = inner_required_height {
+            if let Some(current_fuel_block_height) = response
+                .extensions
+                .as_ref()
+                .and_then(|e| e.current_fuel_block_height)
+            {
+                let mut lock = inner_required_height.lock().expect("Mutex poisoned");
+
+                if current_fuel_block_height >= lock.unwrap_or_default() {
+                    *lock = Some(current_fuel_block_height);
+                }
+            }
+        }
+    }
+
     /// Send the GraphQL query to the client.
     pub async fn query<ResponseData, Vars>(
         &self,
@@ -340,34 +414,14 @@ impl FuelClient {
             .await
             .map_err(|e| io::Error::new(io::ErrorKind::Other, e))?;
 
-        let inner_required_height = match &self.require_height {
-            ConsistencyPolicy::Auto { height } => Some(height.clone()),
-            _ => None,
-        };
-
-        Self::decode_response(response, inner_required_height)
+        self.decode_response(response)
     }
 
-    fn decode_response<R, E>(
-        response: FuelGraphQlResponse<R, E>,
-        inner_required_height: Option<Arc<Mutex<Option<BlockHeight>>>>,
-    ) -> io::Result<R>
+    fn decode_response<R, E>(&self, response: FuelGraphQlResponse<R, E>) -> io::Result<R>
     where
         R: serde::de::DeserializeOwned + 'static,
     {
-        if let Some(inner_required_height) = inner_required_height {
-            if let Some(current_fuel_block_height) = response
-                .extensions
-                .as_ref()
-                .and_then(|e| e.current_fuel_block_height)
-            {
-                let mut lock = inner_required_height.lock().expect("Mutex poisoned");
-
-                if current_fuel_block_height >= lock.unwrap_or_default() {
-                    *lock = Some(current_fuel_block_height);
-                }
-            }
-        }
+        self.update_chain_state_info(&response);
 
         if let Some(failed) = response
             .extensions
@@ -398,7 +452,7 @@ impl FuelClient {
     async fn subscribe<ResponseData, Vars>(
         &self,
         q: StreamingOperation<ResponseData, Vars>,
-    ) -> io::Result<impl futures::Stream<Item = io::Result<ResponseData>>>
+    ) -> io::Result<impl futures::Stream<Item = io::Result<ResponseData>> + '_>
     where
         Vars: serde::Serialize,
         ResponseData: serde::de::DeserializeOwned + 'static,
@@ -471,25 +525,19 @@ impl FuelClient {
 
         let mut last = None;
 
-        let inner_required_height = match &self.require_height {
-            ConsistencyPolicy::Auto { height } => Some(height.clone()),
-            _ => None,
-        };
-
         let stream = es::Client::stream(&client)
-            .zip(futures::stream::repeat(inner_required_height))
-            .take_while(|(result, _)| {
+            .take_while(|result| {
                 futures::future::ready(!matches!(result, Err(es::Error::Eof)))
             })
-            .filter_map(move |(result, inner_required_height)| {
+            .filter_map(move |result| {
                 tracing::debug!("Got result: {result:?}");
                 let r = match result {
                     Ok(es::SSE::Event(es::Event { data, .. })) => {
                         match serde_json::from_str::<FuelGraphQlResponse<ResponseData>>(
                             &data,
                         ) {
                             Ok(resp) => {
-                                match Self::decode_response(resp, inner_required_height) {
+                                match self.decode_response(resp) {
                                     Ok(resp) => {
                                         match last.replace(data) {
                                             // Remove duplicates
@@ -527,6 +575,24 @@ impl FuelClient {
         Ok(stream)
     }
 
+    pub fn latest_stf_version(&self) -> Option<StateTransitionBytecodeVersion> {
+        self.chain_state_info
+            .current_stf_version
+            .lock()
+            .ok()
+            .and_then(|value| *value)
+    }
+
+    pub fn latest_consensus_parameters_version(
+        &self,
+    ) -> Option<ConsensusParametersVersion> {
+        self.chain_state_info
+            .current_consensus_parameters_version
+            .lock()
+            .ok()
+            .and_then(|value| *value)
+    }
+
     pub async fn health(&self) -> io::Result<bool> {
         let query = schema::Health::build(());
         self.query(query).await.map(|r| r.health)
@@ -764,10 +830,10 @@ impl FuelClient {
     /// Compared to the `submit_and_await_commit`, the stream also contains
     /// `SubmittedStatus` as an intermediate state.
     #[cfg(feature = "subscriptions")]
-    pub async fn submit_and_await_status(
-        &self,
-        tx: &Transaction,
-    ) -> io::Result<impl Stream<Item = io::Result<TransactionStatus>>> {
+    pub async fn submit_and_await_status<'a>(
+        &'a self,
+        tx: &'a Transaction,
+    ) -> io::Result<impl Stream<Item = io::Result<TransactionStatus>> + 'a> {
         use cynic::SubscriptionBuilder;
         let tx = tx.clone().to_bytes();
         let s = schema::tx::SubmitAndAwaitStatusSubscription::build(TxArg {
@@ -926,10 +992,10 @@ impl FuelClient {
     #[tracing::instrument(skip(self), level = "debug")]
     #[cfg(feature = "subscriptions")]
     /// Subscribe to the status of a transaction
-    pub async fn subscribe_transaction_status(
-        &self,
-        id: &TxId,
-    ) -> io::Result<impl futures::Stream<Item = io::Result<TransactionStatus>>> {
+    pub async fn subscribe_transaction_status<'a>(
+        &'a self,
+        id: &'a TxId,
+    ) -> io::Result<impl futures::Stream<Item = io::Result<TransactionStatus>> + 'a> {
         use cynic::SubscriptionBuilder;
         let tx_id: TransactionId = (*id).into();
         let s = schema::tx::StatusChangeSubscription::build(TxIdArgs { id: tx_id });

crates/client/src/client.rs

@@ -3,7 +3,13 @@ use cynic::{
     GraphQlResponse,
     Operation,
 };
-use fuel_core_types::fuel_types::BlockHeight;
+use fuel_core_types::{
+    blockchain::header::{
+        ConsensusParametersVersion,
+        StateTransitionBytecodeVersion,
+    },
+    fuel_types::BlockHeight,
+};
 use std::{
     future::Future,
     marker::PhantomData,
@@ -20,6 +26,8 @@ pub struct ExtensionsResponse {
     pub required_fuel_block_height: Option<BlockHeight>,
     pub current_fuel_block_height: Option<BlockHeight>,
     pub fuel_block_height_precondition_failed: Option<bool>,
+    pub current_stf_version: Option<StateTransitionBytecodeVersion>,
+    pub current_consensus_parameters_version: Option<ConsensusParametersVersion>,
 }
 
 #[derive(Debug, serde::Serialize)]

crates/client/src/reqwest_ext.rs

@@ -12,12 +12,10 @@ pub mod api_service;
 pub(crate) mod block_height_subscription;
 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 mod worker_service;
 
 #[derive(Clone, Debug)]

crates/fuel-core/src/graphql_api.rs

@@ -1,6 +1,5 @@
 use crate::{
     fuel_core_graphql_api::{
-        metrics_extension::MetricsExtension,
         ports::{
             BlockProducerPort,
             ConsensusModulePort,
@@ -11,12 +10,16 @@ use crate::{
             P2pPort,
             TxPoolPort,
         },
-        validation_extension::ValidationExtension,
         Config,
     },
     graphql_api::{
         self,
-        required_fuel_block_height_extension::RequiredFuelBlockHeightExtension,
+        extensions::{
+            chain_state_info::ChainStateInfoExtension,
+            metrics::MetricsExtension,
+            required_fuel_block_height::RequiredFuelBlockHeightExtension,
+            validation::ValidationExtension,
+        },
     },
     schema::{
         CoreSchema,
@@ -294,8 +297,9 @@ where
         .extension(RequiredFuelBlockHeightExtension::new(
             required_fuel_block_height_tolerance,
             required_fuel_block_height_timeout,
-            block_height_subscriber,
+            block_height_subscriber.clone(),
         ))
+        .extension(ChainStateInfoExtension::new(block_height_subscriber))
         .finish();
 
     let graphql_endpoint = "/v1/graphql";

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

@@ -33,7 +33,7 @@ impl Handler {
             // get all sending endpoint corresponding to subscribers that are waiting for a block height
             // that is at most `block_height`.
             let to_notify = inner_map.tx_handles.split_off(&Reverse(block_height));
-            inner_map.latest_seen_block_height = block_height;
+            inner_map.current_block_height = block_height;
 
             to_notify.into_values().flatten()
         };
@@ -59,7 +59,7 @@ impl Subscriber {
         let future = {
             let mut inner_map = self.inner.write();
 
-            if inner_map.latest_seen_block_height >= block_height {
+            if inner_map.current_block_height >= block_height {
                 return Ok(());
             }
 
@@ -77,22 +77,22 @@ impl Subscriber {
         })
     }
 
-    pub fn latest_seen_block_height(&self) -> BlockHeight {
-        self.inner.read().latest_seen_block_height
+    pub fn current_block_height(&self) -> BlockHeight {
+        self.inner.read().current_block_height
     }
 }
 
 #[derive(Debug, Default)]
 struct HandlersMapInner {
     tx_handles: BTreeMap<Reverse<BlockHeight>, Vec<oneshot::Sender<()>>>,
-    latest_seen_block_height: BlockHeight,
+    current_block_height: BlockHeight,
 }
 
 impl HandlersMapInner {
-    fn new(latest_seen_block_height: BlockHeight) -> Self {
+    fn new(current_block_height: BlockHeight) -> Self {
         Self {
             tx_handles: BTreeMap::new(),
-            latest_seen_block_height,
+            current_block_height,
         }
     }
 }

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

@@ -0,0 +1,4 @@
+pub(crate) mod chain_state_info;
+pub(crate) mod metrics;
+pub(crate) mod required_fuel_block_height;
+pub(crate) mod validation;