tycho-collator 0.3.9

A collator node.
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

use std::sync::Arc;

use anyhow::Result;
use tycho_network::PeerId;
use tycho_types::cell::HashBytes;
use tycho_types::models::{
    BlockId, ConsensusConfig, ConsensusInfo, ValidatorDescription, ValidatorSet,
};

use super::MempoolAnchorId;

#[derive(Debug)]
pub struct StateUpdateContext {
    pub mc_block_id: BlockId,
    pub mc_block_chain_time: u64,
    pub top_processed_to_anchor_id: MempoolAnchorId,
    pub consensus_info: ConsensusInfo,
    pub consensus_config: ConsensusConfig,
    pub shuffle_validators: bool,
    pub prev_validator_set: Option<(HashBytes, Arc<ValidatorSet>)>,
    pub current_validator_set: (HashBytes, Arc<ValidatorSet>),
    pub next_validator_set: Option<(HashBytes, Arc<ValidatorSet>)>,
}

/// Contains all data needed to deterministically derive all v(sub)sets
#[derive(PartialEq, Eq)]
pub struct VSetsId<'a> {
    prev_vset_switch_round: u32,
    prev_shuffle_mc_validators: bool,
    prev_validator_set: Option<&'a HashBytes>,

    vset_switch_round: u32,
    shuffle_validators: bool,
    current_validator_set: &'a HashBytes,

    next_validator_set: Option<&'a HashBytes>,
}

impl StateUpdateContext {
    /// equality by vid means all contained and derived v(sub)sets are the same
    pub fn vid(&self) -> VSetsId<'_> {
        VSetsId {
            prev_vset_switch_round: self.consensus_info.prev_vset_switch_round,
            prev_shuffle_mc_validators: self.consensus_info.prev_shuffle_mc_validators,
            prev_validator_set: self.prev_validator_set.as_ref().map(|(hash, _)| hash),

            vset_switch_round: self.consensus_info.vset_switch_round,
            shuffle_validators: self.shuffle_validators,
            current_validator_set: &self.current_validator_set.0,

            next_validator_set: self.next_validator_set.as_ref().map(|(hash, _)| hash),
        }
    }

    /// Preserves blockchain config peer order to pass into mempool
    pub fn prev_v_set(&self) -> Vec<PeerId> {
        Self::peer_ids((self.prev_validator_set.iter()).flat_map(|(_, v_set)| v_set.list.iter()))
    }

    /// Preserves blockchain config peer order to pass into mempool
    pub fn curr_v_set(&self) -> Vec<PeerId> {
        Self::peer_ids(self.current_validator_set.1.list.iter())
    }

    /// Preserves blockchain config peer order to pass into mempool
    pub fn next_v_set(&self) -> Vec<PeerId> {
        Self::peer_ids((self.next_validator_set.iter()).flat_map(|(_, v_set)| v_set.list.iter()))
    }

    /// Preserves shuffled peer order to pass into mempool;
    /// contains `validator_idx` peer position in original blockchain config
    pub fn prev_v_subset(&self) -> Result<Vec<(PeerId, u16)>> {
        let Some((_, prev_validator_set)) = self.prev_validator_set.as_ref() else {
            return Ok(Vec::new());
        };
        Self::compute_subset(
            prev_validator_set,
            self.consensus_info.prev_vset_switch_round,
            self.consensus_info.prev_shuffle_mc_validators,
        )
        .ok_or_else(|| anyhow::anyhow!("failed to compute previous validator subset"))
    }

    /// Preserves shuffled peer order to pass into mempool;
    /// contains `validator_idx` peer position in original blockchain config
    pub fn curr_v_subset(&self) -> Result<Vec<(PeerId, u16)>> {
        Self::compute_subset(
            &self.current_validator_set.1,
            self.consensus_info.vset_switch_round,
            self.shuffle_validators,
        )
        .ok_or_else(|| anyhow::anyhow!("failed to compute current validator subset"))
    }

    // NOTE: do not try to calculate subset from next set
    //  because it is impossible without known future `switch_round`

    fn compute_subset(
        validator_set: &ValidatorSet,
        switch_round: u32,
        shuffle_validators: bool,
    ) -> Option<Vec<(PeerId, u16)>> {
        let (v_subset, _) =
            validator_set.compute_mc_subset_indexed(switch_round, shuffle_validators)?;
        let peer_idxs = v_subset
            .into_iter()
            .map(|desc| (PeerId(desc.public_key.0), desc.validator_idx))
            .collect();
        Some(peer_idxs)
    }

    fn peer_ids<'a>(iter: impl Iterator<Item = &'a ValidatorDescription>) -> Vec<PeerId> {
        iter.map(|descr| PeerId(descr.public_key.0)).collect()
    }
}

pub struct DebugStateUpdateContext<'a>(pub &'a StateUpdateContext);
impl std::fmt::Debug for DebugStateUpdateContext<'_> {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("StateUpdateContext")
            .field("mc_block_id", &self.0.mc_block_id.as_short_id())
            .field("mc_block_chain_time", &self.0.mc_block_chain_time)
            .field(
                "top_processed_to_anchor_id",
                &self.0.top_processed_to_anchor_id,
            )
            .field("consensus_info", &self.0.consensus_info)
            .field("consensus_config", &self.0.consensus_config)
            .field("shuffle_validators", &self.0.shuffle_validators)
            .field(
                "prev_validator_set.hash",
                &self.0.prev_validator_set.as_ref().map(|s| s.0),
            )
            .field(
                "current_validator_set.hash",
                &self.0.current_validator_set.0,
            )
            .field(
                "next_validator_set.hash",
                &self.0.next_validator_set.as_ref().map(|s| s.0),
            )
            .finish()
    }
}