Execution tracing: GraphQL query to get storage inputs for past blocks

CHANGELOG.md

@@ -12,6 +12,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ### Added
 - [2150](https://github.com/FuelLabs/fuel-core/pull/2150): Upgraded `libp2p` to `0.54.1` and introduced `ConnectionLimiter` to limit pending incoming/outgoing connections.
+- [2491](https://github.com/FuelLabs/fuel-core/pull/2491): Storage read replays of historical blocks for execution tracing. Only available behind `--historical-execution` flag.
 - [2666](https://github.com/FuelLabs/fuel-core/pull/2666): Added two new CLI arguments to control the GraphQL queries consistency: `--graphql-block-height-tolerance` (default: `10`) and `--graphql-block-height-min-timeout` (default: `30s`). If a request requires a specific block height and the node is slightly behind, it will wait instead of failing.
 
 ### Fixed

Cargo.toml

@@ -126,6 +126,7 @@ postcard = "1.0"
 tracing-attributes = "0.1"
 tracing-subscriber = "0.3"
 serde = "1.0"
+serde-big-array = { version = "0.5", default-features = false }
 serde_json = { version = "1.0", default-features = false, features = ["alloc"] }
 serde_with = { version = "3.4", default-features = false }
 strum = { version = "0.25" }

bin/fuel-core/src/cli/run.rs

@@ -608,6 +608,7 @@ impl Command {
                     get_peers: graphql.costs.get_peers,
                     estimate_predicates: graphql.costs.estimate_predicates,
                     dry_run: graphql.costs.dry_run,
+                    storage_read_replay: graphql.costs.storage_read_replay,
                     submit: graphql.costs.submit,
                     submit_and_await: graphql.costs.submit_and_await,
                     status_change: graphql.costs.status_change,

bin/fuel-core/src/cli/run/graphql.rs

@@ -131,6 +131,14 @@ pub struct QueryCosts {
     )]
     pub dry_run: usize,
 
+    /// Query costs for generating execution trace for a block.
+    #[clap(
+        long = "query-cost-storage-read-replay",
+        default_value = DEFAULT_QUERY_COSTS.storage_read_replay.to_string(),
+        env
+    )]
+    pub storage_read_replay: usize,
+
     /// Query costs for submitting a transaction.
     #[clap(
         long = "query-cost-submit",

crates/client/assets/schema.sdl

@@ -943,6 +943,10 @@ type Query {
 	"""
 	allReceipts: [Receipt!]!
 	"""
+	Get execution trace for an already-executed block.
+	"""
+	storageReadReplay(height: U32!): [StorageReadReplayEvent!]!
+	"""
 	Returns true when the GraphQL API is serving requests.
 	"""
 	health: Boolean!
@@ -1156,6 +1160,12 @@ type StateTransitionPurpose {
 	root: Bytes32!
 }
 
+type StorageReadReplayEvent {
+	column: U32!
+	key: HexString!
+	value: HexString
+}
+
 
 scalar SubId
 

crates/client/src/client.rs

@@ -70,7 +70,10 @@ use fuel_core_types::{
         BlockHeight,
         Nonce,
     },
-    services::executor::TransactionExecutionStatus,
+    services::executor::{
+        StorageReadReplayEvent,
+        TransactionExecutionStatus,
+    },
 };
 #[cfg(feature = "subscriptions")]
 use futures::{
@@ -98,6 +101,10 @@ use schema::{
     },
     da_compressed::DaCompressedBlockByHeightArgs,
     gas_price::BlockHorizonArgs,
+    storage_read_replay::{
+        StorageReadReplay,
+        StorageReadReplayArgs,
+    },
     tx::{
         TransactionsByOwnerConnectionArgs,
         TxArg,
@@ -652,6 +659,24 @@ impl FuelClient {
             .collect()
     }
 
+    /// Get storage read replay for a block
+    pub async fn storage_read_replay(
+        &self,
+        height: &BlockHeight,
+    ) -> io::Result<Vec<StorageReadReplayEvent>> {
+        let query: Operation<StorageReadReplay, StorageReadReplayArgs> =
+            StorageReadReplay::build(StorageReadReplayArgs {
+                height: (*height).into(),
+            });
+        Ok(self
+            .query(query)
+            .await
+            .map(|r| r.storage_read_replay)?
+            .into_iter()
+            .map(Into::into)
+            .collect())
+    }
+
     /// Estimate predicates for the transaction
     pub async fn estimate_predicates(&self, tx: &mut Transaction) -> io::Result<()> {
         let serialized_tx = tx.to_bytes();

crates/client/src/client/schema.rs

@@ -36,6 +36,7 @@ pub mod contract;
 pub mod da_compressed;
 pub mod message;
 pub mod node_info;
+pub mod storage_read_replay;
 pub mod upgrades;
 
 pub mod gas_price;

crates/client/src/client/schema/snapshots/fuel_core_client__client__schema__storage_read_replay__tests__execution_trace_block_tx_gql_output.snap

@@ -0,0 +1,11 @@
+---
+source: crates/client/src/client/schema/storage_read_replay.rs
+expression: query.query
+---
+mutation StorageReadReplay($height: U32!) {
+  storageReadReplay(height: $height) {
+    column
+    key
+    value
+  }
+}

crates/client/src/client/schema/snapshots/fuel_core_client__client__schema__storage_read_replay__tests__storage_read_replay_gql_output.snap

@@ -0,0 +1,11 @@
+---
+source: crates/client/src/client/schema/storage_read_replay.rs
+expression: query.query
+---
+query StorageReadReplay($height: U32!) {
+  storageReadReplay(height: $height) {
+    column
+    key
+    value
+  }
+}

crates/client/src/client/schema/storage_read_replay.rs

@@ -0,0 +1,56 @@
+use super::HexString;
+use crate::client::schema::{
+    schema,
+    U32,
+};
+
+#[derive(cynic::QueryFragment, Clone, Debug)]
+#[cynic(schema_path = "./assets/schema.sdl")]
+pub struct StorageReadReplayEvent {
+    pub column: U32,
+    pub key: HexString,
+    pub value: Option<HexString>,
+}
+impl From<StorageReadReplayEvent>
+    for fuel_core_types::services::executor::StorageReadReplayEvent
+{
+    fn from(event: StorageReadReplayEvent) -> Self {
+        fuel_core_types::services::executor::StorageReadReplayEvent {
+            column: event.column.into(),
+            key: event.key.into(),
+            value: event.value.map(Into::into),
+        }
+    }
+}
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct StorageReadReplayArgs {
+    pub height: U32,
+}
+
+/// Retrieves the transaction in opaque form
+#[derive(cynic::QueryFragment, Clone, Debug)]
+#[cynic(
+    schema_path = "./assets/schema.sdl",
+    graphql_type = "Query",
+    variables = "StorageReadReplayArgs"
+)]
+pub struct StorageReadReplay {
+    #[arguments(height: $height)]
+    pub storage_read_replay: Vec<StorageReadReplayEvent>,
+}
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+    use fuel_core_types::fuel_types::BlockHeight;
+
+    #[test]
+    fn storage_read_replay_gql_output() {
+        use cynic::QueryBuilder;
+        let query = StorageReadReplay::build(StorageReadReplayArgs {
+            height: BlockHeight::new(1234).into(),
+        });
+        insta::assert_snapshot!(query.query)
+    }
+}

crates/client/src/client/schema/tx.rs

@@ -310,7 +310,7 @@ impl TryFrom<DryRunTransactionStatus> for TransactionExecutionResult {
                 }
             }
             DryRunTransactionStatus::Unknown => {
-                return Err(Self::Error::UnknownVariant("DryRuynTxStatus"))
+                return Err(Self::Error::UnknownVariant("DryRunTxStatus"))
             }
         })
     }

crates/fuel-core/src/graphql_api.rs

@@ -66,6 +66,7 @@ pub struct Costs {
     pub get_peers: usize,
     pub estimate_predicates: usize,
     pub dry_run: usize,
+    pub storage_read_replay: usize,
     pub submit: usize,
     pub submit_and_await: usize,
     pub status_change: usize,
@@ -98,6 +99,7 @@ pub const DEFAULT_QUERY_COSTS: Costs = Costs {
     get_peers: 40001,
     estimate_predicates: 40001,
     dry_run: 12000,
+    storage_read_replay: 40001,
     submit: 40001,
     submit_and_await: 40001,
     status_change: 40001,

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

@@ -63,7 +63,10 @@ use fuel_core_types::{
     },
     fuel_vm::interpreter::Memory,
     services::{
-        executor::TransactionExecutionStatus,
+        executor::{
+            StorageReadReplayEvent,
+            TransactionExecutionStatus,
+        },
         graphql_api::ContractBalance,
         p2p::PeerInfo,
         txpool::TransactionStatus,
@@ -256,6 +259,11 @@ pub trait BlockProducerPort: Send + Sync {
         utxo_validation: Option<bool>,
         gas_price: Option<u64>,
     ) -> anyhow::Result<Vec<TransactionExecutionStatus>>;
+
+    async fn storage_read_replay(
+        &self,
+        height: BlockHeight,
+    ) -> anyhow::Result<Vec<StorageReadReplayEvent>>;
 }
 
 #[async_trait::async_trait]

crates/fuel-core/src/schema/tx.rs

@@ -77,6 +77,7 @@ use std::{
 };
 use types::{
     DryRunTransactionExecutionStatus,
+    StorageReadReplayEvent,
     Transaction,
 };
 
@@ -277,6 +278,31 @@ impl TxQuery {
             .map(Into::into)
             .collect()
     }
+
+    /// Get execution trace for an already-executed block.
+    #[graphql(complexity = "query_costs().storage_read_replay + child_complexity")]
+    async fn storage_read_replay(
+        &self,
+        ctx: &Context<'_>,
+        height: U32,
+    ) -> async_graphql::Result<Vec<StorageReadReplayEvent>> {
+        let config = ctx.data_unchecked::<GraphQLConfig>();
+        if !config.historical_execution {
+            return Err(anyhow::anyhow!(
+                "`--historical-execution` is required for this operation"
+            )
+            .into());
+        }
+
+        let block_height = height.into();
+        let block_producer = ctx.data_unchecked::<BlockProducer>();
+        Ok(block_producer
+            .storage_read_replay(block_height)
+            .await?
+            .into_iter()
+            .map(StorageReadReplayEvent::from)
+            .collect())
+    }
 }
 
 #[derive(Default)]

crates/fuel-core/src/schema/tx/types.rs

@@ -980,6 +980,39 @@ impl DryRunTransactionExecutionStatus {
     }
 }
 
+pub struct StorageReadReplayEvent {
+    column: U32,
+    key: HexString,
+    value: Option<HexString>,
+}
+
+impl From<fuel_core_types::services::executor::StorageReadReplayEvent>
+    for StorageReadReplayEvent
+{
+    fn from(event: fuel_core_types::services::executor::StorageReadReplayEvent) -> Self {
+        Self {
+            column: event.column.into(),
+            key: HexString(event.key),
+            value: event.value.map(HexString),
+        }
+    }
+}
+
+#[Object]
+impl StorageReadReplayEvent {
+    async fn column(&self) -> U32 {
+        self.column
+    }
+
+    async fn key(&self) -> HexString {
+        self.key.clone()
+    }
+
+    async fn value(&self) -> Option<HexString> {
+        self.value.clone()
+    }
+}
+
 #[tracing::instrument(level = "debug", skip(query, txpool), ret, err)]
 pub(crate) async fn get_tx_status(
     id: fuel_core_types::fuel_types::Bytes32,

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

@@ -46,7 +46,10 @@ use fuel_core_types::{
     fuel_types::BlockHeight,
     services::{
         block_importer::SharedImportResult,
-        executor::TransactionExecutionStatus,
+        executor::{
+            StorageReadReplayEvent,
+            TransactionExecutionStatus,
+        },
         p2p::PeerInfo,
         txpool::TransactionStatus,
     },
@@ -130,6 +133,13 @@ impl BlockProducerPort for BlockProducerAdapter {
             .dry_run(transactions, height, time, utxo_validation, gas_price)
             .await
     }
+
+    async fn storage_read_replay(
+        &self,
+        height: BlockHeight,
+    ) -> anyhow::Result<Vec<StorageReadReplayEvent>> {
+        self.block_producer.storage_read_replay(height).await
+    }
 }
 
 #[async_trait::async_trait]