Upstream 0.17.5

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "tonlib"
-version = "0.17.4"
+version = "0.17.5"
 edition = "2021"
 description = "Rust SDK for The Open Network"
 license = "MIT"

src/cell/dict_loader.rs

@@ -178,7 +178,7 @@ mod test {
     #[test]
     fn dict_loader_test() {
         let dict_boc_str = "te6cckEBBgEAWgABGccNPKUADZm5MepOjMABAgHNAgMCASAEBQAnQAAAAAAAAAAAAAABMlF4tR2RgCAAJgAAAAAAAAAAAAABaFhaZZhr6AAAJgAAAAAAAAAAAAAAR8sYU4eC4AA1PIC5";
-        let dict_boc = BagOfCells::parse_base64(&dict_boc_str).unwrap();
+        let dict_boc = BagOfCells::parse_base64(dict_boc_str).unwrap();
         let cell = dict_boc.single_root().unwrap();
         let loader = GenericDictLoader::new(key_extractor_u8, value_extractor_uint, 8);
         let result = cell

src/cell/parser.rs

@@ -248,7 +248,12 @@ impl<'a> CellParser<'a> {
         } else {
             let remaining_bits = self.remaining_bits();
             let data = self.load_bits(remaining_bits)?;
-            let result = Arc::new(Cell::new(data, remaining_bits, vec![], false)?);
+            let remaining_ref_count = self.references.len() - self.next_ref;
+            let mut references = vec![];
+            for _ in 0..remaining_ref_count {
+                references.push(self.next_reference()?)
+            }
+            let result = Arc::new(Cell::new(data, remaining_bits, references, false)?);
             Ok(result)
         }
     }
@@ -266,10 +271,12 @@ impl<'a> CellParser<'a> {
 #[cfg(test)]
 mod tests {
 
+    use std::sync::Arc;
+
     use num_bigint::{BigInt, BigUint};
 
     use crate::address::TonAddress;
-    use crate::cell::Cell;
+    use crate::cell::{Cell, CellBuilder};
 
     #[test]
     fn test_load_bit() {
@@ -545,4 +552,33 @@ mod tests {
         assert!(parser.next_reference().is_ok());
         assert!(parser.next_reference().is_err());
     }
+
+    #[test]
+    fn test_either_with_references() {
+        let reference_cell = Cell::new([0xA5, 0x5A].to_vec(), 12, vec![], false).unwrap();
+        let cell_either = Arc::new(
+            Cell::new(
+                [0xFF, 0xB0].to_vec(),
+                12,
+                vec![reference_cell.into()],
+                false,
+            )
+            .unwrap(),
+        );
+        let cell = CellBuilder::new()
+            .store_bit(true)
+            .unwrap()
+            .store_either_cell_or_cell_ref(&cell_either)
+            .unwrap()
+            .build()
+            .unwrap();
+
+        let mut parser = cell.parser();
+
+        let result_first_bit = parser.load_bit().unwrap();
+        let result_cell_either = parser.load_either_cell_or_cell_ref().unwrap();
+
+        assert!(result_first_bit);
+        assert_eq!(result_cell_either, cell_either);
+    }
 }