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