Traits and data structs for reachability services (#5)

kaspad/Cargo.toml

@@ -10,6 +10,7 @@ include = [
 async-std = "1.11.0"
 regex = "1"
 hex = "0.4.3"
+thiserror = "1.0.31"
 kaspa-core = {path="../core"}
 
 [features]

kaspad/src/domain/consensus/model/api/hash.rs

@@ -4,6 +4,14 @@ use std::fmt::Debug;
 
 const DOMAIN_HASH_SIZE: usize = 32;
 
+/**
+ * TODO: consider the right design for passing domain hashes around. Some options:
+ * 1. Pass around by value. Pros: simple concurrency management; no indirect access to heap. Cons: x4 size of a pointer
+ * 2. Use Box<DomainHash> or Arc<DomainHash> or a combination per need.    
+ *
+ * Ideally we manage to wrap the type correctly and make easy conventions for using it.
+ */
+
 #[derive(PartialEq, Eq, Clone, Debug)]
 pub struct DomainHash {
     byte_array: [u8; DOMAIN_HASH_SIZE],

kaspad/src/domain/consensus/model/mod.rs

@@ -1,2 +1,4 @@
 pub mod api;
+pub mod services;
 pub mod staging_area;
+pub mod stores;

kaspad/src/domain/consensus/model/services/mod.rs

@@ -0,0 +1 @@
+pub mod reachability_service;

kaspad/src/domain/consensus/model/services/reachability_service.rs

@@ -0,0 +1,38 @@
+use thiserror::Error;
+
+use crate::domain::consensus::model::{
+    api::hash::DomainHash, staging_area::StagingArea, stores::errors::StoreError,
+};
+
+#[derive(Error, Debug)]
+pub enum ReachabilityError {
+    #[error("data store error")]
+    ReachabilityStoreError(#[from] StoreError),
+}
+
+pub trait ReachabilityService {
+    fn init(&mut self, staging: &dyn StagingArea) -> Result<(), ReachabilityError>;
+    fn add(
+        &mut self,
+        staging: &dyn StagingArea,
+        block: DomainHash,
+        selected_parent: DomainHash,
+        mergeset: &[DomainHash],
+        is_selected_leaf: bool,
+    ) -> Result<(), ReachabilityError>;
+    fn is_chain_ancestor_of(
+        &self,
+        low: DomainHash,
+        high: DomainHash,
+    ) -> Result<bool, ReachabilityError>;
+    fn is_dag_ancestor_of(
+        &self,
+        low: DomainHash,
+        high: DomainHash,
+    ) -> Result<bool, ReachabilityError>;
+    fn get_next_chain_ancestor(
+        &self,
+        descendant: DomainHash,
+        ancestor: DomainHash,
+    ) -> Result<DomainHash, ReachabilityError>;
+}

kaspad/src/domain/consensus/model/staging_area.rs

@@ -1 +1,11 @@
-pub struct StagingArea {}
+pub trait StagingArea {
+    fn commit(&mut self);
+}
+
+pub struct InMemoryStagingArea {}
+
+impl StagingArea for InMemoryStagingArea {
+    fn commit(&mut self) {
+        todo!()
+    }
+}

kaspad/src/domain/consensus/model/stores/errors.rs

@@ -0,0 +1,20 @@
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum StoreError {
+    #[error("Key not found in store")]
+    KeyNotFound,
+    // More usage examples:
+    //
+    // #[error("data store disconnected")]
+    // Disconnect(#[from] io::Error),
+    // #[error("the data for key `{0}` is not available")]
+    // Redaction(String),
+    // #[error("invalid header (expected {expected:?}, found {found:?})")]
+    // InvalidHeader {
+    //     expected: String,
+    //     found: String,
+    // },
+    // #[error("unknown data store error")]
+    // Unknown,
+}

kaspad/src/domain/consensus/model/stores/mod.rs

@@ -0,0 +1,2 @@
+pub mod errors;
+pub mod reachability_store;

kaspad/src/domain/consensus/model/stores/reachability_store.rs

@@ -0,0 +1,43 @@
+use super::errors::StoreError;
+use crate::domain::consensus::{
+    model::{api::hash::DomainHash, staging_area::StagingArea},
+    processes::reachability::interval::Interval,
+};
+
+pub struct ReachabilityData {
+    pub children: Vec<DomainHash>,
+    pub parent: DomainHash,
+    pub interval: Interval,
+    pub future_covering_set: Vec<DomainHash>,
+}
+
+impl ReachabilityData {
+    pub fn new(
+        children: Vec<DomainHash>,
+        parent: DomainHash,
+        interval: Interval,
+        future_covering_set: Vec<DomainHash>,
+    ) -> Self {
+        Self {
+            children,
+            parent,
+            interval,
+            future_covering_set,
+        }
+    }
+}
+
+pub trait ReachabilityStore {
+    fn stage(
+        &mut self,
+        staging: &dyn StagingArea,
+        hash: &DomainHash,
+        data: &ReachabilityData,
+    ) -> Result<(), StoreError>;
+    fn get(
+        &self,
+        staging: &dyn StagingArea,
+        hash: &DomainHash,
+    ) -> Result<ReachabilityData, StoreError>;
+    fn has(&self, staging: &dyn StagingArea, hash: &DomainHash) -> Result<bool, StoreError>;
+}

kaspad/src/domain/consensus/processes/mod.rs

@@ -1 +1 @@
-pub mod reachabilitymanager;
+pub mod reachability;

kaspad/src/domain/consensus/processes/reachabilitymanager/interval.rs → kaspad/src/domain/consensus/processes/reachability/interval.rs

@@ -114,7 +114,9 @@ impl Interval {
             return self.split_exact(sizes);
         }
 
+        //
         // Add a fractional bias to every size in the provided sizes
+        //
 
         let mut remaining_bias = interval_size - sizes_sum;
         let total_bias = remaining_bias as f64;

kaspad/src/domain/consensus/processes/reachability/manager.rs

@@ -0,0 +1,64 @@
+use crate::domain::consensus::model::services::reachability_service::ReachabilityService;
+
+pub struct ReachabilityManager {}
+
+impl ReachabilityManager {}
+
+impl ReachabilityService for ReachabilityManager {
+    fn init(
+        &mut self,
+        staging: &dyn crate::domain::consensus::model::staging_area::StagingArea,
+    ) -> Result<
+        (),
+        crate::domain::consensus::model::services::reachability_service::ReachabilityError,
+    > {
+        todo!()
+    }
+
+    fn add(
+        &mut self,
+        staging: &dyn crate::domain::consensus::model::staging_area::StagingArea,
+        block: crate::domain::consensus::model::api::hash::DomainHash,
+        selected_parent: crate::domain::consensus::model::api::hash::DomainHash,
+        mergeset: &[crate::domain::consensus::model::api::hash::DomainHash],
+        is_selected_leaf: bool,
+    ) -> Result<
+        (),
+        crate::domain::consensus::model::services::reachability_service::ReachabilityError,
+    > {
+        todo!()
+    }
+
+    fn is_chain_ancestor_of(
+        &self,
+        low: crate::domain::consensus::model::api::hash::DomainHash,
+        high: crate::domain::consensus::model::api::hash::DomainHash,
+    ) -> Result<
+        bool,
+        crate::domain::consensus::model::services::reachability_service::ReachabilityError,
+    > {
+        todo!()
+    }
+
+    fn is_dag_ancestor_of(
+        &self,
+        low: crate::domain::consensus::model::api::hash::DomainHash,
+        high: crate::domain::consensus::model::api::hash::DomainHash,
+    ) -> Result<
+        bool,
+        crate::domain::consensus::model::services::reachability_service::ReachabilityError,
+    > {
+        todo!()
+    }
+
+    fn get_next_chain_ancestor(
+        &self,
+        descendant: crate::domain::consensus::model::api::hash::DomainHash,
+        ancestor: crate::domain::consensus::model::api::hash::DomainHash,
+    ) -> Result<
+        crate::domain::consensus::model::api::hash::DomainHash,
+        crate::domain::consensus::model::services::reachability_service::ReachabilityError,
+    > {
+        todo!()
+    }
+}

kaspad/src/domain/consensus/processes/reachabilitymanager/mod.rs → kaspad/src/domain/consensus/processes/reachability/mod.rs

@@ -1 +1,2 @@
 pub mod interval;
+pub mod manager;

kaspad/src/main.rs

@@ -11,7 +11,7 @@ use kaspa_core::*;
 mod domain;
 
 use domain::consensus::model::api::hash::DomainHash;
-use domain::consensus::processes::reachabilitymanager::interval;
+use domain::consensus::processes::reachability::interval;
 
 const SERVICE_THREADS : usize = 1;
 // if sleep time is < 0, sleep is skipped