feat: Add Chain Data tables

src/client/chain_data.rs

@@ -0,0 +1,21 @@
+use super::Client;
+
+use crate::errors::ClientError;
+use objects::BlockHeader;
+
+impl Client {
+    pub fn get_block_headers(
+        &self,
+        start: u32,
+        finish: u32,
+    ) -> Result<Vec<BlockHeader>, ClientError> {
+        let mut headers = Vec::new();
+        for block_number in start..=finish {
+            if let Ok(block_header) = self.store.get_block_header_by_num(block_number) {
+                headers.push(block_header)
+            }
+        }
+
+        Ok(headers)
+    }
+}

src/client/mod.rs

@@ -11,14 +11,15 @@ use objects::{accounts::AccountId, Digest};
 
 use crate::{
     config::ClientConfig,
-    errors::{ClientError, RpcApiError},
+    errors::{ClientError, RpcApiError, StoreError},
     store::{mock_executor_data_store::MockDataStore, Store},
 };
 
 #[cfg(any(test, feature = "testing"))]
 use crate::mock::MockRpcApi;
 
 pub mod accounts;
+pub mod chain_data;
 pub mod notes;
 pub mod transactions;
 
@@ -124,8 +125,18 @@ impl Client {
             })
             .collect::<Vec<_>>();
 
+        let new_block_header = match response.block_header {
+            Some(block_header) => match objects::BlockHeader::try_from(block_header) {
+                Ok(block_header) => Some(block_header),
+                Err(err) => {
+                    return Err(ClientError::StoreError(StoreError::ConvertionFailure(err)));
+                }
+            },
+            None => None,
+        };
+
         self.store
-            .apply_state_sync(new_block_num, new_nullifiers)
+            .apply_state_sync(new_block_num, new_nullifiers, new_block_header)
             .map_err(ClientError::StoreError)?;
 
         Ok(new_block_num)

src/errors.rs

@@ -1,8 +1,7 @@
 use core::fmt;
-use crypto::{
-    dsa::rpo_falcon512::FalconError,
-    utils::{DeserializationError, HexParseError},
-};
+use crypto::utils::DeserializationError;
+use crypto::{dsa::rpo_falcon512::FalconError, utils::HexParseError};
+use miden_node_proto::error::ParseError;
 use miden_tx::{TransactionExecutorError, TransactionProverError};
 use objects::{accounts::AccountId, AccountError, Digest, NoteError, TransactionScriptError};
 use tonic::{transport::Error as TransportError, Status as TonicStatus};
@@ -68,6 +67,9 @@ pub enum StoreError {
     NoteTagAlreadyTracked(u64),
     QueryError(rusqlite::Error),
     TransactionError(rusqlite::Error),
+    BlockHeaderNotFound(u32),
+    ChainMmrNodeNotFound(u64),
+    ConvertionFailure(ParseError),
     TransactionScriptError(TransactionScriptError),
     VaultDataNotFound(Digest),
 }
@@ -114,6 +116,13 @@ impl fmt::Display for StoreError {
                 write!(f, "error instantiating transaction script: {err}")
             }
             VaultDataNotFound(root) => write!(f, "account vault data for root {} not found", root),
+            BlockHeaderNotFound(block_number) => {
+                write!(f, "block header for block {} not found", block_number)
+            }
+            ChainMmrNodeNotFound(node_index) => {
+                write!(f, "chain mmr node at index {} not found", node_index)
+            }
+            ConvertionFailure(err) => write!(f, "failed to convert data: {err}"),
         }
     }
 }

src/lib.rs

@@ -203,6 +203,9 @@ mod tests {
             0
         );
 
+        // assert that we don't have any block headers prior to syncing state
+        assert_eq!(client.get_block_headers(10, 10).unwrap().len(), 0);
+
         // sync state
         let block_num = client.sync_state().await.unwrap();
 
@@ -238,6 +241,9 @@ mod tests {
                 .1
                 .chain_tip
         );
+
+        // verify that the database now holds the latest block header
+        assert_eq!(client.get_block_headers(10, 10).unwrap().len(), 1);
     }
 
     #[tokio::test]

src/mock.rs

@@ -3,18 +3,20 @@ use crate::client::{Client, FILTER_ID_SHIFT};
 use crate::store::mock_executor_data_store::MockDataStore;
 use crate::store::AuthInfo;
 use crypto::dsa::rpo_falcon512::KeyPair;
