tonlib_core_anychain/cell/
parser.rs

1use std::collections::HashMap;
2use std::hash::Hash;
3use std::io::Cursor;
4use std::sync::Arc;
5
6use bitstream_io::{BigEndian, BitRead, BitReader, Numeric};
7use num_bigint::{BigInt, BigUint, Sign};
8use num_traits::identities::Zero;
9
10use super::dict::{DictParser, KeyReader, SnakeFormatDict, ValReader};
11use super::{ArcCell, Cell, CellBuilder};
12use crate::cell::dict::predefined_readers::{key_reader_256bit, val_reader_snake_formatted_string};
13use crate::cell::util::*;
14use crate::cell::{MapTonCellError, TonCellError};
15use crate::TonAddress;
16
17pub struct CellParser<'a> {
18    pub(crate) bit_len: usize,
19    pub(crate) bit_reader: BitReader<Cursor<&'a [u8]>, BigEndian>,
20    pub(crate) references: &'a [ArcCell],
21    next_ref: usize,
22}
23
24impl<'a> CellParser<'a> {
25    pub fn new(bit_len: usize, data: &'a [u8], references: &'a [ArcCell]) -> Self {
26        let cursor = Cursor::new(data);
27        let bit_reader = BitReader::endian(cursor, BigEndian);
28        CellParser {
29            bit_len,
30            bit_reader,
31            references,
32            next_ref: 0,
33        }
34    }
35
36    pub fn remaining_bits(&mut self) -> usize {
37        let pos = self.bit_reader.position_in_bits().unwrap_or_default() as usize;
38        if self.bit_len > pos {
39            self.bit_len - pos
40        } else {
41            0
42        }
43    }
44
45    /// Return number of full bytes remaining
46    pub fn remaining_bytes(&mut self) -> usize {
47        self.remaining_bits() / 8
48    }
49
50    pub fn load_bit(&mut self) -> Result<bool, TonCellError> {
51        self.ensure_enough_bits(1)?;
52        self.bit_reader.read_bit().map_cell_parser_error()
53    }
54
55    pub fn load_u8(&mut self, bit_len: usize) -> Result<u8, TonCellError> {
56        self.load_number(bit_len)
57    }
58
59    pub fn load_i8(&mut self, bit_len: usize) -> Result<i8, TonCellError> {
60        self.load_number(bit_len)
61    }
62
63    pub fn load_u16(&mut self, bit_len: usize) -> Result<u16, TonCellError> {
64        self.load_number(bit_len)
65    }
66
67    pub fn load_i16(&mut self, bit_len: usize) -> Result<i16, TonCellError> {
68        self.load_number(bit_len)
69    }
70
71    pub fn load_u32(&mut self, bit_len: usize) -> Result<u32, TonCellError> {
72        self.load_number(bit_len)
73    }
74
75    pub fn load_i32(&mut self, bit_len: usize) -> Result<i32, TonCellError> {
76        self.load_number(bit_len)
77    }
78
79    pub fn load_u64(&mut self, bit_len: usize) -> Result<u64, TonCellError> {
80        self.load_number(bit_len)
81    }
82
83    pub fn load_i64(&mut self, bit_len: usize) -> Result<i64, TonCellError> {
84        self.load_number(bit_len)
85    }
86
87    pub fn load_uint(&mut self, bit_len: usize) -> Result<BigUint, TonCellError> {
88        self.ensure_enough_bits(bit_len)?;
89        let num_words = (bit_len + 31) / 32;
90        let high_word_bits = if bit_len % 32 == 0 { 32 } else { bit_len % 32 };
91        let mut words: Vec<u32> = vec![0_u32; num_words];
92        let high_word = self.load_u32(high_word_bits)?;
93        words[num_words - 1] = high_word;
94        for i in (0..num_words - 1).rev() {
95            let word = self.load_u32(32)?;
96            words[i] = word;
97        }
98        let big_uint = BigUint::new(words);
99        Ok(big_uint)
100    }
101
102    pub fn load_int(&mut self, bit_len: usize) -> Result<BigInt, TonCellError> {
103        self.ensure_enough_bits(bit_len)?;
104        let num_words = (bit_len + 31) / 32;
105        let high_word_bits = if bit_len % 32 == 0 { 32 } else { bit_len % 32 };
106        let mut words: Vec<u32> = vec![0_u32; num_words];
107        let high_word = self.load_u32(high_word_bits)?;
108        let sign = if (high_word & (1 << 31)) == 0 {
109            Sign::Plus
110        } else {
111            Sign::Minus
112        };
113        words[num_words - 1] = high_word;
114        for i in (0..num_words - 1).rev() {
115            let word = self.load_u32(32)?;
116            words[i] = word;
117        }
118        let big_uint = BigInt::new(sign, words);
119        Ok(big_uint)
120    }
121
122    pub fn load_byte(&mut self) -> Result<u8, TonCellError> {
123        self.load_u8(8)
124    }
125
126    pub fn load_slice(&mut self, slice: &mut [u8]) -> Result<(), TonCellError> {
127        self.ensure_enough_bits(slice.len() * 8)?;
128        self.bit_reader.read_bytes(slice).map_cell_parser_error()
129    }
130
131    pub fn load_bytes(&mut self, num_bytes: usize) -> Result<Vec<u8>, TonCellError> {
132        let mut res = vec![0_u8; num_bytes];
133        self.load_slice(res.as_mut_slice())?;
134        Ok(res)
135    }
136
137    pub fn load_bits_to_slice(
138        &mut self,
139        num_bits: usize,
140        slice: &mut [u8],
141    ) -> Result<(), TonCellError> {
142        self.ensure_enough_bits(num_bits)?;
143        self.bit_reader.read_bits(num_bits, slice)?;
144        Ok(())
145    }
146
147    pub fn load_bits(&mut self, num_bits: usize) -> Result<Vec<u8>, TonCellError> {
148        let total_bytes = (num_bits + 7) / 8;
149        let mut res = vec![0_u8; total_bytes];
150        self.load_bits_to_slice(num_bits, res.as_mut_slice())?;
151        Ok(res)
152    }
153
154    pub fn load_utf8(&mut self, num_bytes: usize) -> Result<String, TonCellError> {
155        let bytes = self.load_bytes(num_bytes)?;
156        String::from_utf8(bytes).map_cell_parser_error()
157    }
158
159    pub fn load_coins(&mut self) -> Result<BigUint, TonCellError> {
160        let num_bytes = self.load_u8(4)?;
161        if num_bytes == 0 {
162            Ok(BigUint::zero())
163        } else {
164            self.load_uint(num_bytes as usize * 8)
165        }
166    }
167
168    pub fn load_remaining(&mut self) -> Result<Cell, TonCellError> {
169        let mut builder = CellBuilder::new();
170        builder.store_remaining_bits(self)?;
171        builder.store_references(&self.references[self.next_ref..])?;
172        let cell = builder.build();
173        self.next_ref = self.references.len();
174        cell
175    }
176
177    pub fn load_address(&mut self) -> Result<TonAddress, TonCellError> {
178        self.ensure_enough_bits(2)?;
179        let tp = self.bit_reader.read::<u8>(2).map_cell_parser_error()?;
180        match tp {
181            0 => Ok(TonAddress::null()),
182            2 => {
183                self.ensure_enough_bits(1 + 8 + 32 * 8)?;
184                let _res1 = self.bit_reader.read::<u8>(1).map_cell_parser_error()?;
185                let wc = self.bit_reader.read::<u8>(8).map_cell_parser_error()?;
186                let mut hash_part = [0_u8; 32];
187                self.bit_reader
188                    .read_bytes(&mut hash_part)
189                    .map_cell_parser_error()?;
190                let addr = TonAddress::new(wc as i32, &hash_part);
191                Ok(addr)
192            }
193            _ => Err(TonCellError::InvalidAddressType(tp)),
194        }
195    }
196
197    pub fn load_unary_length(&mut self) -> Result<usize, TonCellError> {
198        let mut res = 0;
199        while self.load_bit()? {
200            res += 1;
201        }
202        Ok(res)
203    }
204
205    pub fn load_dict<K: Eq + Hash, V>(
206        &mut self,
207        key_len: usize,
208        key_reader: KeyReader<K>,
209        val_reader: ValReader<V>,
210    ) -> Result<HashMap<K, V>, TonCellError> {
211        let mut dict_parser = DictParser::new(key_len, key_reader, val_reader);
212        dict_parser.parse(self)
213    }
214
215    ///Snake format when we store part of the data in a cell and the rest of the data in the first child cell (and so recursively).
216    ///
217    ///Must be prefixed with 0x00 byte.
218    ///### TL-B scheme:
219    ///
220    /// ``` tail#_ {bn:#} b:(bits bn) = SnakeData ~0; ```
221    ///
222    /// ``` cons#_ {bn:#} {n:#} b:(bits bn) next:^(SnakeData ~n) = SnakeData ~(n + 1); ```
223    pub fn load_dict_snake_format(&mut self) -> Result<SnakeFormatDict, TonCellError> {
224        self.load_dict(256, key_reader_256bit, val_reader_snake_formatted_string)
225    }
226
227    pub fn ensure_empty(&mut self) -> Result<(), TonCellError> {
228        let remaining_bits = self.remaining_bits();
229        let remaining_refs = self.references.len() - self.next_ref;
230        // if remaining_bits == 0 && remaining_refs == 0 { // todo: We will restore reference checking in in 0.18
231        if remaining_bits == 0 {
232            Ok(())
233        } else {
234            Err(TonCellError::NonEmptyReader {
235                remaining_bits,
236                remaining_refs,
237            })
238        }
239    }
240
241    pub fn skip_bits(&mut self, num_bits: usize) -> Result<(), TonCellError> {
242        self.ensure_enough_bits(num_bits)?;
243        self.bit_reader
244            .skip(num_bits as u32)
245            .map_cell_parser_error()
246    }
247
248    fn load_number<N: Numeric>(&mut self, bit_len: usize) -> Result<N, TonCellError> {
249        self.ensure_enough_bits(bit_len)?;
250
251        self.bit_reader
252            .read::<N>(bit_len as u32)
253            .map_cell_parser_error()
254    }
255
256    fn ensure_enough_bits(&mut self, bit_len: usize) -> Result<(), TonCellError> {
257        if self.remaining_bits() < bit_len {
258            return Err(TonCellError::CellParserError(
259                "Not enough bits to read".to_owned(),
260            ));
261        }
262        Ok(())
263    }
264
265    pub fn next_reference(&mut self) -> Result<ArcCell, TonCellError> {
266        if self.next_ref < self.references.len() {
267            let reference = self.references[self.next_ref].clone();
268            self.next_ref += 1;
269
270            Ok(reference)
271        } else {
272            Err(TonCellError::CellParserError(
273                "Not enough references to read".to_owned(),
274            ))
275        }
276    }
277    // https://docs.ton.org/develop/data-formats/tl-b-types#eiher
278    pub fn load_either_cell_or_cell_ref(&mut self) -> Result<ArcCell, TonCellError> {
279        // TODO: think about how we can make it generic
280        let is_ref = self.load_bit()?;
281        if is_ref {
282            Ok(self.next_reference()?)
283        } else {
284            let remaining_bits = self.remaining_bits();
285            let data = self.load_bits(remaining_bits)?;
286            let remaining_ref_count = self.references.len() - self.next_ref;
287            let mut references = vec![];
288            for _ in 0..remaining_ref_count {
289                references.push(self.next_reference()?)
290            }
291            let result = Arc::new(Cell::new(data, remaining_bits, references, false)?);
292            Ok(result)
293        }
294    }
295    // https://docs.ton.org/develop/data-formats/tl-b-types#maybe
296    pub fn load_maybe_cell_ref(&mut self) -> Result<Option<ArcCell>, TonCellError> {
297        let is_some = self.load_bit()?;
298        if is_some {
299            Ok(Some(self.next_reference()?))
300        } else {
301            Ok(None)
302        }
303    }
304}
305
306#[cfg(test)]
307mod tests {
308
309    use std::sync::Arc;
310
311    use num_bigint::{BigInt, BigUint};
312
313    use crate::cell::{Cell, CellBuilder, EitherCellLayout};
314    use crate::TonAddress;
315
316    #[test]
317    fn test_load_bit() {
318        let cell = Cell::new([0b10101010].to_vec(), 4, vec![], false).unwrap();
319        let mut parser = cell.parser();
320        assert!(parser.load_bit().unwrap());
321        assert!(!parser.load_bit().unwrap());
322        assert!(parser.load_bit().unwrap());
323        assert!(!parser.load_bit().unwrap());
324        assert!(parser.load_bit().is_err());
325    }
326
327    #[test]
328    fn test_load_u8() {
329        let cell = Cell::new([0b10101010].to_vec(), 4, vec![], false).unwrap();
330        let mut parser = cell.parser();
331        assert_eq!(parser.load_u8(4).unwrap(), 0b1010);
332        assert!(parser.load_u8(1).is_err());
333    }
334
335    #[test]
336    fn test_load_i8() {
337        let cell = Cell::new([0b10101010].to_vec(), 4, vec![], false).unwrap();
338        let mut parser = cell.parser();
339        assert_eq!(parser.load_i8(4).unwrap(), 0b1010);
340        assert!(parser.load_i8(2).is_err());
341
342        let cell = Cell::new([0b10100110, 0b10101010].to_vec(), 13, vec![], false).unwrap();
343        let mut parser = cell.parser();
344        assert_eq!(parser.load_i8(4).unwrap(), 0b1010);
345        assert_eq!(parser.load_i8(8).unwrap(), 0b01101010);
346        assert!(parser.load_i8(2).is_err());
347    }
348
349    #[test]
350    fn test_load_u16() {
351        let cell = Cell::new([0b10101010, 0b01010101].to_vec(), 12, vec![], false).unwrap();
352        let mut parser = cell.parser();
353        assert_eq!(parser.load_u16(8).unwrap(), 0b10101010);
354        assert!(parser.load_u16(8).is_err());
355    }
356
357    #[test]
358    fn test_load_i16() {
359        let cell = Cell::new([0b10101010, 0b01010101].to_vec(), 12, vec![], false).unwrap();
360        let mut parser = cell.parser();
361        assert_eq!(parser.load_i16(9).unwrap(), 0b101010100);
362        assert!(parser.load_i16(4).is_err());
363    }
364
365    #[test]
366    fn test_load_u32() {
367        let cell = Cell::new([0b10101010, 0b01010101].to_vec(), 13, vec![], false).unwrap();
368        let mut parser = cell.parser();
369
370        assert_eq!(parser.load_u32(8).unwrap(), 0b10101010);
371        assert!(parser.load_u32(8).is_err());
372    }
373
374    #[test]
375    fn test_load_i32() {
376        let cell = Cell::new([0b10101010, 0b01010101].to_vec(), 14, vec![], false).unwrap();
377        let mut parser = cell.parser();
378        assert_eq!(parser.load_i32(10).unwrap(), 0b1010101001);
379        assert!(parser.load_i32(5).is_err());
380    }
381
382    #[test]
383    fn test_load_u64() {
384        let cell = Cell::new([0b10101010, 0b01010101].to_vec(), 13, vec![], false).unwrap();
385        let mut parser = cell.parser();
386        assert_eq!(parser.load_u64(8).unwrap(), 0b10101010);
387        assert!(parser.load_u64(8).is_err());
388    }
389
390    #[test]
391    fn test_load_i64() {
392        let cell = Cell::new([0b10101010, 0b01010101].to_vec(), 14, vec![], false).unwrap();
393        let mut parser = cell.parser();
394        assert_eq!(parser.load_i64(10).unwrap(), 0b1010101001);
395        assert!(parser.load_i64(5).is_err());
396    }
397
398    #[test]
399    fn test_load_int() {
400        let cell = Cell::new([0b10101010, 0b01010101].to_vec(), 14, vec![], false).unwrap();
401        let mut parser = cell.parser();
402        assert_eq!(parser.load_int(10).unwrap(), BigInt::from(0b1010101001));
403        assert!(parser.load_int(5).is_err());
404    }
405
406    #[test]
407    fn test_load_uint() {
408        let cell = Cell::new([0b10101010, 0b01010101].to_vec(), 14, vec![], false).unwrap();
409        let mut parser = cell.parser();
410        assert_eq!(
411            parser.load_uint(10).unwrap(),
412            BigUint::from(0b1010101001u64)
413        );
414        assert!(parser.load_uint(5).is_err());
415    }
416
417    #[test]
418    fn test_load_byte() {
419        let cell = Cell::new([0b10101010, 0b01010101].to_vec(), 15, vec![], false).unwrap();
420        let mut parser = cell.parser();
421        parser.load_bit().unwrap();
422        assert_eq!(parser.load_byte().unwrap(), 0b01010100u8);
423        assert!(parser.load_byte().is_err());
424    }
425
426    #[test]
427    fn test_load_slice() {
428        let cell = Cell::new(
429            [0b10101010, 0b01010101, 0b10101010, 0b10101010, 0b10101010].to_vec(),
430            32,
431            vec![],
432            false,
433        )
434        .unwrap();
435        let mut parser = cell.parser();
436        parser.load_bit().unwrap();
437        let mut slice = [0; 2];
438        parser.load_slice(&mut slice).unwrap();
439        assert_eq!(slice, [0b01010100, 0b10101011]);
440        assert!(parser.load_slice(&mut slice).is_err());
441    }
442
443    #[test]
444    fn test_load_bytes() {
445        let cell = Cell::new(
446            [0b10101010, 0b01010101, 0b10101010, 0b10101010, 0b10101010].to_vec(),
447            32,
448            vec![],
449            false,
450        )
451        .unwrap();
452        let mut parser = cell.parser();
453        parser.load_bit().unwrap();
454        let slice = parser.load_bytes(2).unwrap();
455        assert_eq!(slice, [0b01010100, 0b10101011]);
456        assert!(parser.load_bytes(2).is_err());
457    }
458
459    #[test]
460    fn test_load_bits_to_slice() {
461        let cell = Cell::new(
462            [0b10101010, 0b01010101, 0b10101010, 0b10101010, 0b10101010].to_vec(),
463            22,
464            vec![],
465            false,
466        )
467        .unwrap();
468        let mut parser = cell.parser();
469        parser.load_bit().unwrap();
470        let mut slice = [0; 2];
471        parser.load_bits_to_slice(12, &mut slice).unwrap();
472        assert_eq!(slice, [0b01010100, 0b10100000]);
473        assert!(parser.load_bits_to_slice(10, &mut slice).is_err());
474    }
475
476    #[test]
477    fn test_load_bits() {
478        let cell = Cell::new(
479            [0b10101010, 0b01010101, 0b10101010, 0b10101010, 0b10101010].to_vec(),
480            25,
481            vec![],
482            false,
483        )
484        .unwrap();
485        let mut parser = cell.parser();
486        parser.load_bit().unwrap();
487        let slice = parser.load_bits(5).unwrap();
488        assert_eq!(slice, [0b01010000]);
489        let slice = parser.load_bits(15).unwrap();
490        assert_eq!(slice, [0b10010101, 0b01101010]);
491        assert!(parser.load_bits(5).is_err());
492    }
493
494    #[test]
495    fn test_load_utf8() {
496        let cell = Cell::new("a1j\0".as_bytes().to_vec(), 31, vec![], false).unwrap();
497        let mut parser = cell.parser();
498        let string = parser.load_utf8(2).unwrap();
499        assert_eq!(string, "a1");
500        let string = parser.load_utf8(1).unwrap();
501        assert_eq!(string, "j");
502        assert!(parser.load_utf8(1).is_err());
503    }
504
505    #[test]
506    fn test_load_coins() {
507        let cell = Cell::new(
508            [
509                0b00011111, 0b11110011, 0b11110011, 0b11110011, 0b11110011, 0b00011111, 0b11110011,
510            ]
511            .to_vec(),
512            48,
513            vec![],
514            false,
515        )
516        .unwrap();
517        let mut parser = cell.parser();
518
519        assert_eq!(parser.load_coins().unwrap(), BigUint::from(0b11111111u64));
520        assert_eq!(
521            parser.load_coins().unwrap(),
522            BigUint::from(0b111100111111001111110011u64)
523        );
524        assert!(parser.load_coins().is_err());
525    }
526
527    #[test]
528    fn test_load_address() {
529        let cell = Cell::new([0].to_vec(), 3, vec![], false).unwrap();
530        let mut parser = cell.parser();
531        assert_eq!(parser.load_address().unwrap(), TonAddress::null());
532        assert!(parser.load_address().is_err());
533
534        // with full addresses
535        let cell = Cell::new(
536            [
537                0b10000000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
538                0, 0, 0, 0, 0, 0, 0, 0, 0b00010000, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
539                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0b00000010, 0, 0, 0, 0, 0, 0, 0, 0,
540                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
541            ]
542            .to_vec(),
543            (3 + 8 + 32 * 8) * 3 - 1,
544            vec![],
545            false,
546        )
547        .unwrap();
548        let mut parser = cell.parser();
549        assert_eq!(parser.load_address().unwrap(), TonAddress::null());
550        assert_eq!(parser.load_address().unwrap(), TonAddress::null());
551        assert!(parser.load_address().is_err());
552    }
553
554    #[test]
555    fn test_ensure_empty() {
556        let cell = Cell::new([0b10101010].to_vec(), 7, vec![], false).unwrap();
557        let mut parser = cell.parser();
558        parser.load_u8(4).unwrap();
559        assert!(parser.ensure_empty().is_err());
560        parser.load_u8(3).unwrap();
561        assert!(parser.ensure_empty().is_ok());
562    }
563
564    #[test]
565    fn test_skip_bits_not_enough_bits() {
566        let cell = Cell::new([0b11111001, 0b00001010].to_vec(), 12, vec![], false).unwrap();
567        let mut parser = cell.parser();
568        assert!(parser.skip_bits(5).is_ok());
569        assert_eq!(parser.load_bits(5).unwrap(), [0b00100000]);
570        assert!(parser.skip_bits(3).is_err());
571    }
572
573    #[test]
574    fn test_parser_with_refs() {
575        let ref1 = Cell::new([0b11111001, 0b00001010].to_vec(), 12, vec![], false).unwrap();
576        let ref2 = Cell::new([0b11111001, 0b00001010].to_vec(), 12, vec![], false).unwrap();
577        let cell = Cell::new(
578            [0b11111001, 0b00001010].to_vec(),
579            12,
580            vec![ref1.into(), ref2.into()],
581            false,
582        )
583        .unwrap();
584        let mut parser = cell.parser();
585
586        assert!(parser.next_reference().is_ok());
587        assert!(parser.next_reference().is_ok());
588        assert!(parser.next_reference().is_err());
589    }
590
591    #[test]
592    fn test_either_with_references() {
593        let reference_cell = Cell::new([0xA5, 0x5A].to_vec(), 12, vec![], false).unwrap();
594        let cell_either = Arc::new(
595            Cell::new(
596                [0xFF, 0xB0].to_vec(),
597                12,
598                vec![reference_cell.into()],
599                false,
600            )
601            .unwrap(),
602        );
603        let cell = CellBuilder::new()
604            .store_bit(true)
605            .unwrap()
606            .store_either_cell_or_cell_ref(&cell_either, EitherCellLayout::Native)
607            .unwrap()
608            .build()
609            .unwrap();
610
611        let mut parser = cell.parser();
612
613        let result_first_bit = parser.load_bit().unwrap();
614        let result_cell_either = parser.load_either_cell_or_cell_ref().unwrap();
615
616        assert!(result_first_bit);
617        assert_eq!(result_cell_either, cell_either);
618    }
619}
tonlib_core_anychain/cell/parser.rs

tonlib_core_anychain/cell/
parser.rs
