feat(sync): add StateSyncClient and SyncBlock (#2007)

Cargo.toml

@@ -48,6 +48,7 @@ members = [
   "crates/starknet_sequencer_infra",
   "crates/starknet_sequencer_node",
   "crates/starknet_sierra_compile",
+  "crates/starknet_state_sync_types",
   "crates/starknet_task_executor",
   "workspace_tests",
 ]

crates/starknet_state_sync_types/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "starknet_state_sync_types"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+repository.workspace = true
+
+[lints]
+workspace = true
+
+[dependencies]
+async-trait.workspace = true
+serde = { workspace = true, features = ["derive"] }
+starknet_api.workspace = true
+starknet_sequencer_infra.workspace = true
+thiserror.workspace = true

crates/starknet_state_sync_types/src/communication.rs

@@ -0,0 +1,30 @@
+use async_trait::async_trait;
+use starknet_api::block::BlockNumber;
+use starknet_sequencer_infra::component_client::ClientError;
+use thiserror::Error;
+
+use crate::errors::StateSyncError;
+use crate::state_sync_types::SyncBlock;
+
+#[async_trait]
+pub trait StateSyncClient: Send + Sync {
+    /// Request for a block at a specific height.
+    /// If the block doesn't exist, or if the sync didn't download it yet, returns None.
+    async fn get_block(
+        &self,
+        block_number: BlockNumber,
+    ) -> StateSyncClientResult<Option<SyncBlock>>;
+
+    // TODO: Add state reader methods for gateway.
+}
+
+#[derive(Clone, Debug, Error)]
+pub enum StateSyncClientError {
+    #[error(transparent)]
+    ClientError(#[from] ClientError),
+    #[error(transparent)]
+    StateSyncError(#[from] StateSyncError),
+}
+pub type StateSyncClientResult<T> = Result<T, StateSyncClientError>;
+
+// TODO: Add client types and request/response enums

crates/starknet_state_sync_types/src/errors.rs

@@ -0,0 +1,6 @@
+use serde::{Deserialize, Serialize};
+use thiserror::Error;
+
+// This error is defined even though it's empty to be compatible with the other components.
+#[derive(Debug, Error, Serialize, Deserialize, Clone)]
+pub enum StateSyncError {}

crates/starknet_state_sync_types/src/lib.rs

@@ -0,0 +1,3 @@
+pub mod communication;
+pub mod errors;
+pub mod state_sync_types;

crates/starknet_state_sync_types/src/state_sync_types.rs

@@ -0,0 +1,19 @@
+use serde::{Deserialize, Serialize};
+use starknet_api::state::ThinStateDiff;
+use starknet_api::transaction::TransactionHash;
+
+use crate::errors::StateSyncError;
+
+pub type StateSyncResult<T> = Result<T, StateSyncError>;
+
+/// A block that came from the state sync.
+/// Contains all the data needed to update the state of the system about this block.
+///
+/// Blocks that came from the state sync are trusted. Therefore, SyncBlock doesn't contain data
+/// needed for verifying the block
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct SyncBlock {
+    pub state_diff: ThinStateDiff,
+    // TODO: decide if we want block hash, parent block hash and full classes here.
+    pub transaction_hashes: Vec<TransactionHash>,
+}