tari_core 5.3.1

Core Tari protocol components
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

// Copyright 2022 The Tari Project
// SPDX-License-Identifier: BSD-3-Clause

use std::{cmp::Ordering, fmt::Debug};

use tari_node_components::blocks::ChainHeader;

pub trait ChainStrengthComparer: Debug {
    fn compare(&self, a: &ChainHeader, b: &ChainHeader) -> Ordering;
}

#[derive(Default, Debug)]
pub struct AccumulatedDifficultySquaredComparer {}

impl ChainStrengthComparer for AccumulatedDifficultySquaredComparer {
    fn compare(&self, a: &ChainHeader, b: &ChainHeader) -> Ordering {
        let a_val = a.accumulated_data().total_accumulated_difficulty;
        let b_val = b.accumulated_data().total_accumulated_difficulty;
        a_val.cmp(&b_val)
    }
}

#[derive(Debug)]
pub struct ThenComparer {
    before: Box<dyn ChainStrengthComparer + Send + Sync>,
    after: Box<dyn ChainStrengthComparer + Send + Sync>,
}

impl ThenComparer {
    pub fn new(
        before: Box<dyn ChainStrengthComparer + Send + Sync>,
        after: Box<dyn ChainStrengthComparer + Send + Sync>,
    ) -> Self {
        ThenComparer { before, after }
    }
}

impl ChainStrengthComparer for ThenComparer {
    fn compare(&self, a: &ChainHeader, b: &ChainHeader) -> Ordering {
        match self.before.compare(a, b) {
            Ordering::Equal => self.after.compare(a, b),
            Ordering::Less => Ordering::Less,
            Ordering::Greater => Ordering::Greater,
        }
    }
}

#[derive(Default, Debug)]
pub struct MoneroRandomxDifficultyComparer {}

impl ChainStrengthComparer for MoneroRandomxDifficultyComparer {
    fn compare(&self, a: &ChainHeader, b: &ChainHeader) -> Ordering {
        a.accumulated_data()
            .accumulated_monero_randomx_difficulty()
            .cmp(&b.accumulated_data().accumulated_monero_randomx_difficulty())
    }
}

#[derive(Default, Debug)]
pub struct TariRandomxDifficultyComparer {}

impl ChainStrengthComparer for TariRandomxDifficultyComparer {
    fn compare(&self, a: &ChainHeader, b: &ChainHeader) -> Ordering {
        a.accumulated_data()
            .accumulated_tari_randomx_difficulty()
            .cmp(&b.accumulated_data().accumulated_tari_randomx_difficulty())
    }
}

#[derive(Default, Debug)]
pub struct Sha3xDifficultyComparer {}

impl ChainStrengthComparer for Sha3xDifficultyComparer {
    fn compare(&self, a: &ChainHeader, b: &ChainHeader) -> Ordering {
        a.accumulated_data()
            .accumulated_sha3x_difficulty()
            .cmp(&b.accumulated_data().accumulated_sha3x_difficulty())
    }
}
#[derive(Default, Debug)]
pub struct CuckarooCycleDifficultyComparer {}

impl ChainStrengthComparer for CuckarooCycleDifficultyComparer {
    fn compare(&self, a: &ChainHeader, b: &ChainHeader) -> Ordering {
        a.accumulated_data()
            .accumulated_cuckaroo_difficulty()
            .cmp(&b.accumulated_data().accumulated_cuckaroo_difficulty())
    }
}
#[derive(Default, Debug)]
pub struct HeightComparer {}

impl ChainStrengthComparer for HeightComparer {
    fn compare(&self, a: &ChainHeader, b: &ChainHeader) -> Ordering {
        a.height().cmp(&b.height())
    }
}

pub struct ChainStrengthComparerBuilder {
    target: Option<Box<dyn ChainStrengthComparer + Send + Sync>>,
}

impl ChainStrengthComparerBuilder {
    pub fn new() -> ChainStrengthComparerBuilder {
        ChainStrengthComparerBuilder { target: None }
    }

    fn add_comparer_as_then(mut self, inner: Box<dyn ChainStrengthComparer + Send + Sync>) -> Self {
        self.target = match self.target {
            Some(t) => Some(Box::new(ThenComparer::new(t, inner))),
            None => Some(inner),
        };
        self
    }

    pub fn by_accumulated_difficulty(self) -> Self {
        self.add_comparer_as_then(Box::<AccumulatedDifficultySquaredComparer>::default())
    }

    pub fn by_monero_randomx_difficulty(self) -> Self {
        self.add_comparer_as_then(Box::<MoneroRandomxDifficultyComparer>::default())
    }

    pub fn by_tari_randomx_difficulty(self) -> Self {
        self.add_comparer_as_then(Box::<TariRandomxDifficultyComparer>::default())
    }

    pub fn by_sha3x_difficulty(self) -> Self {
        self.add_comparer_as_then(Box::<Sha3xDifficultyComparer>::default())
    }

    pub fn by_cuckaroo_cycle_difficulty(self) -> Self {
        self.add_comparer_as_then(Box::<CuckarooCycleDifficultyComparer>::default())
    }

    pub fn by_height(self) -> Self {
        self.add_comparer_as_then(Box::<HeightComparer>::default())
    }

    pub fn then(self) -> Self {
        // convenience method for wording
        self
    }

    pub fn build(self) -> Box<dyn ChainStrengthComparer + Send + Sync> {
        self.target.unwrap()
    }
}

pub fn strongest_chain() -> ChainStrengthComparerBuilder {
    ChainStrengthComparerBuilder::new()
}