hypercore/
encoding.rs

1//! Hypercore-specific compact encodings
2pub use compact_encoding::{CompactEncoding, EncodingError, EncodingErrorKind, State};
3use std::convert::TryInto;
4use std::ops::{Deref, DerefMut};
5
6use crate::{
7    crypto::{Manifest, ManifestSigner},
8    DataBlock, DataHash, DataSeek, DataUpgrade, Node, RequestBlock, RequestSeek, RequestUpgrade,
9};
10
11#[derive(Debug, Clone)]
12/// Wrapper struct for compact_encoding::State
13pub struct HypercoreState(pub State);
14
15impl Default for HypercoreState {
16    /// Passthrought to compact_encoding
17    fn default() -> Self {
18        Self::new()
19    }
20}
21
22impl HypercoreState {
23    /// Passthrought to compact_encoding
24    pub fn new() -> HypercoreState {
25        HypercoreState(State::new())
26    }
27
28    /// Passthrought to compact_encoding
29    pub fn new_with_size(size: usize) -> (HypercoreState, Box<[u8]>) {
30        let (state, buffer) = State::new_with_size(size);
31        (HypercoreState(state), buffer)
32    }
33
34    /// Passthrought to compact_encoding
35    pub fn new_with_start_and_end(start: usize, end: usize) -> HypercoreState {
36        HypercoreState(State::new_with_start_and_end(start, end))
37    }
38
39    /// Passthrought to compact_encoding
40    pub fn from_buffer(buffer: &[u8]) -> HypercoreState {
41        HypercoreState(State::from_buffer(buffer))
42    }
43}
44
45impl Deref for HypercoreState {
46    type Target = State;
47
48    fn deref(&self) -> &Self::Target {
49        &self.0
50    }
51}
52
53impl DerefMut for HypercoreState {
54    fn deref_mut(&mut self) -> &mut State {
55        &mut self.0
56    }
57}
58
59impl CompactEncoding<Node> for HypercoreState {
60    fn preencode(&mut self, value: &Node) -> Result<usize, EncodingError> {
61        self.0.preencode(&value.index)?;
62        self.0.preencode(&value.length)?;
63        self.0.preencode_fixed_32()
64    }
65
66    fn encode(&mut self, value: &Node, buffer: &mut [u8]) -> Result<usize, EncodingError> {
67        self.0.encode(&value.index, buffer)?;
68        self.0.encode(&value.length, buffer)?;
69        self.0.encode_fixed_32(&value.hash, buffer)
70    }
71
72    fn decode(&mut self, buffer: &[u8]) -> Result<Node, EncodingError> {
73        let index: u64 = self.0.decode(buffer)?;
74        let length: u64 = self.0.decode(buffer)?;
75        let hash: Box<[u8]> = self.0.decode_fixed_32(buffer)?;
76        Ok(Node::new(index, hash.to_vec(), length))
77    }
78}
79
80impl CompactEncoding<Vec<Node>> for HypercoreState {
81    fn preencode(&mut self, value: &Vec<Node>) -> Result<usize, EncodingError> {
82        let len = value.len();
83        self.0.preencode(&len)?;
84        for val in value {
85            self.preencode(val)?;
86        }
87        Ok(self.end())
88    }
89
90    fn encode(&mut self, value: &Vec<Node>, buffer: &mut [u8]) -> Result<usize, EncodingError> {
91        let len = value.len();
92        self.0.encode(&len, buffer)?;
93        for val in value {
94            self.encode(val, buffer)?;
95        }
96        Ok(self.start())
97    }
98
99    fn decode(&mut self, buffer: &[u8]) -> Result<Vec<Node>, EncodingError> {
100        let len: usize = self.0.decode(buffer)?;
101        let mut value = Vec::with_capacity(len);
102        for _ in 0..len {
103            value.push(self.decode(buffer)?);
104        }
105        Ok(value)
106    }
107}
108
109impl CompactEncoding<RequestBlock> for HypercoreState {
110    fn preencode(&mut self, value: &RequestBlock) -> Result<usize, EncodingError> {
111        self.0.preencode(&value.index)?;
112        self.0.preencode(&value.nodes)
113    }
114
115    fn encode(&mut self, value: &RequestBlock, buffer: &mut [u8]) -> Result<usize, EncodingError> {
116        self.0.encode(&value.index, buffer)?;
117        self.0.encode(&value.nodes, buffer)
118    }
119
120    fn decode(&mut self, buffer: &[u8]) -> Result<RequestBlock, EncodingError> {
121        let index: u64 = self.0.decode(buffer)?;
122        let nodes: u64 = self.0.decode(buffer)?;
123        Ok(RequestBlock { index, nodes })
124    }
125}
126
127impl CompactEncoding<RequestSeek> for HypercoreState {
128    fn preencode(&mut self, value: &RequestSeek) -> Result<usize, EncodingError> {
129        self.0.preencode(&value.bytes)
130    }
131
132    fn encode(&mut self, value: &RequestSeek, buffer: &mut [u8]) -> Result<usize, EncodingError> {
133        self.0.encode(&value.bytes, buffer)
134    }
135
136    fn decode(&mut self, buffer: &[u8]) -> Result<RequestSeek, EncodingError> {
137        let bytes: u64 = self.0.decode(buffer)?;
138        Ok(RequestSeek { bytes })
139    }
140}
141
142impl CompactEncoding<RequestUpgrade> for HypercoreState {
143    fn preencode(&mut self, value: &RequestUpgrade) -> Result<usize, EncodingError> {
144        self.0.preencode(&value.start)?;
145        self.0.preencode(&value.length)
146    }
147
148    fn encode(
149        &mut self,
150        value: &RequestUpgrade,
151        buffer: &mut [u8],
152    ) -> Result<usize, EncodingError> {
153        self.0.encode(&value.start, buffer)?;
154        self.0.encode(&value.length, buffer)
155    }
156
157    fn decode(&mut self, buffer: &[u8]) -> Result<RequestUpgrade, EncodingError> {
158        let start: u64 = self.0.decode(buffer)?;
159        let length: u64 = self.0.decode(buffer)?;
160        Ok(RequestUpgrade { start, length })
161    }
162}
163
164impl CompactEncoding<DataBlock> for HypercoreState {
165    fn preencode(&mut self, value: &DataBlock) -> Result<usize, EncodingError> {
166        self.0.preencode(&value.index)?;
167        self.0.preencode(&value.value)?;
168        self.preencode(&value.nodes)
169    }
170
171    fn encode(&mut self, value: &DataBlock, buffer: &mut [u8]) -> Result<usize, EncodingError> {
172        self.0.encode(&value.index, buffer)?;
173        self.0.encode(&value.value, buffer)?;
174        self.encode(&value.nodes, buffer)
175    }
176
177    fn decode(&mut self, buffer: &[u8]) -> Result<DataBlock, EncodingError> {
178        let index: u64 = self.0.decode(buffer)?;
179        let value: Vec<u8> = self.0.decode(buffer)?;
180        let nodes: Vec<Node> = self.decode(buffer)?;
181        Ok(DataBlock {
182            index,
183            value,
184            nodes,
185        })
186    }
187}
188
189impl CompactEncoding<DataHash> for HypercoreState {
190    fn preencode(&mut self, value: &DataHash) -> Result<usize, EncodingError> {
191        self.0.preencode(&value.index)?;
192        self.preencode(&value.nodes)
193    }
194
195    fn encode(&mut self, value: &DataHash, buffer: &mut [u8]) -> Result<usize, EncodingError> {
196        self.0.encode(&value.index, buffer)?;
197        self.encode(&value.nodes, buffer)
198    }
199
200    fn decode(&mut self, buffer: &[u8]) -> Result<DataHash, EncodingError> {
201        let index: u64 = self.0.decode(buffer)?;
202        let nodes: Vec<Node> = self.decode(buffer)?;
203        Ok(DataHash { index, nodes })
204    }
205}
206
207impl CompactEncoding<DataSeek> for HypercoreState {
208    fn preencode(&mut self, value: &DataSeek) -> Result<usize, EncodingError> {
209        self.0.preencode(&value.bytes)?;
210        self.preencode(&value.nodes)
211    }
212
213    fn encode(&mut self, value: &DataSeek, buffer: &mut [u8]) -> Result<usize, EncodingError> {
214        self.0.encode(&value.bytes, buffer)?;
215        self.encode(&value.nodes, buffer)
216    }
217
218    fn decode(&mut self, buffer: &[u8]) -> Result<DataSeek, EncodingError> {
219        let bytes: u64 = self.0.decode(buffer)?;
220        let nodes: Vec<Node> = self.decode(buffer)?;
221        Ok(DataSeek { bytes, nodes })
222    }
223}
224
225impl CompactEncoding<DataUpgrade> for HypercoreState {
226    fn preencode(&mut self, value: &DataUpgrade) -> Result<usize, EncodingError> {
227        self.0.preencode(&value.start)?;
228        self.0.preencode(&value.length)?;
229        self.preencode(&value.nodes)?;
230        self.preencode(&value.additional_nodes)?;
231        self.0.preencode(&value.signature)
232    }
233
234    fn encode(&mut self, value: &DataUpgrade, buffer: &mut [u8]) -> Result<usize, EncodingError> {
235        self.0.encode(&value.start, buffer)?;
236        self.0.encode(&value.length, buffer)?;
237        self.encode(&value.nodes, buffer)?;
238        self.encode(&value.additional_nodes, buffer)?;
239        self.0.encode(&value.signature, buffer)
240    }
241
242    fn decode(&mut self, buffer: &[u8]) -> Result<DataUpgrade, EncodingError> {
243        let start: u64 = self.0.decode(buffer)?;
244        let length: u64 = self.0.decode(buffer)?;
245        let nodes: Vec<Node> = self.decode(buffer)?;
246        let additional_nodes: Vec<Node> = self.decode(buffer)?;
247        let signature: Vec<u8> = self.0.decode(buffer)?;
248        Ok(DataUpgrade {
249            start,
250            length,
251            nodes,
252            additional_nodes,
253            signature,
254        })
255    }
256}
257
258impl CompactEncoding<Manifest> for State {
259    fn preencode(&mut self, value: &Manifest) -> Result<usize, EncodingError> {
260        self.add_end(1)?; // Version
261        self.add_end(1)?; // hash in one byte
262        self.add_end(1)?; // type in one byte
263        self.preencode(&value.signer)
264    }
265
266    fn encode(&mut self, value: &Manifest, buffer: &mut [u8]) -> Result<usize, EncodingError> {
267        self.set_byte_to_buffer(0, buffer)?; // Version
268        if &value.hash == "blake2b" {
269            self.set_byte_to_buffer(0, buffer)?; // Version
270        } else {
271            return Err(EncodingError::new(
272                EncodingErrorKind::InvalidData,
273                &format!("Unknown hash: {}", &value.hash),
274            ));
275        }
276        // Type. 0: static, 1: signer, 2: multiple signers
277        self.set_byte_to_buffer(1, buffer)?; // Version
278        self.encode(&value.signer, buffer)
279    }
280
281    fn decode(&mut self, buffer: &[u8]) -> Result<Manifest, EncodingError> {
282        let version: u8 = self.decode_u8(buffer)?;
283        if version != 0 {
284            panic!("Unknown manifest version {}", version);
285        }
286        let hash_id: u8 = self.decode_u8(buffer)?;
287        let hash: String = if hash_id != 0 {
288            return Err(EncodingError::new(
289                EncodingErrorKind::InvalidData,
290                &format!("Unknown hash id: {hash_id}"),
291            ));
292        } else {
293            "blake2b".to_string()
294        };
295
296        let manifest_type: u8 = self.decode_u8(buffer)?;
297        if manifest_type != 1 {
298            return Err(EncodingError::new(
299                EncodingErrorKind::InvalidData,
300                &format!("Unknown manifest type: {manifest_type}"),
301            ));
302        }
303        let signer: ManifestSigner = self.decode(buffer)?;
304
305        Ok(Manifest { hash, signer })
306    }
307}
308
309impl CompactEncoding<ManifestSigner> for State {
310    fn preencode(&mut self, _value: &ManifestSigner) -> Result<usize, EncodingError> {
311        self.add_end(1)?; // Signature
312        self.preencode_fixed_32()?;
313        self.preencode_fixed_32()
314    }
315
316    fn encode(
317        &mut self,
318        value: &ManifestSigner,
319        buffer: &mut [u8],
320    ) -> Result<usize, EncodingError> {
321        if &value.signature == "ed25519" {
322            self.set_byte_to_buffer(0, buffer)?;
323        } else {
324            return Err(EncodingError::new(
325                EncodingErrorKind::InvalidData,
326                &format!("Unknown signature type: {}", &value.signature),
327            ));
328        }
329        self.encode_fixed_32(&value.namespace, buffer)?;
330        self.encode_fixed_32(&value.public_key, buffer)
331    }
332
333    fn decode(&mut self, buffer: &[u8]) -> Result<ManifestSigner, EncodingError> {
334        let signature_id: u8 = self.decode_u8(buffer)?;
335        let signature: String = if signature_id != 0 {
336            return Err(EncodingError::new(
337                EncodingErrorKind::InvalidData,
338                &format!("Unknown signature id: {signature_id}"),
339            ));
340        } else {
341            "ed25519".to_string()
342        };
343        let namespace: [u8; 32] =
344            self.decode_fixed_32(buffer)?
345                .to_vec()
346                .try_into()
347                .map_err(|_err| {
348                    EncodingError::new(
349                        EncodingErrorKind::InvalidData,
350                        "Invalid namespace in manifest signer",
351                    )
352                })?;
353        let public_key: [u8; 32] =
354            self.decode_fixed_32(buffer)?
355                .to_vec()
356                .try_into()
357                .map_err(|_err| {
358                    EncodingError::new(
359                        EncodingErrorKind::InvalidData,
360                        "Invalid public key in manifest signer",
361                    )
362                })?;
363
364        Ok(ManifestSigner {
365            signature,
366            namespace,
367            public_key,
368        })
369    }
370}
hypercore/encoding.rs

hypercore/
encoding.rs
