refactor: Move Block type into essential-node-types. Introduce BlockHeader. (#169)

* refactor: Move Block type into essential-node-types. Introduce BlockHeader.

* refactor: Complete migration of Block type to essential-node-types

* deps: bump base versions (#171)

---------

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

Author: mitchmindtree

Cargo.lock

@@ -17,10 +17,10 @@ axum = "0.7.7"
 clap = { version = "4.5", features = ["derive"] }
 crossbeam = "0.8"
 dirs = "5"
-essential-check = "0.10.0"
-essential-hash = "0.8.0"
-essential-sign = "0.8.0"
-essential-types = "0.6.0"
+essential-check = "0.11.0"
+essential-hash = "0.9.0"
+essential-sign = "0.9.0"
+essential-types = "0.7.0"
 futures = "0.3.30"
 hex = "0.4.3"
 http = "1.1.0"

Cargo.toml

@@ -9,8 +9,8 @@ use axum::{
     Json,
 };
 use essential_node::db;
-use essential_node_types::block_notify::BlockRx;
-use essential_types::{convert::word_from_bytes, Block, ContentAddress, Value, Word};
+use essential_node_types::{block_notify::BlockRx, Block};
+use essential_types::{convert::word_from_bytes, ContentAddress, Value, Word};
 use futures::{Stream, StreamExt};
 use serde::Deserialize;
 use thiserror::Error;

crates/node-api/src/endpoint.rs

@@ -1,7 +1,7 @@
 use essential_node::{self as node};
 use essential_node_api as node_api;
-use essential_node_types::block_notify::BlockTx;
-use essential_types::{convert::bytes_from_word, Block, Value};
+use essential_node_types::{block_notify::BlockTx, Block};
+use essential_types::{convert::bytes_from_word, Value};
 use futures::{StreamExt, TryStreamExt};
 use tokio_util::{
     bytes::{self, Buf},

crates/node-api/tests/endpoints.rs

@@ -15,10 +15,11 @@ pub use error::QueryError;
 use essential_hash::content_addr;
 #[doc(inline)]
 pub use essential_node_db_sql as sql;
+use essential_node_types::{block, Block, BlockHeader};
 use essential_types::{
     convert::{bytes_from_word, word_from_bytes},
     solution::{Mutation, Solution, SolutionSet},
-    Block, ContentAddress, Hash, Key, PredicateAddress, Value, Word,
+    ContentAddress, Hash, Key, PredicateAddress, Value, Word,
 };
 use futures::Stream;
 #[cfg(feature = "pool")]
@@ -71,14 +72,12 @@ pub fn create_tables(tx: &Transaction) -> rusqlite::Result<()> {
 /// Returns the `ContentAddress` of the inserted block.
 pub fn insert_block(tx: &Transaction, block: &Block) -> rusqlite::Result<ContentAddress> {
     // Insert the header.
-    let secs = block.timestamp.as_secs();
-    let nanos = block.timestamp.subsec_nanos() as u64;
+    let secs = block.header.timestamp.as_secs();
+    let nanos = block.header.timestamp.subsec_nanos() as u64;
     let solution_set_addrs: Vec<ContentAddress> =
         block.solution_sets.iter().map(content_addr).collect();
-    let block_address = essential_hash::block_addr::from_block_and_solution_set_addrs_slice(
-        block,
-        &solution_set_addrs,
-    );
+    let block_address =
+        block::addr::from_header_and_solution_set_addrs_slice(&block.header, &solution_set_addrs);
 
     // TODO: Use real parent block address once blocks have parent addresses.
     let parent_block_address = ContentAddress([0; 32]);
@@ -88,7 +87,7 @@ pub fn insert_block(tx: &Transaction, block: &Block) -> rusqlite::Result<Content
         named_params! {
             ":block_address": block_address.0,
             ":parent_block_address": parent_block_address.0,
-            ":number": block.number,
+            ":number": block.header.number,
             ":timestamp_secs": secs,
             ":timestamp_nanos": nanos,
         },
@@ -307,7 +306,7 @@ pub fn query_state(
 pub fn get_block_header(
     conn: &Connection,
     block_address: &ContentAddress,
-) -> rusqlite::Result<Option<(Word, Duration)>> {
+) -> rusqlite::Result<Option<BlockHeader>> {
     conn.query_row(
         sql::query::GET_BLOCK_HEADER,
         named_params! {
@@ -318,7 +317,7 @@ pub fn get_block_header(
             let timestamp_secs: u64 = row.get("timestamp_secs")?;
             let timestamp_nanos: u32 = row.get("timestamp_nanos")?;
             let timestamp = Duration::new(timestamp_secs, timestamp_nanos);
-            Ok((number, timestamp))
+            Ok(BlockHeader { number, timestamp })
         },
     )
     .optional()
@@ -329,7 +328,7 @@ pub fn get_block(
     tx: &Transaction,
     block_address: &ContentAddress,
 ) -> Result<Option<Block>, QueryError> {
-    let Some((block_number, timestamp)) = get_block_header(tx, block_address)? else {
+    let Some(header) = get_block_header(tx, block_address)? else {
         return Ok(None);
     };
     let mut stmt = tx.prepare(sql::query::GET_BLOCK)?;
@@ -344,8 +343,7 @@ pub fn get_block(
     )?;
 
     let mut block = Block {
-        number: block_number,
-        timestamp,
+        header,
         solution_sets: vec![],
     };
     for res in rows {
@@ -461,8 +459,10 @@ pub fn list_blocks(tx: &Transaction, block_range: Range<Word>) -> Result<Vec<Blo
             _ => {
                 last_block_address = Some(block_address);
                 blocks.push(Block {
-                    number: block_number,
-                    timestamp,
+                    header: BlockHeader {
+                        number: block_number,
+                        timestamp,
+                    },
                     solution_sets: vec![],
                 });
                 blocks.last_mut().expect("last block must exist")
@@ -528,8 +528,10 @@ pub fn list_blocks_by_time(
             _ => {
                 last_block_address = Some(block_address);
                 blocks.push(Block {
-                    number: block_number,
-                    timestamp,
+                    header: BlockHeader {
+                        number: block_number,
+                        timestamp,
+                    },
                     solution_sets: vec![],
                 });
                 blocks.last_mut().expect("last block must exist")
@@ -615,8 +617,10 @@ pub fn list_unchecked_blocks(
             _ => {
                 last_block_address = Some(block_address);
                 blocks.push(Block {
-                    number: block_number,
-                    timestamp,
+                    header: BlockHeader {
+                        number: block_number,
+                        timestamp,
+                    },
                     solution_sets: vec![],
                 });
                 blocks.last_mut().expect("last block must exist")

crates/node-db/src/lib.rs

@@ -5,8 +5,8 @@
 
 use crate::{with_tx, AcquireConnection, AwaitNewBlock, QueryError};
 use core::ops::Range;
-use essential_node_types::block_notify::BlockRx;
-use essential_types::{solution::SolutionSet, Block, ContentAddress, Key, Value, Word};
+use essential_node_types::{block_notify::BlockRx, Block};
+use essential_types::{solution::SolutionSet, ContentAddress, Key, Value, Word};
 use futures::Stream;
 use rusqlite_pool::tokio::{AsyncConnectionHandle, AsyncConnectionPool};
 use std::{path::PathBuf, sync::Arc, time::Duration};
@@ -240,11 +240,15 @@ impl ConnectionPool {
             let Some(addr) = crate::get_latest_finalized_block_address(&tx)? else {
                 return Ok(None);
             };
-            let Some((number, _)) = crate::get_block_header(&tx, &addr)? else {
+            let Some(header) = crate::get_block_header(&tx, &addr)? else {
                 return Ok(None);
             };
-            let value =
-                crate::finalized::query_state_inclusive_block(&tx, &contract_ca, &key, number)?;
+            let value = crate::finalized::query_state_inclusive_block(
+                &tx,
+                &contract_ca,
+                &key,
+                header.number,
+            )?;
             tx.finish()?;
             Ok(value)
         })

crates/node-db/src/pool.rs

@@ -37,8 +37,8 @@ fn test_insert_block() {
         let timestamp_nanos: u32 = row.get(2).expect("timestamp_nanos");
         let timestamp = Duration::new(timestamp_secs, timestamp_nanos);
 
-        assert_eq!(id, block.number);
-        assert_eq!(timestamp, block.timestamp);
+        assert_eq!(id, block.header.number);
+        assert_eq!(timestamp, block.header.timestamp);
 
         // Verify that the solution sets were inserted correctly
         for solution_set in block.solution_sets.iter() {
@@ -241,14 +241,14 @@ fn test_failed_block() {
     // Check failed blocks.
     let failed_blocks = node_db::list_failed_blocks(&conn, 0..(NUM_BLOCKS + 10)).unwrap();
     assert_eq!(failed_blocks.len(), 1);
-    assert_eq!(failed_blocks[0].0, blocks[0].number);
+    assert_eq!(failed_blocks[0].0, blocks[0].header.number);
     assert_eq!(failed_blocks[0].1, solution_set_addr);
 
     // Same failed block should not be inserted again.
     node_db::insert_failed_block(&conn, &block_address, &solution_set_addr).unwrap();
     let failed_blocks = node_db::list_failed_blocks(&conn, 0..(NUM_BLOCKS + 10)).unwrap();
     assert_eq!(failed_blocks.len(), 1);
-    assert_eq!(failed_blocks[0].0, blocks[0].number);
+    assert_eq!(failed_blocks[0].0, blocks[0].header.number);
     assert_eq!(failed_blocks[0].1, solution_set_addr);
 
     // Insert another failed block.
@@ -266,7 +266,7 @@ fn test_failed_block() {
     .unwrap();
 
     assert_eq!(failed_blocks.len(), 2);
-    assert_eq!(failed_blocks[1].0, blocks[1].number);
+    assert_eq!(failed_blocks[1].0, blocks[1].header.number);
     assert_eq!(failed_blocks[1].1, solution_set_addr);
 }