merge smolstc

chain/Cargo.toml

@@ -23,6 +23,7 @@ starcoin-types = { package = "starcoin-types", workspace = true }
 starcoin-vm-types = { workspace = true }
 starcoin-storage = { workspace = true }
 thiserror = { workspace = true }
+starcoin-network-rpc-api = { workspace = true }
 
 [dev-dependencies]
 proptest = { workspace = true }
@@ -39,6 +40,7 @@ stdlib = { workspace = true }
 stest = { workspace = true }
 test-helper = { workspace = true }
 tokio = { features = ["full"], workspace = true }
+starcoin-network-rpc-api = { workspace = true }
 
 [features]
 default = []

chain/api/Cargo.toml

@@ -15,6 +15,7 @@ starcoin-time-service = { workspace = true }
 starcoin-types = { workspace = true }
 starcoin-vm-types = { workspace = true }
 thiserror = { workspace = true }
+starcoin-network-rpc-api = { workspace = true }
 
 
 [dev-dependencies]

chain/api/src/message.rs

@@ -4,6 +4,9 @@
 use crate::TransactionInfoWithProof;
 use anyhow::Result;
 use starcoin_crypto::HashValue;
+use starcoin_network_rpc_api::dag_protocol::{
+    TargetDagAccumulatorLeaf, TargetDagAccumulatorLeafDetail,
+};
 use starcoin_service_registry::ServiceRequest;
 use starcoin_types::transaction::RichTransactionInfo;
 use starcoin_types::{
@@ -60,6 +63,14 @@ pub enum ChainRequest {
         access_path: Option<AccessPath>,
     },
     GetBlockInfos(Vec<HashValue>),
+    GetDagAccumulatorLeaves {
+        start_index: u64,
+        batch_size: u64,
+    },
+    GetTargetDagAccumulatorLeafDetail {
+        leaf_index: u64,
+        batch_size: u64,
+    },
 }
 
 impl ServiceRequest for ChainRequest {
@@ -88,4 +99,6 @@ pub enum ChainResponse {
     HashVec(Vec<HashValue>),
     TransactionProof(Box<Option<TransactionInfoWithProof>>),
     BlockInfoVec(Box<Vec<Option<BlockInfo>>>),
+    TargetDagAccumulatorLeaf(Vec<TargetDagAccumulatorLeaf>),
+    TargetDagAccumulatorLeafDetail(Vec<TargetDagAccumulatorLeafDetail>),
 }

chain/api/src/service.rs

@@ -5,6 +5,7 @@ use crate::message::{ChainRequest, ChainResponse};
 use crate::TransactionInfoWithProof;
 use anyhow::{bail, Result};
 use starcoin_crypto::HashValue;
+use starcoin_network_rpc_api::dag_protocol;
 use starcoin_service_registry::{ActorService, ServiceHandler, ServiceRef};
 use starcoin_types::contract_event::{ContractEvent, ContractEventInfo};
 use starcoin_types::filter::Filter;
@@ -139,6 +140,14 @@ pub trait ChainAsyncService:
     ) -> Result<Option<TransactionInfoWithProof>>;
 
     async fn get_block_infos(&self, hashes: Vec<HashValue>) -> Result<Vec<Option<BlockInfo>>>;
+    async fn get_dag_accumulator_leaves(
+        &self,
+        req: dag_protocol::GetDagAccumulatorLeaves,
+    ) -> Result<Vec<dag_protocol::TargetDagAccumulatorLeaf>>;
+    async fn get_dag_accumulator_leaves_detail(
+        &self,
+        req: dag_protocol::GetTargetDagAccumulatorLeafDetail,
+    ) -> Result<Option<Vec<dag_protocol::TargetDagAccumulatorLeafDetail>>>;
 }
 
 #[async_trait::async_trait]
@@ -180,6 +189,40 @@ where
         }
     }
 
