cardano_serialization_lib/chain_core/
abor.rs

1/// ABOR Encoder
2pub struct Encoder {
3    data: Vec<u8>,
4    hole: Vec<(usize, usize)>,
5    current_element: usize,
6}
7
8/// ABOR Types
9#[repr(u8)]
10#[derive(Debug, Clone, Copy, PartialEq, Eq)]
11pub enum Tag {
12    U8 = 1,
13    U16 = 2,
14    U32 = 3,
15    U64 = 4,
16    U128 = 5,
17    Bytes = 6,
18    Array = 7,
19}
20
21impl Tag {
22    pub fn from_u8(v: u8) -> Option<Tag> {
23        match v {
24            1 => Some(Tag::U8),
25            2 => Some(Tag::U16),
26            3 => Some(Tag::U32),
27            4 => Some(Tag::U64),
28            5 => Some(Tag::U128),
29            6 => Some(Tag::Bytes),
30            7 => Some(Tag::Array),
31            _ => None,
32        }
33    }
34}
35
36impl Encoder {
37    pub fn new() -> Self {
38        Encoder {
39            data: Vec::new(),
40            hole: Vec::new(),
41            current_element: 0,
42        }
43    }
44
45    fn push_byte(self, u: u8) -> Self {
46        let mut v = self.data;
47        v.push(u);
48        Self {
49            data: v,
50            hole: self.hole,
51            current_element: self.current_element,
52        }
53    }
54
55    fn push_tag(self, tag: Tag) -> Self {
56        self.push_byte(tag as u8)
57    }
58
59    fn push_slice(self, s: &[u8]) -> Self {
60        let mut v = self.data;
61        v.extend_from_slice(s);
62        Self {
63            data: v,
64            hole: self.hole,
65            current_element: self.current_element,
66        }
67    }
68
69    fn incr(self) -> Self {
70        Self {
71            data: self.data,
72            hole: self.hole,
73            current_element: self.current_element + 1,
74        }
75    }
76
77    /// Add an unsigned byte
78    pub fn u8(self, u: u8) -> Self {
79        self.push_tag(Tag::U8).push_byte(u).incr()
80    }
81
82    /// Add a 16-bit unsigned value in little endian format
83    pub fn u16(self, u: u16) -> Self {
84        self.push_tag(Tag::U16).push_slice(&u.to_le_bytes()).incr()
85    }
86
87    /// Add a 32-bit unsigned value in little endian format
88    pub fn u32(self, u: u32) -> Self {
89        self.push_tag(Tag::U32).push_slice(&u.to_le_bytes()).incr()
90    }
91
92    /// Add a 64-bit unsigned value in little endian format
93    pub fn u64(self, u: u64) -> Self {
94        self.push_tag(Tag::U64).push_slice(&u.to_le_bytes()).incr()
95    }
96
97    /// Add a 128-bit unsigned value in little endian format
98    pub fn u128(self, u: u128) -> Self {
99        self.push_tag(Tag::U128).push_slice(&u.to_le_bytes()).incr()
100    }
101
102    /// cannot serialize more than 256 bytes of contiguous data
103    pub fn bytes(self, bs: &[u8]) -> Self {
104        assert!(bs.len() < 256);
105        self.push_tag(Tag::Bytes)
106            .push_byte(bs.len() as u8)
107            .push_slice(&bs)
108            .incr()
109    }
110
111    /// Array cannot contain more than 256 elements
112    pub fn struct_start(self) -> Self {
113        let mut d = self.push_tag(Tag::Array);
114        let mut h = d.hole;
115        let c = d.current_element + 1;
116        h.push((c, d.data.len()));
117        d.data.push(0xfe); // placeholder poison until struct end fill the actual size
118        Self {
119            data: d.data,
120            hole: h,
121            current_element: c,
122        }
123    }
124
125    /// Terminate an array
126    pub fn struct_end(self) -> Self {
127        let mut h = self.hole;
128        match h.pop() {
129            None => panic!("unmatched end"),
130            Some((start_element, ofs)) => {
131                let mut v = self.data;
132                let nb_elements = self.current_element - start_element;
133                assert!(nb_elements < 256);
134                v[ofs] = nb_elements as u8;
135                Self {
136                    data: v,
137                    hole: h,
138                    current_element: self.current_element,
139                }
140            }
141        }
142    }
143
144    /// Finalize the encoder into an immutable array of data
145    pub fn finalize(self) -> Box<[u8]> {
146        assert_eq!(self.hole.len(), 0);
147        self.data.into()
148    }
149}
150
151/// Create a decoder on some data
152pub struct Decoder<'a> {
153    slice: &'a [u8],
154    //ctx: Vec<usize>,
155    //element: usize,
156}
157
158#[derive(Debug, Clone)]
159pub enum DecodeError {
160    EndOfStream,
161    StreamTooSmall { want: usize, has: usize },
162    StreamPending { left: usize },
163    TypeUnknown(u8),
164    TypeMismatch { got: Tag, expected: Tag },
165}
166
167impl<'a> Decoder<'a> {
168    #[must_use]
169    pub fn new(data: &'a [u8]) -> Self {
170        Decoder { slice: data }
171    }
172
173    #[must_use]
174    fn pop(&mut self) -> Result<u8, DecodeError> {
175        if self.slice.len() > 0 {
176            let v = self.slice[0];
177            self.slice = &self.slice[1..];
178            Ok(v)
179        } else {
180            Err(DecodeError::EndOfStream)
181        }
182    }
183
184    #[must_use]
185    fn expect_tag(&mut self, tag: Tag) -> Result<(), DecodeError> {
186        let t = self.pop()?;
187        match Tag::from_u8(t) {
188            None => Err(DecodeError::TypeUnknown(self.slice[0])),
189            Some(got) if got == tag => Ok(()),
190            Some(got) => Err(DecodeError::TypeMismatch { got, expected: tag }),
191        }
192    }
193
194    #[must_use]
195    fn expect_size(&self, nb_bytes: usize) -> Result<(), DecodeError> {
196        if nb_bytes <= self.slice.len() {
197            Ok(())
198        } else {
199            Err(DecodeError::StreamTooSmall {
200                want: nb_bytes,
201                has: self.slice.len(),
202            })
203        }
204    }
205
206    #[must_use]
207    fn expect_tag_size(&mut self, tag: Tag, nb_bytes: usize) -> Result<(), DecodeError> {
208        self.expect_tag(tag)?;
209        self.expect_size(nb_bytes)
210    }
211
212    #[must_use]
213    pub fn array(&mut self) -> Result<usize, DecodeError> {
214        self.expect_tag_size(Tag::Array, 1)?;
215        let len = self.pop()?;
216        Ok(len as usize)
217    }
218
219    #[must_use]
220    pub fn u8(&mut self) -> Result<u8, DecodeError> {
221        self.expect_tag_size(Tag::U8, 1)?;
222        let len = self.pop()?;
223        Ok(len)
224    }
225
226    #[must_use]
227    pub fn u16(&mut self) -> Result<u16, DecodeError> {
228        self.expect_tag_size(Tag::U16, 2)?;
229        let v = {
230            let mut b = [0; 2];
231            b.copy_from_slice(&self.slice[0..2]);
232            u16::from_le_bytes(b)
233        };
234        self.slice = &self.slice[2..];
235        Ok(v)
236    }
237
238    #[must_use]
239    pub fn u32(&mut self) -> Result<u32, DecodeError> {
240        self.expect_tag_size(Tag::U32, 2)?;
241        let v = {
242            let mut b = [0; 4];
243            b.copy_from_slice(&self.slice[0..4]);
244            u32::from_le_bytes(b)
245        };
246        self.slice = &self.slice[4..];
247        Ok(v)
248    }
249
250    #[must_use]
251    pub fn u64(&mut self) -> Result<u64, DecodeError> {
252        self.expect_tag_size(Tag::U64, 8)?;
253        let v = {
254            let mut b = [0; 8];
255            b.copy_from_slice(&self.slice[0..8]);
256            u64::from_le_bytes(b)
257        };
258        self.slice = &self.slice[8..];
259        Ok(v)
260    }
261
262    #[must_use]
263    pub fn u128(&mut self) -> Result<u128, DecodeError> {
264        self.expect_tag_size(Tag::U128, 16)?;
265        let v = {
266            let mut b = [0; 16];
267            b.copy_from_slice(&self.slice[0..16]);
268            u128::from_le_bytes(b)
269        };
270        self.slice = &self.slice[16..];
271        Ok(v)
272    }
273
274    #[must_use]
275    pub fn bytes(&mut self) -> Result<Box<[u8]>, DecodeError> {
276        self.expect_tag_size(Tag::Bytes, 1)?;
277        let len = self.pop()? as usize;
278        self.expect_size(len)?;
279        let mut v = Vec::with_capacity(len);
280        v.extend_from_slice(&self.slice[0..len]);
281        self.slice = &self.slice[len..];
282        Ok(v.into())
283    }
284
285    #[must_use]
286    pub fn end(self) -> Result<(), DecodeError> {
287        if self.slice.len() == 0 {
288            Ok(())
289        } else {
290            Err(DecodeError::StreamPending {
291                left: self.slice.len(),
292            })
293        }
294    }
295}
296
297#[cfg(test)]
298mod tests {
299    use super::*;
300
301    #[test]
302    pub fn serialize_unit1() {
303        let v = 0xf1235_fc;
304        let e = Encoder::new().u32(v).finalize();
305        let mut d = Decoder::new(&e);
306        let ev = d.u32().unwrap();
307        assert_eq!(d.end().is_ok(), true);
308        assert_eq!(v, ev)
309    }
310
311    #[test]
312    pub fn serialize_unit2() {
313        let v1 = 10;
314        let v2 = 0x12345;
315        let v3 = 0xffeeddcc00112233;
316        let v4 = 0xffeeddcc0011223321490219480912;
317        let bs1 = vec![1, 2, 3, 4, 5, 6, 7, 8, 9];
318        let e = Encoder::new()
319            .u16(v1)
320            .u32(v2)
321            .u64(v3)
322            .u128(v4)
323            .bytes(&bs1[..])
324            .finalize();
325        let mut d = Decoder::new(&e);
326        let ev1 = d.u16().unwrap();
327        let ev2 = d.u32().unwrap();
328        let ev3 = d.u64().unwrap();
329        let ev4 = d.u128().unwrap();
330        let ebs1 = d.bytes().unwrap();
331        let is_end = d.end();
332        assert_eq!(v1, ev1);
333        assert_eq!(v2, ev2);
334        assert_eq!(v3, ev3);
335        assert_eq!(v4, ev4);
336        assert_eq!(&bs1[..], &ebs1[..]);
337        assert_eq!(
338            is_end.is_ok(),
339            true,
340            "not reached end {:?}",
341            is_end.unwrap_err()
342        );
343    }
344}
cardano_serialization_lib/chain_core/abor.rs

cardano_serialization_lib/chain_core/
abor.rs
