Pruning logic

chain/api/src/chain.rs

@@ -106,14 +106,16 @@ pub trait ChainReader {
         access_path: Option<AccessPath>,
     ) -> Result<Option<TransactionInfoWithProof>>;
 
-    fn current_tips_hash(&self) -> Result<Vec<HashValue>>;
+    fn current_tips_hash(&self, pruning_point: HashValue) -> Result<Vec<HashValue>>;
     fn has_dag_block(&self, header_id: HashValue) -> Result<bool>;
     fn check_chain_type(&self) -> Result<ChainType>;
     fn verify_and_ghostdata(
         &self,
         uncles: &[BlockHeader],
         header: &BlockHeader,
     ) -> Result<GhostdagData>;
+    fn is_dag_ancestor_of(&self, ancestor: HashValue, descendants: Vec<HashValue>) -> Result<bool>;
+    fn get_pruning_height(&self) -> BlockNumber;
 }
 
 pub trait ChainWriter {

chain/api/src/message.rs

@@ -4,7 +4,7 @@
 use crate::{ChainType, TransactionInfoWithProof};
 use anyhow::Result;
 use starcoin_crypto::HashValue;
-use starcoin_dag::consensusdb::consenses_state::DagStateView;
+use starcoin_dag::consensusdb::consenses_state::{DagStateView, ReachabilityView};
 use starcoin_dag::types::ghostdata::GhostdagData;
 use starcoin_service_registry::ServiceRequest;
 use starcoin_types::transaction::RichTransactionInfo;
@@ -68,6 +68,10 @@ pub enum ChainRequest {
     GetDagStateView,
     CheckChainType,
     GetGhostdagData(HashValue),
+    IsAncestorOfCommand {
+        ancestor: HashValue,
+        descendants: Vec<HashValue>,
+    },
 }
 
 impl ServiceRequest for ChainRequest {
@@ -99,4 +103,5 @@ pub enum ChainResponse {
     DagStateView(Box<DagStateView>),
     CheckChainType(ChainType),
     GhostdagDataOption(Box<Option<GhostdagData>>),
+    IsAncestorOfCommand { reachability_view: ReachabilityView },
 }

chain/api/src/service.rs

@@ -5,7 +5,7 @@ use crate::message::{ChainRequest, ChainResponse};
 use crate::{ChainType, TransactionInfoWithProof};
 use anyhow::{bail, Result};
 use starcoin_crypto::HashValue;
-use starcoin_dag::consensusdb::consenses_state::DagStateView;
+use starcoin_dag::consensusdb::consenses_state::{DagStateView, ReachabilityView};
 use starcoin_dag::types::ghostdata::GhostdagData;
 use starcoin_service_registry::{ActorService, ServiceHandler, ServiceRef};
 use starcoin_types::contract_event::{ContractEvent, ContractEventInfo};
@@ -149,6 +149,11 @@ pub trait ChainAsyncService:
     async fn get_dag_state(&self) -> Result<DagStateView>;
     async fn check_chain_type(&self) -> Result<ChainType>;
     async fn get_ghostdagdata(&self, id: HashValue) -> Result<Option<GhostdagData>>;
+    async fn is_ancestor_of(
+        &self,
+        ancestor: HashValue,
+        descendants: Vec<HashValue>,
+    ) -> Result<starcoin_dag::consensusdb::consenses_state::ReachabilityView>;
 }
 
 #[async_trait::async_trait]
@@ -486,4 +491,21 @@ where
             bail!("failed to get ghostdag data")
         }
     }
+    async fn is_ancestor_of(
+        &self,
+        ancestor: HashValue,
+        descendants: Vec<HashValue>,
+    ) -> Result<ReachabilityView> {
+        let response = self
+            .send(ChainRequest::IsAncestorOfCommand {
+                ancestor,
+                descendants,
+            })
+            .await??;
+        if let ChainResponse::IsAncestorOfCommand { reachability_view } = response {
+            Ok(reachability_view)
+        } else {
+            bail!("failed to get ghostdag data")
+        }
+    }
 }

chain/service/src/chain_service.rs

