feat(ethexe-db): db versioning

.gitignore

@@ -23,3 +23,4 @@ utils/**/fuzz/fuzz/*
 fuzz_run
 lazy_pages_fuzz_run
 seed.bin
+.vscode/settings.json

Cargo.toml

@@ -111,6 +111,7 @@ members = [
     "ethexe/*",
     "ethexe/runtime/common",
     "ethexe/service/utils",
+    "ethexe/db/init",
 ]
 
 [workspace.dependencies]
@@ -332,6 +333,7 @@ ethexe-rpc = { path = "ethexe/rpc", default-features = false }
 ethexe-common = { path = "ethexe/common", default-features = false }
 ethexe-compute = { path = "ethexe/compute", default-features = false }
 ethexe-blob-loader = { path = "ethexe/blob-loader", default-features = false }
+ethexe-db-init = { path = "ethexe/db/init", default-features = false }
 
 # Common executor between `sandbox-host` and `lazy-pages-fuzzer`
 wasmi = { version = "0.38" }
@@ -592,6 +594,7 @@ ignored = [
     "pallet-authorship",
     "pallet-timestamp",
     "sp-application-crypto",
+    "ethexe-sdk",
 ]
 
 [profile.dev.package.corosensei]

core/Cargo.toml

@@ -41,9 +41,6 @@ serde = { workspace = true, features = ["derive"], optional = true }
 impl-serde = { workspace = true, optional = true }
 gear-workspace-hack.workspace = true
 
-[package.metadata.cargo-shear]
-ignored = ["impl-serde"]
-
 [dev-dependencies]
 tracing-subscriber.workspace = true
 wat.workspace = true

ethexe/cli/src/commands/check.rs

@@ -20,10 +20,10 @@ use anyhow::{Context, Result, anyhow, ensure};
 use clap::Parser;
 use ethexe_common::{
     Announce, HashOf, SimpleBlockData,
-    db::{AnnounceStorageRO, LatestData, LatestDataStorageRO, OnChainStorageRO},
+    db::{AnnounceStorageRO, DBGlobals, GlobalsStorageRO, OnChainStorageRO},
 };
 use ethexe_db::{
-    Database, RocksDatabase,
+    Database, RawDatabase, RocksDatabase,
     iterator::{BlockNode, DatabaseIterator},
     verifier::IntegrityVerifier,
     visitor::{self},
@@ -81,15 +81,13 @@ impl CheckCommand {
         }
 
         let rocks_db = RocksDatabase::open(self.db).context("failed to open rocks database")?;
-        let db = Database::from_one(&rocks_db);
+        let db = Database::try_from_raw(RawDatabase::from_one(&rocks_db))?;
 
-        let latest_data = db
-            .latest_data()
-            .ok_or_else(|| anyhow!("no latest data found in db"))?;
+        let globals = db.globals().clone();
 
         let checker = Checker {
             db,
-            latest_data,
+            globals,
             progress_bar: !self.verbose,
             chunk_size: self.chunk_size,
             canonical_quarantine: self.canonical_quarantine,
@@ -116,7 +114,7 @@ impl CheckCommand {
 #[derive(Clone)]
 struct Checker {
     db: Database,
-    latest_data: LatestData,
+    globals: DBGlobals,
     progress_bar: bool,
     chunk_size: usize,
     canonical_quarantine: u8,
@@ -125,8 +123,8 @@ struct Checker {
 impl Checker {
     async fn integrity_check(&self) -> Result<()> {
         let db = &self.db;
-        let bottom = self.latest_data.start_block_hash;
-        let head = self.latest_data.synced_block.hash;
+        let bottom = self.globals.start_block_hash;
+        let head = self.globals.latest_synced_block.hash;
 
         let bottom = db
             .block_header(bottom)
@@ -199,8 +197,8 @@ impl Checker {
 
     async fn computation_check(&self) -> Result<()> {
         let db = &self.db;
-        let bottom = self.latest_data.start_announce_hash;
-        let head = self.latest_data.computed_announce_hash;
+        let bottom = self.globals.start_announce_hash;
+        let head = self.globals.latest_computed_announce_hash;
         let progress_bar = self.progress_bar;
         let chunk_size = self.chunk_size;
         let canonical_quarantine = self.canonical_quarantine;

ethexe/common/src/db.rs

@@ -19,7 +19,7 @@
 //! Common db types and traits.
 
 use crate::{
-    Announce, BlockHeader, CodeBlobInfo, Digest, HashOf, ProgramStates, ProtocolTimelines,
+    Address, Announce, BlockHeader, CodeBlobInfo, Digest, HashOf, ProgramStates, ProtocolTimelines,
     Schedule, SimpleBlockData, ValidatorsVec,
     events::BlockEvent,
     gear::StateTransition,
@@ -114,15 +114,13 @@ pub trait OnChainStorageRO {
     fn validators(&self, era_index: u64) -> Option<ValidatorsVec>;
     // TODO kuzmindev: temporal solution - must move into block meta or something else.
     fn block_validators_committed_for_era(&self, block_hash: H256) -> Option<u64>;
-    fn protocol_timelines(&self) -> Option<ProtocolTimelines>;
 }
 
 #[auto_impl::auto_impl(&)]
 pub trait OnChainStorageRW: OnChainStorageRO {
     fn set_block_header(&self, block_hash: H256, header: BlockHeader);
     fn set_block_events(&self, block_hash: H256, events: &[BlockEvent]);
     fn set_code_blob_info(&self, code_id: CodeId, code_info: CodeBlobInfo);
-    fn set_protocol_timelines(&self, timelines: ProtocolTimelines);
     fn set_validators(&self, era_index: u64, validator_set: ValidatorsVec);
     fn set_block_validators_committed_for_era(&self, block_hash: H256, era_index: u64);
     fn set_block_synced(&self, block_hash: H256);
@@ -174,43 +172,6 @@ pub trait AnnounceStorageRW: AnnounceStorageRO {
     );
 }
 
-#[derive(Debug, Clone, Default, Encode, Decode, TypeInfo, PartialEq, Eq)]
-pub struct LatestData {
-    /// Latest synced block
-    pub synced_block: SimpleBlockData,
-    /// Latest prepared block hash
-    pub prepared_block_hash: H256,
-    /// Latest computed announce hash
-    pub computed_announce_hash: HashOf<Announce>,
-    /// Genesis block hash
-    pub genesis_block_hash: H256,
-    /// Genesis announce hash
-    pub genesis_announce_hash: HashOf<Announce>,
-    /// Start block hash: genesis or defined by fast-sync
-    pub start_block_hash: H256,
-    /// Start announce hash: genesis or defined by fast-sync
-    pub start_announce_hash: HashOf<Announce>,
-}
-
-#[auto_impl::auto_impl(&, Box)]
-pub trait LatestDataStorageRO {
-    fn latest_data(&self) -> Option<LatestData>;
-}
-
-#[auto_impl::auto_impl(&)]
-pub trait LatestDataStorageRW: LatestDataStorageRO {
-    fn set_latest_data(&self, data: LatestData);
-    fn mutate_latest_data(&self, f: impl FnOnce(&mut LatestData)) -> Option<()> {
-        if let Some(mut latest_data) = self.latest_data() {
-            f(&mut latest_data);
-            self.set_latest_data(latest_data);
-            Some(())
-        } else {
-            None
-        }
-    }
-}
-
 pub struct PreparedBlockData {
     pub header: BlockHeader,
     pub events: Vec<BlockEvent>,
@@ -228,6 +189,67 @@ pub struct ComputedAnnounceData {
     pub schedule: Schedule,
 }
 
+#[derive(Debug, Clone, Encode, Decode, TypeInfo, PartialEq, Eq)]
+pub struct DBConfig {
+    pub version: u32,
+    pub chain_id: u64,
+    pub router_address: Address,
+    pub timelines: ProtocolTimelines,
+    pub genesis_block_hash: H256,
+    pub genesis_announce_hash: HashOf<Announce>,
+}
+
+#[derive(Debug, Clone, Encode, Decode, TypeInfo, PartialEq, Eq)]
+pub struct DBGlobals {
+    pub start_block_hash: H256,
+    pub start_announce_hash: HashOf<Announce>,
+    pub latest_synced_block: SimpleBlockData,
+    pub latest_prepared_block_hash: H256,
+    pub latest_computed_announce_hash: HashOf<Announce>,
+}
+
+#[cfg(feature = "std")]
+mod std_interfaces {
+    use super::{DBConfig, DBGlobals};
+    use std::sync::RwLockReadGuard;
+
+    #[auto_impl::auto_impl(&, Box)]
+    pub trait GlobalsStorageRO {
+        fn globals(&self) -> RwLockReadGuard<'_, DBGlobals>;
+    }
+
+    #[auto_impl::auto_impl(&, Box)]
+    pub trait GlobalsStorageRW: GlobalsStorageRO {
+        fn globals_mutate<R>(&self, f: impl FnMut(&mut DBGlobals) -> R) -> R;
+    }
+
+    #[auto_impl::auto_impl(&, Box)]
+    pub trait ConfigStorageRO {
+        fn config(&self) -> RwLockReadGuard<'_, DBConfig>;
+    }
+}
+
+#[cfg(feature = "std")]
+pub use std_interfaces::{ConfigStorageRO, GlobalsStorageRO, GlobalsStorageRW};
+
+#[cfg(feature = "mock")]
+mod mock_interfaces {
+    use super::{DBConfig, DBGlobals};
+
+    #[auto_impl::auto_impl(&, Box)]
+    pub trait SetGlobals {
+        fn set_globals(&self, globals: DBGlobals);
+    }
+
+    #[auto_impl::auto_impl(&, Box)]
+    pub trait SetConfig {
+        fn set_config(&self, config: DBConfig);
+    }
+}
+
+#[cfg(feature = "mock")]
+pub use mock_interfaces::{SetConfig, SetGlobals};
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -238,7 +260,7 @@ mod tests {
     #[test]
     fn ensure_types_unchanged() {
         const EXPECTED_TYPE_INFO_HASH: &str =
-            "8a30677f0819eeffd02548e0e91adf940fa39173e509ad24b50cbb92ce61f907";
+            "c6e5e519f690a94c75602e1bd455828161dba9feabc832a823b72d624b8f6780";
 
         let types = [
             meta_type::<BlockMeta>(),
@@ -256,7 +278,8 @@ mod tests {
             meta_type::<StateTransition>(),
             meta_type::<Schedule>(),
             meta_type::<AnnounceMeta>(),
-            meta_type::<LatestData>(),
+            meta_type::<DBConfig>(),
+            meta_type::<DBGlobals>(),
         ];
 
         let mut registry = Registry::new();

ethexe/common/src/gear.rs

@@ -450,3 +450,10 @@ pub enum MessageType {
     Canonical,
     Injected,
 }
+
+#[derive(Debug)]
+pub struct GenesisBlockInfo {
+    pub hash: H256,
+    pub number: u32,
+    pub timestamp: u64,
+}

ethexe/common/src/hash.rs

@@ -96,6 +96,12 @@ impl<T> Hash for HashOf<T> {
     }
 }
 
+impl<T> AsRef<[u8]> for HashOf<T> {
+    fn as_ref(&self) -> &[u8] {
+        self.hash.as_ref()
+    }
+}
+
 impl<T> HashOf<T> {
     /// # Safety
     /// Use it only for low-level storage implementations or tests.
@@ -118,7 +124,7 @@ impl<T> HashOf<T> {
         }
     }
 
-    #[cfg(feature = "std")]
+    #[cfg(feature = "mock")]
     pub fn random() -> Self {
         Self {
             hash: H256::random(),