solana-leader 0.4.0

solana leader library
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

use crate::leader_buffer::SLOTS_PER_LEADER;
use crate::leader_entry::LeaderEntry;

#[derive(Debug, Clone)]
pub struct ScheduleSnapshot {
    epoch: u64,
    epoch_start_slot: u64,
    first_leader_index: u64,
    leaders: Box<[LeaderEntry]>,
}

impl ScheduleSnapshot {
    #[inline]
    pub fn new(epoch: u64, epoch_start_slot: u64, leaders: Box<[LeaderEntry]>) -> Self {
        Self {
            epoch,
            epoch_start_slot,
            first_leader_index: epoch_start_slot / SLOTS_PER_LEADER,
            leaders,
        }
    }

    #[inline]
    pub fn epoch(&self) -> u64 {
        self.epoch
    }

    #[inline]
    pub fn epoch_start_slot(&self) -> u64 {
        self.epoch_start_slot
    }

    #[inline]
    pub fn leaders_len(&self) -> usize {
        self.leaders.len()
    }

    #[inline]
    pub fn leaders(&self) -> &[LeaderEntry] {
        &self.leaders
    }

    #[inline]
    pub fn covers_slot(&self, slot: u64) -> bool {
        let leader_index = slot / SLOTS_PER_LEADER;
        leader_index >= self.first_leader_index
            && leader_index < self.first_leader_index + self.leaders.len() as u64
    }

    #[inline]
    pub fn get_leader_at_slot(&self, slot: u64) -> Option<LeaderEntry> {
        let index = self.index_for_slot(slot)?;
        Some(self.leaders[index])
    }

    #[inline]
    pub fn get_next_leaders_into(&self, start_slot: u64, buffer: &mut [LeaderEntry]) -> usize {
        let mut written = 0usize;
        let mut leader_index = (start_slot / SLOTS_PER_LEADER).max(self.first_leader_index);

        while written < buffer.len() {
            let offset = leader_index.saturating_sub(self.first_leader_index) as usize;
            if offset >= self.leaders.len() {
                break;
            }

            buffer[written] = self.leaders[offset];
            written += 1;
            leader_index += 1;
        }

        written
    }

    #[inline]
    fn index_for_slot(&self, slot: u64) -> Option<usize> {
        let leader_index = slot / SLOTS_PER_LEADER;
        if leader_index < self.first_leader_index {
            return None;
        }

        let offset = leader_index - self.first_leader_index;
        (offset < self.leaders.len() as u64).then_some(offset as usize)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::leader_entry::LeaderPubkey;

    #[test]
    fn schedule_snapshot_indexes_by_leader() {
        let leader = LeaderEntry::new_ipv4(
            LeaderPubkey::new([1; 32]),
            [127, 0, 0, 1],
            8000,
            [127, 0, 0, 1],
            8001,
        );
        let snapshot = ScheduleSnapshot::new(1, 100, vec![leader, LeaderEntry::EMPTY].into());

        assert!(snapshot.covers_slot(100));
        assert_eq!(
            snapshot.get_leader_at_slot(103).unwrap().pubkey.to_bytes()[0],
            1
        );
        assert!(snapshot.get_leader_at_slot(108).is_none());
    }
}