arc-malachitebft-sync 0.7.0-pre

Synchronization protocol for the Malachite BFT consensus engine
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

use {
    crate::{RawDecidedValue, Request, Response, Status, ValueRequest, ValueResponse},
    borsh::BorshSerialize,
    malachitebft_core_types::{CommitCertificate, Context},
    malachitebft_peer::PeerId,
    std::ops::RangeInclusive,
};

impl<Ctx: Context> borsh::BorshSerialize for Status<Ctx>
where
    Ctx::Height: borsh::BorshSerialize,
{
    fn serialize<W: borsh::io::Write>(&self, writer: &mut W) -> borsh::io::Result<()> {
        self.peer_id.serialize(writer)?;
        self.tip_height.serialize(writer)?;
        self.history_min_height.serialize(writer)?;
        Ok(())
    }
}

impl<Ctx: Context> borsh::BorshDeserialize for Status<Ctx>
where
    Ctx::Height: borsh::BorshDeserialize,
{
    fn deserialize_reader<R: borsh::io::Read>(reader: &mut R) -> borsh::io::Result<Self> {
        let peer_id = PeerId::deserialize_reader(reader)?;
        let tip_height = Ctx::Height::deserialize_reader(reader)?;
        let history_min_height = Ctx::Height::deserialize_reader(reader)?;
        Ok(Status {
            peer_id,
            tip_height,
            history_min_height,
        })
    }
}

impl<Ctx: Context> borsh::BorshSerialize for Request<Ctx>
where
    Ctx::Height: borsh::BorshSerialize,
{
    fn serialize<W: borsh::io::Write>(&self, writer: &mut W) -> borsh::io::Result<()> {
        match self {
            Request::ValueRequest(value_request) => value_request.range.serialize(writer),
        }
    }
}

impl<Ctx: Context> borsh::BorshDeserialize for Request<Ctx>
where
    Ctx::Height: borsh::BorshDeserialize,
{
    fn deserialize_reader<R: borsh::io::Read>(reader: &mut R) -> borsh::io::Result<Self> {
        let range = RangeInclusive::<Ctx::Height>::deserialize_reader(reader)?;
        Ok(Request::ValueRequest(ValueRequest::new(range)))
    }
}

impl<Ctx: Context> borsh::BorshSerialize for Response<Ctx>
where
    ValueResponse<Ctx>: borsh::BorshSerialize,
{
    fn serialize<W: borsh::io::Write>(&self, writer: &mut W) -> borsh::io::Result<()> {
        match self {
            Response::ValueResponse(value_response) => value_response.serialize(writer),
        }
    }
}

impl<Ctx: Context> borsh::BorshDeserialize for Response<Ctx>
where
    ValueResponse<Ctx>: borsh::BorshDeserialize,
{
    fn deserialize_reader<R: borsh::io::Read>(reader: &mut R) -> borsh::io::Result<Self> {
        let value = ValueResponse::deserialize_reader(reader)?;
        Ok(Response::ValueResponse(value))
    }
}

impl<Ctx: Context> borsh::BorshSerialize for ValueResponse<Ctx>
where
    Ctx::Height: borsh::BorshSerialize,
    RawDecidedValue<Ctx>: borsh::BorshSerialize,
{
    fn serialize<W: borsh::io::Write>(&self, writer: &mut W) -> borsh::io::Result<()> {
        self.start_height.serialize(writer)?;
        self.values.serialize(writer)?;
        Ok(())
    }
}

impl<Ctx: Context> borsh::BorshDeserialize for ValueResponse<Ctx>
where
    Ctx::Height: borsh::BorshDeserialize,
    RawDecidedValue<Ctx>: borsh::BorshDeserialize,
{
    fn deserialize_reader<R: borsh::io::Read>(reader: &mut R) -> borsh::io::Result<Self> {
        let start_height = Ctx::Height::deserialize_reader(reader)?;
        let values = Vec::<RawDecidedValue<Ctx>>::deserialize_reader(reader)?;
        Ok(ValueResponse {
            start_height,
            values,
        })
    }
}

impl<Ctx: Context> borsh::BorshSerialize for RawDecidedValue<Ctx>
where
    CommitCertificate<Ctx>: borsh::BorshSerialize,
{
    fn serialize<W: borsh::io::Write>(&self, writer: &mut W) -> borsh::io::Result<()> {
        BorshSerialize::serialize(&self.value_bytes.to_vec(), writer)?;
        self.certificate.serialize(writer)?;
        Ok(())
    }
}

impl<Ctx: Context> borsh::BorshDeserialize for RawDecidedValue<Ctx>
where
    CommitCertificate<Ctx>: borsh::BorshDeserialize,
{
    fn deserialize_reader<R: borsh::io::Read>(reader: &mut R) -> borsh::io::Result<Self> {
        let value_bytes = Vec::<u8>::deserialize_reader(reader)?;
        let certificate = CommitCertificate::deserialize_reader(reader)?;
        Ok(RawDecidedValue {
            value_bytes: value_bytes.into(),
            certificate,
        })
    }
}