release/node/v0.5.2

CHANGELOG.md

@@ -6,6 +6,30 @@ For Helm chart changes, see [helm/ton-rust-node/CHANGELOG.md](helm/ton-rust-node
 The format is based on [Keep a Changelog](https://keepachangelog.com/).
 Versions follow the node release tags (e.g. `v0.1.2-mainnet`).
 
+## [v0.5.2] - 2026-04-21
+
+Image: `ghcr.io/rsquad/ton-rust-node/node:v0.5.2`
+
+### Changed
+
+- Optimized fast-sync overlay operation over QUIC
+
+### Fixed
+
+- TVM stack slice TL-serialization fix for LiteServer
+
+## [v0.5.1] - 2026-04-17
+
+Image: `ghcr.io/rsquad/ton-rust-node/node:v0.5.1`
+
+### Added
+
+- Switch to ubuntu base image and add console binary
+
+### Fixed
+
+- Fix LiteServer response handling for listBlockTransactions so clients accept it correctly
+
 ## [v0.5.0] - 2026-04-11
 
 Image: `ghcr.io/rsquad/ton-rust-node/node:v0.5.0`

src/adnl/src/overlay/mod.rs

@@ -26,7 +26,7 @@ use num_traits::pow::Pow;
 use std::{
     borrow::Borrow,
     cmp::min,
-    collections::HashMap,
+    collections::{HashMap, HashSet},
     convert::TryInto,
     sync::{
         atomic::{AtomicU32, AtomicU64, Ordering},
@@ -359,13 +359,16 @@ enum OverlayType {
     },
     // Overlay with externally certified members
     CertifiedMembers {
-        key: Option<Arc<dyn KeyOption>>,
-        // KeyId -> (Slot -> SlaveInfo)
-        root_members: HashMap<Arc<KeyId>, lockfree::map::Map<u32, SlaveInfo>>,
-        max_slaves: usize,
         // Prefix to use in broadcasts instead of Overlay::message_prefix
         bcast_prefix: Vec<u8>,
         certificate: Option<MemberCertificate>,
+        key: Option<Arc<dyn KeyOption>>,
+        max_slaves: usize,
+        // Validator ADNL IDs, bypassing the certificate check
+        root_adnl_ids: HashSet<Arc<KeyId>>,
+        // Validator Signing KeyId -> (Slot -> SlaveInfo)
+        root_public_keys: HashMap<Arc<KeyId>, lockfree::map::Map<u32, SlaveInfo>>,
+        use_quic: bool,
     },
 }
 
@@ -378,7 +381,11 @@ impl OverlayType {
     }
 
     fn quic_requested(&self) -> bool {
-        matches!(self, OverlayType::Private { use_quic: true, .. })
+        matches!(
+            self,
+            OverlayType::Private { use_quic: true, .. }
+                | OverlayType::CertifiedMembers { use_quic: true, .. }
+        )
     }
 
     fn calc_message_prefix(&self, overlay_id: &OverlayShortId) -> Result<Vec<u8>> {
@@ -583,10 +590,6 @@ impl Overlay {
         }
     }
 
-    pub(crate) fn calc_broadcast_twostep_neighbours(&self) -> u32 {
-        self.neighbours.count() as u32
-    }
-
     pub(crate) fn select_broadcast_neighbours(
         &self,
         count: u32,
@@ -599,14 +602,33 @@ impl Overlay {
         &self,
         skip: Option<&Arc<KeyId>>,
     ) -> Vec<Arc<KeyId>> {
+        let root_adnl_ids = match &self.overlay_type {
+            OverlayType::CertifiedMembers { root_adnl_ids, .. } => Some(root_adnl_ids),
+            OverlayType::Private { .. } => None,
+            _ => {
+                let mut neighbours = Vec::new();
+                let (mut iter, mut neighbour) = self.neighbours.first();
+                while let Some(node) = neighbour {
+                    let skipped = skip.map_or(false, |skip| &node == skip);
+                    if !skipped {
+                        neighbours.push(node);
+                    }
+                    neighbour = self.neighbours.next(&mut iter);
+                }
+                return neighbours;
+            }
+        };
         let mut neighbours = Vec::new();
-        let (mut iter, mut neighbour) = self.neighbours.first();
+        let mut iter = None;
+        let mut neighbour = self.known_peers.next(&mut iter);
         while let Some(node) = neighbour {
-            let skipped = if let Some(skip) = &skip { &node == *skip } else { false };
-            if !skipped {
+            let skipped = skip.map_or(false, |skip| &node == skip);
+            // Skip CertifiedMembers: only send twostep to root members (validators).
+            let root = root_adnl_ids.map_or(true, |roots| roots.contains(&node));
+            if !skipped && root {
                 neighbours.push(node);
             }
-            neighbour = self.neighbours.next(&mut iter);
+            neighbour = self.known_peers.next(&mut iter);
         }
         neighbours
     }
@@ -618,6 +640,24 @@ impl Overlay {
         Ok(buf)
     }
 
+    fn calc_broadcast_twostep_neighbours(&self) -> u32 {
+        let root_adnl_ids = match &self.overlay_type {
+            OverlayType::CertifiedMembers { root_adnl_ids, .. } => Some(root_adnl_ids),
+            OverlayType::Private { .. } => None,
+            _ => return self.neighbours.count(),
+        };
+        let mut count = 0u32;
+        let mut iter = None;
+        let mut neighbour = self.known_peers.next(&mut iter);
+        while let Some(node) = neighbour {
+            if root_adnl_ids.map_or(true, |root_adnl_ids| root_adnl_ids.contains(&node)) {
+                count += 1;
+            }
+            neighbour = self.known_peers.next(&mut iter);
+        }
+        count
+    }
+
     fn check_peer(&self, peer: &Arc<KeyId>, certificate: Option<&MemberCertificate>) -> Result<()> {
         match &self.overlay_type {
             OverlayType::Public => Ok(()),
@@ -627,8 +667,8 @@ impl Overlay {
                 }
                 Ok(())
             }
-            OverlayType::CertifiedMembers { root_members, .. } => {
-                if root_members.contains_key(peer) {
+            OverlayType::CertifiedMembers { root_adnl_ids, .. } => {
+                if root_adnl_ids.contains(peer) {
                     return Ok(());
                 }
                 // Bcasts are sent without a certificate, hoping the target already knows
@@ -1035,14 +1075,13 @@ impl Overlay {
 
     fn validate_certificate(&self, peer: &Arc<KeyId>, cert: &MemberCertificate) -> Result<()> {
         let utime = UnixTime::now() as u32;
-
-        let (max_slaves, root_members) =
-            if let OverlayType::CertifiedMembers { max_slaves, root_members, .. } =
+        let (max_slaves, root_public_keys) =
+            if let OverlayType::CertifiedMembers { max_slaves, root_public_keys, .. } =
                 &self.overlay_type
             {
-                (*max_slaves, root_members)
+                (*max_slaves, root_public_keys)
             } else {
-                fail!("Overlay type is not certificated members")
+                fail!("Overlay type is not certified members")
             };
 
         // 1) Expire check
@@ -1058,7 +1097,7 @@ impl Overlay {
 
         // 3) Issuer
         let issuer: Arc<dyn KeyOption> = (&cert.issued_by).try_into()?;
-        let Some(slaves_info) = root_members.get(issuer.id()) else {
+        let Some(slaves_info) = root_public_keys.get(issuer.id()) else {
             fail!("Certificate is issued by unknown member: {}", cert.issued_by);
         };
 
@@ -1557,22 +1596,27 @@ impl OverlayNode {
         &self,
         params: OverlayParams,
         overlay_key: Option<&Arc<dyn KeyOption>>,
-        root_members: &[Arc<KeyId>],
+        root_adnl_ids: &[Arc<KeyId>],
+        root_public_keys: &[Arc<KeyId>], // Can be empty if overlay created by non-validator
         certificate: Option<MemberCertificate>,
         max_slaves: usize,
+        use_quic: bool,
     ) -> Result<bool> {
-        let mut root_members_full = HashMap::with_capacity(root_members.len());
-        for member in root_members {
-            root_members_full.insert(member.clone(), lockfree::map::Map::new());
+        let root_adnl_set: HashSet<Arc<KeyId>> = root_adnl_ids.iter().cloned().collect();
+        let mut root_public_keys_map = HashMap::with_capacity(root_public_keys.len());
+        for pk in root_public_keys {
+            root_public_keys_map.insert(pk.clone(), lockfree::map::Map::new());
         }
         let overlay_type = OverlayType::CertifiedMembers {
-            root_members: root_members_full,
-            max_slaves,
             bcast_prefix: OverlayUtils::calc_message_prefix(params.overlay_id)?,
             certificate,
             key: overlay_key.cloned(),
+            max_slaves,
+            root_adnl_ids: root_adnl_set,
+            root_public_keys: root_public_keys_map,
+            use_quic,
         };
-        self.add_typed_private_overlay(overlay_type, params, root_members)
+        self.add_typed_private_overlay(overlay_type, params, root_adnl_ids)
     }
 
     /// Broadcast message
@@ -1977,11 +2021,7 @@ impl OverlayNode {
             penalty: 1,
             to_block: Self::MAX_FAIL_COUNT,
         };
-        let quic = if let OverlayType::Private { use_quic: true, .. } = &overlay_type {
-            self.quic.get().cloned()
-        } else {
-            None
-        };
+        let quic = if overlay_type.quic_requested() { self.quic.get().cloned() } else { None };
         let overlay = Overlay {
             adnl: self.adnl.clone(),
             rldp: self.rldp.get().cloned(),

src/adnl/tests/test_overlay.rs

@@ -1373,7 +1373,17 @@ async fn test_overlay_semiprivate() -> Result<()> {
 
         adnl.start_over_udp(vec![pi.overlay.clone().unwrap()]).await.unwrap();
         let params = OverlayParams::with_id_only(overlay_id);
-        assert!(overlay.add_semiprivate_overlay(params, Some(&pi.key), roots, None, 1)?);
+        // In this test the overlay key serves both as ADNL id and as cert signer,
+        // so root_adnl_ids == root_public_keys.
+        assert!(overlay.add_semiprivate_overlay(
+            params,
+            Some(&pi.key),
+            roots,
+            roots,
+            None,
+            1,
+            false
+        )?);
         overlay
             .add_consumer(overlay_id, Arc::new(TestConsumer { received: pi.received.clone() }))?;
 
@@ -1428,7 +1438,17 @@ async fn test_overlay_semiprivate() -> Result<()> {
 
         pi.certificate = Some(cert.clone());
         let params = OverlayParams::with_id_only(overlay_id);
-        assert!(overlay.add_semiprivate_overlay(params, Some(&pi.key), roots, Some(cert), 1)?);
+        // In this test the overlay key serves both as ADNL id and as cert signer,
+        // so root_adnl_ids == root_public_keys.
+        assert!(overlay.add_semiprivate_overlay(
+            params,
+            Some(&pi.key),
+            roots,
+            roots,
+            Some(cert),
+            1,
+            false
+        )?);
         overlay
             .add_consumer(overlay_id, Arc::new(TestConsumer { received: pi.received.clone() }))?;
 

src/node/src/network/fast_sync_overlay_client.rs

@@ -27,7 +27,7 @@ use ton_api::{
     },
     BoxedSerialize,
 };
-use ton_block::{fail, KeyId, KeyOption, Result, ShardIdent, ValidatorSet};
+use ton_block::{fail, KeyId, KeyOption, Result, ShardIdent, ValidatorDescr};
 
 const MAX_FAST_SYNC_OVERLAY_CLIENTS: usize = 5;
 
@@ -36,23 +36,27 @@ pub struct FastSyncOverlayClient {
     shard: ShardIdent,
     client: Arc<OverlayClient>,
     engine: Arc<dyn EngineOperations>,
+    use_twostep: bool,
 }
 
 impl FastSyncOverlayClient {
     pub async fn new(
         shard: ShardIdent,
-        validators: &ValidatorSet,
+        validators: &[ValidatorDescr],
         key: Option<&Arc<dyn KeyOption>>,
         certificate: Option<MemberCertificate>,
         cancellation_token: tokio_util::sync::CancellationToken,
         network_context: Arc<NetworkContext>,
         engine: Arc<dyn EngineOperations>,
         policy: DhtSearchPolicy,
         default_rldp_roundtrip: Option<u32>,
+        use_quic: bool,
     ) -> Result<Arc<Self>> {
-        let mut root_members = Vec::new();
-        for vd in validators.list() {
-            root_members.push(vd.adnl_addr().clone());
+        let mut root_adnl_ids = Vec::with_capacity(validators.len());
+        let mut root_public_keys = Vec::with_capacity(validators.len());
+        for vd in validators {
+            root_adnl_ids.push(vd.adnl_addr().clone());
+            root_public_keys.push(vd.public_key.pub_key().id().clone());
         }
         let id = ton_api::ton::ton_node::fastsyncoverlayid::FastSyncOverlayId {
             zero_state_file_hash: engine.zerostate_id()?.file_hash().clone(),
@@ -62,6 +66,11 @@ impl FastSyncOverlayClient {
         let overlay_key = OverlayKey { name: id_full.clone().into() };
         let id_short = OverlayShortId::from_data(hash(overlay_key)?);
 
+        let use_twostep = use_quic && network_context.stack.quic.is_some() && key.is_some();
+        if use_quic && !use_twostep {
+            log::warn!("Fast sync overlay {id_short}: use_quic=true but QUIC or key not available");
+        }
+
         log::info!(
             "Creating fast sync overlay client for shard {shard}, id: {id_short}, adnl id: {}",
             key.map(|k| k.id().to_string()).unwrap_or_default()
@@ -70,18 +79,20 @@ impl FastSyncOverlayClient {
         let client = OverlayClient::new_semiprivate(
             id_short.clone(),
             id_full,
-            root_members,
+            root_adnl_ids,
+            root_public_keys,
             key,
             certificate,
             network_context,
             cancellation_token.clone(),
             policy,
             default_rldp_roundtrip,
             MAX_FAST_SYNC_OVERLAY_CLIENTS,
+            use_twostep,
         )
         .await?;
 
-        let result = Arc::new(Self { id: id_short, shard, client, engine });
+        let result = Arc::new(Self { id: id_short, shard, client, engine, use_twostep });
 
         result.clone().listen_broadcasts(cancellation_token.clone());
 
@@ -263,4 +274,38 @@ impl FastSyncOverlayClient {
             }
         }
     }
+
+    pub async fn send_twostep_broadcast(
+        &self,
+        data: &TaggedByteSlice<'_>,
+        flags: u32,
+    ) -> Result<()> {
+        match self
+            .client
+            .broadcast_twostep(data, None, flags | OverlayNode::FLAG_BCAST_ANY_SENDER)
+            .await
+        {
+            Ok(info) => {
+                #[cfg(feature = "telemetry")]
+                log::debug!(
+                    "sent twostep broadcast {:08x} in {} to {} nodes",
+                    data.tag,
+                    self.id,
+                    info.send_to
+                );
+                #[cfg(not(feature = "telemetry"))]
+                log::debug!("sent twostep broadcast in {} to {} nodes", self.id, info.send_to);
+
+                Ok(())
+            }
+            Err(e) => {
+                log::warn!("Error sending twostep broadcast: {}", e);
+                Err(e)
+            }
+        }
+    }
+
+    pub fn use_twostep(&self) -> bool {
+        self.use_twostep
+    }
 }