KIP 7 implementation

Author: someone235

components/consensusmanager/src/session.rs

@@ -8,7 +8,7 @@ use kaspa_consensus_core::{
     block::Block,
     blockstatus::BlockStatus,
     daa_score_timestamp::DaaScoreTimestamp,
-    errors::consensus::ConsensusResult,
+    errors::{consensus::ConsensusResult, pruning::PruningImportResult},
     header::Header,
     pruning::{PruningPointProof, PruningPointTrustedData, PruningPointsList},
     trusted::{ExternalGhostdagData, TrustedBlock},
@@ -437,8 +437,8 @@ impl ConsensusSessionOwned {
         self.clone().spawn_blocking(move |c| c.validate_pruning_points()).await
     }
 
-    pub async fn async_are_pruning_points_violating_finality(&self, pp_list: PruningPointsList) -> bool {
-        self.clone().spawn_blocking(move |c| c.are_pruning_points_violating_finality(pp_list)).await
+    pub async fn async_next_good_finality_point(&self, pp_list: PruningPointsList) -> PruningImportResult<Hash> {
+        self.clone().spawn_blocking(move |c| c.next_good_finality_point(pp_list)).await
     }
 
     pub async fn async_creation_timestamp(&self) -> u64 {

consensus/core/src/api/mod.rs

@@ -207,7 +207,12 @@ pub trait ConsensusApi: Send + Sync {
         unimplemented!()
     }
 
-    fn apply_pruning_proof(&self, proof: PruningPointProof, trusted_set: &[TrustedBlock]) -> PruningImportResult<()> {
+    fn apply_pruning_proof(
+        &self,
+        proof: PruningPointProof,
+        trusted_set: &[TrustedBlock],
+        good_finality_point: Hash,
+    ) -> PruningImportResult<()> {
         unimplemented!()
     }
 
@@ -351,7 +356,7 @@ pub trait ConsensusApi: Send + Sync {
         unimplemented!()
     }
 
-    fn are_pruning_points_violating_finality(&self, pp_list: PruningPointsList) -> bool {
+    fn next_good_finality_point(&self, pp_list: PruningPointsList) -> PruningImportResult<Hash> {
         unimplemented!()
     }
 
@@ -362,6 +367,10 @@ pub trait ConsensusApi: Send + Sync {
     fn finality_point(&self) -> Hash {
         unimplemented!()
     }
+
+    fn get_good_finality_point(&self) -> Hash {
+        unimplemented!()
+    }
 }
 
 pub type DynConsensus = Arc<dyn ConsensusApi>;

consensus/core/src/errors/pruning.rs

@@ -59,6 +59,9 @@ pub enum PruningImportError {
 
     #[error("process exit was initiated while validating pruning point proof")]
     PruningValidationInterrupted,
+
+    #[error("pruning point list violates finality")]
+    PruningPointListViolatesFinality,
 }
 
 pub type PruningImportResult<T> = std::result::Result<T, PruningImportError>;

consensus/src/consensus/mod.rs

@@ -17,6 +17,7 @@ use crate::{
             acceptance_data::AcceptanceDataStoreReader,
             block_transactions::BlockTransactionsStoreReader,
             ghostdag::{GhostdagData, GhostdagStoreReader},
+            good_finality_point::GoodFinalityPointStoreReader,
             headers::{CompactHeaderData, HeaderStoreReader},
             headers_selected_tip::HeadersSelectedTipStoreReader,
             past_pruning_points::PastPruningPointsStoreReader,
@@ -271,6 +272,7 @@ impl Consensus {
             pruning_lock.clone(),
             notification_root.clone(),
             counters.clone(),
+            creation_timestamp,
         ));
 
         let pruning_processor = Arc::new(PruningProcessor::new(
@@ -760,8 +762,13 @@ impl ConsensusApi for Consensus {
         self.services.pruning_proof_manager.validate_pruning_point_proof(proof)
     }
 
-    fn apply_pruning_proof(&self, proof: PruningPointProof, trusted_set: &[TrustedBlock]) -> PruningImportResult<()> {
-        self.services.pruning_proof_manager.apply_proof(proof, trusted_set)
+    fn apply_pruning_proof(
+        &self,
+        proof: PruningPointProof,
+        trusted_set: &[TrustedBlock],
+        good_finality_point: Hash,
+    ) -> PruningImportResult<()> {
+        self.services.pruning_proof_manager.apply_proof(proof, trusted_set, good_finality_point)
     }
 
     fn import_pruning_points(&self, pruning_points: PruningPointsList) {
@@ -1031,8 +1038,8 @@ impl ConsensusApi for Consensus {
         }
     }
 
-    fn are_pruning_points_violating_finality(&self, pp_list: PruningPointsList) -> bool {
-        self.virtual_processor.are_pruning_points_violating_finality(pp_list)
+    fn next_good_finality_point(&self, pp_list: PruningPointsList) -> PruningImportResult<Hash> {
+        self.virtual_processor.next_good_finality_point(pp_list)
     }
 
     fn creation_timestamp(&self) -> u64 {
@@ -1042,4 +1049,12 @@ impl ConsensusApi for Consensus {
     fn finality_point(&self) -> Hash {
         self.virtual_processor.virtual_finality_point(&self.lkg_virtual_state.load().ghostdag_data, self.pruning_point())
     }
+
+    fn get_good_finality_point(&self) -> Hash {
+        if self.virtual_processor.is_consensus_mature() {
+            self.pruning_point()
+        } else {
+            self.storage.good_finality_point_store.read().get().unwrap()
+        }
+    }
 }

consensus/src/consensus/storage.rs

@@ -7,6 +7,7 @@ use crate::{
         daa::DbDaaStore,
         depth::DbDepthStore,
         ghostdag::{CompactGhostdagData, DbGhostdagStore},
+        good_finality_point::DbGoodFinalityPointStore,
         headers::{CompactHeaderData, DbHeadersStore},
         headers_selected_tip::DbHeadersSelectedTipStore,
         past_pruning_points::DbPastPruningPointsStore,
@@ -48,6 +49,7 @@ pub struct ConsensusStorage {
     pub pruning_utxoset_stores: Arc<RwLock<PruningUtxosetStores>>,
     pub virtual_stores: Arc<RwLock<VirtualStores>>,
     pub selected_chain_store: Arc<RwLock<DbSelectedChainStore>>,
+    pub good_finality_point_store: Arc<RwLock<DbGoodFinalityPointStore>>,
 
     // Append-only stores
     pub ghostdag_stores: Arc<Vec<Arc<DbGhostdagStore>>>,
@@ -235,6 +237,8 @@ impl ConsensusStorage {
         let virtual_stores =
             Arc::new(RwLock::new(VirtualStores::new(db.clone(), lkg_virtual_state.clone(), utxo_set_builder.build())));
 
+        let good_finality_point_store = Arc::new(RwLock::new(DbGoodFinalityPointStore::new(db.clone())));
+
         // Ensure that reachability stores are initialized
         reachability::init(reachability_store.write().deref_mut()).unwrap();
         relations::init(reachability_relations_store.write().deref_mut());
@@ -264,6 +268,7 @@ impl ConsensusStorage {
             block_window_cache_for_difficulty,
             block_window_cache_for_past_median_time,
             lkg_virtual_state,
+            good_finality_point_store,
         })
     }
 }

consensus/src/model/stores/good_finality_point.rs

@@ -0,0 +1,49 @@
+use kaspa_database::prelude::StoreResult;
+use kaspa_database::prelude::DB;
+use kaspa_database::prelude::{BatchDbWriter, CachedDbItem, DirectDbWriter};
+use kaspa_database::registry::DatabaseStorePrefixes;
+use kaspa_hashes::Hash;
+use rocksdb::WriteBatch;
+use std::sync::Arc;
+
+/// Reader API for `SelectedTipStore`.
+pub trait GoodFinalityPointStoreReader {
+    fn get(&self) -> StoreResult<Hash>;
+}
+
+pub trait GoodFinalityPointStore: GoodFinalityPointStoreReader {
+    fn set(&mut self, hash: Hash) -> StoreResult<()>;
+}
+
+/// A DB + cache implementation of `GoodFinalityPointStore` trait
+#[derive(Clone)]
+pub struct DbGoodFinalityPointStore {
+    db: Arc<DB>,
+    access: CachedDbItem<Hash>,
+}
+
+impl DbGoodFinalityPointStore {
+    pub fn new(db: Arc<DB>) -> Self {
+        Self { db: Arc::clone(&db), access: CachedDbItem::new(db, DatabaseStorePrefixes::GoodFinalityPoint.into()) }
+    }
+
+    pub fn clone_with_new_cache(&self) -> Self {
+        Self::new(Arc::clone(&self.db))
+    }
+
+    pub fn set_batch(&mut self, batch: &mut WriteBatch, hash: Hash) -> StoreResult<()> {
+        self.access.write(BatchDbWriter::new(batch), &hash)
+    }
+}
+
+impl GoodFinalityPointStoreReader for DbGoodFinalityPointStore {
+    fn get(&self) -> StoreResult<Hash> {
+        self.access.read()
+    }
+}
+
+impl GoodFinalityPointStore for DbGoodFinalityPointStore {
+    fn set(&mut self, hash: Hash) -> StoreResult<()> {
+        self.access.write(DirectDbWriter::new(&self.db), &hash)
+    }
+}

consensus/src/model/stores/mod.rs

@@ -5,6 +5,7 @@ pub mod children;
 pub mod daa;
 pub mod depth;
 pub mod ghostdag;
+pub mod good_finality_point;
 pub mod headers;
 pub mod headers_selected_tip;
 pub mod past_pruning_points;

consensus/src/pipeline/virtual_processor/processor.rs

@@ -19,6 +19,7 @@ use crate::{
             daa::DbDaaStore,
             depth::{DbDepthStore, DepthStoreReader},
             ghostdag::{DbGhostdagStore, GhostdagData, GhostdagStoreReader},
+            good_finality_point::{DbGoodFinalityPointStore, GoodFinalityPointStore, GoodFinalityPointStoreReader},
             headers::{DbHeadersStore, HeaderStoreReader},
             past_pruning_points::DbPastPruningPointsStore,
             pruning::{DbPruningStore, PruningStoreReader},
@@ -113,6 +114,8 @@ pub struct VirtualStateProcessor {
     pub(super) max_block_parents: u8,
     pub(super) mergeset_size_limit: u64,
     pub(super) pruning_depth: u64,
+    consensus_creation_time: u64,
+    finality_duration: u64,
 
     // Stores
     pub(super) statuses_store: Arc<RwLock<DbStatusesStore>>,
@@ -133,6 +136,8 @@ pub struct VirtualStateProcessor {
     pub(super) virtual_stores: Arc<RwLock<VirtualStores>>,
     pub(super) pruning_utxoset_stores: Arc<RwLock<PruningUtxosetStores>>,
 
+    pub(super) good_finality_point_store: Arc<RwLock<DbGoodFinalityPointStore>>,
+
     /// The "last known good" virtual state. To be used by any logic which does not want to wait
     /// for a possible virtual state write to complete but can rather settle with the last known state
     pub lkg_virtual_state: LkgVirtualState,
@@ -176,6 +181,7 @@ impl VirtualStateProcessor {
         pruning_lock: SessionLock,
         notification_root: Arc<ConsensusNotificationRoot>,
         counters: Arc<ProcessingCounters>,
+        consensus_creation_time: u64,
     ) -> Self {
         Self {
             receiver,
@@ -205,6 +211,7 @@ impl VirtualStateProcessor {
             virtual_stores: storage.virtual_stores.clone(),
             pruning_utxoset_stores: storage.pruning_utxoset_stores.clone(),
             lkg_virtual_state: storage.lkg_virtual_state.clone(),
+            good_finality_point_store: storage.good_finality_point_store.clone(),
 
             ghostdag_manager: services.ghostdag_primary_manager.clone(),
             reachability_service: services.reachability_service.clone(),
@@ -221,6 +228,8 @@ impl VirtualStateProcessor {
             notification_root,
             counters,
             storage_mass_activation_daa_score: params.storage_mass_activation_daa_score,
+            consensus_creation_time,
+            finality_duration: params.finality_duration(),
         }
     }
 
@@ -1027,6 +1036,7 @@ impl VirtualStateProcessor {
             pruning_point_write.set_history_root(&mut batch, self.genesis.hash).unwrap();
             pruning_utxoset_write.set_utxoset_position(&mut batch, self.genesis.hash).unwrap();
             self.db.write(batch).unwrap();
+            self.good_finality_point_store.write().set(self.genesis.hash).unwrap(); // TODO: Wrong lock behavior?
             drop(pruning_point_write);
             drop(pruning_utxoset_write);
         }
@@ -1132,33 +1142,46 @@ impl VirtualStateProcessor {
         Ok(())
     }
 
-    pub fn are_pruning_points_violating_finality(&self, pp_list: PruningPointsList) -> bool {
-        // Ideally we would want to check if the last known pruning point has the finality point
-        // in its chain, but in some cases it's impossible: let `lkp` be the last known pruning
-        // point from the list, and `fup` be the first unknown pruning point (the one following `lkp`).
-        // fup.blue_score - lkp.blue_score ≈ finality_depth (±k), so it's possible for `lkp` not to
-        // have the finality point in its past. So we have no choice but to check if `lkp`
-        // has `finality_point.finality_point` in its chain (in the worst case `fup` is one block
-        // above the current finality point, and in this case `lkp` will be a few blocks above the
-        // finality_point.finality_point), meaning this function can only detect finality violations
-        // in depth of 2*finality_depth, and can give false negatives for smaller finality violations.
-        let current_pp = self.pruning_point_store.read().pruning_point().unwrap();
-        let vf = self.virtual_finality_point(&self.lkg_virtual_state.load().ghostdag_data, current_pp);
-        let vff = self.depth_manager.calc_finality_point(&self.ghostdag_primary_store.get_data(vf).unwrap(), current_pp);
-
-        let last_known_pp = pp_list.iter().rev().find(|pp| match self.statuses_store.read().get(pp.hash).unwrap_option() {
-            Some(status) => status.is_valid(),
-            None => false,
-        });
-
-        if let Some(last_known_pp) = last_known_pp {
-            !self.reachability_service.is_chain_ancestor_of(vff, last_known_pp.hash)
+    pub fn next_good_finality_point(&self, pp_list: PruningPointsList) -> PruningImportResult<Hash> {
+        if self.is_consensus_mature() {
+            // TODO: Fix comment
+            // Ideally we would want to check if the last known pruning point has the finality point
+            // in its chain, but in some cases it's impossible: let `lkp` be the last known pruning
+            // point from the list, and `fup` be the first unknown pruning point (the one following `lkp`).
+            // fup.blue_score - lkp.blue_score ≈ finality_depth (±k), so it's possible for `lkp` not to
+            // have the finality point in its past. So we have no choice but to check if `lkp`
+            // has `finality_point.finality_point` in its chain (in the worst case `fup` is one block
+            // above the current finality point, and in this case `lkp` will be a few blocks above the
+            // finality_point.finality_point), meaning this function can only detect finality violations
+            // in depth of 2*finality_depth, and can give false negatives for smaller finality violations.
+            let current_pp = self.pruning_point_store.read().pruning_point().unwrap();
+            let vf = self.virtual_finality_point(&self.lkg_virtual_state.load().ghostdag_data, current_pp);
+            let vff = self.depth_manager.calc_finality_point(&self.ghostdag_primary_store.get_data(vf).unwrap(), current_pp);
+
+            let first_pp_in_future_of_vff = pp_list
+                .iter()
+                .map(|pp| pp.hash)
+                .filter(|pp| match self.statuses_store.read().get(*pp).unwrap_option() {
+                    Some(status) => status.is_valid(),
+                    None => false,
+                })
+                .find(|pp| self.reachability_service.is_chain_ancestor_of(vff, *pp));
+
+            first_pp_in_future_of_vff.ok_or(PruningImportError::PruningPointListViolatesFinality)
         } else {
-            // If no pruning point is known, there's definitely a finality violation
-            // (normally at least genesis should be known).
-            true
+            let good_finality_point = self.good_finality_point_store.read().get().unwrap();
+            if pp_list.iter().map(|h| h.hash).contains(&good_finality_point) {
+                Ok(good_finality_point)
+            } else {
+                Err(PruningImportError::PruningPointListViolatesFinality)
+            }
         }
     }
+
+    pub fn is_consensus_mature(&self) -> bool {
+        // TODO: Maybe we should replace creation time with staging commitment time
+        unix_now() - self.consensus_creation_time > self.finality_duration
+    }
 }
 
 enum MergesetIncreaseResult {

consensus/src/processes/pruning_proof/mod.rs

@@ -42,6 +42,7 @@ use crate::{
         stores::{
             depth::DbDepthStore,
             ghostdag::{DbGhostdagStore, GhostdagData, GhostdagStore, GhostdagStoreReader},
+            good_finality_point::{DbGoodFinalityPointStore, GoodFinalityPointStore},
             headers::{DbHeadersStore, HeaderStore, HeaderStoreReader},
             headers_selected_tip::DbHeadersSelectedTipStore,
             past_pruning_points::{DbPastPruningPointsStore, PastPruningPointsStore},
@@ -104,6 +105,7 @@ pub struct PruningProofManager {
     headers_selected_tip_store: Arc<RwLock<DbHeadersSelectedTipStore>>,
     depth_store: Arc<DbDepthStore>,
     selected_chain_store: Arc<RwLock<DbSelectedChainStore>>,
+    good_finality_point_store: Arc<RwLock<DbGoodFinalityPointStore>>,
 
     ghostdag_managers: Arc<Vec<DbGhostdagManager>>,
     traversal_manager: DbDagTraversalManager,
@@ -154,6 +156,7 @@ impl PruningProofManager {
             headers_selected_tip_store: storage.headers_selected_tip_store.clone(),
             selected_chain_store: storage.selected_chain_store.clone(),
             depth_store: storage.depth_store.clone(),
+            good_finality_point_store: storage.good_finality_point_store.clone(),
 
             ghostdag_managers,
             traversal_manager,
@@ -199,7 +202,13 @@ impl PruningProofManager {
         drop(pruning_point_write);
     }
 
-    pub fn apply_proof(&self, mut proof: PruningPointProof, trusted_set: &[TrustedBlock]) -> PruningImportResult<()> {
+    pub fn apply_proof(
+        &self,
+        mut proof: PruningPointProof,
+        trusted_set: &[TrustedBlock],
+        good_finality_point: Hash,
+    ) -> PruningImportResult<()> {
+        self.good_finality_point_store.write().set(good_finality_point).unwrap();
         let pruning_point_header = proof[0].last().unwrap().clone();
         let pruning_point = pruning_point_header.hash;
 

database/src/registry.rs

@@ -41,6 +41,8 @@ pub enum DatabaseStorePrefixes {
     ReachabilityTreeChildren = 30,
     ReachabilityFutureCoveringSet = 31,
 
+    GoodFinalityPoint = 32,
+
     // ---- Metadata ----
     MultiConsensusMetadata = 124,
     ConsensusEntries = 125,