@@ -254,6 +254,12 @@ impl ServiceHandler<Self, ChainRequest> for ChainReaderService {
             ChainRequest::GetGhostdagData(id) => Ok(ChainResponse::GhostdagDataOption(Box::new(
                 self.inner.get_ghostdagdata(id)?,
             ))),
+            ChainRequest::IsAncestorOfCommand {
+                ancestor,
+                descendants,
+            } => Ok(ChainResponse::IsAncestorOfCommand {
+                reachability_view: self.inner.dag.is_ancestor_of(ancestor, descendants)?,
+            }),
         }
     }
 }

chain/src/chain.rs

@@ -13,13 +13,13 @@ use starcoin_chain_api::{
     ExcludedTxns, ExecutedBlock, MintedUncleNumber, TransactionInfoWithProof, VerifiedBlock,
     VerifyBlockField,
 };
-use starcoin_config::genesis_config::G_DAG_TEST_CONFIG;
 use starcoin_consensus::Consensus;
 use starcoin_crypto::hash::PlainCryptoHash;
 use starcoin_crypto::HashValue;
 use starcoin_dag::blockdag::{BlockDAG, MineNewDagBlockInfo};
 use starcoin_dag::consensusdb::consenses_state::DagState;
 use starcoin_dag::consensusdb::prelude::StoreError;
+use starcoin_dag::consensusdb::schemadb::GhostdagStoreReader;
 use starcoin_executor::VMMetrics;
 use starcoin_logger::prelude::*;
 use starcoin_open_block::OpenedBlock;