+use miden_node_proto::block_header::BlockHeader as NodeBlockHeader;
 use miden_node_proto::requests::SubmitProvenTransactionRequest;
 use miden_node_proto::responses::SubmitProvenTransactionResponse;
 use miden_node_proto::{
     account_id::AccountId as ProtoAccountId,
     requests::SyncStateRequest,
     responses::{NullifierUpdate, SyncStateResponse},
 };
+use mock::mock::block;
+use objects::{utils::collections::BTreeMap, StarkField};
 
 use miden_tx::TransactionExecutor;
 use objects::accounts::AccountType;
 use objects::assets::FungibleAsset;
-use objects::{utils::collections::BTreeMap, StarkField};
 
 /// Mock RPC API
 ///
@@ -93,12 +95,18 @@ fn generate_sync_state_mock_requests() -> BTreeMap<SyncStateRequest, SyncStateRe
         nullifiers,
     };
 
+    let chain_tip = 10;
+
+    // create a block header for the response
+    let block_header: objects::BlockHeader =
+        block::mock_block_header(chain_tip.into(), None, None, &[]);
+
     // create a state sync response
     let response = SyncStateResponse {
-        chain_tip: 10,
+        chain_tip,
         mmr_delta: None,
         block_path: None,
-        block_header: None,
+        block_header: Some(NodeBlockHeader::from(block_header)),
         accounts: vec![],
         notes: vec![],
         nullifiers: vec![NullifierUpdate {

src/store/chain_data.rs

@@ -0,0 +1,194 @@
+use super::Store;
+
+use crate::errors::StoreError;
+
+use clap::error::Result;
+
+use objects::{BlockHeader, ChainMmr};
+use rusqlite::params;
+
+type SerializedBlockHeaderData = (i64, String, String, String, String);
+type SerializedBlockHeaderParts = (i64, String, String, String, String);
+
+type SerializedChainMmrNodeData = String;
+type SerializedChainMmrNodeParts = (i64, String);
+
+impl Store {
+    // CHAIN DATA
+    // --------------------------------------------------------------------------------------------
+    pub fn insert_block_header(&mut self, block_header: BlockHeader) -> Result<(), StoreError> {
+        let (block_num, header, notes_root, sub_hash, chain_mmr) =
+            serialize_block_header(block_header)?;
+
+        const QUERY: &str = "\
+        INSERT INTO block_headers
+            (block_num, header, notes_root, sub_hash, chain_mmr)
+         VALUES (?, ?, ?, ?, ?)";
+
+        self.db
+            .execute(
+                QUERY,
+                params![block_num, header, notes_root, sub_hash, chain_mmr],
+            )
+            .map_err(StoreError::QueryError)
+            .map(|_| ())
+    }
+
+    pub fn get_block_header_by_num(&self, block_number: u32) -> Result<BlockHeader, StoreError> {
+        const QUERY: &str = "SELECT block_num, header, notes_root, sub_hash, chain_mmr FROM block_headers WHERE block_num = ?";
+        self.db
+            .prepare(QUERY)
+            .map_err(StoreError::QueryError)?
+            .query_map(params![block_number as i64], parse_block_headers_columns)
+            .map_err(StoreError::QueryError)?
+            .map(|result| {
+                result
+                    .map_err(StoreError::ColumnParsingError)
+                    .and_then(parse_block_header)
+            })
+            .next()
+            .ok_or(StoreError::BlockHeaderNotFound(block_number))?
+    }
+
+    pub fn insert_chain_mmr_node(&mut self, chain_mmr: ChainMmr) -> Result<(), StoreError> {
+        let node = serialize_chain_mmr(chain_mmr)?;
+
+        const QUERY: &str = "INSERT INTO chain_mmr_nodes (node) VALUES (?)";
+
+        self.db
+            .execute(QUERY, params![node])
+            .map_err(StoreError::QueryError)
+            .map(|_| ())
+    }
+
+    pub fn get_chain_mmr_hash_by_id(&self, id: u64) -> Result<ChainMmr, StoreError> {
+        const QUERY: &str = "SELECT id, node FROM chain_mmr_nodes WHERE id = ?";
+        self.db
+            .prepare(QUERY)
+            .map_err(StoreError::QueryError)?
+            .query_map(params![id as i64], parse_chain_mmr_nodes_columns)
+            .map_err(StoreError::QueryError)?
+            .map(|result| {
+                result
+                    .map_err(StoreError::ColumnParsingError)
+                    .and_then(parse_chain_mmr_nodes)
+            })
+            .next()
+            .ok_or(StoreError::ChainMmrNodeNotFound(id))?
+    }
+}
+
+// HELPERS
+// ================================================================================================
+
+fn serialize_block_header(
+    block_header: BlockHeader,
+) -> Result<SerializedBlockHeaderData, StoreError> {
+    let block_num: u64 = block_header.block_num().into();
+    let header =
+        serde_json::to_string(&block_header).map_err(StoreError::InputSerializationError)?;
+    let notes_root = serde_json::to_string(&block_header.note_root())
+        .map_err(StoreError::InputSerializationError)?;
+    let sub_hash = serde_json::to_string(&block_header.sub_hash())
+        .map_err(StoreError::InputSerializationError)?;
+    let chain_mmr = serde_json::to_string(&block_header.chain_root())
+        .map_err(StoreError::InputSerializationError)?;
+
+    Ok((block_num as i64, header, notes_root, sub_hash, chain_mmr))
+}
+
+fn parse_block_headers_columns(
+    row: &rusqlite::Row<'_>,
+) -> Result<SerializedBlockHeaderParts, rusqlite::Error> {
+    let block_num: i64 = row.get(0)?;
+    let header: String = row.get(1)?;
+    let notes_root: String = row.get(2)?;
+    let sub_hash: String = row.get(3)?;
+    let chain_mmr: String = row.get(4)?;
+    Ok((block_num, header, notes_root, sub_hash, chain_mmr))
+}
+
+fn parse_block_header(
+    serialized_block_header_parts: SerializedBlockHeaderParts,
+) -> Result<BlockHeader, StoreError> {
+    let (_, header, _, _, _) = serialized_block_header_parts;
+
+    serde_json::from_str(&header).map_err(StoreError::JsonDataDeserializationError)
+}
+
+fn serialize_chain_mmr(chain_mmr: ChainMmr) -> Result<SerializedChainMmrNodeData, StoreError> {
+    serde_json::to_string(&chain_mmr).map_err(StoreError::InputSerializationError)
+}
+
+fn parse_chain_mmr_nodes_columns(
+    row: &rusqlite::Row<'_>,
+) -> Result<SerializedChainMmrNodeParts, rusqlite::Error> {
+    let id = row.get(0)?;
+    let node = row.get(1)?;
+    Ok((id, node))
+}
+
+fn parse_chain_mmr_nodes(
+    serialized_chain_mmr_node_parts: SerializedChainMmrNodeParts,
+) -> Result<ChainMmr, StoreError> {
+    let (_, node) = serialized_chain_mmr_node_parts;
+
+    serde_json::from_str(&node).map_err(StoreError::JsonDataDeserializationError)
+}
+
+// TESTS
+// ================================================================================================
+#[cfg(test)]
+pub mod tests {
+    use mock::mock::block;
+    use objects::ChainMmr;
+
+    use crate::store::tests::create_test_store;
+
+    #[test]
+    fn test_block_header_insertion() {
+        let mut store = create_test_store();
+        let block_header = block::mock_block_header(0u8.into(), None, None, &[]);
+
+        assert!(store.insert_block_header(block_header).is_ok());
+    }
+
+    #[test]
+    fn test_block_header_by_number() {
+        let mut store = create_test_store();
+        let block_header = block::mock_block_header(0u8.into(), None, None, &[]);
+        store.insert_block_header(block_header).unwrap();
+
+        // Retrieving an existing block header should succeed
+        match store.get_block_header_by_num(0) {
+            Ok(block_header_from_db) => assert_eq!(block_header_from_db, block_header),
+            Err(e) => {
+                panic!("{:?}", e);
+            }
+        }
+
+        // Retrieving a non existing block header should fail
+        assert!(store.get_block_header_by_num(1).is_err());
+    }
+
+    #[test]
+    fn test_chain_mmr_node_insertion() {
+        let mut store = create_test_store();
+        let chain_mmr = ChainMmr::default();
+
+        assert!(store.insert_chain_mmr_node(chain_mmr).is_ok());
+    }
+
+    #[test]
+    fn test_chain_mmr_node_by_id() {
+        let mut store = create_test_store();
+        let chain_mmr = ChainMmr::default();
+        store.insert_chain_mmr_node(chain_mmr).unwrap();
+
+        // Retrieving an existing chain mmr node should succeed
+        assert!(store.get_chain_mmr_hash_by_id(1).is_ok());
+
+        // Retrieving a non existing chain mmr node should fail
+        assert!(store.get_chain_mmr_hash_by_id(2).is_err());
+    }
+}