GraphQL: historical contract storage and balances

.changes/added/2682.md

@@ -0,0 +1 @@
+Added GraphQL APIs to get contract storage and balances for current and past blocks.

.changes/fixed/2682.md

@@ -0,0 +1 @@
+Fixed the issue with RPC consistency feature for the subscriptions(without the fix first we perform the logic of the query, and only after verify the required height).

crates/client/assets/schema.sdl

@@ -1034,6 +1034,18 @@ type Query {
 	consensusParameters(version: Int!): ConsensusParameters!
 	stateTransitionBytecodeByVersion(version: Int!): StateTransitionBytecode
 	stateTransitionBytecodeByRoot(root: HexString!): StateTransitionBytecode!
+	"""
+	Get storage slot values for a contract at a specific block height.
+	Use the latest block height if not provided.
+	Requires historical execution config to be enabled.
+	"""
+	contractSlotValues(contractId: ContractId!, blockHeight: U32, storageSlots: [Bytes32!]!): [StorageSlot!]!
+	"""
+	Get balance values for a contract at a specific block height.
+	Use the latest block height if not provided.
+	Requires historical execution config to be enabled.
+	"""
+	contractBalanceValues(contractId: ContractId!, blockHeight: U32, assets: [AssetId!]!): [ContractBalance!]!
 }
 
 type Receipt {
@@ -1166,6 +1178,11 @@ type StorageReadReplayEvent {
 	value: HexString
 }
 
+type StorageSlot {
+	key: Bytes32!
+	value: HexString!
+}
+
 
 scalar SubId
 
@@ -1204,6 +1221,8 @@ type Subscription {
 	SubmittedStatus` as an intermediate state.
 	"""
 	submitAndAwaitStatus(tx: HexString!): TransactionStatus!
+	contractStorageSlots(contractId: ContractId!): StorageSlot!
+	contractStorageBalances(contractId: ContractId!): ContractBalance!
 }
 
 type SuccessStatus {

crates/client/src/client.rs

@@ -850,6 +850,103 @@ impl FuelClient {
         Ok(stream)
     }
 
+    /// Requests all storage slots for the `contract_id`.
+    #[cfg(feature = "subscriptions")]
+    pub async fn contract_storage_slots<'a>(
+        &'a self,
+        contract_id: &'a ContractId,
+    ) -> io::Result<impl Stream<Item = io::Result<(Bytes32, Vec<u8>)>> + 'a> {
+        use cynic::SubscriptionBuilder;
+        use schema::storage::ContractStorageSlotsArgs;
+        let s = schema::storage::ContractStorageSlots::build(ContractStorageSlotsArgs {
+            contract_id: (*contract_id).into(),
+        });
+
+        let stream = self.subscribe(s).await?.map(
+            |result: io::Result<schema::storage::ContractStorageSlots>| {
+                let result: (Bytes32, Vec<u8>) = result?.contract_storage_slots.into();
+                Result::<_, io::Error>::Ok(result)
+            },
+        );
+
+        Ok(stream)
+    }
+
+    /// Requests all storage balances for the `contract_id`.
+    #[cfg(feature = "subscriptions")]
+    pub async fn contract_storage_balances<'a>(
+        &'a self,
+        contract_id: &'a ContractId,
+    ) -> io::Result<impl Stream<Item = io::Result<schema::contract::ContractBalance>> + 'a>
+    {
+        use cynic::SubscriptionBuilder;
+        use schema::{
+            contract::ContractBalance,
+            storage::ContractStorageBalancesArgs,
+        };
+        let s = schema::storage::ContractStorageBalances::build(
+            ContractStorageBalancesArgs {
+                contract_id: (*contract_id).into(),
+            },
+        );
+
+        let stream = self.subscribe(s).await?.map(
+            |result: io::Result<schema::storage::ContractStorageBalances>| {
+                let result: ContractBalance = result?.contract_storage_balances;
+                Result::<_, io::Error>::Ok(result)
+            },
+        );
+
+        Ok(stream)
+    }
+
+    pub async fn contract_slots_values(
+        &self,
+        contract_id: &ContractId,
+        block_height: Option<BlockHeight>,
+        requested_storage_slots: Vec<Bytes32>,
+    ) -> io::Result<Vec<(Bytes32, Vec<u8>)>> {
+        let query = schema::storage::ContractSlotValues::build(
+            schema::storage::ContractSlotValuesArgs {
+                contract_id: (*contract_id).into(),
+                block_height: block_height.map(|b| (*b).into()),
+                storage_slots: requested_storage_slots
+                    .into_iter()
+                    .map(Into::into)
+                    .collect(),
+            },
+        );
+
+        self.query(query)
+            .await
+            .map(|r| r.contract_slot_values.into_iter().map(Into::into).collect())
+    }
+
+    pub async fn contract_balance_values(
+        &self,
+        contract_id: &ContractId,
+        block_height: Option<BlockHeight>,
+        requested_storage_slots: Vec<AssetId>,
+    ) -> io::Result<Vec<schema::contract::ContractBalance>> {
+        let query = schema::storage::ContractBalanceValues::build(
+            schema::storage::ContractBalanceValuesArgs {
+                contract_id: (*contract_id).into(),
+                block_height: block_height.map(|b| (*b).into()),
+                assets: requested_storage_slots
+                    .into_iter()
+                    .map(Into::into)
+                    .collect(),
+            },
+        );
+
+        self.query(query).await.map(|r| {
+            r.contract_balance_values
+                .into_iter()
+                .map(Into::into)
+                .collect()
+        })
+    }
+
     pub async fn start_session(&self) -> io::Result<String> {
         let query = schema::StartSession::build(());
 

crates/client/src/client/schema.rs

@@ -44,6 +44,7 @@ pub mod primitives;
 pub mod tx;
 
 pub mod relayed_tx;
+pub mod storage;
 
 #[derive(cynic::QueryFragment, Clone, Debug)]
 #[cynic(schema_path = "./assets/schema.sdl", graphql_type = "Query")]

crates/client/src/client/schema/storage.rs

@@ -0,0 +1,93 @@
+use crate::client::schema::{
+    contract::ContractBalance,
+    schema,
+    AssetId,
+    Bytes32,
+    ContractId,
+    HexString,
+    U32,
+};
+use fuel_core_types::fuel_tx;
+
+#[derive(cynic::QueryFragment, Clone, Debug)]
+#[cynic(
+    schema_path = "./assets/schema.sdl",
+    graphql_type = "Subscription",
+    variables = "ContractStorageSlotsArgs"
+)]
+pub struct ContractStorageSlots {
+    #[arguments(contractId: $contract_id)]
+    pub contract_storage_slots: StorageSlot,
+}
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct ContractStorageSlotsArgs {
+    /// The ID of the contract.
+    pub contract_id: ContractId,
+}
+
+#[derive(cynic::QueryFragment, Clone, Debug)]
+#[cynic(
+    schema_path = "./assets/schema.sdl",
+    graphql_type = "Query",
+    variables = "ContractSlotValuesArgs"
+)]
+pub struct ContractSlotValues {
+    #[arguments(contractId: $contract_id, blockHeight: $block_height, storageSlots: $storage_slots)]
+    pub contract_slot_values: Vec<StorageSlot>,
+}
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct ContractSlotValuesArgs {
+    pub contract_id: ContractId,
+    pub block_height: Option<U32>,
+    pub storage_slots: Vec<Bytes32>,
+}
+
+#[derive(cynic::QueryFragment, Clone, Debug)]
+#[cynic(schema_path = "./assets/schema.sdl")]
+pub struct StorageSlot {
+    pub key: Bytes32,
+    pub value: HexString,
+}
+
+impl From<StorageSlot> for (fuel_tx::Bytes32, Vec<u8>) {
+    fn from(value: StorageSlot) -> Self {
+        (value.key.into(), value.value.into())
+    }
+}
+
+#[derive(cynic::QueryFragment, Clone, Debug)]
+#[cynic(
+    schema_path = "./assets/schema.sdl",
+    graphql_type = "Subscription",
+    variables = "ContractStorageBalancesArgs"
+)]
+pub struct ContractStorageBalances {
+    #[arguments(contractId: $contract_id)]
+    pub contract_storage_balances: ContractBalance,
+}
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct ContractStorageBalancesArgs {
+    /// The ID of the contract.
+    pub contract_id: ContractId,
+}
+
+#[derive(cynic::QueryFragment, Clone, Debug)]
+#[cynic(
+    schema_path = "./assets/schema.sdl",
+    graphql_type = "Query",
+    variables = "ContractBalanceValuesArgs"
+)]
+pub struct ContractBalanceValues {
+    #[arguments(contractId: $contract_id, blockHeight: $block_height, assets: $assets)]
+    pub contract_balance_values: Vec<ContractBalance>,
+}
+
+#[derive(cynic::QueryVariables, Debug)]
+pub struct ContractBalanceValuesArgs {
+    pub contract_id: ContractId,
+    pub block_height: Option<U32>,
+    pub assets: Vec<AssetId>,
+}

crates/client/src/client/types.rs

@@ -318,3 +318,8 @@ impl TryFrom<TransactionType> for Transaction {
         }
     }
 }
+
+pub struct StorageSlot {
+    pub key: primitives::Bytes32,
+    pub value: primitives::Bytes,
+}

crates/fuel-core/Cargo.toml

@@ -45,6 +45,7 @@ hex = { workspace = true }
 hyper = { workspace = true }
 indicatif = { workspace = true, default-features = true }
 itertools = { workspace = true }
+mockall = { workspace = true, optional = true }
 num_cpus = { version = "1.16.0", optional = true }
 parking_lot = { workspace = true }
 paste = { workspace = true }
@@ -85,7 +86,6 @@ fuel-core-types = { path = "./../types", features = ["test-helpers"] }
 fuel-core-upgradable-executor = { workspace = true, features = [
   "test-helpers",
 ] }
-mockall = { workspace = true }
 proptest = { workspace = true }
 test-case = { workspace = true }
 test-strategy = { workspace = true }
@@ -114,6 +114,7 @@ test-helpers = [
   "fuel-core-services/test-helpers",
   "fuel-core-shared-sequencer?/test-helpers",
   "fuel-core-importer/test-helpers",
+  "dep:mockall",
 ]
 # features to enable in production, but increase build times
 rocksdb-production = ["rocksdb", "rocksdb/jemalloc"]

crates/fuel-core/src/database.rs

@@ -131,8 +131,10 @@ where
 
 pub type Database<Description = OnChain, Stage = RegularStage<Description>> =
     GenericDatabase<DataSource<Description, Stage>, Empty>;
+pub type OnChainKeyValueView = KeyValueView<ColumnType<OnChain>, HeightType<OnChain>>;
 pub type OnChainIterableKeyValueView =
     IterableKeyValueView<ColumnType<OnChain>, HeightType<OnChain>>;
+pub type OffChainKeyValueView = KeyValueView<ColumnType<OffChain>, HeightType<OffChain>>;
 pub type OffChainIterableKeyValueView =
     IterableKeyValueView<ColumnType<OffChain>, HeightType<OffChain>>;
 pub type RelayerIterableKeyValueView =

crates/fuel-core/src/graphql_api.rs

@@ -1,3 +1,4 @@
+use async_graphql::Context;
 use fuel_core_storage::{
     Error as StorageError,
     IsNotFound,
@@ -168,3 +169,15 @@ impl<T> IntoApiResult<T> for Result<T, StorageError> {
         }
     }
 }
+
+pub fn require_historical_execution(ctx: &Context<'_>) -> async_graphql::Result<()> {
+    let config = ctx.data_unchecked::<Config>();
+
+    if config.historical_execution {
+        Ok(())
+    } else {
+        Err(async_graphql::Error::new(
+            "`--historical-execution` is required for this operation",
+        ))
+    }
+}