@@ -178,7 +178,7 @@ impl BlockChain {
     }
 
     fn init_dag(mut dag: BlockDAG, genesis_header: BlockHeader) -> Result<BlockDAG> {
-        match dag.get_dag_state() {
+        match dag.get_dag_state(genesis_header.id()) {
             anyhow::Result::Ok(_dag_state) => (),
             Err(e) => match e.downcast::<StoreError>()? {
                 StoreError::KeyNotFound(_) => {
@@ -319,10 +319,14 @@ impl BlockChain {
                 pruning_point, // TODO: new test cases will need pass this field if they have some special requirements.
             }
         } else {
-            self.dag().calc_mergeset_and_tips(
-                G_DAG_TEST_CONFIG.pruning_depth,
-                G_DAG_TEST_CONFIG.pruning_finality,
-            )?
+            let dag_state = self.get_dag_state()?;
+            let ghostdata = self.dag().ghost_dag_manager().ghostdag(&dag_state.tips)?;
+
+            MineNewDagBlockInfo {
+                tips: dag_state.tips,
+                blue_blocks: (*ghostdata.mergeset_blues).clone(),
+                pruning_point: HashValue::zero(),
+            }
         };
         debug!(
             "Blue blocks:{:?} in chain/create_block_template_by_header",
@@ -983,7 +987,12 @@ impl BlockChain {
     }
 
     pub fn get_dag_state(&self) -> Result<DagState> {
-        self.dag.get_dag_state()
+        let current_pruning_point = self.status().head().pruning_point();
+        if current_pruning_point == HashValue::zero() {
+            self.dag.get_dag_state(self.genesis_hash)
+        } else {
+            self.dag.get_dag_state(current_pruning_point)
+        }
     }
 }
 
@@ -1334,8 +1343,10 @@ impl ChainReader for BlockChain {
         }))
     }
 
-    fn current_tips_hash(&self) -> Result<Vec<HashValue>> {
-        self.dag.get_dag_state().map(|state| state.tips)
+    fn current_tips_hash(&self, pruning_point: HashValue) -> Result<Vec<HashValue>> {
+        self.dag
+            .get_dag_state(pruning_point)
+            .map(|state| state.tips)
     }
 
     fn has_dag_block(&self, header_id: HashValue) -> Result<bool> {
@@ -1360,7 +1371,42 @@ impl ChainReader for BlockChain {
         uncles: &[BlockHeader],
         header: &BlockHeader,
     ) -> Result<starcoin_dag::types::ghostdata::GhostdagData> {
-        self.dag().verify_and_ghostdata(uncles, header)
+        let previous_header = self
+            .storage
+            .get_block_header_by_hash(header.parent_hash())?
+            .ok_or_else(|| format_err!("cannot find parent block header"))?;
+        let next_ghostdata = self.dag().verify_and_ghostdata(uncles, header)?;
+
+        if self.status().head().pruning_point() != HashValue::zero() {
+            let previous_ghostdata = if previous_header.pruning_point() == HashValue::zero() {
+                let genesis = self
+                    .storage
+                    .get_genesis()?
+                    .ok_or_else(|| format_err!("the genesis id is none!"))?;
+                self.dag().storage.ghost_dag_store.get_data(genesis)?
+            } else {
+                self.dag()
+                    .storage
+                    .ghost_dag_store
+                    .get_data(previous_header.pruning_point())?
+            };
+            self.dag().verify_pruning_point(
+                previous_header.pruning_point(),
+                previous_ghostdata.as_ref(),
+                header.pruning_point(),
+                &next_ghostdata,
+            )?;
+        }
+
+        Ok(next_ghostdata)
+    }
+
+    fn is_dag_ancestor_of(&self, ancestor: HashValue, descendants: Vec<HashValue>) -> Result<bool> {
+        self.dag().check_ancestor_of(ancestor, descendants)
+    }
+
+    fn get_pruning_height(&self) -> BlockNumber {
+        self.get_pruning_height()
     }
 }
 
@@ -1469,16 +1515,30 @@ impl BlockChain {
     fn connect_dag(&mut self, executed_block: ExecutedBlock) -> Result<ExecutedBlock> {
         let dag = self.dag.clone();
         let (new_tip_block, _) = (executed_block.block(), executed_block.block_info());
-        let mut tips = self.current_tips_hash()?;
-        let parents = executed_block.block.header.parents_hash();
-        if !tips.contains(&new_tip_block.id()) {
-            for hash in parents {
-                tips.retain(|x| *x != hash);
-            }
-            if !dag.check_ancestor_of(new_tip_block.id(), tips.clone())? {
-                tips.push(new_tip_block.id());
+        let parent_header = self
+            .storage
+            .get_block_header_by_hash(new_tip_block.header().parent_hash())?
+            .ok_or_else(|| {
+                format_err!(
+                    "Dag block should exist, block id: {:?}",
+                    new_tip_block.header().parent_hash()
+                )
+            })?;
+        let mut tips = if parent_header.pruning_point() == HashValue::zero() {
+            self.current_tips_hash(self.genesis_hash)?
+        } else {
+            self.current_tips_hash(parent_header.pruning_point())?
+        };
+
+        let mut new_tips = vec![];
+        for hash in tips {
+            if !dag.check_ancestor_of(hash, vec![new_tip_block.id()])? {
+                new_tips.push(hash);
             }
         }
+        tips = new_tips;
+        tips.push(new_tip_block.id());
+
         // Caculate the ghostdata of the virutal node created by all tips.
         // And the ghostdata.selected of the tips will be the latest head.
         let block_hash = dag
@@ -1519,9 +1579,47 @@ impl BlockChain {
         if self.epoch.end_block_number() == block.header().number() {
             self.epoch = get_epoch_from_statedb(&self.statedb)?;
         }
-        self.dag.save_dag_state(DagState { tips })?;
+
+        if parent_header.pruning_point() == block.header().pruning_point() {
+            info!("pruning point not changed, save dag state without prune. tips are {:?}, pruning point is {:?}", tips, block.header().pruning_point());
+            if block.header().pruning_point() == HashValue::zero() {
+                self.dag
+                    .save_dag_state(self.genesis_hash, DagState { tips })?;
+            } else {
+                self.dag
+                    .save_dag_state(block.header().pruning_point(), DagState { tips })?;
+            }
+        } else {
+            let new_tips = dag.pruning_point_manager().prune(
+                &DagState { tips: tips.clone() },
+                parent_header.pruning_point(),
+                block.header().pruning_point(),
+            )?;
+            info!("pruning point changed, previous tips are: {:?}, save dag state with prune. tips are {:?}, previous  pruning point is  {:?}, current pruning point is {:?}", 
+            tips, new_tips, parent_header.pruning_point(), block.header().pruning_point());
+            self.dag
+                .save_dag_state(block.header().pruning_point(), DagState { tips: new_tips })?;
+        }
+
         Ok(executed_block)
     }
+
+    pub fn get_pruning_height(&self) -> BlockNumber {
+        let chain_id = self.status().head().chain_id();
+        if chain_id.is_vega() {
+            4000000
+        } else if chain_id.is_proxima() {
+            850000
+        } else if chain_id.is_halley() {
+            4200000
+        } else if chain_id.is_main() {
+            0
+        } else if chain_id.is_dag_test() || chain_id.is_test() || chain_id.is_dev() {
+            BlockNumber::MAX
+        } else {
+            0
+        }
+    }
 }
 
 impl ChainWriter for BlockChain {
@@ -1545,7 +1643,6 @@ impl ChainWriter for BlockChain {
     fn chain_state(&mut self) -> &ChainStateDB {
         &self.statedb
     }
-
     fn apply_for_sync(&mut self, block: Block) -> Result<ExecutedBlock> {
         self.apply_with_verifier::<DagVerifierWithGhostData>(block)
     }

chain/src/verifier/mod.rs

@@ -7,6 +7,7 @@ use starcoin_chain_api::{
     verify_block, ChainReader, ConnectBlockError, VerifiedBlock, VerifyBlockField,
 };
 use starcoin_consensus::{Consensus, ConsensusVerifyError};
+use starcoin_crypto::HashValue;
 use starcoin_dag::types::ghostdata::GhostdagData;
 use starcoin_logger::prelude::debug;
 use starcoin_open_block::AddressFilter;
@@ -347,7 +348,6 @@ impl BasicDagVerifier {
         R: ChainReader,
     {
         let parents_hash = new_block_header.parents_hash();
-
         verify_block!(
             VerifyBlockField::Header,
             parents_hash.len() == parents_hash.iter().collect::<HashSet<_>>().len(),
@@ -363,6 +363,7 @@ impl BasicDagVerifier {
             parents_hash,
             new_block_header.parent_hash()
         );
+
         parents_hash.iter().try_for_each(|parent_hash| {
             verify_block!(
                 VerifyBlockField::Header,
@@ -383,6 +384,33 @@ impl BasicDagVerifier {
             Ok::<(), ConnectBlockError>(())
         })?;
 
+        // verify the pruning point
+        let parent_header = current_chain.current_header();
+        if parent_header.pruning_point() != HashValue::zero() {
+            // the chain had pruning point already checking the descendants of the pruning point is a must
+            // check the parents are the descendants of the pruning point
+            parents_hash.iter().try_for_each(|parent_hash| {
+                verify_block!(
+                    VerifyBlockField::Header,
+                    current_chain.is_dag_ancestor_of(new_block_header.pruning_point(), vec![*parent_hash]).map_err(|e| {
+                        ConnectBlockError::VerifyBlockFailed(
+                            VerifyBlockField::Header,
+                            anyhow::anyhow!(
+                                "the block {:?} 's parent: {:?} is not the descendant of pruning point {:?}, error: {:?}",
+                                new_block_header.id(),
+                                parent_hash,
+                                new_block_header.pruning_point(),
+                                e
+                            ),
+                        )
+                    })?,
+                    "Invalid block: parent {} might not exist.",
+                    parent_hash
+                );
+                Ok::<(), ConnectBlockError>(())
+            })?;
+        }
+
         ConsensusVerifier::verify_header(current_chain, new_block_header)
     }
 
@@ -397,7 +425,7 @@ impl BasicDagVerifier {
         current_chain.verify_and_ghostdata(uncles, header)
     }
 }
-//TODO: Implement it.
+
 pub struct DagVerifier;
 impl BlockVerifier for DagVerifier {
     fn verify_header<R>(current_chain: &R, new_block_header: &BlockHeader) -> Result<()>
@@ -408,14 +436,18 @@ impl BlockVerifier for DagVerifier {
     }
 
     fn verify_uncles<R>(
-        _current_chain: &R,
-        _uncles: &[BlockHeader],
-        _header: &BlockHeader,
+        current_chain: &R,
+        uncles: &[BlockHeader],
+        header: &BlockHeader,
     ) -> Result<Option<GhostdagData>>
     where
         R: ChainReader,
     {
-        Ok(None)
+        Ok(Some(BasicDagVerifier::verify_blue_blocks(
+            current_chain,
+            uncles,
+            header,
+        )?))
     }
 }