+    async fn get_dag_accumulator_leaves(
+        &self,
+        req: dag_protocol::GetDagAccumulatorLeaves,
+    ) -> Result<Vec<dag_protocol::TargetDagAccumulatorLeaf>> {
+        if let ChainResponse::TargetDagAccumulatorLeaf(leaves) = self
+            .send(ChainRequest::GetDagAccumulatorLeaves {
+                start_index: req.accumulator_leaf_index,
+                batch_size: req.batch_size,
+            })
+            .await??
+        {
+            Ok(leaves)
+        } else {
+            bail!("get_dag_accumulator_leaves response type error.")
+        }
+    }
+
+    async fn get_dag_accumulator_leaves_detail(
+        &self,
+        req: dag_protocol::GetTargetDagAccumulatorLeafDetail,
+    ) -> Result<Option<Vec<dag_protocol::TargetDagAccumulatorLeafDetail>>> {
+        if let ChainResponse::TargetDagAccumulatorLeafDetail(details) = self
+            .send(ChainRequest::GetTargetDagAccumulatorLeafDetail {
+                leaf_index: req.leaf_index,
+                batch_size: req.batch_size,
+            })
+            .await??
+        {
+            Ok(Some(details))
+        } else {
+            Ok(None)
+        }
+    }
+
     async fn get_headers(&self, ids: Vec<HashValue>) -> Result<Vec<Option<BlockHeader>>> {
         if let ChainResponse::BlockHeaderVec(headers) =
             self.send(ChainRequest::GetHeaders(ids)).await??

chain/service/Cargo.toml

@@ -18,6 +18,7 @@ starcoin-vm-runtime = { workspace = true }
 starcoin-vm-types = { workspace = true }
 thiserror = { workspace = true }
 tokio = { workspace = true }
+starcoin-network-rpc-api = { workspace = true }
 
 [dev-dependencies]
 stest = { workspace = true }

chain/service/src/chain_service.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 
 use anyhow::{format_err, Error, Result};
+use starcoin_chain::dag_chain::DagBlockChain;
 use starcoin_chain::BlockChain;
 use starcoin_chain_api::message::{ChainRequest, ChainResponse};
 use starcoin_chain_api::{
@@ -10,6 +11,9 @@ use starcoin_chain_api::{
 use starcoin_config::NodeConfig;
 use starcoin_crypto::HashValue;
 use starcoin_logger::prelude::*;
+use starcoin_network_rpc_api::dag_protocol::{
+    GetDagAccumulatorLeaves, GetTargetDagAccumulatorLeafDetail,
+};
 use starcoin_service_registry::{
     ActorService, EventHandler, ServiceContext, ServiceFactory, ServiceHandler,
 };
@@ -32,6 +36,8 @@ use std::sync::Arc;
 /// A Chain reader service to provider Reader API.
 pub struct ChainReaderService {
     inner: ChainReaderServiceInner,
+
+    dag_chain: DagBlockChain,
 }
 
 impl ChainReaderService {
@@ -42,7 +48,13 @@ impl ChainReaderService {
         vm_metrics: Option<VMMetrics>,
     ) -> Result<Self> {
         Ok(Self {
-            inner: ChainReaderServiceInner::new(config, startup_info, storage, vm_metrics)?,
+            inner: ChainReaderServiceInner::new(
+                config.clone(),
+                startup_info,
+                storage.clone(),
+                vm_metrics.clone(),
+            )?,
+            dag_chain: DagBlockChain::new(config.clone(), storage.clone(), vm_metrics)?,
         })
     }
 }
@@ -232,6 +244,27 @@ impl ServiceHandler<Self, ChainRequest> for ChainReaderService {
             ChainRequest::GetBlockInfos(ids) => Ok(ChainResponse::BlockInfoVec(Box::new(
                 self.inner.get_block_infos(ids)?,
             ))),
+            ChainRequest::GetDagAccumulatorLeaves {
+                start_index,
+                batch_size,
+            } => Ok(ChainResponse::TargetDagAccumulatorLeaf(
+                self.dag_chain
+                    .get_accumulator_leaves(GetDagAccumulatorLeaves {
+                        accumulator_leaf_index: start_index,
+                        batch_size,
+                    })?,
+            )),
+            ChainRequest::GetTargetDagAccumulatorLeafDetail {
+                leaf_index,
+                batch_size,
+            } => Ok(ChainResponse::TargetDagAccumulatorLeafDetail(
+                self.dag_chain.get_target_dag_accumulator_leaf_detail(
+                    GetTargetDagAccumulatorLeafDetail {
+                        leaf_index,
+                        batch_size,
+                    },
+                )?,
+            )),
         }
     }
 }

chain/src/dag_chain.rs

@@ -0,0 +1,162 @@
+use std::sync::Arc;
+
+use anyhow::bail;
+use starcoin_accumulator::Accumulator;
+use starcoin_accumulator::{node::AccumulatorStoreType, MerkleAccumulator};
+use starcoin_config::NodeConfig;
+use starcoin_consensus::{BlockDAG, FlexiDagStorage, FlexiDagStorageConfig};
+use starcoin_crypto::HashValue;
+use starcoin_executor::VMMetrics;
+use starcoin_network_rpc_api::dag_protocol::{
+    GetDagAccumulatorLeaves, GetTargetDagAccumulatorLeafDetail, RelationshipPair,
+    TargetDagAccumulatorLeaf, TargetDagAccumulatorLeafDetail,
+};
+use starcoin_storage::storage::CodecKVStore;
+use starcoin_storage::{flexi_dag::SyncFlexiDagSnapshotStorage, Store};
+use starcoin_types::block::BlockHeader;
+use starcoin_types::{blockhash::ORIGIN, header::Header};
+
+pub struct DagBlockChain {
+    dag: Option<BlockDAG>,
+    dag_sync_accumulator: MerkleAccumulator,
+    dag_sync_accumulator_snapshot: Arc<SyncFlexiDagSnapshotStorage>,
+}
+
+impl DagBlockChain {
+    pub fn new(
+        config: Arc<NodeConfig>,
+        storage: Arc<dyn Store>,
+        _vm_metrics: Option<VMMetrics>,
+    ) -> anyhow::Result<Self> {
+        // initialize the dag
+        let db_path = config.storage.dir();
+        let config = FlexiDagStorageConfig::create_with_params(1, 0, 1024);
+        let db = FlexiDagStorage::create_from_path(db_path, config)?;
+        let dag = BlockDAG::new(
+            Header::new(BlockHeader::random(), vec![HashValue::new(ORIGIN)]),
+            16,
+            db,
+        );
+
+        // initialize the block accumulator
+        let startup_info = match storage.get_flexi_dag_startup_info()? {
+            Some(startup_info) => startup_info,
+            None => {
+                return Ok(Self {
+                    dag: Some(dag),
+                    dag_sync_accumulator: MerkleAccumulator::new_empty(
+                        storage.get_accumulator_store(AccumulatorStoreType::SyncDag),
+                    ),
+                    dag_sync_accumulator_snapshot: storage.get_accumulator_snapshot_storage(),
+                })
+            }
+        };
+
+        // let accmulator_info = sync_flexi_dag_store.get_snapshot_storage().get(startup_info.main);
+        let accumulator_info = match storage.query_by_hash(startup_info.main) {
+            Ok(op_snapshot) => match op_snapshot {
+                Some(snapshot) => snapshot.dag_accumulator_info,
+                None => bail!("failed to get sync accumulator info since it is None"),
+            },
+            Err(error) => bail!("failed to get sync accumulator info: {}", error.to_string()),
+        };
+
+        Ok(Self {
+            dag: Some(dag),
+            dag_sync_accumulator: MerkleAccumulator::new_with_info(
+                accumulator_info,
+                storage.get_accumulator_store(AccumulatorStoreType::SyncDag),
+            ),
+            dag_sync_accumulator_snapshot: storage.get_accumulator_snapshot_storage(),
+        })
+    }
+
+    pub fn get_accumulator_leaves(
+        &self,
+        req: GetDagAccumulatorLeaves,
+    ) -> anyhow::Result<Vec<TargetDagAccumulatorLeaf>> {
+        if self.dag.is_none() {
+            bail!("the dag is None");
+        }
+        match self
+            .dag_sync_accumulator
+            .get_leaves(req.accumulator_leaf_index, true, req.batch_size)
+        {
+            Ok(leaves) => Ok(leaves
+                .into_iter()
+                .enumerate()
+                .map(
+                    |(index, leaf)| match self.dag_sync_accumulator_snapshot.get(leaf) {
+                        Ok(op_snapshot) => {
+                            let snapshot = op_snapshot.expect("snapshot must exist");
+                            TargetDagAccumulatorLeaf {
+                                accumulator_root: snapshot.dag_accumulator_info.accumulator_root,
+                                leaf_index: req.accumulator_leaf_index.saturating_sub(index as u64),
+                            }
+                        }
+                        Err(error) => {
+                            panic!(
+                                "error occured when query the accumulator snapshot: {}",
+                                error.to_string()
+                            );
+                        }
+                    },
+                )
+                .collect()),
+            Err(error) => {
+                bail!(
+                    "an error occured when getting the leaves of the accumulator, {}",
+                    error.to_string()
+                );
+            }
+        }
+    }
+
+    pub fn get_target_dag_accumulator_leaf_detail(
+        &self,
+        req: GetTargetDagAccumulatorLeafDetail,
+    ) -> anyhow::Result<Vec<TargetDagAccumulatorLeafDetail>> {
+        let dag = if self.dag.is_some() {
+            self.dag.as_ref().unwrap()
+        } else {
+            bail!("the dag is None");
+        };
+        let end_index = std::cmp::min(
+            req.leaf_index + req.batch_size - 1,
+            self.dag_sync_accumulator.get_info().num_leaves - 1,
+        );
+        let mut details = [].to_vec();
+        for index in req.leaf_index..=end_index {
+            let leaf_hash = self
+                .dag_sync_accumulator
+                .get_leaf(index)
+                .unwrap_or(None)
+                .expect("leaf hash should not be None");
+            let snapshot = self
+                .dag_sync_accumulator_snapshot
+                .get(leaf_hash)
+                .unwrap_or(None)
+                .expect("the snapshot should not be None");
+            let mut relationship_pair = [].to_vec();
+            relationship_pair.extend(
+                snapshot
+                    .child_hashes
+                    .into_iter()
+                    .fold([].to_vec(), |mut pairs, child| {
+                        let parents = dag.get_parents(child).expect("a child must have parents");
+                        parents.into_iter().for_each(|parent| {
+                            pairs.push(RelationshipPair { parent, child });
+                        });
+                        pairs
+                    })
+                    .into_iter(),
+            );
+
+            details.push(TargetDagAccumulatorLeafDetail {
+                accumulator_root: snapshot.dag_accumulator_info.accumulator_root,
+                relationship_pair,
+            });
+        }
+        Ok(details)
+    }
+}

chain/src/lib.rs

@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0
 #![deny(clippy::integer_arithmetic)]
 mod chain;
+pub mod dag_chain;
 pub mod verifier;
 pub use chain::BlockChain;
 pub use starcoin_chain_api::{ChainReader, ChainWriter};