muta_protocol/fixed_codec/
epoch.rs

1use bytes::BytesMut;
2
3use crate::fixed_codec::{FixedCodec, FixedCodecError};
4use crate::types::epoch::{Epoch, EpochHeader, Pill, Proof, Validator};
5use crate::types::primitive::Hash;
6use crate::types::Bloom;
7use crate::{impl_default_fixed_codec_for, ProtocolResult};
8
9// Impl FixedCodec trait for types
10impl_default_fixed_codec_for!(epoch, [Proof, Validator, Epoch, EpochHeader, Pill]);
11
12impl rlp::Encodable for Proof {
13    fn rlp_append(&self, s: &mut rlp::RlpStream) {
14        s.begin_list(5)
15            .append(&self.bitmap.to_vec())
16            .append(&self.epoch_hash)
17            .append(&self.epoch_id)
18            .append(&self.round)
19            .append(&self.signature.to_vec());
20    }
21}
22
23impl rlp::Decodable for Proof {
24    fn decode(r: &rlp::Rlp) -> Result<Self, rlp::DecoderError> {
25        if !r.is_list() && r.size() != 5 {
26            return Err(rlp::DecoderError::RlpIncorrectListLen);
27        }
28
29        let bitmap = BytesMut::from(r.at(0)?.data()?).freeze();
30        let epoch_hash: Hash = rlp::decode(r.at(1)?.as_raw())?;
31        let epoch_id = r.at(2)?.as_val()?;
32        let round = r.at(3)?.as_val()?;
33        let signature = BytesMut::from(r.at(4)?.data()?).freeze();
34
35        Ok(Proof {
36            epoch_id,
37            round,
38            epoch_hash,
39            signature,
40            bitmap,
41        })
42    }
43}
44
45impl rlp::Encodable for Validator {
46    fn rlp_append(&self, s: &mut rlp::RlpStream) {
47        s.begin_list(3)
48            .append(&self.address)
49            .append(&self.propose_weight)
50            .append(&self.vote_weight);
51    }
52}
53
54impl rlp::Decodable for Validator {
55    fn decode(r: &rlp::Rlp) -> Result<Self, rlp::DecoderError> {
56        if !r.is_list() && r.size() != 3 {
57            return Err(rlp::DecoderError::RlpIncorrectListLen);
58        }
59
60        let address = rlp::decode(r.at(0)?.as_raw())?;
61        let propose_weight = r.at(1)?.as_val()?;
62        let vote_weight = r.at(2)?.as_val()?;
63
64        Ok(Validator {
65            address,
66            propose_weight,
67            vote_weight,
68        })
69    }
70}
71
72impl rlp::Encodable for EpochHeader {
73    fn rlp_append(&self, s: &mut rlp::RlpStream) {
74        s.begin_list(15)
75            .append(&self.chain_id)
76            .append_list(&self.confirm_root)
77            .append_list(&self.cycles_used)
78            .append(&self.epoch_id)
79            .append(&self.exec_epoch_id)
80            .append_list(&self.logs_bloom)
81            .append(&self.order_root)
82            .append(&self.pre_hash)
83            .append(&self.proof)
84            .append(&self.proposer)
85            .append_list(&self.receipt_root)
86            .append(&self.state_root)
87            .append(&self.timestamp)
88            .append(&self.validator_version)
89            .append_list(&self.validators);
90    }
91}
92
93impl rlp::Decodable for EpochHeader {
94    fn decode(r: &rlp::Rlp) -> Result<Self, rlp::DecoderError> {
95        if !r.is_list() && r.size() != 15 {
96            return Err(rlp::DecoderError::RlpIncorrectListLen);
97        }
98
99        let chain_id: Hash = rlp::decode(r.at(0)?.as_raw())?;
100        let confirm_root: Vec<Hash> = rlp::decode_list(r.at(1)?.as_raw());
101        let cycles_used: Vec<u64> = rlp::decode_list(r.at(2)?.as_raw());
102        let epoch_id: u64 = r.at(3)?.as_val()?;
103        let exec_epoch_id: u64 = r.at(4)?.as_val()?;
104        let logs_bloom: Vec<Bloom> = rlp::decode_list(r.at(5)?.as_raw());
105        let order_root = rlp::decode(r.at(6)?.as_raw())?;
106        let pre_hash = rlp::decode(r.at(7)?.as_raw())?;
107        let proof: Proof = rlp::decode(r.at(8)?.as_raw())?;
108        let proposer = rlp::decode(r.at(9)?.as_raw())?;
109        let receipt_root: Vec<Hash> = rlp::decode_list(r.at(10)?.as_raw());
110        let state_root = rlp::decode(r.at(11)?.as_raw())?;
111        let timestamp: u64 = r.at(12)?.as_val()?;
112        let validator_version: u64 = r.at(13)?.as_val()?;
113        let validators: Vec<Validator> = rlp::decode_list(r.at(14)?.as_raw());
114
115        Ok(EpochHeader {
116            chain_id,
117            epoch_id,
118            exec_epoch_id,
119            pre_hash,
120            timestamp,
121            logs_bloom,
122            order_root,
123            confirm_root,
124            state_root,
125            receipt_root,
126            cycles_used,
127            proposer,
128            proof,
129            validator_version,
130            validators,
131        })
132    }
133}
134
135impl rlp::Encodable for Epoch {
136    fn rlp_append(&self, s: &mut rlp::RlpStream) {
137        s.begin_list(2)
138            .append(&self.header)
139            .append_list(&self.ordered_tx_hashes);
140    }
141}
142
143impl rlp::Decodable for Epoch {
144    fn decode(r: &rlp::Rlp) -> Result<Self, rlp::DecoderError> {
145        if !r.is_list() && r.size() != 2 {
146            return Err(rlp::DecoderError::RlpIncorrectListLen);
147        }
148
149        let header: EpochHeader = rlp::decode(r.at(0)?.as_raw())?;
150        let ordered_tx_hashes: Vec<Hash> = rlp::decode_list(r.at(1)?.as_raw());
151
152        Ok(Epoch {
153            header,
154            ordered_tx_hashes,
155        })
156    }
157}
158
159impl rlp::Encodable for Pill {
160    fn rlp_append(&self, s: &mut rlp::RlpStream) {
161        s.begin_list(2)
162            .append(&self.epoch)
163            .append_list(&self.propose_hashes);
164    }
165}
166
167impl rlp::Decodable for Pill {
168    fn decode(r: &rlp::Rlp) -> Result<Self, rlp::DecoderError> {
169        if !r.is_list() && r.size() != 2 {
170            return Err(rlp::DecoderError::RlpIncorrectListLen);
171        }
172
173        let epoch: Epoch = rlp::decode(r.at(0)?.as_raw())?;
174        let propose_hashes: Vec<Hash> = rlp::decode_list(r.at(1)?.as_raw());
175
176        Ok(Pill {
177            epoch,
178            propose_hashes,
179        })
180    }
181}
muta_protocol/fixed_codec/epoch.rs

muta_protocol/fixed_codec/
epoch.rs
