[Ton] Integrate with Ton and Telegram

Cargo.toml

@@ -234,6 +234,7 @@ tracing = "0.1.37"
 tracing-appender = "0.2.2"
 tracing-subscriber = { version = "0.3.15" }
 tungstenite = "0.24.0"
+tonlib-core = "0.20"
 
 codespan-reporting = "0.11.1"
 codespan = "0.11.1"

crates/rooch-types/Cargo.toml

@@ -43,6 +43,8 @@ argon2 = { workspace = true }
 tracing = { workspace = true }
 xxhash-rust = { workspace = true, features = ["xxh3"] }
 lz4 = { workspace = true }
+tonlib-core = { workspace = true }
+base64 = { workspace = true }
 
 move-core-types = { workspace = true }
 move-vm-types = { workspace = true }

crates/rooch-types/src/address.rs

@@ -93,6 +93,10 @@ impl MultiChainAddress {
                 let pk = NostrPublicKey::from_str(str)?;
                 Ok(pk.into())
             }
+            RoochMultiChainID::Ton => {
+                let ton_address = TonAddress::from_str(str)?;
+                Ok(ton_address.into())
+            }
         }
     }
 
@@ -122,6 +126,10 @@ impl MultiChainAddress {
                 let pk = NostrPublicKey::try_from(self.clone()).unwrap();
                 pk.to_string()
             }
+            RoochMultiChainID::Ton => {
+                let ton_address = TonAddress::try_from(self.clone()).unwrap();
+                ton_address.to_string()
+            }
         }
     }
 
@@ -987,6 +995,9 @@ impl fmt::Display for NostrPublicKey {
     }
 }
 
+mod ton_address;
+pub use ton_address::TonAddress;
+
 // Parsed Address, either a name or a numerical address, or Bitcoin Address
 #[derive(Eq, PartialEq, Debug, Clone)]
 pub enum ParsedAddress {

crates/rooch-types/src/address/ton_address.rs

@@ -0,0 +1,128 @@
+// Copyright (c) RoochNetwork
+// SPDX-License-Identifier: Apache-2.0
+
+use framework_types::addresses::ROOCH_FRAMEWORK_ADDRESS;
+use move_core_types::account_address::AccountAddress;
+use move_core_types::identifier::IdentStr;
+use move_core_types::language_storage::TypeTag;
+use move_core_types::value::{MoveStructLayout, MoveTypeLayout};
+use moveos_types::state::{MoveStructState, MoveStructType};
+use serde::{Deserialize, Serialize};
+use std::fmt;
+use std::str::FromStr;
+use crate::multichain_id::RoochMultiChainID;
+use super::MultiChainAddress;
+
+pub const MODULE_NAME: &IdentStr = IdentStr::new("ton_address").unwrap();
+
+/// The Ton address type
+#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
+pub struct TonAddress {
+    workchain: i32,
+    hash_part: AccountAddress,
+}
+
+impl TonAddress {
+    pub fn workchain(&self) -> i32 {
+        self.workchain
+    }
+
+    pub fn hash_part(&self) -> [u8; 32] {
+        self.hash_part.into()
+    }
+
+    pub fn from_bytes(bytes: &[u8]) -> Result<Self, anyhow::Error> {
+        bcs::from_bytes(bytes).map_err(|e| anyhow::anyhow!("TonAddress deserialize error: {}", e))
+    }
+
+    pub fn to_bytes(&self) -> Result<Vec<u8>, anyhow::Error> {
+        bcs::to_bytes(self).map_err(|e| anyhow::anyhow!("TonAddress serialize error: {}", e))
+    }
+}
+
+impl MoveStructType for TonAddress {
+    const ADDRESS: AccountAddress = ROOCH_FRAMEWORK_ADDRESS;
+    const MODULE_NAME: &'static IdentStr = MODULE_NAME;
+    const STRUCT_NAME: &'static IdentStr = IdentStr::new("TonAddress").unwrap();
+}
+
+impl MoveStructState for TonAddress {
+    fn struct_layout() -> MoveStructLayout {
+        MoveStructLayout::new(vec![
+            MoveTypeLayout::U32,
+            MoveTypeLayout::Address,
+        ])
+    }
+}
+
+impl fmt::Display for TonAddress {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let ton_addr: tonlib_core::TonAddress = self.clone().into();
+        write!(f, "{}", ton_addr)
+    }
+}
+
+impl FromStr for TonAddress {
+    type Err = anyhow::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let ton_addr = tonlib_core::TonAddress::from_str(s)?;
+        Ok(ton_addr.into())
+    }
+}
+
+impl From<tonlib_core::TonAddress> for TonAddress {
+    fn from(address: tonlib_core::TonAddress) -> Self {
+        Self {
+            workchain: address.workchain,
+            hash_part: address.hash_part.into(),
+        }
+    }
+}
+
+impl From<TonAddress> for tonlib_core::TonAddress {
+    fn from(address: TonAddress) -> Self {
+        tonlib_core::TonAddress {
+            workchain: address.workchain,
+            hash_part: address.hash_part.into(),
+        }
+    }
+}
+
+impl TryFrom<MultiChainAddress> for TonAddress {
+    type Error = anyhow::Error;
+
+    fn try_from(value: MultiChainAddress) -> Result<Self, Self::Error> {
+        if value.multichain_id != RoochMultiChainID::Ton {
+            return Err(anyhow::anyhow!(
+                "multichain_id type {} is invalid",
+                value.multichain_id
+            ));
+        }
+        TonAddress::from_bytes(&value.raw_address)
+    }
+}
+
+impl From<TonAddress> for MultiChainAddress {
+    fn from(address: TonAddress) -> Self {
+        MultiChainAddress {
+            multichain_id: RoochMultiChainID::Ton,
+            raw_address: address
+                .to_bytes()
+                .expect("TonAddress to_bytes should not fail"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_ton_address() {
+        let addr = TonAddress::from_str("-1:e4d954ef9f4e1250a26b5bbad76a1cdd17cfd08babad6f4c23e372270aef6f76").unwrap();
+        //println!("addr: {}", addr);
+        let bytes = addr.to_bytes().unwrap();
+        println!("bytes: {:?}", hex::encode(bytes));
+    }
+}

crates/rooch-types/src/framework/mod.rs

@@ -27,6 +27,7 @@ pub mod oracle;
 pub mod session_key;
 pub mod session_validator;
 pub mod timestamp;
+pub mod ton_proof;
 pub mod transaction_validator;
 pub mod transfer;