Merge pull request #30 from tonlabs/master-RC

Automatic update project. #none

Author: tonjen

commit_hash.txt

@@ -1 +1 @@
-8a4777b6bc1065019a9b5c52ac2a740a48fd926c
+44cb7e493735f425c1191e5df6239a4a6fd53d26

deps_map.json

@@ -1 +1 @@
-{"ton-block":"447a265d0013336b3c506cad45558922aa67f9f6","ton-types":"164867fa842b1efd0eeb378e727a17677ae8a322"}
+{"ton-block":"20dd6ecb7dec5163d7316fdacd9bb2876008a8c7","ton-types":"164867fa842b1efd0eeb378e727a17677ae8a322"}

ton_api/Cargo.toml

@@ -3,7 +3,7 @@ authors = [ 'Aaron Gallagher <[email protected]>', 'Connie Hilarides <[email protected]
 description = 'Minimal wrappers for TON serialization using TL-schema'
 edition = '2018'
 name = 'ton_api'
-version = '0.2.116'
+version = '0.2.117'
 
 [dependencies]
 byteorder = '1.4'
@@ -15,7 +15,7 @@ ordered-float = '2.8'
 secstr = '0.4'
 serde = '1.0'
 serde_derive = '1.0'
-ton_block = { git = 'https://github.com/tonlabs/ton-labs-block', tag = '1.7.35' }
+ton_block = { git = 'https://github.com/tonlabs/ton-labs-block', tag = '1.7.36' }
 ton_types = { git = 'https://github.com/tonlabs/ton-labs-types', tag = '1.10.12' }
 
 [build-dependencies]

ton_api/src/lib.rs

@@ -14,21 +14,13 @@
 #![allow(clippy::unreadable_literal)]
 #![deny(private_in_public)]
 
-use std::{fmt, io};
-use std::any::Any;
-use std::cmp::Ordering;
-use std::convert::TryInto;
-use std::fmt::{Display, Formatter};
-use std::hash::Hash;
-
 use failure::Fail;
+use std::{any::Any, fmt, hash::Hash, io::{self, Read, Write}};
 
-use ton_block::ShardIdent;
-pub use ton_types::Result;
+use ton_block::{BlockIdExt, ShardIdent};
+use ton_types::Result;
 use ton_types::UInt256;
 
-use crate::ton::ton_node::blockidext::BlockIdExt;
-
 macro_rules! _invalid_id {
     ($id:ident) => {
         Err(crate::InvalidConstructor { expected: Self::possible_constructors(), received: $id }.into())
@@ -60,12 +52,12 @@ pub struct InvalidConstructor {
 
 /// Struct for deserializing TL-scheme objects from any `io::Read`
 pub struct Deserializer<'r> {
-    reader: &'r mut dyn io::Read,
+    reader: &'r mut dyn Read,
 }
 
 impl<'r> Deserializer<'r> {
     /// Create `Deserializer` with given `io::Read` trait object
-    pub fn new(reader: &'r mut dyn io::Read) -> Self {
+    pub fn new(reader: &'r mut dyn Read) -> Self {
         Deserializer { reader }
     }
 
@@ -95,7 +87,7 @@ impl<'r> Deserializer<'r> {
     }
 }
 
-impl<'r> io::Read for Deserializer<'r> {
+impl<'r> Read for Deserializer<'r> {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         self.reader.read(buf)
     }
@@ -165,12 +157,12 @@ impl DynamicDeserializer {
 
 /// Struct for serializing TL-scheme objects into any `io::Write`
 pub struct Serializer<'w> {
-    writer: &'w mut dyn io::Write,
+    writer: &'w mut dyn Write,
 }
 
 impl<'w> Serializer<'w> {
     /// Create `Serializer` with given `io::Write` trait object
-    pub fn new(writer: &'w mut dyn io::Write) -> Self {
+    pub fn new(writer: &'w mut dyn Write) -> Self {
         Serializer { writer }
     }
 
@@ -205,7 +197,7 @@ impl<'w> Serializer<'w> {
     }
 }
 
-impl<'w> io::Write for Serializer<'w> {
+impl<'w> Write for Serializer<'w> {
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
         self.writer.write(buf)
     }
@@ -266,85 +258,70 @@ pub trait Function: AnyBoxedSerialize {
     type Reply: BoxedDeserialize + AnyBoxedSerialize;
 }
 
-impl PartialOrd for BlockIdExt {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for BlockIdExt {
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.workchain.cmp(&other.workchain)
-            .then(self.shard.cmp(&other.shard))
-            .then(self.seqno.cmp(&other.seqno))
-            .then(self.root_hash.cmp(&other.root_hash))
-            .then(self.file_hash.cmp(&other.file_hash))
+impl BareDeserialize for BlockIdExt {
+    fn deserialize_bare(de: &mut Deserializer) -> Result<Self> {
+        let shard = ShardIdent::with_tagged_prefix(
+            de.read_bare::<crate::ton::int>()?,
+            de.read_bare::<crate::ton::long>()? as u64
+        )?;
+        let ret = Self::with_params(
+            shard, 
+            de.read_bare::<crate::ton::int>()? as u32, 
+            de.read_bare::<UInt256>()?,
+            de.read_bare::<UInt256>()? 
+        );
+        Ok(ret)
     }
 }
 
-impl Display for BlockIdExt {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "({}:{:016x}, {}, rh {}, fh {})", self.workchain, self.shard, self.seqno, hex::encode(self.root_hash.0), hex::encode(self.file_hash.0))
+impl BareSerialize for BlockIdExt {
+    fn constructor(&self) -> ConstructorNumber {
+        crate::ton::ton_node::blockidext::TL_TAG
     }
-}
-
-impl From<&ton_block::BlockIdExt> for BlockIdExt {
-    fn from(block_id_ext: &ton_block::BlockIdExt) -> Self {
-        Self {
-            workchain: block_id_ext.shard().workchain_id(),
-            shard: block_id_ext.shard().shard_prefix_with_tag() as i64,
-            seqno: block_id_ext.seq_no() as i32,
-            root_hash: block_id_ext.root_hash().into(),
-            file_hash: block_id_ext.file_hash().into(),
-        }
-    }
-}
-
-impl From<ton_block::BlockIdExt> for BlockIdExt {
-    fn from(block_id_ext: ton_block::BlockIdExt) -> Self {
-        Self::from(&block_id_ext)
+    fn serialize_bare(&self, se: &mut Serializer) -> Result<()> {
+        let shard = self.shard();
+        se.write_bare::<crate::ton::int>(&shard.workchain_id())?;
+        se.write_bare::<crate::ton::long>(&(shard.shard_prefix_with_tag() as i64))?;
+        se.write_bare::<crate::ton::int>(&(self.seq_no() as i32))?;
+        se.write_bare::<UInt256>(self.root_hash())?;
+        se.write_bare::<UInt256>(self.file_hash())?;
+        Ok(())
     }
 }
 
-impl TryInto<ton_block::BlockIdExt> for &BlockIdExt {
-    type Error = failure::Error;
-
-    fn try_into(self) -> Result<ton_block::BlockIdExt> {
-        Ok(ton_block::BlockIdExt::with_params(
-            ShardIdent::with_tagged_prefix(self.workchain, self.shard as u64)?,
-            self.seqno as u32,
-            self.root_hash.into(),
-            self.file_hash.into(),
-        ))
+impl BoxedDeserialize for BlockIdExt {
+    fn possible_constructors() -> Vec<crate::ConstructorNumber> {
+        vec![crate::ton::ton_node::blockidext::TL_TAG]
     }
-}
-
-impl Display for crate::ton::int256 {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(f, "{}", hex::encode(self.0))
+    fn deserialize_boxed(id: ConstructorNumber, de: &mut Deserializer) -> Result<Self> {
+        if id == crate::ton::ton_node::blockidext::TL_TAG {
+            de.read_bare()
+        } else {
+            _invalid_id!(id)
+        }
     }
 }
 
-impl From<UInt256> for crate::ton::int256 {
-    fn from(value: UInt256) -> Self {
-        Self(value.into())
+impl BoxedSerialize for BlockIdExt {
+    fn serialize_boxed(&self) -> (ConstructorNumber, &dyn BareSerialize) {
+        (crate::ton::ton_node::blockidext::TL_TAG, self)
     }
 }
 
-impl From<&UInt256> for crate::ton::int256 {
-    fn from(value: &UInt256) -> Self {
-        Self(value.clone().into())
+impl BareDeserialize for UInt256 {
+    fn deserialize_bare(de: &mut Deserializer) -> Result<Self> {
+        let mut data = [0u8; 32];
+        de.read_exact(&mut data)?;
+        Ok(Self::with_array(data))
     }
 }
 
-impl Into<UInt256> for crate::ton::int256 {
-    fn into(self) -> UInt256 {
-        UInt256::from(self.0)
+impl BareSerialize for UInt256 {
+    fn constructor(&self) -> ConstructorNumber { 
+        unreachable!() 
     }
-}
-
-impl Into<UInt256> for &crate::ton::int256 {
-    fn into(self) -> UInt256 {
-        UInt256::from(self.0)
+    fn serialize_bare(&self, se: &mut Serializer) -> Result<()> {
+        se.write_all(self.as_slice())?;
+        Ok(())
     }
 }

ton_api/src/ton_prelude.rs

@@ -104,12 +104,13 @@ impl From<Vec<u8>> for bytes {
 pub struct int128(pub [u8; 16]);
 
 /// Represents 256-bit unsigned integer.
-#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Hash)]
-pub struct int256(pub [u8; 32]);
+//#[derive(Clone, Copy, Default, PartialEq, Eq, PartialOrd, Ord, Serialize, Deserialize, Hash)]
+//pub struct int256(pub [u8; 32]);
+pub(crate) type int256 = ton_types::UInt256;
 
 impl_byteslike!(@common bytes);
 impl_byteslike!(@arraylike int128);
-impl_byteslike!(@arraylike int256);
+//impl_byteslike!(@arraylike int256);
 
 /// Represents base TL-object type.
 pub struct TLObject(Box<dyn AnyBoxedSerialize>);

ton_tl_codegen/src/lib.rs

@@ -1422,7 +1422,7 @@ impl Constructor<TypeIR, FieldIR> {
         let derives = gen_derives(config, quote! { Debug, Default, Clone, PartialEq }, name.to_string());
         let impl_generics = self.impl_generics();
         let fields = self.fields_tokens(quote! {pub}, quote! {;});
-
+ 
         quote! {
             #[derive(#derives)]
             #[doc = #doc]
@@ -1534,6 +1534,13 @@ impl Constructor<TypeIR, FieldIR> {
     }
 
     fn as_variant_type_struct(&self, config: &Option<Config>, matched: &str) -> Tokens {
+        if self.variant_name() == "BlockIdExt" {
+            let tl_id = self.tl_id().unwrap();
+            return quote! {
+                pub(crate) type BlockIdExt = ton_block::BlockIdExt;
+                pub(crate) const TL_TAG: crate::ConstructorNumber = #tl_id; 
+            }
+        }
         if self.fields.is_empty() {
             quote!()
         } else {
@@ -2065,6 +2072,11 @@ impl Constructors<TypeIR, FieldIR> {
         }
         let name = self.first_constructor().output.name();
         let doc = self.as_enum_doc();
+        if name == "BlockIdExt" {
+            return quote! {
+                pub(crate) type BlockIdExt = ton_block::BlockIdExt;
+            }
+        }
         let derives = gen_derives(config, quote! { Debug, Clone, PartialEq }, name.to_string());
         let variants = self.0.iter()
             .map(|cm| cm.0.as_variant());