On-demand calculation for Ghostdag for Higher Levels

consensus/src/consensus/factory.rs

@@ -59,7 +59,7 @@ pub struct MultiConsensusMetadata {
     version: u32,
 }
 
-const LATEST_DB_VERSION: u32 = 3;
+const LATEST_DB_VERSION: u32 = 4;
 impl Default for MultiConsensusMetadata {
     fn default() -> Self {
         Self {
@@ -219,6 +219,23 @@ impl MultiConsensusManagementStore {
         }
     }
 
+    /// Returns the current version of this database
+    pub fn version(&self) -> StoreResult<u32> {
+        match self.metadata.read() {
+            Ok(data) => Ok(data.version),
+            Err(err) => Err(err),
+        }
+    }
+
+    /// Set the database version to a different one
+    pub fn set_version(&mut self, version: u32) -> StoreResult<()> {
+        self.metadata.update(DirectDbWriter::new(&self.db), |mut data| {
+            data.version = version;
+            data
+        })?;
+        Ok(())
+    }
+
     pub fn should_upgrade(&self) -> StoreResult<bool> {
         match self.metadata.read() {
             Ok(data) => Ok(data.version != LATEST_DB_VERSION),

consensus/src/consensus/mod.rs

@@ -243,7 +243,7 @@ impl Consensus {
             block_processors_pool,
             db.clone(),
             storage.statuses_store.clone(),
-            storage.ghostdag_primary_store.clone(),
+            storage.ghostdag_store.clone(),
             storage.headers_store.clone(),
             storage.block_transactions_store.clone(),
             storage.body_tips_store.clone(),
@@ -500,7 +500,7 @@ impl ConsensusApi for Consensus {
 
     fn get_virtual_merge_depth_blue_work_threshold(&self) -> BlueWorkType {
         // PRUNE SAFETY: merge depth root is never close to being pruned (in terms of block depth)
-        self.get_virtual_merge_depth_root().map_or(BlueWorkType::ZERO, |root| self.ghostdag_primary_store.get_blue_work(root).unwrap())
+        self.get_virtual_merge_depth_root().map_or(BlueWorkType::ZERO, |root| self.ghostdag_store.get_blue_work(root).unwrap())
     }
 
     fn get_sink(&self) -> Hash {
@@ -533,7 +533,7 @@ impl ConsensusApi for Consensus {
 
         for child in initial_children {
             if visited.insert(child) {
-                let blue_work = self.ghostdag_primary_store.get_blue_work(child).unwrap();
+                let blue_work = self.ghostdag_store.get_blue_work(child).unwrap();
                 heap.push(Reverse(SortableBlock::new(child, blue_work)));
             }
         }
@@ -560,7 +560,7 @@ impl ConsensusApi for Consensus {
 
             for child in children {
                 if visited.insert(child) {
-                    let blue_work = self.ghostdag_primary_store.get_blue_work(child).unwrap();
+                    let blue_work = self.ghostdag_store.get_blue_work(child).unwrap();
                     heap.push(Reverse(SortableBlock::new(child, blue_work)));
                 }
             }
@@ -909,7 +909,7 @@ impl ConsensusApi for Consensus {
             Some(BlockStatus::StatusInvalid) => return Err(ConsensusError::InvalidBlock(hash)),
             _ => {}
         };
-        let ghostdag = self.ghostdag_primary_store.get_data(hash).unwrap_option().ok_or(ConsensusError::MissingData(hash))?;
+        let ghostdag = self.ghostdag_store.get_data(hash).unwrap_option().ok_or(ConsensusError::MissingData(hash))?;
         Ok((&*ghostdag).into())
     }
 
@@ -985,7 +985,7 @@ impl ConsensusApi for Consensus {
         Ok(self
             .services
             .window_manager
-            .block_window(&self.ghostdag_primary_store.get_data(hash).unwrap(), WindowType::SampledDifficultyWindow)
+            .block_window(&self.ghostdag_store.get_data(hash).unwrap(), WindowType::SampledDifficultyWindow)
             .unwrap()
             .deref()
             .iter()
@@ -1024,7 +1024,7 @@ impl ConsensusApi for Consensus {
         match start_hash {
             Some(hash) => {
                 self.validate_block_exists(hash)?;
-                let ghostdag_data = self.ghostdag_primary_store.get_data(hash).unwrap();
+                let ghostdag_data = self.ghostdag_store.get_data(hash).unwrap();
                 // The selected parent header is used within to check for sampling activation, so we verify its existence first
                 if !self.headers_store.has(ghostdag_data.selected_parent).unwrap() {
                     return Err(ConsensusError::DifficultyError(DifficultyError::InsufficientWindowData(0)));

consensus/src/consensus/services.rs

@@ -53,8 +53,7 @@ pub struct ConsensusServices {
     pub reachability_service: MTReachabilityService<DbReachabilityStore>,
     pub window_manager: DbWindowManager,
     pub dag_traversal_manager: DbDagTraversalManager,
-    pub ghostdag_managers: Arc<Vec<DbGhostdagManager>>,
-    pub ghostdag_primary_manager: DbGhostdagManager,
+    pub ghostdag_manager: DbGhostdagManager,
     pub coinbase_manager: CoinbaseManager,
     pub pruning_point_manager: DbPruningPointManager,
     pub pruning_proof_manager: Arc<PruningProofManager>,
@@ -82,13 +81,13 @@ impl ConsensusServices {
         let reachability_service = MTReachabilityService::new(storage.reachability_store.clone());
         let dag_traversal_manager = DagTraversalManager::new(
             params.genesis.hash,
-            storage.ghostdag_primary_store.clone(),
+            storage.ghostdag_store.clone(),
             relations_service.clone(),
             reachability_service.clone(),
         );
         let window_manager = DualWindowManager::new(
             &params.genesis,
-            storage.ghostdag_primary_store.clone(),
+            storage.ghostdag_store.clone(),
             storage.headers_store.clone(),
             storage.daa_excluded_store.clone(),
             storage.block_window_cache_for_difficulty.clone(),
@@ -110,27 +109,17 @@ impl ConsensusServices {
             params.genesis.hash,
             storage.depth_store.clone(),
             reachability_service.clone(),
-            storage.ghostdag_primary_store.clone(),
+            storage.ghostdag_store.clone(),
         );
-        let ghostdag_managers = Arc::new(
-            storage
-                .ghostdag_stores
-                .iter()
-                .cloned()
-                .enumerate()
-                .map(|(level, ghostdag_store)| {
-                    GhostdagManager::new(
-                        params.genesis.hash,
-                        params.ghostdag_k,
-                        ghostdag_store,
-                        relations_services[level].clone(),
-                        storage.headers_store.clone(),
-                        reachability_service.clone(),
-                    )
-                })
-                .collect_vec(),
+        let ghostdag_manager = GhostdagManager::new(
+            params.genesis.hash,
+            params.ghostdag_k,
+            storage.ghostdag_store.clone(),
+            relations_services[0].clone(),
+            storage.headers_store.clone(),
+            reachability_service.clone(),
+            false,
         );
-        let ghostdag_primary_manager = ghostdag_managers[0].clone();
 
         let coinbase_manager = CoinbaseManager::new(
             params.coinbase_payload_script_public_key_max_len,
@@ -165,7 +154,7 @@ impl ConsensusServices {
             params.finality_depth,
             params.genesis.hash,
             reachability_service.clone(),
-            storage.ghostdag_primary_store.clone(),
+            storage.ghostdag_store.clone(),
             storage.headers_store.clone(),
             storage.past_pruning_points_store.clone(),
             storage.headers_selected_tip_store.clone(),
@@ -184,7 +173,7 @@ impl ConsensusServices {
             &storage,
             parents_manager.clone(),
             reachability_service.clone(),
-            ghostdag_managers.clone(),
+            ghostdag_manager.clone(),
             dag_traversal_manager.clone(),
             window_manager.clone(),
             params.max_block_level,
@@ -199,7 +188,7 @@ impl ConsensusServices {
             params.mergeset_size_limit as usize,
             reachability_service.clone(),
             dag_traversal_manager.clone(),
-            storage.ghostdag_primary_store.clone(),
+            storage.ghostdag_store.clone(),
             storage.selected_chain_store.clone(),
             storage.headers_selected_tip_store.clone(),
             storage.pruning_point_store.clone(),
@@ -213,8 +202,7 @@ impl ConsensusServices {
             reachability_service,
             window_manager,
             dag_traversal_manager,
-            ghostdag_managers,
-            ghostdag_primary_manager,
+            ghostdag_manager,
             coinbase_manager,
             pruning_point_manager,
             pruning_proof_manager,

consensus/src/consensus/storage.rs

@@ -50,8 +50,7 @@ pub struct ConsensusStorage {
     pub selected_chain_store: Arc<RwLock<DbSelectedChainStore>>,
 
     // Append-only stores
-    pub ghostdag_stores: Arc<Vec<Arc<DbGhostdagStore>>>,
-    pub ghostdag_primary_store: Arc<DbGhostdagStore>,
+    pub ghostdag_store: Arc<DbGhostdagStore>,
     pub headers_store: Arc<DbHeadersStore>,
     pub block_transactions_store: Arc<DbBlockTransactionsStore>,
     pub past_pruning_points_store: Arc<DbPastPruningPointsStore>,
@@ -193,19 +192,12 @@ impl ConsensusStorage {
             children_builder.build(),
         )));
 
-        let ghostdag_stores = Arc::new(
-            (0..=params.max_block_level)
-                .map(|level| {
-                    Arc::new(DbGhostdagStore::new(
-                        db.clone(),
-                        level,
-                        ghostdag_builder.downscale(level).build(),
-                        ghostdag_compact_builder.downscale(level).build(),
-                    ))
-                })
-                .collect_vec(),
-        );
-        let ghostdag_primary_store = ghostdag_stores[0].clone();
+        let ghostdag_store = Arc::new(DbGhostdagStore::new(
+            db.clone(),
+            0,
+            ghostdag_builder.downscale(0).build(),
+            ghostdag_compact_builder.downscale(0).build(),
+        ));
         let daa_excluded_store = Arc::new(DbDaaStore::new(db.clone(), daa_excluded_builder.build()));
         let headers_store = Arc::new(DbHeadersStore::new(db.clone(), headers_builder.build(), headers_compact_builder.build()));
         let depth_store = Arc::new(DbDepthStore::new(db.clone(), header_data_builder.build()));
@@ -245,8 +237,7 @@ impl ConsensusStorage {
             relations_stores,
             reachability_relations_store,
             reachability_store,
-            ghostdag_stores,
-            ghostdag_primary_store,
+            ghostdag_store,
             pruning_point_store,
             headers_selected_tip_store,
             body_tips_store,

consensus/src/consensus/test_consensus.rs

@@ -118,7 +118,7 @@ impl TestConsensus {
 
     pub fn build_header_with_parents(&self, hash: Hash, parents: Vec<Hash>) -> Header {
         let mut header = header_from_precomputed_hash(hash, parents);
-        let ghostdag_data = self.consensus.services.ghostdag_primary_manager.ghostdag(header.direct_parents());
+        let ghostdag_data = self.consensus.services.ghostdag_manager.ghostdag(header.direct_parents());
         header.pruning_point = self
             .consensus
             .services
@@ -201,7 +201,7 @@ impl TestConsensus {
     }
 
     pub fn ghostdag_store(&self) -> &Arc<DbGhostdagStore> {
-        &self.consensus.ghostdag_primary_store
+        &self.consensus.ghostdag_store
     }
 
     pub fn reachability_store(&self) -> &Arc<RwLock<DbReachabilityStore>> {
@@ -233,7 +233,7 @@ impl TestConsensus {
     }
 
     pub fn ghostdag_manager(&self) -> &DbGhostdagManager {
-        &self.consensus.services.ghostdag_primary_manager
+        &self.consensus.services.ghostdag_manager
     }
 }
 

consensus/src/model/stores/ghostdag.rs

@@ -270,6 +270,27 @@ impl DbGhostdagStore {
         }
     }
 
+    pub fn new_temp(
+        db: Arc<DB>,
+        level: BlockLevel,
+        cache_policy: CachePolicy,
+        compact_cache_policy: CachePolicy,
+        temp_index: u8,
+    ) -> Self {
+        assert_ne!(SEPARATOR, level, "level {} is reserved for the separator", level);
+        let lvl_bytes = level.to_le_bytes();
+        let temp_index_bytes = temp_index.to_le_bytes();
+        let prefix = DatabaseStorePrefixes::TempGhostdag.into_iter().chain(lvl_bytes).chain(temp_index_bytes).collect_vec();
+        let compact_prefix =
+            DatabaseStorePrefixes::TempGhostdagCompact.into_iter().chain(lvl_bytes).chain(temp_index_bytes).collect_vec();
+        Self {
+            db: Arc::clone(&db),
+            level,
+            access: CachedDbAccess::new(db.clone(), cache_policy, prefix),
+            compact_access: CachedDbAccess::new(db, compact_cache_policy, compact_prefix),
+        }
+    }
+
     pub fn clone_with_new_cache(&self, cache_policy: CachePolicy, compact_cache_policy: CachePolicy) -> Self {
         Self::new(Arc::clone(&self.db), self.level, cache_policy, compact_cache_policy)
     }