1use std::collections::HashMap;
2use std::hash::Hash;
3use std::io::{Cursor, SeekFrom};
4use std::sync::Arc;
5
6use bitstream_io::{BigEndian, BitRead, BitReader};
7use num_bigint::{BigInt, BigUint};
8use num_traits::identities::Zero;
9
10use super::dict::{DictParser, KeyReader, SnakeFormatDict, ValReader};
11use super::{ArcCell, Cell, CellBuilder, TonCellNum};
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::tlb_types::block::msg_address::MsgAddress;
16use crate::tlb_types::tlb::TLB;
17use crate::types::TON_HASH_LEN;
18use crate::{TonAddress, TonHash};
19
20pub struct CellParser<'a> {
21 pub cell: &'a Cell,
22 data_bit_reader: BitReader<Cursor<&'a [u8]>, BigEndian>,
23 next_ref: usize,
24}
25
26impl<'a> CellParser<'a> {
27 pub fn new(cell: &'a Cell) -> Self {
28 let cursor = Cursor::new(cell.data.as_slice());
29 let data_bit_reader = BitReader::endian(cursor, BigEndian);
30 CellParser {
31 cell,
32 data_bit_reader,
33 next_ref: 0,
34 }
35 }
36
37 pub fn remaining_bits(&mut self) -> usize {
38 let pos = self.data_bit_reader.position_in_bits().unwrap_or_default() as usize;
39 self.cell.bit_len.saturating_sub(pos)
40 }
41
42 pub fn remaining_refs(&self) -> usize {
43 self.cell.references.len() - self.next_ref
44 }
45
46 pub fn remaining_bytes(&mut self) -> usize {
48 self.remaining_bits() / 8
49 }
50
51 pub fn load_bit(&mut self) -> Result<bool, TonCellError> {
52 self.ensure_enough_bits(1)?;
53 self.data_bit_reader.read_bit().map_cell_parser_error()
54 }
55
56 pub fn seek(&mut self, num_bits: i64) -> Result<(), TonCellError> {
57 let cur_pos = self
58 .data_bit_reader
59 .position_in_bits()
60 .map_cell_parser_error()?;
61 let new_pos = cur_pos as i64 + num_bits;
62 if new_pos < 0 || new_pos > self.cell.bit_len as i64 {
63 let err_msg = format!(
64 "Attempt to advance beyond data range (new_pos: {new_pos}, bit_len: {})",
65 self.cell.bit_len
66 );
67 return Err(TonCellError::CellParserError(err_msg));
68 }
69 self.data_bit_reader
70 .seek_bits(SeekFrom::Current(num_bits))
71 .map_cell_parser_error()?;
72 Ok(())
73 }
74
75 pub fn load_u8(&mut self, bit_len: usize) -> Result<u8, TonCellError> {
76 self.load_number(bit_len)
77 }
78
79 pub fn load_i8(&mut self, bit_len: usize) -> Result<i8, TonCellError> {
80 Ok(self.load_number::<u8>(bit_len)? as i8)
81 }
82
83 pub fn load_u16(&mut self, bit_len: usize) -> Result<u16, TonCellError> {
84 self.load_number(bit_len)
85 }
86
87 pub fn load_i16(&mut self, bit_len: usize) -> Result<i16, TonCellError> {
88 Ok(self.load_number::<u16>(bit_len)? as i16)
89 }
90
91 pub fn load_u32(&mut self, bit_len: usize) -> Result<u32, TonCellError> {
92 self.load_number(bit_len)
93 }
94
95 pub fn load_i32(&mut self, bit_len: usize) -> Result<i32, TonCellError> {
96 Ok(self.load_number::<u32>(bit_len)? as i32)
97 }
98
99 pub fn load_u64(&mut self, bit_len: usize) -> Result<u64, TonCellError> {
100 self.load_number(bit_len)
101 }
102
103 pub fn load_i64(&mut self, bit_len: usize) -> Result<i64, TonCellError> {
104 Ok(self.load_number::<u64>(bit_len)? as i64)
105 }
106
107 pub fn load_uint(&mut self, bit_len: usize) -> Result<BigUint, TonCellError> {
108 self.ensure_enough_bits(bit_len)?;
109 let num_words = bit_len.div_ceil(32);
110 let high_word_bits = if bit_len % 32 == 0 { 32 } else { bit_len % 32 };
111 let mut words: Vec<u32> = vec![0_u32; num_words];
112 let high_word = self.load_u32(high_word_bits)?;
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 = BigUint::new(words);
119 Ok(big_uint)
120 }
121
122 pub fn load_int(&mut self, bit_len: usize) -> Result<BigInt, TonCellError> {
123 self.ensure_enough_bits(bit_len)?;
124 let bytes = self.load_bits(bit_len)?;
125 let res = BigInt::from_signed_bytes_be(&bytes);
126 let extra_bits = bit_len % 8;
127 if extra_bits != 0 {
128 return Ok(res >> (8 - extra_bits));
129 }
130 Ok(res)
131 }
132
133 pub fn load_byte(&mut self) -> Result<u8, TonCellError> {
134 self.load_u8(8)
135 }
136
137 pub fn load_slice(&mut self, slice: &mut [u8]) -> Result<(), TonCellError> {
138 self.ensure_enough_bits(slice.len() * 8)?;
139 self.data_bit_reader
140 .read_bytes(slice)
141 .map_cell_parser_error()
142 }
143
144 pub fn load_bytes(&mut self, num_bytes: usize) -> Result<Vec<u8>, TonCellError> {
145 let mut res = vec![0_u8; num_bytes];
146 self.load_slice(res.as_mut_slice())?;
147 Ok(res)
148 }
149
150 pub fn load_ref_cell_optional(&mut self) -> Result<Option<ArcCell>, TonCellError> {
151 if self.load_bit()? {
152 Ok(Some(self.next_reference()?))
153 } else {
154 Ok(None)
155 }
156 }
157
158 pub fn load_bits_to_slice(
159 &mut self,
160 num_bits: usize,
161 slice: &mut [u8],
162 ) -> Result<(), TonCellError> {
163 self.ensure_enough_bits(num_bits)?;
164 self.data_bit_reader.read_bits(num_bits, slice)?;
165 Ok(())
166 }
167
168 pub fn load_bits(&mut self, bit_len: usize) -> Result<Vec<u8>, TonCellError> {
169 self.ensure_enough_bits(bit_len)?;
170 let mut dst = vec![0; bit_len.div_ceil(8)];
171 let full_bytes = bit_len / 8;
172 let remaining_bits = bit_len % 8;
173
174 self.data_bit_reader.read_bytes(&mut dst[..full_bytes])?;
175
176 if remaining_bits != 0 {
177 let last_byte = self.data_bit_reader.read_var::<u8>(remaining_bits as u32)?;
178 dst[full_bytes] = last_byte << (8 - remaining_bits);
179 }
180 Ok(dst)
181 }
182
183 pub fn load_utf8(&mut self, num_bytes: usize) -> Result<String, TonCellError> {
184 let bytes = self.load_bytes(num_bytes)?;
185 String::from_utf8(bytes).map_cell_parser_error()
186 }
187
188 pub fn load_coins(&mut self) -> Result<BigUint, TonCellError> {
189 let num_bytes = self.load_u8(4)?;
190 if num_bytes == 0 {
191 Ok(BigUint::zero())
192 } else {
193 self.load_uint(num_bytes as usize * 8)
194 }
195 }
196
197 pub fn load_remaining(&mut self) -> Result<Cell, TonCellError> {
198 let mut builder = CellBuilder::new();
199 builder.store_remaining_bits(self)?;
200 builder.store_references(&self.cell.references[self.next_ref..])?;
201 let cell = builder.build();
202 self.next_ref = self.cell.references.len();
203 cell
204 }
205
206 pub fn load_msg_address(&mut self) -> Result<MsgAddress, TonCellError> {
207 MsgAddress::read(self)
208 }
209
210 pub fn load_address(&mut self) -> Result<TonAddress, TonCellError> {
211 let msg_addr = MsgAddress::read(self)?;
212 TonAddress::from_msg_address(msg_addr)
213 .map_err(|e| TonCellError::InvalidCellData(e.to_string()))
214 }
215
216 pub fn load_unary_length(&mut self) -> Result<usize, TonCellError> {
217 let mut res = 0;
218 while self.load_bit()? {
219 res += 1;
220 }
221 Ok(res)
222 }
223
224 pub fn load_dict_data<K: Eq + Hash, V>(
225 &mut self,
226 key_len: usize,
227 key_reader: KeyReader<K>,
228 val_reader: ValReader<V>,
229 ) -> Result<HashMap<K, V>, TonCellError> {
230 let mut dict_parser = DictParser::new(key_len, key_reader, val_reader);
231 dict_parser.parse(self)
232 }
233
234 pub fn load_dict<K: Eq + Hash, V>(
235 &mut self,
236 key_len: usize,
237 key_reader: KeyReader<K>,
238 val_reader: ValReader<V>,
239 ) -> Result<HashMap<K, V>, TonCellError> {
240 let has_data = self.load_bit()?;
241 if !has_data {
242 Ok(HashMap::new())
243 } else {
244 let reference_cell = self.next_reference()?;
245 let mut reference_parser = reference_cell.parser();
246 reference_parser.load_dict_data(key_len, key_reader, val_reader)
247 }
248 }
249 pub fn load_dict_snake_format(&mut self) -> Result<SnakeFormatDict, TonCellError> {
258 self.load_dict(256, key_reader_256bit, val_reader_snake_formatted_string)
259 }
260
261 pub fn load_dict_data_snake_format(&mut self) -> Result<SnakeFormatDict, TonCellError> {
262 self.load_dict_data(256, key_reader_256bit, val_reader_snake_formatted_string)
263 }
264
265 pub fn ensure_empty(&mut self) -> Result<(), TonCellError> {
266 let remaining_bits = self.remaining_bits();
267 let remaining_refs = self.cell.references.len() - self.next_ref;
268 if remaining_bits == 0 {
270 Ok(())
271 } else {
272 Err(TonCellError::NonEmptyReader {
273 remaining_bits,
274 remaining_refs,
275 })
276 }
277 }
278
279 pub fn load_remaining_data_aligned(&mut self) -> Result<Vec<u8>, TonCellError> {
280 let remaining = self.remaining_bytes();
281 self.load_bytes(remaining)
282 }
283
284 pub fn load_snake_format_aligned(&mut self, has_prefix: bool) -> Result<Vec<u8>, TonCellError> {
286 if has_prefix {
287 let prefix = self.load_byte()?;
288 if prefix != 0x00 {
289 let err_str = format!("Expected snake_format prefix: 0x00, got={prefix}");
290 return Err(TonCellError::CellParserError(err_str));
291 }
292 }
293 let mut buffer = self.load_remaining_data_aligned()?;
294 if self.next_ref >= self.cell.references.len() {
295 return Ok(buffer);
296 }
297 let mut cur_child = self.next_reference()?;
298 let mut cur_parser = cur_child.parser();
299 buffer.extend(cur_parser.load_remaining_data_aligned()?);
300 while let Ok(next_child) = cur_parser.next_reference() {
301 cur_child = next_child;
302 cur_parser = cur_child.parser();
303 buffer.extend(cur_parser.load_remaining_data_aligned()?);
304 }
305 Ok(buffer)
306 }
307
308 pub fn skip_bits(&mut self, num_bits: usize) -> Result<(), TonCellError> {
309 self.ensure_enough_bits(num_bits)?;
310 self.data_bit_reader
311 .skip(num_bits as u32)
312 .map_cell_parser_error()
313 }
314
315 pub fn load_number<N: TonCellNum>(&mut self, bit_len: usize) -> Result<N, TonCellError> {
316 self.ensure_enough_bits(bit_len)?;
317 if bit_len == 0 {
318 Ok(N::tcn_from_primitive(N::Primitive::zero()))
319 } else if N::IS_PRIMITIVE {
320 let primitive = self
321 .data_bit_reader
322 .read_var::<N::Primitive>(bit_len as u32)?;
323 Ok(N::tcn_from_primitive(primitive))
324 } else {
325 let bytes = self.load_bits(bit_len)?;
326 let res = N::tcn_from_bytes(&bytes);
327 if bit_len % 8 != 0 {
328 Ok(res.tcn_shr(8 - bit_len as u32 % 8))
329 } else {
330 Ok(res)
331 }
332 }
333 }
334
335 pub fn load_number_optional<N: TonCellNum>(
336 &mut self,
337 bit_len: usize,
338 ) -> Result<Option<N>, TonCellError> {
339 if self.load_bit()? {
340 self.load_number(bit_len).map(Some)
341 } else {
342 Ok(None)
343 }
344 }
345
346 fn ensure_enough_bits(&mut self, bit_len: usize) -> Result<(), TonCellError> {
347 if self.remaining_bits() < bit_len {
348 return Err(TonCellError::CellParserError(format!(
349 "Not enough bits to read (requested: {}, remaining: {})",
350 bit_len,
351 self.remaining_bits()
352 )));
353 }
354 Ok(())
355 }
356
357 pub fn next_reference(&mut self) -> Result<ArcCell, TonCellError> {
358 if self.next_ref < self.cell.references.len() {
359 let reference = self.cell.references[self.next_ref].clone();
360 self.next_ref += 1;
361
362 Ok(reference)
363 } else {
364 Err(TonCellError::CellParserError(
365 "Not enough references to read".to_owned(),
366 ))
367 }
368 }
369 pub fn load_either_cell_or_cell_ref(&mut self) -> Result<ArcCell, TonCellError> {
371 let is_ref = self.load_bit()?;
373 if is_ref {
374 Ok(self.next_reference()?)
375 } else {
376 let remaining_bits = self.remaining_bits();
377 let data = self.load_bits(remaining_bits)?;
378 let remaining_ref_count = self.cell.references.len() - self.next_ref;
379 let mut references = vec![];
380 for _ in 0..remaining_ref_count {
381 references.push(self.next_reference()?)
382 }
383 let result = Arc::new(Cell::new(data, remaining_bits, references, false)?);
384 Ok(result)
385 }
386 }
387 pub fn load_maybe_cell_ref(&mut self) -> Result<Option<ArcCell>, TonCellError> {
389 let is_some = self.load_bit()?;
390 if is_some {
391 Ok(Some(self.next_reference()?))
392 } else {
393 Ok(None)
394 }
395 }
396
397 pub fn load_tlb<T: TLB>(&mut self) -> Result<T, TonCellError> {
398 T::read(self)
399 }
400
401 pub fn load_tonhash(&mut self) -> Result<TonHash, TonCellError> {
402 let mut res = [0_u8; TON_HASH_LEN];
403 self.load_slice(&mut res)?;
404 Ok(TonHash::from(res))
405 }
406}
407
408#[cfg(test)]
409mod tests {
410 use std::sync::Arc;
411
412 use num_bigint::{BigInt, BigUint};
413 use tokio_test::{assert_err, assert_ok};
414
415 use crate::cell::parser::TonAddress;
416 use crate::cell::{BagOfCells, Cell, CellBuilder, EitherCellLayout};
417 use crate::TonHash;
418
419 #[test]
420 fn test_remaining_bits() -> anyhow::Result<()> {
421 let cell = Cell::new([0b10101010, 0b01010101].to_vec(), 13, vec![], false)?;
422 let mut parser = cell.parser();
423 assert_eq!(parser.remaining_bits(), 13);
424 parser.load_bit()?;
425 assert_eq!(parser.remaining_bits(), 12);
426 parser.load_u8(4)?;
427 assert_eq!(parser.remaining_bits(), 8);
428 parser.load_u8(8)?;
429 assert_eq!(parser.remaining_bits(), 0);
430 Ok(())
431 }
432
433 #[test]
434 fn test_load_bit() {
435 let cell = Cell::new([0b10101010].to_vec(), 4, vec![], false).unwrap();
436 let mut parser = cell.parser();
437 assert!(parser.load_bit().unwrap());
438 assert!(!parser.load_bit().unwrap());
439 assert!(parser.load_bit().unwrap());
440 assert!(!parser.load_bit().unwrap());
441 assert!(parser.load_bit().is_err());
442 }
443
444 #[test]
445 fn test_load_u8() {
446 let cell = Cell::new([0b10101010].to_vec(), 4, vec![], false).unwrap();
447 let mut parser = cell.parser();
448 assert_eq!(parser.load_u8(4).unwrap(), 0b1010);
449 assert!(parser.load_u8(1).is_err());
450 }
451
452 #[test]
453 fn test_load_i8() {
454 let cell = Cell::new([0b10101010].to_vec(), 4, vec![], false).unwrap();
455 let mut parser = cell.parser();
456 assert_eq!(parser.load_i8(4).unwrap(), 0b1010);
457 assert!(parser.load_i8(2).is_err());
458
459 let cell = Cell::new([0b10100110, 0b10101010].to_vec(), 13, vec![], false).unwrap();
460 let mut parser = cell.parser();
461 assert_eq!(parser.load_i8(4).unwrap(), 0b1010);
462 assert_eq!(parser.load_i8(8).unwrap(), 0b01101010);
463 assert!(parser.load_i8(2).is_err());
464 }
465
466 #[test]
467 fn test_load_u16() {
468 let cell = Cell::new([0b10101010, 0b01010101].to_vec(), 12, vec![], false).unwrap();
469 let mut parser = cell.parser();
470 assert_eq!(parser.load_u16(8).unwrap(), 0b10101010);
471 assert!(parser.load_u16(8).is_err());
472 }
473
474 #[test]
475 fn test_load_i16() {
476 let cell = Cell::new([0b10101010, 0b01010101].to_vec(), 12, vec![], false).unwrap();
477 let mut parser = cell.parser();
478 assert_eq!(parser.load_i16(9).unwrap(), 0b101010100);
479 assert!(parser.load_i16(4).is_err());
480 }
481
482 #[test]
483 fn test_load_u32() {
484 let cell = Cell::new([0b10101010, 0b01010101].to_vec(), 13, vec![], false).unwrap();
485 let mut parser = cell.parser();
486
487 assert_eq!(parser.load_u32(8).unwrap(), 0b10101010);
488 assert!(parser.load_u32(8).is_err());
489 }
490
491 #[test]
492 fn test_load_i32() {
493 let cell = Cell::new([0b10101010, 0b01010101].to_vec(), 14, vec![], false).unwrap();
494 let mut parser = cell.parser();
495 assert_eq!(parser.load_i32(10).unwrap(), 0b1010101001);
496 assert!(parser.load_i32(5).is_err());
497 }
498
499 #[test]
500 fn test_load_u64() {
501 let cell = Cell::new([0b10101010, 0b01010101].to_vec(), 13, vec![], false).unwrap();
502 let mut parser = cell.parser();
503 assert_eq!(parser.load_u64(8).unwrap(), 0b10101010);
504 assert!(parser.load_u64(8).is_err());
505 }
506
507 #[test]
508 fn test_load_i64() {
509 let cell = Cell::new([0b10101010, 0b01010101].to_vec(), 14, vec![], false).unwrap();
510 let mut parser = cell.parser();
511 assert_eq!(parser.load_i64(10).unwrap(), 0b1010101001);
512 assert!(parser.load_i64(5).is_err());
513 }
514
515 #[test]
516 fn test_load_int() {
517 let cell = Cell::new([0b10101010, 0b01010101].to_vec(), 14, vec![], false).unwrap();
518 let mut parser = cell.parser();
519 assert_eq!(parser.load_int(10).unwrap(), BigInt::from(-343));
520 assert!(parser.load_int(5).is_err());
521
522 let cell = Cell::new([0b0010_1000].to_vec(), 5, vec![], false).unwrap();
523 let mut parser = cell.parser();
524 assert_eq!(parser.load_int(5).unwrap(), BigInt::from(5));
525
526 let cell = Cell::new([0b0000_1010].to_vec(), 7, vec![], false).unwrap();
527 let mut parser = cell.parser();
528 assert_eq!(parser.load_int(7).unwrap(), BigInt::from(5));
529
530 let cell = Cell::new([0b1111_0110].to_vec(), 7, vec![], false).unwrap();
531 let mut parser = cell.parser();
532 assert_eq!(parser.load_int(7).unwrap(), BigInt::from(-5));
533
534 let cell = Cell::new([0b1101_1000].to_vec(), 5, vec![], false).unwrap();
535 let mut parser = cell.parser();
536 assert_eq!(parser.load_int(5).unwrap(), BigInt::from(-5));
537
538 let cell = Cell::new([0b11101111].to_vec(), 8, vec![], false).unwrap();
539 let mut parser = cell.parser();
540 assert_eq!(parser.load_int(8).unwrap(), BigInt::from(-17));
541 }
542
543 #[test]
544 fn test_store_load_int() -> anyhow::Result<()> {
545 let cell = CellBuilder::new()
546 .store_int(15, &BigInt::from(0))?
547 .store_int(15, &BigInt::from(15))?
548 .store_int(123, &BigInt::from(-16))?
549 .store_int(123, &BigInt::from(75))?
550 .store_int(15, &BigInt::from(-93))?
551 .store_int(32, &BigInt::from(83))?
552 .store_int(64, &BigInt::from(-183))?
553 .store_int(32, &BigInt::from(1401234567u32))?
554 .store_int(64, &BigInt::from(-1200617341))?
555 .build()?;
556
557 println!("{cell:?}");
558
559 let mut parser = cell.parser();
560
561 assert_eq!(parser.load_int(15)?, BigInt::ZERO);
562 assert_eq!(parser.load_int(15)?, BigInt::from(15));
563 assert_eq!(parser.load_int(123)?, BigInt::from(-16));
564 assert_eq!(parser.load_int(123)?, BigInt::from(75));
565 assert_eq!(parser.load_int(15)?, BigInt::from(-93));
566 assert_eq!(parser.load_int(32)?, BigInt::from(83));
567 assert_eq!(parser.load_int(64)?, BigInt::from(-183));
568 assert_eq!(parser.load_int(32)?, BigInt::from(1401234567u32));
569 assert_eq!(parser.load_int(64)?, BigInt::from(-1200617341));
570
571 assert!(parser.ensure_empty().is_ok());
572 Ok(())
573 }
574
575 #[test]
576 fn test_load_uint() -> anyhow::Result<()> {
577 let cell = Cell::new([0b10101010, 0b01010101].to_vec(), 14, vec![], false)?;
578 let mut parser = cell.parser();
579 assert_eq!(parser.load_uint(10)?, BigUint::from(0b1010101001u64));
580 assert!(parser.load_uint(5).is_err());
581 Ok(())
582 }
583
584 #[test]
585 fn test_load_byte() {
586 let cell = Cell::new([0b10101010, 0b01010101].to_vec(), 15, vec![], false).unwrap();
587 let mut parser = cell.parser();
588 parser.load_bit().unwrap();
589 assert_eq!(parser.load_byte().unwrap(), 0b01010100u8);
590 assert!(parser.load_byte().is_err());
591 }
592
593 #[test]
594 fn test_load_slice() {
595 let cell = Cell::new(
596 [0b10101010, 0b01010101, 0b10101010, 0b10101010, 0b10101010].to_vec(),
597 32,
598 vec![],
599 false,
600 )
601 .unwrap();
602 let mut parser = cell.parser();
603 parser.load_bit().unwrap();
604 let mut slice = [0; 2];
605 parser.load_slice(&mut slice).unwrap();
606 assert_eq!(slice, [0b01010100, 0b10101011]);
607 assert!(parser.load_slice(&mut slice).is_err());
608 }
609
610 #[test]
611 fn test_load_bytes() {
612 let cell = Cell::new(
613 [0b10101010, 0b01010101, 0b10101010, 0b10101010, 0b10101010].to_vec(),
614 32,
615 vec![],
616 false,
617 )
618 .unwrap();
619 let mut parser = cell.parser();
620 parser.load_bit().unwrap();
621 let slice = parser.load_bytes(2).unwrap();
622 assert_eq!(slice, [0b01010100, 0b10101011]);
623 assert!(parser.load_bytes(2).is_err());
624 }
625
626 #[test]
627 fn test_load_bits_to_slice() {
628 let cell = Cell::new(
629 [0b10101010, 0b01010101, 0b10101010, 0b10101010, 0b10101010].to_vec(),
630 22,
631 vec![],
632 false,
633 )
634 .unwrap();
635 let mut parser = cell.parser();
636 parser.load_bit().unwrap();
637 let mut slice = [0; 2];
638 parser.load_bits_to_slice(12, &mut slice).unwrap();
639 assert_eq!(slice, [0b01010100, 0b10100000]);
640 assert!(parser.load_bits_to_slice(10, &mut slice).is_err());
641 }
642
643 #[test]
644 fn test_load_bits() {
645 let cell = Cell::new(
646 [0b10101010, 0b01010101, 0b10101010, 0b10101010, 0b10101010].to_vec(),
647 25,
648 vec![],
649 false,
650 )
651 .unwrap();
652 let mut parser = cell.parser();
653 parser.load_bit().unwrap();
654 let slice = parser.load_bits(5).unwrap();
655 assert_eq!(slice, [0b01010000]);
656 let slice = parser.load_bits(15).unwrap();
657 assert_eq!(slice, [0b10010101, 0b01101010]);
658 assert!(parser.load_bits(5).is_err());
659 }
660
661 #[test]
662 fn test_load_utf8() {
663 let cell = Cell::new("a1j\0".as_bytes().to_vec(), 31, vec![], false).unwrap();
664 let mut parser = cell.parser();
665 let string = parser.load_utf8(2).unwrap();
666 assert_eq!(string, "a1");
667 let string = parser.load_utf8(1).unwrap();
668 assert_eq!(string, "j");
669 assert!(parser.load_utf8(1).is_err());
670 }
671
672 #[test]
673 fn test_load_coins() {
674 let cell = Cell::new(
675 [
676 0b00011111, 0b11110011, 0b11110011, 0b11110011, 0b11110011, 0b00011111, 0b11110011,
677 ]
678 .to_vec(),
679 48,
680 vec![],
681 false,
682 )
683 .unwrap();
684 let mut parser = cell.parser();
685
686 assert_eq!(parser.load_coins().unwrap(), BigUint::from(0b11111111u64));
687 assert_eq!(
688 parser.load_coins().unwrap(),
689 BigUint::from(0b111100111111001111110011u64)
690 );
691 assert!(parser.load_coins().is_err());
692 }
693
694 #[test]
695 fn test_load_address() {
696 let cell = Cell::new([0].to_vec(), 2, vec![], false).unwrap();
697 let mut parser = cell.parser();
698 assert_eq!(parser.load_address().unwrap(), TonAddress::NULL);
699 assert!(parser.load_address().is_err());
700
701 let cell = Cell::new(
703 [
704 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,
705 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,
706 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,
707 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,
708 ]
709 .to_vec(),
710 (3 + 8 + 32 * 8) * 3 - 1,
711 vec![],
712 false,
713 )
714 .unwrap();
715 let mut parser = cell.parser();
716 assert_eq!(parser.load_address().unwrap(), TonAddress::NULL);
717 assert_eq!(parser.load_address().unwrap(), TonAddress::NULL);
718 assert!(parser.load_address().is_err());
719 }
720
721 #[test]
722 fn test_ensure_empty() {
723 let cell = Cell::new([0b10101010].to_vec(), 7, vec![], false).unwrap();
724 let mut parser = cell.parser();
725 parser.load_u8(4).unwrap();
726 assert!(parser.ensure_empty().is_err());
727 parser.load_u8(3).unwrap();
728 assert!(parser.ensure_empty().is_ok());
729 }
730
731 #[test]
732 fn test_skip_bits_not_enough_bits() {
733 let cell = Cell::new([0b11111001, 0b00001010].to_vec(), 12, vec![], false).unwrap();
734 let mut parser = cell.parser();
735 assert!(parser.skip_bits(5).is_ok());
736 assert_eq!(parser.load_bits(5).unwrap(), [0b00100000]);
737 assert!(parser.skip_bits(3).is_err());
738 }
739
740 #[test]
741 fn test_parser_with_refs() {
742 let ref1 = Cell::new([0b11111001, 0b00001010].to_vec(), 12, vec![], false).unwrap();
743 let ref2 = Cell::new([0b11111001, 0b00001010].to_vec(), 12, vec![], false).unwrap();
744 let cell = Cell::new(
745 [0b11111001, 0b00001010].to_vec(),
746 12,
747 vec![ref1.into(), ref2.into()],
748 false,
749 )
750 .unwrap();
751 let mut parser = cell.parser();
752
753 assert!(parser.next_reference().is_ok());
754 assert!(parser.next_reference().is_ok());
755 assert!(parser.next_reference().is_err());
756 }
757
758 #[test]
759 fn test_either_with_references() -> anyhow::Result<()> {
760 let reference_cell = Cell::new([0xA5, 0x5A].to_vec(), 12, vec![], false)?;
761 let cell_either = Arc::new(Cell::new(
762 [0xFF, 0xB0].to_vec(),
763 12,
764 vec![reference_cell.into()],
765 false,
766 )?);
767 let cell = CellBuilder::new()
768 .store_bit(true)?
769 .store_either_cell_or_cell_ref(&cell_either, EitherCellLayout::Native)?
770 .build()?;
771
772 let mut parser = cell.parser();
773
774 let result_first_bit = parser.load_bit()?;
775 let result_cell_either = parser.load_either_cell_or_cell_ref()?;
776
777 assert!(result_first_bit);
778 assert_eq!(result_cell_either, cell_either);
779 Ok(())
780 }
781
782 #[test]
783 fn test_load_tonhash() {
784 let ton_hash =
785 TonHash::from_hex("9f31f4f413a3accb706c88962ac69d59103b013a0addcfaeed5dd73c18fa98a8")
786 .unwrap();
787 let cell = Cell::new(ton_hash.to_vec(), 256, vec![], false).unwrap();
788 let mut parser = cell.parser();
789 let loaded = parser.load_tonhash().unwrap();
790 assert_eq!(loaded, ton_hash);
791 }
792
793 #[test]
794 fn test_load_address_anycast() -> anyhow::Result<()> {
795 let addr_boc = hex::decode("b5ee9c7201010101002800004bbe031053100134ea6c68e2f2cee9619bdd2732493f3a1361eccd7c5267a9eb3c5dcebc533bb6")?;
796 let addr_cell = BagOfCells::parse(&addr_boc)?.single_root()?;
797 let mut parser = addr_cell.parser();
798 let parsed = assert_ok!(parser.load_address());
799 let expected: TonAddress = "EQADEFMSOLyzulhm90nMkk_OhNh7M18Umep6zxdzrxTO7Zz7".parse()?;
800 assert_eq!(parsed, expected);
801
802 let addr_boc = hex::decode("b5ee9c7201010101002800004bbe779dcc80039c768512c82704ef59297e7991b21b469367a4aac9d9ae9fe74a834b2448490e")?;
803 let addr_cell = BagOfCells::parse(&addr_boc)?.single_root()?;
804 let mut parser = addr_cell.parser();
805 let parsed = assert_ok!(parser.load_address());
806 let expected: TonAddress = "EQB3ncyAsgnBO9ZKX55kbIbRpNnpKrJ2a6f50qDSyRISQ19D".parse()?;
807 assert_eq!(parsed, expected);
808 Ok(())
809 }
810
811 #[test]
812 fn test_load_remaining_data_aligned() -> anyhow::Result<()> {
813 let cell = CellBuilder::new()
814 .store_bits(512, &[0b10101010; 64])?
815 .build()?;
816 let mut parser = cell.parser();
817 parser.load_u8(8)?;
818 let remaining_data = parser.load_remaining_data_aligned()?;
819 assert_eq!(remaining_data, &[0b10101010; 63]);
820 Ok(())
821 }
822
823 #[test]
824 fn test_snake_format_aligned() -> anyhow::Result<()> {
825 let child2 = CellBuilder::new()
826 .store_bits(512, &[0b10101010; 64])?
827 .build()?;
828 let child1 = CellBuilder::new()
829 .store_bits(512, &[0b01010101; 64])?
830 .store_reference(&child2.to_arc())?
831 .build()?;
832 let cell = CellBuilder::new()
833 .store_bits(512, &[0b00000000; 64])?
834 .store_reference(&child1.to_arc())?
835 .build()?;
836 let mut expected = vec![0b00000000; 64];
837 expected.extend(vec![0b01010101; 64]);
838 expected.extend(vec![0b10101010; 64]);
839
840 let snake_data = cell.parser().load_snake_format_aligned(false)?;
841 assert_eq!(snake_data, expected);
842 let snake_data = cell.parser().load_snake_format_aligned(true)?;
843 assert_eq!(snake_data, expected[1..]);
844 Ok(())
845 }
846
847 #[test]
848 fn test_seek() -> anyhow::Result<()> {
849 let cell = Cell::new([0b11000011].to_vec(), 8, vec![], false)?;
850 let mut parser = cell.parser();
851 assert_ok!(parser.seek(4));
852 assert_eq!(parser.load_u8(4)?, 0b0011);
853 assert_ok!(parser.seek(-8));
854 assert_eq!(parser.load_u8(4)?, 0b1100);
855 assert_ok!(parser.seek(-4));
856 assert_eq!(parser.load_u8(4)?, 0b1100);
857 assert_err!(parser.seek(-5));
858 assert_eq!(parser.load_u8(4)?, 0b0011);
859 Ok(())
860 }
861}