From 4622ce44440120c4d04eb3528338b51e804203f5 Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Tue, 15 Sep 2026 09:55:30 -0700 Subject: [PATCH 01/23] Compress and share transaction set responses across peers Prefer the negotiated zstd tx-set response protocol and cache each set's encoded payload for fanout. Encode and decode off Tokio network workers, retain existing size and send-admission bounds, and preserve legacy peer compatibility. Port 125a2487c onto the batched-getdata branch. Rust tests: 191 passed, 3 pre-existing ignored; cargo fmt passed. --- Cargo.lock | 47 ++++ overlay/Cargo.toml | 3 + overlay/src/flood/mod.rs | 2 + overlay/src/flood/txset.rs | 35 +-- overlay/src/flood/txset_encoding.rs | 195 +++++++++++++++ overlay/src/libp2p_overlay.rs | 244 +++++++++++++------ overlay/src/libp2p_overlay/dispatch_tests.rs | 148 ++++++++++- overlay/src/main.rs | 2 +- 8 files changed, 570 insertions(+), 106 deletions(-) create mode 100644 overlay/src/flood/txset_encoding.rs diff --git a/Cargo.lock b/Cargo.lock index 23b4413290..b45d7b694f 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -581,6 +581,8 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "5add81bb678e6cb321aff7fa0dc7689ad82b112dbc032cea19f91d6b8e3582b9" dependencies = [ "find-msvc-tools", + "jobserver", + "libc", "shlex", ] @@ -1793,6 +1795,16 @@ version = "1.0.6" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "453ad9f582a441959e5f0d088b02ce04cfe8d51a8eaf077f12ac6d3e94164ca6" +[[package]] +name = "jobserver" +version = "0.1.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1c00acbd29eabad4a2392fa0e921c874934dbbf4194312ad20f04a0ed67a3cb3" +dependencies = [ + "getrandom 0.4.3", + "libc", +] + [[package]] name = "js-sys" version = "0.3.77" @@ -2655,6 +2667,12 @@ dependencies = [ "spki 0.8.1", ] +[[package]] +name = "pkg-config" +version = "0.3.34" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f6b464fbc74e149a392436b17d523f769e057cb6877f6a5c4618bc6f11800548" + [[package]] name = "polling" version = "3.11.0" @@ -4254,6 +4272,7 @@ dependencies = [ "toml", "tracing", "tracing-subscriber", + "zstd", ] [[package]] @@ -5569,3 +5588,31 @@ dependencies = [ "quote", "syn 2.0.119", ] + +[[package]] +name = "zstd" +version = "0.13.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e91ee311a569c327171651566e07972200e76fcfe2242a4fa446149a3881c08a" +dependencies = [ + "zstd-safe", +] + +[[package]] +name = "zstd-safe" +version = "7.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "64d80649ab6db9d9f6f9c80a40becd948eda4714a0a5ac8c4d157a32231c7882" +dependencies = [ + "zstd-sys", +] + +[[package]] +name = "zstd-sys" +version = "2.1.0+zstd.1.5.7" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0ef0a8027ec3ee71300ab3bcbcd0393f434aa72b91ca6d635a39941deae8eea0" +dependencies = [ + "cc", + "pkg-config", +] diff --git a/overlay/Cargo.toml b/overlay/Cargo.toml index 04b665747e..1ad9ab16af 100644 --- a/overlay/Cargo.toml +++ b/overlay/Cargo.toml @@ -29,6 +29,9 @@ libp2p = { version = "0.54", features = ["tokio", "macros", "identify", "quic"] libp2p-stream = "0.2.0-alpha" futures = "0.3" +# TX set response compression +zstd = { version = "0.13.3", default-features = false } + # Logging tracing = "0.1" tracing-subscriber = { version = "0.3", features = ["env-filter"] } diff --git a/overlay/src/flood/mod.rs b/overlay/src/flood/mod.rs index 59a6adcaac..ecefbc36db 100644 --- a/overlay/src/flood/mod.rs +++ b/overlay/src/flood/mod.rs @@ -9,6 +9,7 @@ mod mempool; mod pending_requests; mod tx_buffer; mod txset; +pub(crate) mod txset_encoding; pub use inv_batcher::InvBatcher; pub use inv_messages::{GetData, InvBatch, InvEntry, TxStreamMessage, INV_BATCH_MAX_SIZE}; @@ -17,3 +18,4 @@ pub use mempool::Mempool; pub use pending_requests::PendingRequests; pub use tx_buffer::TxBuffer; pub use txset::{CachedTxSet, Hash256, TxSetCache}; +pub use txset_encoding::TxSetData; diff --git a/overlay/src/flood/txset.rs b/overlay/src/flood/txset.rs index d8d487a52f..6a800aad33 100644 --- a/overlay/src/flood/txset.rs +++ b/overlay/src/flood/txset.rs @@ -1,5 +1,6 @@ //! TX set cache for peer request/response handling. +use super::TxSetData; use std::collections::{HashMap, VecDeque}; use std::sync::Arc; @@ -11,9 +12,9 @@ pub type Hash256 = [u8; 32]; pub struct CachedTxSet { /// The TX set hash (SHA256 of XDR) pub hash: Hash256, - /// Immutable XDR shared by the cache and pending peer responses. Keep the - /// Vec allocation when caching; fanout clones only the Arc. - pub xdr: Arc>, + /// Immutable XDR and lazily encoded response shared by the cache and + /// pending peer responses. Fanout clones only the Arc. + pub xdr: Arc, /// Ledger sequence this was built for pub ledger_seq: u32, } @@ -85,7 +86,7 @@ mod tests { let tx_set = CachedTxSet { hash: [1u8; 32], - xdr: vec![1, 2, 3].into(), + xdr: Arc::new(vec![1, 2, 3].into()), ledger_seq: 100, }; @@ -105,12 +106,12 @@ mod tests { cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: vec![].into(), + xdr: Arc::new(vec![].into()), ledger_seq: 100, }); cache.insert(CachedTxSet { hash: [2u8; 32], - xdr: vec![].into(), + xdr: Arc::new(vec![].into()), ledger_seq: 200, }); @@ -126,12 +127,12 @@ mod tests { cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: vec![].into(), + xdr: Arc::new(vec![].into()), ledger_seq: 100, }); cache.insert(CachedTxSet { hash: [2u8; 32], - xdr: vec![].into(), + xdr: Arc::new(vec![].into()), ledger_seq: 101, }); @@ -140,7 +141,7 @@ mod tests { // Insert 3rd - should evict one cache.insert(CachedTxSet { hash: [3u8; 32], - xdr: vec![].into(), + xdr: Arc::new(vec![].into()), ledger_seq: 102, }); @@ -165,14 +166,14 @@ mod tests { cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: vec![1, 2, 3].into(), + xdr: Arc::new(vec![1, 2, 3].into()), ledger_seq: 100, }); // Insert with same hash but different data cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: vec![4, 5, 6].into(), + xdr: Arc::new(vec![4, 5, 6].into()), ledger_seq: 200, }); @@ -188,7 +189,7 @@ mod tests { cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: vec![1, 2, 3].into(), + xdr: Arc::new(vec![1, 2, 3].into()), ledger_seq: 100, }); assert_eq!(cache.len(), 1, "Cache is full"); @@ -197,7 +198,7 @@ mod tests { // not evict the entry or shrink the cache below capacity. cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: vec![4, 5, 6].into(), + xdr: Arc::new(vec![4, 5, 6].into()), ledger_seq: 102, }); @@ -216,12 +217,12 @@ mod tests { // Insert, then overwrite the same hash with a newer ledger_seq. cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: vec![1, 2, 3].into(), + xdr: Arc::new(vec![1, 2, 3].into()), ledger_seq: 100, }); cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: vec![4, 5, 6].into(), + xdr: Arc::new(vec![4, 5, 6].into()), ledger_seq: 200, }); @@ -239,12 +240,12 @@ mod tests { // cache exactly at capacity (not one over). cache.insert(CachedTxSet { hash: [2u8; 32], - xdr: vec![].into(), + xdr: Arc::new(vec![].into()), ledger_seq: 300, }); cache.insert(CachedTxSet { hash: [3u8; 32], - xdr: vec![].into(), + xdr: Arc::new(vec![].into()), ledger_seq: 400, }); diff --git a/overlay/src/flood/txset_encoding.rs b/overlay/src/flood/txset_encoding.rs new file mode 100644 index 0000000000..34bc6d7e15 --- /dev/null +++ b/overlay/src/flood/txset_encoding.rs @@ -0,0 +1,195 @@ +//! Cached TX set encoding for the compressed response protocol. +//! +//! Inside the usual length-prefixed frame: a big-endian u32 XDR length, +//! followed by one zstd frame. The high bit marks uncompressed XDR when +//! compression would not save space. Both encodings retain the legacy limit. +use std::{io, sync::Arc}; +use tokio::sync::OnceCell; + +pub(crate) const MAX_TXSET_XDR_SIZE: usize = 16 * 1024 * 1024 - 4; +const RAW: u32 = 1 << 31; + +/// One immutable allocation per cached set, shared by all peer sends. The +/// compressed representation is computed on demand once for the whole fanout. +#[derive(Debug)] +pub struct TxSetData { + xdr: Vec, + compressed: OnceCell>>, +} + +impl From> for TxSetData { + fn from(xdr: Vec) -> Self { + Self { + xdr, + compressed: OnceCell::new(), + } + } +} + +impl TxSetData { + pub fn as_slice(&self) -> &[u8] { + &self.xdr + } + + pub fn len(&self) -> usize { + self.xdr.len() + } + + pub fn is_empty(&self) -> bool { + self.xdr.is_empty() + } + + pub(crate) async fn encoded(self: &Arc) -> io::Result<([u8; 4], &[u8])> { + let compressed = self + .compressed + .get_or_try_init(|| async { + let data = Arc::clone(self); + // Compression must not occupy a Tokio network worker. Admission + // already bounds the number and raw bytes of outstanding sends. + tokio::task::spawn_blocking(move || compress(&data.xdr)) + .await + .map_err(io::Error::other)? + }) + .await?; + let length = self.len() as u32; + Ok(match compressed { + Some(bytes) => (length.to_be_bytes(), bytes), + None => ((length | RAW).to_be_bytes(), &self.xdr), + }) + } +} + +fn compress(xdr: &[u8]) -> io::Result>> { + if xdr.len() > MAX_TXSET_XDR_SIZE { + return Err(io::Error::new( + io::ErrorKind::InvalidInput, + "TX set exceeds wire limit", + )); + } + let mut bytes = zstd::bulk::compress(xdr, 1)?; + if bytes.len() >= xdr.len() { + return Ok(None); + } + // bulk::compress reserves the worst-case size, approximately the raw + // length. Do not retain that spare allocation throughout the cache lifetime. + bytes.shrink_to_fit(); + Ok(Some(bytes)) +} + +pub(crate) fn decode(mut frame: Vec) -> io::Result> { + let invalid = || io::Error::new(io::ErrorKind::InvalidData, "invalid TX set encoding"); + if frame.len() < 4 || frame.len() > MAX_TXSET_XDR_SIZE + 4 { + return Err(invalid()); + } + let header = u32::from_be_bytes(frame[..4].try_into().unwrap()); + let length = (header & !RAW) as usize; + // Check before any decompressor or output allocation. Never trust the + // content size embedded in the compressed frame to allocate memory. + if length > MAX_TXSET_XDR_SIZE { + return Err(invalid()); + } + if header & RAW != 0 { + if frame.len() - 4 != length { + return Err(invalid()); + } + frame.drain(..4); + return Ok(frame); + } + let compressed = &frame[4..]; + if zstd::zstd_safe::find_frame_compressed_size(compressed).map_err(|_| invalid())? + != compressed.len() + { + return Err(invalid()); + } + let mut decoder = zstd::bulk::Decompressor::new()?; + decoder.window_log_max(24)?; + let output = decoder.decompress(compressed, length)?; + if output.len() != length { + return Err(invalid()); + } + Ok(output) +} + +#[cfg(test)] +mod tests { + use super::*; + use rand::{RngCore, SeedableRng}; + + async fn encode(xdr: Vec) -> Vec { + let data = Arc::new(TxSetData::from(xdr)); + let (header, bytes) = data.encoded().await.unwrap(); + [header.as_slice(), bytes].concat() + } + + #[tokio::test] + async fn roundtrip_and_size_bound_for_both_encodings() { + let mut random = vec![0; 64 * 1024]; + rand::rngs::StdRng::seed_from_u64(17).fill_bytes(&mut random); + for xdr in [vec![], vec![17], random, vec![0; MAX_TXSET_XDR_SIZE]] { + let frame = encode(xdr.clone()).await; + assert!(frame.len() <= xdr.len() + 4); + assert_eq!(decode(frame).unwrap(), xdr); + } + let raw = encode(vec![17]).await; + assert_ne!(raw[0] & 0x80, 0); + let compressed = encode(vec![17; 1024]).await; + assert_eq!(compressed[0] & 0x80, 0); + assert!(compressed.len() < 100); + } + + #[tokio::test] + async fn concurrent_fanout_shares_one_encoded_allocation() { + let data = Arc::new(TxSetData::from(vec![13; 4 * 1024 * 1024])); + let results = futures::future::join_all((0..29).map(|_| data.encoded())).await; + let (header, bytes) = results[0].as_ref().unwrap(); + assert_eq!(header[0] & 0x80, 0); + for result in &results { + let (other_header, other_bytes) = result.as_ref().unwrap(); + assert_eq!(other_header, header); + assert!(std::ptr::eq(bytes.as_ptr(), other_bytes.as_ptr())); + } + let (_, again) = data.encoded().await.unwrap(); + assert!(std::ptr::eq(bytes.as_ptr(), again.as_ptr())); + } + + #[tokio::test] + async fn rejects_truncation_corruption_and_length_mismatch() { + let frame = encode(vec![13; 4096]).await; + for end in 0..frame.len() { + assert!(decode(frame[..end].to_vec()).is_err()); + } + let mut corrupt = frame.clone(); + corrupt[4] ^= 0xff; // Invalid zstd magic. + assert!(decode(corrupt).is_err()); + for length in [0, 4095, 4097, MAX_TXSET_XDR_SIZE + 1] { + let mut bad = frame.clone(); + bad[..4].copy_from_slice(&(length as u32).to_be_bytes()); + assert!(decode(bad).is_err()); + } + // Exactly one zstd frame must consume the entire payload. + let mut trailing = frame.clone(); + trailing.push(0); + assert!(decode(trailing).is_err()); + let mut concatenated = frame.clone(); + concatenated.extend_from_slice(&frame[4..]); + assert!(decode(concatenated).is_err()); + let mut raw = encode(vec![19]).await; + raw.push(0); + assert!(decode(raw).is_err()); + } + + #[tokio::test] + async fn compression_does_not_allow_oversized_raw_sets() { + let oversized = vec![0; MAX_TXSET_XDR_SIZE + 1]; + let data = Arc::new(TxSetData::from(oversized)); + assert!(data.encoded().await.is_err()); + // Even if its compressed bytes fit, an over-limit raw size is rejected. + let frame = [ + (MAX_TXSET_XDR_SIZE as u32 + 1).to_be_bytes().as_slice(), + zstd::bulk::compress(data.as_slice(), 1).unwrap().as_slice(), + ] + .concat(); + assert!(decode(frame).is_err()); + assert!(decode(vec![0; MAX_TXSET_XDR_SIZE + 5]).is_err()); + } +} diff --git a/overlay/src/libp2p_overlay.rs b/overlay/src/libp2p_overlay.rs index 0e11b78647..551aa542a9 100644 --- a/overlay/src/libp2p_overlay.rs +++ b/overlay/src/libp2p_overlay.rs @@ -12,7 +12,8 @@ //! QUIC provides independent loss recovery per stream. use crate::flood::{ - GetData, InvBatch, InvBatcher, InvEntry, InvTracker, PendingRequests, TxBuffer, TxStreamMessage, + GetData, InvBatch, InvBatcher, InvEntry, InvTracker, PendingRequests, TxBuffer, TxSetData, + TxStreamMessage, }; #[cfg(test)] use crate::integrated::CoreCommand; @@ -46,10 +47,12 @@ pub const SCP_PROTOCOL: StreamProtocol = StreamProtocol::new("/stellar/scp/1.0.0 pub const CONTROL_PROTOCOL: StreamProtocol = StreamProtocol::new("/stellar/control/1.0.0"); pub const TX_PROTOCOL: StreamProtocol = StreamProtocol::new("/stellar/tx/1.0.0"); pub const TXSET_PROTOCOL: StreamProtocol = StreamProtocol::new("/stellar/txset/1.0.0"); +pub const COMPRESSED_TXSET_PROTOCOL: StreamProtocol = + StreamProtocol::new("/stellar/txset/zstd/1.0.0"); /// Message frame: 4-byte length prefix + payload /// Max message size: 16MB (for large TX sets) -const MAX_MESSAGE_SIZE: usize = 16 * 1024 * 1024; +const MAX_MESSAGE_SIZE: usize = crate::flood::txset_encoding::MAX_TXSET_XDR_SIZE + 4; // Bound queued + active bulk sends. Admission waits in the caller, never in // the swarm loop: a backpressured peer must not stop SCP or swarm polling. @@ -100,7 +103,7 @@ pub enum OverlayCommand { /// Send TX set to a specific peer (response to their request) SendTxSet { hash: [u8; 32], - data: Arc>, + data: Arc, to: PeerId, permits: (OwnedSemaphorePermit, OwnedSemaphorePermit), }, @@ -225,8 +228,7 @@ impl OverlayHandle { } } - pub async fn send_txset(&self, hash: [u8; 32], data: impl Into>>, to: PeerId) { - let data = data.into(); + pub async fn send_txset(&self, hash: [u8; 32], data: Arc, to: PeerId) { // Include the StellarMessage discriminant in the existing wire limit. if data.len() > MAX_MESSAGE_SIZE - 4 { warn!( @@ -543,13 +545,21 @@ impl StellarOverlay { self.run_event_loop_with_control( #[cfg(test)] true, + #[cfg(test)] + true, ) .await; } - // Keeping the legacy-only mode in this helper lets interoperability tests - // exercise real protocol negotiation; production always advertises control. - async fn run_event_loop_with_control(mut self, #[cfg(test)] accept_control: bool) { + // Test-only switches exercise real negotiation with legacy peers. + // Production always advertises control and compressed responses. + async fn run_event_loop_with_control( + mut self, + #[cfg(test)] accept_control: bool, + #[cfg(test)] accept_compressed: bool, + ) { + #[cfg(not(test))] + let accept_compressed = true; #[cfg(not(test))] let accept_control = true; // Accept incoming streams for each protocol @@ -596,6 +606,18 @@ impl StellarOverlay { None }; + let compressed_incoming = if accept_compressed { + match self.control.accept(COMPRESSED_TXSET_PROTOCOL) { + Ok(incoming) => Some(incoming), + Err(e) => { + error!("Failed to accept compressed TxSet protocol: {:?}", e); + return; + } + } + } else { + None + }; + // Spawn inbound stream handlers let state = self.state.clone(); tokio::spawn(handle_inbound_scp_streams( @@ -607,7 +629,15 @@ impl StellarOverlay { tokio::spawn(handle_inbound_scp_streams(incoming, state.clone(), true)); } tokio::spawn(handle_inbound_tx_streams(tx_incoming, state.clone())); - tokio::spawn(handle_inbound_txset_streams(txset_incoming, state.clone())); + tokio::spawn(handle_inbound_txset_streams( + txset_incoming, + state.clone(), + false, + )); + + if let Some(incoming) = compressed_incoming { + tokio::spawn(handle_inbound_txset_streams(incoming, state.clone(), true)); + } // Spawn INV/GETDATA housekeeping task tokio::spawn(inv_getdata_housekeeping_task(state.clone())); @@ -1150,7 +1180,7 @@ async fn send_txset_response( state: Arc, peer: PeerId, hash: [u8; 32], - data: Arc>, + data: Arc, ) { info!( "TXSET_SEND: Sending TX set {:02x?}... ({} bytes) to {}", @@ -1159,16 +1189,8 @@ async fn send_txset_response( peer ); - // `data` is a tx set we already validated on entry (from a peer) or - // built locally (trusted core). Keep the payload shared through admission - // and transmission, writing the small discriminant separately under the - // same stream lock as the payload. - let discriminant = (stellar_xdr::MessageType::GeneralizedTxSet as i32).to_be_bytes(); - let bytes = discriminant.len() + data.len(); - - match send_to_peer_stream_parts(&state, peer, StreamType::TxSet, &[&discriminant, &data]).await - { - Ok(_) => { + match send_peer_frames(&state, peer, StreamType::TxSet, PeerFrames::TxSet(&data)).await { + Ok(bytes) => { state.metrics.send_txset.fetch_add(1, Ordering::Relaxed); state.metrics.message_write.fetch_add(1, Ordering::Relaxed); state @@ -1176,7 +1198,7 @@ async fn send_txset_response( .byte_write .fetch_add(bytes as u64, Ordering::Relaxed); info!( - "TXSET_SEND_OK: Successfully sent TX set {:02x?}... ({} bytes on wire) to {}", + "TXSET_SEND_OK: Queued TX set {:02x?}... ({} bytes on wire) to {}", &hash[..4], bytes, peer @@ -1261,7 +1283,8 @@ impl StreamType { match self { StreamType::Control | StreamType::TxSetRequest => CONTROL_PROTOCOL, StreamType::Tx => TX_PROTOCOL, - StreamType::TxSet | StreamType::LegacyTxSetRequest => TXSET_PROTOCOL, + StreamType::TxSet => COMPRESSED_TXSET_PROTOCOL, + StreamType::LegacyTxSetRequest => TXSET_PROTOCOL, } } @@ -1290,6 +1313,12 @@ async fn open_peer_stream( protocol = SCP_PROTOCOL; control.open_stream(peer, protocol.clone()).await } + Err(libp2p_stream::OpenStreamError::UnsupportedProtocol(_)) + if protocol == COMPRESSED_TXSET_PROTOCOL => + { + protocol = TXSET_PROTOCOL; + control.open_stream(peer, protocol.clone()).await + } result => result, } .map_err(|e| io::Error::new(io::ErrorKind::NotConnected, e))?; @@ -1363,7 +1392,45 @@ async fn send_to_peer_stream_parts( stream_type: StreamType, parts: &[&[u8]], ) -> io::Result<()> { - send_peer_frames(state, peer_id, stream_type, framed_io::Frames::One(parts)).await + send_peer_frames( + state, + peer_id, + stream_type, + PeerFrames::Plain(framed_io::Frames::One(parts)), + ) + .await + .map(|_| ()) +} + +// Select response encoding using the protocol actually negotiated on this +// stream, including after reconnect. Other routes keep their original framing. +#[derive(Clone, Copy)] +enum PeerFrames<'a> { + Plain(framed_io::Frames<'a>), + TxSet(&'a Arc), +} + +impl PeerFrames<'_> { + async fn write(self, outbound: &mut OutboundStream) -> io::Result { + match self { + Self::Plain(frames) => { + frames.write(&mut outbound.stream).await?; + Ok(0) + } + Self::TxSet(data) => { + let (header, payload) = if outbound.protocol == COMPRESSED_TXSET_PROTOCOL { + data.encoded().await? + } else { + ( + (stellar_xdr::MessageType::GeneralizedTxSet as i32).to_be_bytes(), + data.as_slice(), + ) + }; + framed_io::write_frame_parts(&mut outbound.stream, &[&header, payload]).await?; + Ok(4 + payload.len()) + } + } + } } /// Write `frames` to the peer's stream for `stream_type`, opening it if @@ -1379,8 +1446,8 @@ async fn send_peer_frames( state: &SharedState, peer_id: PeerId, stream_type: StreamType, - frames: framed_io::Frames<'_>, -) -> io::Result<()> { + frames: PeerFrames<'_>, +) -> io::Result { // Retry up to 2 times (3 attempts total) for reliability const MAX_RETRIES: usize = 2; @@ -1467,8 +1534,8 @@ async fn send_peer_frames( )) .await; } - match frames.write(&mut stream.stream).await { - Ok(()) => return Ok(()), + match frames.write(stream).await { + Ok(bytes) => return Ok(bytes), Err(e) => { // Clear the broken stream *stream_guard = None; @@ -1991,8 +2058,10 @@ async fn serve_getdata(state: &SharedState, peer: PeerId, hashes: Vec<[u8; 32]>) batch.extend_from_slice(part); } } - let frames = framed_io::Frames::Batch(&batch); - let result = send_peer_frames(state, peer, StreamType::Tx, frames).await; + let frames = PeerFrames::Plain(framed_io::Frames::Batch(&batch)); + let result = send_peer_frames(state, peer, StreamType::Tx, frames) + .await + .map(|_| ()); record_tx_response_write(state, peer, result, txs.len(), bytes - 4 * txs.len()) }; if !written { @@ -2172,8 +2241,54 @@ fn handle_txset_request(state: &SharedState, peer_id: PeerId, hash: [u8; 32]) { } } -/// Handle inbound TxSet streams from peers -async fn handle_inbound_txset_streams(mut incoming: IncomingStreams, state: Arc) { +/// Deliver strict-decoded XDR identically for both response encodings. +async fn deliver_txset(state: &SharedState, peer_id: PeerId, txset_data: Vec) { + let hash = crate::xdr::sha256_hash(&txset_data); + + // Clear pending request flag and measure fetch latency + let slot = { + let mut pending = state.pending_txset_requests.write().await; + if let Some((_, request_time, slot)) = pending.remove(&hash) { + let fetch_us = request_time.elapsed().as_micros() as u64; + state + .metrics + .fetch_txset_sum_us + .fetch_add(fetch_us, Ordering::Relaxed); + state + .metrics + .fetch_txset_count + .fetch_add(1, Ordering::Relaxed); + Some(slot) + } else { + None + } + }; + + info!( + "TXSET_RECV: Received TxSet {:02x?}... ({} bytes) from {} (was_pending={})", + &hash[..4], + txset_data.len(), + peer_id, + slot.is_some() + ); + if let Err(e) = state.event_tx.send(OverlayEvent::TxSetReceived { + hash, + data: txset_data, + from: peer_id, + slot, + }) { + warn!( + "Failed to forward TxSetReceived event from {}: {}", + peer_id, e + ); + } +} + +async fn handle_inbound_txset_streams( + mut incoming: IncomingStreams, + state: Arc, + compressed: bool, +) { while let Some((peer_id, mut stream)) = incoming.next().await { debug!("Accepted inbound TxSet stream from {}", peer_id); state.metrics.inbound_live.fetch_add(1, Ordering::Relaxed); @@ -2188,6 +2303,23 @@ async fn handle_inbound_txset_streams(mut incoming: IncomingStreams, state: Arc< .metrics .byte_read .fetch_add(data.len() as u64, Ordering::Relaxed); + if compressed { + // Decode and strict-parse outside the network runtime. Each + // stream awaits completion before reading another frame. + let decoded = tokio::task::spawn_blocking(move || { + use stellar_xdr::{GeneralizedTransactionSet, Limits, ReadXdr}; + let xdr = crate::flood::txset_encoding::decode(data)?; + GeneralizedTransactionSet::from_xdr(&xdr, Limits::none()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?; + Ok::<_, io::Error>(xdr) + }) + .await; + match decoded { + Ok(Ok(xdr)) => deliver_txset(&state, peer_id, xdr).await, + result => warn!("TXSET_PARSE_ERR: Dropping malformed compressed TxSet from {}: {:?}", peer_id, result), + } + continue; + } let message = match crate::xdr::parse_stellar_message(&data) { Ok(message) => message, Err(e) => { @@ -2209,45 +2341,7 @@ async fn handle_inbound_txset_streams(mut incoming: IncomingStreams, state: Arc< // canonical tx set; hash the original bytes // rather than re-encoding. let txset_data = data[4..].to_vec(); - let hash = crate::xdr::sha256_hash(&txset_data); - - // Clear pending request flag and measure fetch latency - let slot = { - let mut pending = state.pending_txset_requests.write().await; - if let Some((_, request_time, slot)) = pending.remove(&hash) { - let fetch_us = request_time.elapsed().as_micros() as u64; - state - .metrics - .fetch_txset_sum_us - .fetch_add(fetch_us, Ordering::Relaxed); - state - .metrics - .fetch_txset_count - .fetch_add(1, Ordering::Relaxed); - Some(slot) - } else { - None - } - }; - - info!( - "TXSET_RECV: Received TxSet {:02x?}... ({} bytes) from {} (was_pending={})", - &hash[..4], - txset_data.len(), - peer_id, - slot.is_some() - ); - if let Err(e) = state.event_tx.send(OverlayEvent::TxSetReceived { - hash, - data: txset_data, - from: peer_id, - slot, - }) { - warn!( - "Failed to forward TxSetReceived event from {}: {}", - peer_id, e - ); - } + deliver_txset(&state, peer_id, txset_data).await; } other => { warn!( @@ -3012,7 +3106,7 @@ mod tests { request_received = true; // Node1 responds with TxSet data - handle1.send_txset(hash, txset_data.clone(), from).await; + handle1.send_txset(hash, Arc::new(txset_data.clone().into()), from).await; } } _ = tokio::time::sleep(Duration::from_millis(10)) => {} @@ -3796,7 +3890,7 @@ async fn test_txset_request_and_response() { Some(event) = events1.recv() => { if let OverlayEvent::TxSetRequested { hash, from } = event { assert_eq!(hash, requested_hash, "Request should have correct hash"); - handle1.send_txset(hash, txset_data.clone(), from).await; + handle1.send_txset(hash, Arc::new(txset_data.clone().into()), from).await; responded = true; } } @@ -3913,7 +4007,7 @@ async fn test_txset_multiple_concurrent_requests() { received_hashes.insert(hash); // Respond to each request let data = format!("txset for {:?}", &hash[..4]).into_bytes(); - handle1.send_txset(hash, data, from).await; + handle1.send_txset(hash, Arc::new(data.into()), from).await; } } _ = tokio::time::sleep(Duration::from_millis(10)) => {} @@ -4248,7 +4342,7 @@ async fn test_concurrent_scp_and_txset_writes_to_same_peer() { let txset_task = tokio::spawn(async move { txset_started_clone.store(true, Ordering::SeqCst); handle1_txset - .send_txset(txset_hash, txset_data, peer2_id) + .send_txset(txset_hash, Arc::new(txset_data.into()), peer2_id) .await; }); @@ -4376,7 +4470,7 @@ async fn test_pending_txset_cleanup_on_disconnect() { // Now have node2 respond with the TxSet // This verifies the pending cleanup works when response is received handle2 - .send_txset(txset_hash, txset_data.clone(), peer1_id) + .send_txset(txset_hash, Arc::new(txset_data.clone().into()), peer1_id) .await; // Verify node1 receives the TxSet response diff --git a/overlay/src/libp2p_overlay/dispatch_tests.rs b/overlay/src/libp2p_overlay/dispatch_tests.rs index 1cb00aa20e..8f5e707dde 100644 --- a/overlay/src/libp2p_overlay/dispatch_tests.rs +++ b/overlay/src/libp2p_overlay/dispatch_tests.rs @@ -26,7 +26,7 @@ async fn dispatcher_with_blocked_write(command: &str) { match command { "txset" => { let (hash, data) = test_txset_xdr(1); - handle.send_txset(hash, data, peer).await; + handle.send_txset(hash, Arc::new(data.into()), peer).await; } "fetch" => handle.fetch_txset([1; 32], 1).await, // Awaiting a direct send must preserve ordering within an SCP-state @@ -94,6 +94,10 @@ impl TestNode { } async fn start_with_control(accept_control: bool) -> Self { + Self::start_with_protocols(accept_control, true).await + } + + async fn start_with_protocols(accept_control: bool, accept_compressed: bool) -> Self { let (handle, events, admissions, mut overlay) = create_test_overlay(Keypair::generate_ed25519(), Arc::new(OverlayMetrics::new())) .unwrap(); @@ -116,7 +120,8 @@ impl TestNode { }) .await .expect("listener did not start"); - let task = tokio::spawn(overlay.run_event_loop_with_control(accept_control)); + let task = + tokio::spawn(overlay.run_event_loop_with_control(accept_control, accept_compressed)); Self { handle, events, @@ -587,6 +592,111 @@ async fn inv_batches_completed_by_relay_or_local_broadcast_reach_the_peer() { receiver.stop().await; } +#[tokio::test] +async fn txset_encoding_negotiates_with_legacy_peers_and_after_reopening() { + for (control, compressed) in [(true, true), (true, false), (false, false)] { + let mut sender = TestNode::start().await; + let mut receiver = TestNode::start_with_protocols(control, compressed).await; + sender.connect(&receiver).await; + let streams = sender.streams_to(receiver.peer).await; + let (hash, xdr) = large_txset(); + let shared = Arc::new(TxSetData::from(xdr.clone())); + for reopen in [false, true] { + if reopen { + streams.txset.lock().await.take(); + } + let bytes = send_peer_frames( + &sender.state, + receiver.peer, + StreamType::TxSet, + PeerFrames::TxSet(&shared), + ) + .await + .unwrap(); + if compressed { + assert!( + bytes < xdr.len() / 2, + "large responses must use compressed bytes" + ); + } else { + assert_eq!(bytes, xdr.len() + 4); + } + { + let guard = streams.txset.lock().await; + let outbound = guard.as_ref().unwrap(); + assert_eq!( + outbound.protocol, + if compressed { + COMPRESSED_TXSET_PROTOCOL + } else { + TXSET_PROTOCOL + } + ); + assert_eq!(outbound.stream.priority().unwrap(), 1); + } + tokio::time::timeout(Duration::from_secs(10), async { + loop { + if let OverlayEvent::TxSetReceived { + hash: got, data, .. + } = receiver.events.recv().await.unwrap() + { + assert_eq!(got, hash); + assert_eq!(data, xdr); + break; + } + } + }) + .await + .expect("negotiated response was not delivered intact"); + } + sender.stop().await; + receiver.stop().await; + } +} + +#[tokio::test] +async fn malformed_compressed_txsets_are_dropped_without_losing_next_frame() { + let mut sender = TestNode::start().await; + let mut receiver = TestNode::start().await; + sender.connect(&receiver).await; + // Well-formed compression is insufficient: XDR must also strict-decode. + let malformed = Arc::new(TxSetData::from(vec![0xff; 1000])); + send_peer_frames( + &sender.state, + receiver.peer, + StreamType::TxSet, + PeerFrames::TxSet(&malformed), + ) + .await + .unwrap(); + let (hash, xdr) = test_txset_xdr(19); + // The uncompressed representation on the new protocol is also accepted. + let raw = [ + ((xdr.len() as u32) | (1 << 31)).to_be_bytes().as_slice(), + &xdr, + ] + .concat(); + send_to_peer_stream(&sender.state, receiver.peer, StreamType::TxSet, &raw) + .await + .unwrap(); + tokio::time::timeout(Duration::from_secs(5), async { + loop { + if let OverlayEvent::TxSetReceived { + hash: got, data, .. + } = receiver.events.recv().await.unwrap() + { + assert_eq!(got, hash, "malformed XDR was forwarded"); + assert_eq!(data, xdr); + break; + } + } + }) + .await + .expect("a bad compressed frame prevented the next response"); + sender.stop().await; + receiver.stop().await; +} + #[tokio::test] async fn inv_batch_demands_only_first_unseen_advertisements_in_order() { use crate::flood::{InvBatch, InvEntry}; @@ -776,7 +886,7 @@ async fn blocked_peer_does_not_delay_other_txsets_or_scp_delivery() { let (hash, data) = large_txset(); sender .handle - .send_txset(hash, data.clone(), slow.peer) + .send_txset(hash, Arc::new(data.clone().into()), slow.peer) .await; // Also exercise reopening: this write can complete only if the dispatcher @@ -785,12 +895,16 @@ async fn blocked_peer_does_not_delay_other_txsets_or_scp_delivery() { healthy_streams.txset.lock().await.take(); sender .handle - .send_txset(hash, data.clone(), healthy.peer) + .send_txset(hash, Arc::new(data.clone().into()), healthy.peer) .await; let (second_hash, second_data) = test_txset_xdr(2); sender .handle - .send_txset(second_hash, second_data.clone(), healthy.peer) + .send_txset( + second_hash, + Arc::new(second_data.clone().into()), + healthy.peer, + ) .await; let scp = test_scp_envelope_xdr(1234); sender.handle.broadcast_scp(scp.clone()).await; @@ -861,7 +975,11 @@ async fn txset_fetch_reaches_peer_while_response_to_same_peer_is_blocked() { let (response_hash, response_data) = test_txset_xdr(1); sender .handle - .send_txset(response_hash, response_data.clone(), receiver.peer) + .send_txset( + response_hash, + Arc::new(response_data.clone().into()), + receiver.peer, + ) .await; // Use the pre-opened stream, reuse it for another frame, then exercise // reopening. All three requests must arrive while the response is blocked. @@ -934,11 +1052,11 @@ async fn quic_transport_priorities_are_applied_to_each_route_and_reopening() { streams.txset.lock().await.take(); let (hash, data) = test_txset_xdr(1); // Await the actual write, rather than command enqueue, to observe reopening. - send_to_peer_stream( + send_peer_frames( &sender.state, receiver.peer, StreamType::TxSet, - &crate::xdr::frame_tx_set(&data), + PeerFrames::TxSet(&Arc::new(data.clone().into())), ) .await .unwrap(); @@ -1025,7 +1143,7 @@ async fn legacy_peer_receives_scp_and_fetches_on_its_supported_routes() { send_to_peer_stream( &legacy.state, sender.peer, - StreamType::TxSet, + StreamType::LegacyTxSetRequest, &crate::xdr::frame_get_tx_set(hash), ) .await @@ -1066,8 +1184,10 @@ async fn bulk_send_admission_is_bounded(byte_limit: bool) { handle.txset_send_slots = Arc::new(Semaphore::new(slots)); handle.txset_send_bytes = Arc::new(Semaphore::new(bytes)); let mut task = tokio::spawn(async move { overlay.run("127.0.0.1", 0).await }); - handle.send_txset(hash, data.clone(), peer).await; - let waiting = handle.send_txset(hash, data, peer); + handle + .send_txset(hash, Arc::new(data.clone().into()), peer) + .await; + let waiting = handle.send_txset(hash, Arc::new(data.into()), peer); tokio::pin!(waiting); assert!(futures::poll!(&mut waiting).is_pending()); tokio::time::timeout(Duration::from_secs(1), handle.ping()) @@ -1106,7 +1226,9 @@ async fn failed_txset_send_releases_admission() { create_test_overlay(Keypair::generate_ed25519(), Arc::new(OverlayMetrics::new())).unwrap(); let mut task = tokio::spawn(async move { overlay.run("127.0.0.1", 0).await }); let (hash, data) = test_txset_xdr(1); - handle.send_txset(hash, data, PeerId::random()).await; + handle + .send_txset(hash, Arc::new(data.into()), PeerId::random()) + .await; tokio::time::timeout(Duration::from_secs(1), async { let _all = Arc::clone(&handle.txset_send_slots) .acquire_many_owned(MAX_OUTSTANDING_TXSET_SENDS as u32) @@ -1179,7 +1301,7 @@ async fn queued_peer_sends_share_payload_and_release_it_on_drop() { let (handle, _events, _admissions, mut overlay) = create_test_overlay(Keypair::generate_ed25519(), Arc::new(OverlayMetrics::new())).unwrap(); let (hash, data) = test_txset_xdr(1); - let data = Arc::new(data); + let data = Arc::new(TxSetData::from(data)); let retained = Arc::downgrade(&data); for _ in 0..29 { handle diff --git a/overlay/src/main.rs b/overlay/src/main.rs index 752ea0d62c..572a3a2183 100644 --- a/overlay/src/main.rs +++ b/overlay/src/main.rs @@ -383,7 +383,7 @@ fn cache_tx_set_xdr( ) { tx_set_cache.insert(CachedTxSet { hash, - xdr: Arc::new(xdr), + xdr: Arc::new(xdr.into()), ledger_seq: current_ledger_seq, }); } From a1060af74678e652d366bb280cfe1597f60eb4d8 Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Thu, 17 Sep 2026 14:14:42 -0700 Subject: [PATCH 02/23] Prepare mandatory compressed transaction sets before validation --- docs/rust-overlay/transport.md | 16 +- docs/rust-overlay/txset-fetching.md | 38 +- overlay/src/flood/txset.rs | 30 +- overlay/src/flood/txset_encoding.rs | 205 +++++------ overlay/src/libp2p_overlay.rs | 361 +++++-------------- overlay/src/libp2p_overlay/dispatch_tests.rs | 323 ++++++++--------- overlay/src/main.rs | 121 ++++++- src/herder/HerderImpl.cpp | 41 ++- src/herder/TxSetFrame.cpp | 11 +- src/herder/TxSetFrame.h | 10 +- src/herder/test/TxSetTests.cpp | 38 ++ 11 files changed, 577 insertions(+), 617 deletions(-) diff --git a/docs/rust-overlay/transport.md b/docs/rust-overlay/transport.md index 55274af13a..95dbefc955 100644 --- a/docs/rust-overlay/transport.md +++ b/docs/rust-overlay/transport.md @@ -74,20 +74,15 @@ QUIC connection. Send priorities are set in Quinn, the QUIC implementation: | Protocol ID | Messages | Send priority | |-------------|----------|---------------| | `/stellar/control/1.0.0` | SCP envelopes, `GET_SCP_STATE`, `GET_TX_SET` | **2 — highest** | -| `/stellar/txset/1.0.0` | Tx-set responses | **1** | +| `/stellar/txset/zstd/2.0.0` | Compressed tx-set responses | **1** | | `/stellar/tx/1.0.0` | Transaction INV, GETDATA, TX | **0 — lowest** | SCP and tx-set requests share one FIFO stream; there is no separate priority between messages on that stream. `DONT_HAVE` handling is not implemented. -Older peers remain supported. An explicit rejection of the control protocol -causes the sender to negotiate `/stellar/scp/1.0.0` for SCP and SCP-state -requests, at priority 2. Tx-set requests then use a separate stream with the -legacy `/stellar/txset/1.0.0` protocol, also at priority 2. This fallback opens -on demand and is reused, preserving request isolation from responses while -using four outbound streams for old peers. Connection errors do not trigger -protocol downgrade. Updated receivers continue accepting both legacy -protocols, including tx-set requests on `/stellar/txset/1.0.0`. +These routes are mandatory on this experimental branch. There is no fallback +to the old SCP or transaction-set protocols. Transaction-set responses always +use zstd; see [TX set fetching](txset-fetching.md) for framing and cache ownership. In addition, libp2p's `Identify` protocol runs as `/stellar/1.0.0` (`libp2p_overlay.rs:380`). It exchanges peer-id + listen addresses on @@ -105,8 +100,7 @@ as independent tasks, so: - INV batches and TX response data flow on `/stellar/tx/1.0.0` only. - Between updated peers, tx-set fetch requests share the control stream with SCP, so a large response to the same peer cannot hold up a request behind - its frame or stream lock. With legacy peers, a separate request stream - preserves that isolation as described above. + its frame or stream lock. - Loss recovery on one stream does not require another stream to wait for that stream's missing bytes. diff --git a/docs/rust-overlay/txset-fetching.md b/docs/rust-overlay/txset-fetching.md index 193c26d48b..2900f9529a 100644 --- a/docs/rust-overlay/txset-fetching.md +++ b/docs/rust-overlay/txset-fetching.md @@ -6,15 +6,37 @@ it establishes demand with `RequestTxSet`. ## Wire formats and routes -Network messages use a four-byte big-endian frame length followed by a -`StellarMessage`. `GetTxSet` contains the 32-byte hash; `GeneralizedTxSet` -contains the set XDR. The response hash is computed from the canonical bytes -after strict decoding, without re-encoding the set. +Requests use a four-byte big-endian frame length followed by a +`StellarMessage::GetTxSet` containing the 32-byte hash. Responses require +`/stellar/txset/zstd/2.0.0` and contain an outer four-byte big-endian frame +length, a four-byte big-endian original XDR length, and exactly one zstd frame. +There is no raw encoding or legacy protocol fallback on this experimental branch. + +The decoder bounds both encoded and original sizes, requires one complete zstd +frame and an exact output length, and strict-parses `GeneralizedTransactionSet`. +The response hash is computed from the recovered canonical XDR without +re-encoding. The XDR limit remains 16 MiB minus four bytes; the encoded-frame +limit also permits zstd's worst-case expansion for incompressible input. Requests share the highest-priority control route with SCP. Responses use the -next-priority tx-set route. Legacy-only peers use separate request and response -streams under the old tx-set protocol, while SCP uses its old protocol. All -routes share QUIC connection limits. See [transport](transport.md). +next-priority tx-set route. All routes share QUIC connection limits. +See [transport](transport.md). + +## Encoding ownership + +Core sends `CacheTxSet` as soon as a locally constructed proposal's final XDR is +available, before the builder's roundtrip and final validation. Rust eagerly +compresses it at zstd level 1 on a blocking worker while Core continues those +checks. App awaits the prepared representation before processing another IPC +message or application event; the network dispatcher remains independent. +Repeated local publication of an already cached hash reuses its encoding. + +A receiving overlay retains the original encoded allocation while decompressing +and strict-parsing on a blocking worker. The cache shares an immutable +`Arc` containing both original XDR and encoded bytes. Peer responses +borrow those encoded bytes directly, so relays never recompress received sets. +Encoding is complete before cache insertion; sending has no lazy initialization +or compression decision. Core continues receiving uncompressed XDR over IPC. ## Core requests and network prefetches @@ -55,7 +77,7 @@ provide a timeout or automatic retry for a silent peer. ## Cache and externalization The cache holds up to 100 sets in App. Each entry contains its content hash, -canonical XDR, and ledger sequence. Capacity eviction uses insertion order; +canonical XDR, encoded response, and ledger sequence. Capacity eviction uses insertion order; updating an existing hash does not move it. `LedgerClosed` evicts entries older than `sequence - 12`, using saturating subtraction. Pending Core demand expires against the same retained-slot boundary. diff --git a/overlay/src/flood/txset.rs b/overlay/src/flood/txset.rs index 6a800aad33..95beb3c44b 100644 --- a/overlay/src/flood/txset.rs +++ b/overlay/src/flood/txset.rs @@ -12,7 +12,7 @@ pub type Hash256 = [u8; 32]; pub struct CachedTxSet { /// The TX set hash (SHA256 of XDR) pub hash: Hash256, - /// Immutable XDR and lazily encoded response shared by the cache and + /// Immutable XDR and prepared zstd response shared by the cache and /// pending peer responses. Fanout clones only the Arc. pub xdr: Arc, /// Ledger sequence this was built for @@ -86,7 +86,7 @@ mod tests { let tx_set = CachedTxSet { hash: [1u8; 32], - xdr: Arc::new(vec![1, 2, 3].into()), + xdr: Arc::new(TxSetData::from_local(vec![1, 2, 3]).unwrap()), ledger_seq: 100, }; @@ -106,12 +106,12 @@ mod tests { cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: Arc::new(vec![].into()), + xdr: Arc::new(TxSetData::from_local(vec![]).unwrap()), ledger_seq: 100, }); cache.insert(CachedTxSet { hash: [2u8; 32], - xdr: Arc::new(vec![].into()), + xdr: Arc::new(TxSetData::from_local(vec![]).unwrap()), ledger_seq: 200, }); @@ -127,12 +127,12 @@ mod tests { cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: Arc::new(vec![].into()), + xdr: Arc::new(TxSetData::from_local(vec![]).unwrap()), ledger_seq: 100, }); cache.insert(CachedTxSet { hash: [2u8; 32], - xdr: Arc::new(vec![].into()), + xdr: Arc::new(TxSetData::from_local(vec![]).unwrap()), ledger_seq: 101, }); @@ -141,7 +141,7 @@ mod tests { // Insert 3rd - should evict one cache.insert(CachedTxSet { hash: [3u8; 32], - xdr: Arc::new(vec![].into()), + xdr: Arc::new(TxSetData::from_local(vec![]).unwrap()), ledger_seq: 102, }); @@ -166,14 +166,14 @@ mod tests { cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: Arc::new(vec![1, 2, 3].into()), + xdr: Arc::new(TxSetData::from_local(vec![1, 2, 3]).unwrap()), ledger_seq: 100, }); // Insert with same hash but different data cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: Arc::new(vec![4, 5, 6].into()), + xdr: Arc::new(TxSetData::from_local(vec![4, 5, 6]).unwrap()), ledger_seq: 200, }); @@ -189,7 +189,7 @@ mod tests { cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: Arc::new(vec![1, 2, 3].into()), + xdr: Arc::new(TxSetData::from_local(vec![1, 2, 3]).unwrap()), ledger_seq: 100, }); assert_eq!(cache.len(), 1, "Cache is full"); @@ -198,7 +198,7 @@ mod tests { // not evict the entry or shrink the cache below capacity. cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: Arc::new(vec![4, 5, 6].into()), + xdr: Arc::new(TxSetData::from_local(vec![4, 5, 6]).unwrap()), ledger_seq: 102, }); @@ -217,12 +217,12 @@ mod tests { // Insert, then overwrite the same hash with a newer ledger_seq. cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: Arc::new(vec![1, 2, 3].into()), + xdr: Arc::new(TxSetData::from_local(vec![1, 2, 3]).unwrap()), ledger_seq: 100, }); cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: Arc::new(vec![4, 5, 6].into()), + xdr: Arc::new(TxSetData::from_local(vec![4, 5, 6]).unwrap()), ledger_seq: 200, }); @@ -240,12 +240,12 @@ mod tests { // cache exactly at capacity (not one over). cache.insert(CachedTxSet { hash: [2u8; 32], - xdr: Arc::new(vec![].into()), + xdr: Arc::new(TxSetData::from_local(vec![]).unwrap()), ledger_seq: 300, }); cache.insert(CachedTxSet { hash: [3u8; 32], - xdr: Arc::new(vec![].into()), + xdr: Arc::new(TxSetData::from_local(vec![]).unwrap()), ledger_seq: 400, }); diff --git a/overlay/src/flood/txset_encoding.rs b/overlay/src/flood/txset_encoding.rs index 34bc6d7e15..a9bab83f9f 100644 --- a/overlay/src/flood/txset_encoding.rs +++ b/overlay/src/flood/txset_encoding.rs @@ -1,32 +1,39 @@ -//! Cached TX set encoding for the compressed response protocol. +//! Immutable TX set bytes and their mandatory zstd response encoding. //! -//! Inside the usual length-prefixed frame: a big-endian u32 XDR length, -//! followed by one zstd frame. The high bit marks uncompressed XDR when -//! compression would not save space. Both encodings retain the legacy limit. -use std::{io, sync::Arc}; -use tokio::sync::OnceCell; +//! Inside the length-prefixed response: a big-endian u32 XDR length followed +//! by exactly one zstd frame. Only locally built sets are compressed; received +//! sets retain the original response bytes for forwarding. +use std::io; pub(crate) const MAX_TXSET_XDR_SIZE: usize = 16 * 1024 * 1024 - 4; -const RAW: u32 = 1 << 31; -/// One immutable allocation per cached set, shared by all peer sends. The -/// compressed representation is computed on demand once for the whole fanout. +/// Allow zstd's worst-case expansion while retaining the original XDR limit. +pub(crate) fn max_encoded_size() -> usize { + 4 + zstd::zstd_safe::compress_bound(MAX_TXSET_XDR_SIZE) +} + #[derive(Debug)] pub struct TxSetData { xdr: Vec, - compressed: OnceCell>>, + encoded: Vec, } -impl From> for TxSetData { - fn from(xdr: Vec) -> Self { - Self { - xdr, - compressed: OnceCell::new(), +impl TxSetData { + /// Compress a locally constructed set eagerly, on a blocking worker. + pub fn from_local(xdr: Vec) -> io::Result { + if xdr.len() > MAX_TXSET_XDR_SIZE { + return Err(io::Error::new( + io::ErrorKind::InvalidInput, + "TX set exceeds XDR limit", + )); } + let compressed = zstd::bulk::compress(&xdr, 1)?; + let mut encoded = Vec::with_capacity(4 + compressed.len()); + encoded.extend_from_slice(&(xdr.len() as u32).to_be_bytes()); + encoded.extend_from_slice(&compressed); + Ok(Self { xdr, encoded }) } -} -impl TxSetData { pub fn as_slice(&self) -> &[u8] { &self.xdr } @@ -39,62 +46,24 @@ impl TxSetData { self.xdr.is_empty() } - pub(crate) async fn encoded(self: &Arc) -> io::Result<([u8; 4], &[u8])> { - let compressed = self - .compressed - .get_or_try_init(|| async { - let data = Arc::clone(self); - // Compression must not occupy a Tokio network worker. Admission - // already bounds the number and raw bytes of outstanding sends. - tokio::task::spawn_blocking(move || compress(&data.xdr)) - .await - .map_err(io::Error::other)? - }) - .await?; - let length = self.len() as u32; - Ok(match compressed { - Some(bytes) => (length.to_be_bytes(), bytes), - None => ((length | RAW).to_be_bytes(), &self.xdr), - }) - } -} - -fn compress(xdr: &[u8]) -> io::Result>> { - if xdr.len() > MAX_TXSET_XDR_SIZE { - return Err(io::Error::new( - io::ErrorKind::InvalidInput, - "TX set exceeds wire limit", - )); - } - let mut bytes = zstd::bulk::compress(xdr, 1)?; - if bytes.len() >= xdr.len() { - return Ok(None); + /// Borrow the exact cached response; sending never invokes a compressor. + pub fn encoded(&self) -> &[u8] { + &self.encoded } - // bulk::compress reserves the worst-case size, approximately the raw - // length. Do not retain that spare allocation throughout the cache lifetime. - bytes.shrink_to_fit(); - Ok(Some(bytes)) } -pub(crate) fn decode(mut frame: Vec) -> io::Result> { +/// Decode on a blocking worker and retain the received allocation unchanged. +/// The caller must also strict-parse the recovered GeneralizedTransactionSet. +pub(crate) fn decode(frame: Vec) -> io::Result { let invalid = || io::Error::new(io::ErrorKind::InvalidData, "invalid TX set encoding"); - if frame.len() < 4 || frame.len() > MAX_TXSET_XDR_SIZE + 4 { + if frame.len() < 4 || frame.len() > max_encoded_size() { return Err(invalid()); } - let header = u32::from_be_bytes(frame[..4].try_into().unwrap()); - let length = (header & !RAW) as usize; - // Check before any decompressor or output allocation. Never trust the - // content size embedded in the compressed frame to allocate memory. + let length = u32::from_be_bytes(frame[..4].try_into().unwrap()) as usize; + // Check before creating a decoder or allocating its output. if length > MAX_TXSET_XDR_SIZE { return Err(invalid()); } - if header & RAW != 0 { - if frame.len() - 4 != length { - return Err(invalid()); - } - frame.drain(..4); - return Ok(frame); - } let compressed = &frame[4..]; if zstd::zstd_safe::find_frame_compressed_size(compressed).map_err(|_| invalid())? != compressed.len() @@ -103,93 +72,105 @@ pub(crate) fn decode(mut frame: Vec) -> io::Result> { } let mut decoder = zstd::bulk::Decompressor::new()?; decoder.window_log_max(24)?; - let output = decoder.decompress(compressed, length)?; - if output.len() != length { + let xdr = decoder.decompress(compressed, length)?; + if xdr.len() != length { return Err(invalid()); } - Ok(output) + Ok(TxSetData { + xdr, + encoded: frame, + }) } #[cfg(test)] mod tests { use super::*; use rand::{RngCore, SeedableRng}; + use std::sync::Arc; - async fn encode(xdr: Vec) -> Vec { - let data = Arc::new(TxSetData::from(xdr)); - let (header, bytes) = data.encoded().await.unwrap(); - [header.as_slice(), bytes].concat() - } - - #[tokio::test] - async fn roundtrip_and_size_bound_for_both_encodings() { - let mut random = vec![0; 64 * 1024]; + #[test] + fn always_compresses_including_empty_and_incompressible_sets() { + let mut random = vec![0; MAX_TXSET_XDR_SIZE]; rand::rngs::StdRng::seed_from_u64(17).fill_bytes(&mut random); for xdr in [vec![], vec![17], random, vec![0; MAX_TXSET_XDR_SIZE]] { - let frame = encode(xdr.clone()).await; - assert!(frame.len() <= xdr.len() + 4); - assert_eq!(decode(frame).unwrap(), xdr); + let data = TxSetData::from_local(xdr.clone()).unwrap(); + let frame = data.encoded().to_vec(); + assert!(frame.len() <= max_encoded_size()); + assert_eq!( + u32::from_be_bytes(frame[..4].try_into().unwrap()) as usize, + xdr.len() + ); + assert_eq!(zstd::bulk::decompress(&frame[4..], xdr.len()).unwrap(), xdr); + let received = decode(frame.clone()).unwrap(); + assert_eq!(received.as_slice(), xdr); + assert_eq!(received.encoded(), frame); } - let raw = encode(vec![17]).await; - assert_ne!(raw[0] & 0x80, 0); - let compressed = encode(vec![17; 1024]).await; - assert_eq!(compressed[0] & 0x80, 0); - assert!(compressed.len() < 100); } - #[tokio::test] - async fn concurrent_fanout_shares_one_encoded_allocation() { - let data = Arc::new(TxSetData::from(vec![13; 4 * 1024 * 1024])); - let results = futures::future::join_all((0..29).map(|_| data.encoded())).await; - let (header, bytes) = results[0].as_ref().unwrap(); - assert_eq!(header[0] & 0x80, 0); - for result in &results { - let (other_header, other_bytes) = result.as_ref().unwrap(); - assert_eq!(other_header, header); - assert!(std::ptr::eq(bytes.as_ptr(), other_bytes.as_ptr())); + #[test] + fn fanout_shares_the_prepared_encoding() { + let data = Arc::new(TxSetData::from_local(vec![13; 4 * 1024 * 1024]).unwrap()); + let peers: Vec<_> = (0..29).map(|_| Arc::clone(&data)).collect(); + for peer in peers { + assert!(std::ptr::eq( + data.encoded().as_ptr(), + peer.encoded().as_ptr() + )); } - let (_, again) = data.encoded().await.unwrap(); - assert!(std::ptr::eq(bytes.as_ptr(), again.as_ptr())); } - #[tokio::test] - async fn rejects_truncation_corruption_and_length_mismatch() { - let frame = encode(vec![13; 4096]).await; + #[test] + fn received_encoding_is_retained_without_recompression() { + let xdr = vec![13; 4 * 1024 * 1024]; + // Deliberately use another compression level. Relays must preserve these + // bytes even when their own encoder would produce a different frame. + let frame = [ + (xdr.len() as u32).to_be_bytes().as_slice(), + zstd::bulk::compress(&xdr, 7).unwrap().as_slice(), + ] + .concat(); + let allocation = frame.as_ptr(); + let expected = frame.clone(); + let received = decode(frame).unwrap(); + assert_eq!(received.as_slice(), xdr); + assert_eq!(received.encoded(), expected); + assert_eq!(received.encoded().as_ptr(), allocation); + } + + #[test] + fn rejects_truncation_corruption_length_mismatch_and_legacy_raw() { + let frame = TxSetData::from_local(vec![13; 4096]).unwrap().encoded; for end in 0..frame.len() { assert!(decode(frame[..end].to_vec()).is_err()); } let mut corrupt = frame.clone(); - corrupt[4] ^= 0xff; // Invalid zstd magic. + corrupt[4] ^= 0xff; assert!(decode(corrupt).is_err()); - for length in [0, 4095, 4097, MAX_TXSET_XDR_SIZE + 1] { + for length in [0, 4095, 4097, MAX_TXSET_XDR_SIZE + 1, 4096 | (1 << 31)] { let mut bad = frame.clone(); bad[..4].copy_from_slice(&(length as u32).to_be_bytes()); assert!(decode(bad).is_err()); } - // Exactly one zstd frame must consume the entire payload. let mut trailing = frame.clone(); trailing.push(0); assert!(decode(trailing).is_err()); let mut concatenated = frame.clone(); concatenated.extend_from_slice(&frame[4..]); assert!(decode(concatenated).is_err()); - let mut raw = encode(vec![19]).await; - raw.push(0); + let raw = [19u32.to_be_bytes().as_slice(), &[19; 19]].concat(); assert!(decode(raw).is_err()); } - #[tokio::test] - async fn compression_does_not_allow_oversized_raw_sets() { + #[test] + fn compression_does_not_allow_oversized_raw_sets() { let oversized = vec![0; MAX_TXSET_XDR_SIZE + 1]; - let data = Arc::new(TxSetData::from(oversized)); - assert!(data.encoded().await.is_err()); - // Even if its compressed bytes fit, an over-limit raw size is rejected. + assert!(TxSetData::from_local(oversized.clone()).is_err()); let frame = [ - (MAX_TXSET_XDR_SIZE as u32 + 1).to_be_bytes().as_slice(), - zstd::bulk::compress(data.as_slice(), 1).unwrap().as_slice(), + (oversized.len() as u32).to_be_bytes().as_slice(), + zstd::bulk::compress(&oversized, 1).unwrap().as_slice(), ] .concat(); assert!(decode(frame).is_err()); - assert!(decode(vec![0; MAX_TXSET_XDR_SIZE + 5]).is_err()); + assert!(decode(vec![0; max_encoded_size() + 1]).is_err()); } } diff --git a/overlay/src/libp2p_overlay.rs b/overlay/src/libp2p_overlay.rs index 551aa542a9..1150902a77 100644 --- a/overlay/src/libp2p_overlay.rs +++ b/overlay/src/libp2p_overlay.rs @@ -43,12 +43,10 @@ use tracing::{debug, error, info, trace, warn}; mod framed_io; // Protocol identifiers for dedicated streams -pub const SCP_PROTOCOL: StreamProtocol = StreamProtocol::new("/stellar/scp/1.0.0"); pub const CONTROL_PROTOCOL: StreamProtocol = StreamProtocol::new("/stellar/control/1.0.0"); pub const TX_PROTOCOL: StreamProtocol = StreamProtocol::new("/stellar/tx/1.0.0"); -pub const TXSET_PROTOCOL: StreamProtocol = StreamProtocol::new("/stellar/txset/1.0.0"); -pub const COMPRESSED_TXSET_PROTOCOL: StreamProtocol = - StreamProtocol::new("/stellar/txset/zstd/1.0.0"); +// This experimental protocol requires zstd for every transaction-set response. +pub const TXSET_PROTOCOL: StreamProtocol = StreamProtocol::new("/stellar/txset/zstd/2.0.0"); /// Message frame: 4-byte length prefix + payload /// Max message size: 16MB (for large TX sets) @@ -75,7 +73,7 @@ pub enum OverlayEvent { /// Received TX set response TxSetReceived { hash: [u8; 32], - data: Vec, + data: Arc, from: PeerId, /// Slot the set was requested for; None if the response was /// unsolicited (no pending request recorded). @@ -135,15 +133,11 @@ struct PeerOutboundStreams { scp: Mutex>, tx: Mutex>, txset: Mutex>, - // Only opened for peers that reject the combined control protocol. Their - // requests still need isolation from response writes, using the old ID. - legacy_txset_request: Mutex>, } struct OutboundStream { stream: Stream, - // Remember negotiation on the cached stream, including after reopening. - // Legacy peers accept requests only on their TxSet protocol. + #[cfg(test)] protocol: StreamProtocol, } @@ -153,7 +147,6 @@ impl PeerOutboundStreams { scp: Mutex::new(None), tx: Mutex::new(None), txset: Mutex::new(None), - legacy_txset_request: Mutex::new(None), } } } @@ -541,103 +534,23 @@ impl StellarOverlay { self.run_event_loop().await; } - pub async fn run_event_loop(self) { - self.run_event_loop_with_control( - #[cfg(test)] - true, - #[cfg(test)] - true, - ) - .await; - } - - // Test-only switches exercise real negotiation with legacy peers. - // Production always advertises control and compressed responses. - async fn run_event_loop_with_control( - mut self, - #[cfg(test)] accept_control: bool, - #[cfg(test)] accept_compressed: bool, - ) { - #[cfg(not(test))] - let accept_compressed = true; - #[cfg(not(test))] - let accept_control = true; - // Accept incoming streams for each protocol - let scp_incoming = match self.control.accept(SCP_PROTOCOL) { - Ok(incoming) => incoming, - Err(e) => { - error!( - "Failed to accept SCP protocol streams: {:?}. Overlay cannot function.", - e - ); - return; - } - }; - let tx_incoming = match self.control.accept(TX_PROTOCOL) { - Ok(incoming) => incoming, - Err(e) => { - error!( - "Failed to accept TX protocol streams: {:?}. Overlay cannot function.", - e - ); - return; - } - }; - let txset_incoming = match self.control.accept(TXSET_PROTOCOL) { - Ok(incoming) => incoming, - Err(e) => { - error!( - "Failed to accept TxSet protocol streams: {:?}. Overlay cannot function.", - e - ); - return; - } - }; - - let control_incoming = if accept_control { - match self.control.accept(CONTROL_PROTOCOL) { - Ok(incoming) => Some(incoming), - Err(e) => { - error!("Failed to accept control protocol: {:?}", e); - return; - } - } - } else { - None - }; - - let compressed_incoming = if accept_compressed { - match self.control.accept(COMPRESSED_TXSET_PROTOCOL) { - Ok(incoming) => Some(incoming), - Err(e) => { - error!("Failed to accept compressed TxSet protocol: {:?}", e); - return; - } - } - } else { - None - }; - - // Spawn inbound stream handlers + pub async fn run_event_loop(mut self) { + let control_incoming = self + .control + .accept(CONTROL_PROTOCOL) + .expect("control protocol registered once"); + let tx_incoming = self + .control + .accept(TX_PROTOCOL) + .expect("TX protocol registered once"); + let txset_incoming = self + .control + .accept(TXSET_PROTOCOL) + .expect("TxSet protocol registered once"); let state = self.state.clone(); - tokio::spawn(handle_inbound_scp_streams( - scp_incoming, - state.clone(), - false, - )); - if let Some(incoming) = control_incoming { - tokio::spawn(handle_inbound_scp_streams(incoming, state.clone(), true)); - } + tokio::spawn(handle_inbound_scp_streams(control_incoming, state.clone())); tokio::spawn(handle_inbound_tx_streams(tx_incoming, state.clone())); - tokio::spawn(handle_inbound_txset_streams( - txset_incoming, - state.clone(), - false, - )); - - if let Some(incoming) = compressed_incoming { - tokio::spawn(handle_inbound_txset_streams(incoming, state.clone(), true)); - } + tokio::spawn(handle_inbound_txset_streams(txset_incoming, state.clone())); // Spawn INV/GETDATA housekeeping task tokio::spawn(inv_getdata_housekeeping_task(state.clone())); @@ -1189,8 +1102,9 @@ async fn send_txset_response( peer ); - match send_peer_frames(&state, peer, StreamType::TxSet, PeerFrames::TxSet(&data)).await { - Ok(bytes) => { + let bytes = data.encoded().len(); + match send_to_peer_stream(&state, peer, StreamType::TxSet, data.encoded()).await { + Ok(()) => { state.metrics.send_txset.fetch_add(1, Ordering::Relaxed); state.metrics.message_write.fetch_add(1, Ordering::Relaxed); state @@ -1275,7 +1189,6 @@ enum StreamType { Tx, TxSet, TxSetRequest, - LegacyTxSetRequest, } impl StreamType { @@ -1283,48 +1196,37 @@ impl StreamType { match self { StreamType::Control | StreamType::TxSetRequest => CONTROL_PROTOCOL, StreamType::Tx => TX_PROTOCOL, - StreamType::TxSet => COMPRESSED_TXSET_PROTOCOL, - StreamType::LegacyTxSetRequest => TXSET_PROTOCOL, + StreamType::TxSet => TXSET_PROTOCOL, } } fn priority(self) -> i32 { match self { - Self::Control | Self::TxSetRequest | Self::LegacyTxSetRequest => 2, + Self::Control | Self::TxSetRequest => 2, Self::TxSet => 1, Self::Tx => 0, } } } -/// Negotiate the route, then set actual QUIC priority before application bytes -/// are written. Only an explicit unsupported-protocol response permits fallback. +/// Open the required protocol and set QUIC priority before application bytes. async fn open_peer_stream( mut control: Control, peer: PeerId, kind: StreamType, ) -> io::Result { - let mut protocol = kind.protocol(); - let result = control.open_stream(peer, protocol.clone()).await; - let stream = match result { - Err(libp2p_stream::OpenStreamError::UnsupportedProtocol(_)) - if protocol == CONTROL_PROTOCOL => - { - protocol = SCP_PROTOCOL; - control.open_stream(peer, protocol.clone()).await - } - Err(libp2p_stream::OpenStreamError::UnsupportedProtocol(_)) - if protocol == COMPRESSED_TXSET_PROTOCOL => - { - protocol = TXSET_PROTOCOL; - control.open_stream(peer, protocol.clone()).await - } - result => result, - } - .map_err(|e| io::Error::new(io::ErrorKind::NotConnected, e))?; + let protocol = kind.protocol(); + let stream = control + .open_stream(peer, protocol.clone()) + .await + .map_err(|e| io::Error::new(io::ErrorKind::NotConnected, e))?; stream.set_priority(kind.priority())?; debug!(%peer, %protocol, priority = kind.priority(), "Opened outbound stream"); - Ok(OutboundStream { stream, protocol }) + Ok(OutboundStream { + stream, + #[cfg(test)] + protocol, + }) } /// Send message to a specific peer's stream only if already open (for flooding) @@ -1347,7 +1249,6 @@ async fn try_send_to_existing_stream( StreamType::Control | StreamType::TxSetRequest => &peer_streams.scp, StreamType::Tx => &peer_streams.tx, StreamType::TxSet => &peer_streams.txset, - StreamType::LegacyTxSetRequest => &peer_streams.legacy_txset_request, }; let mut stream_guard = stream_mutex.lock().await; @@ -1392,45 +1293,7 @@ async fn send_to_peer_stream_parts( stream_type: StreamType, parts: &[&[u8]], ) -> io::Result<()> { - send_peer_frames( - state, - peer_id, - stream_type, - PeerFrames::Plain(framed_io::Frames::One(parts)), - ) - .await - .map(|_| ()) -} - -// Select response encoding using the protocol actually negotiated on this -// stream, including after reconnect. Other routes keep their original framing. -#[derive(Clone, Copy)] -enum PeerFrames<'a> { - Plain(framed_io::Frames<'a>), - TxSet(&'a Arc), -} - -impl PeerFrames<'_> { - async fn write(self, outbound: &mut OutboundStream) -> io::Result { - match self { - Self::Plain(frames) => { - frames.write(&mut outbound.stream).await?; - Ok(0) - } - Self::TxSet(data) => { - let (header, payload) = if outbound.protocol == COMPRESSED_TXSET_PROTOCOL { - data.encoded().await? - } else { - ( - (stellar_xdr::MessageType::GeneralizedTxSet as i32).to_be_bytes(), - data.as_slice(), - ) - }; - framed_io::write_frame_parts(&mut outbound.stream, &[&header, payload]).await?; - Ok(4 + payload.len()) - } - } - } + send_peer_frames(state, peer_id, stream_type, framed_io::Frames::One(parts)).await } /// Write `frames` to the peer's stream for `stream_type`, opening it if @@ -1446,8 +1309,8 @@ async fn send_peer_frames( state: &SharedState, peer_id: PeerId, stream_type: StreamType, - frames: PeerFrames<'_>, -) -> io::Result { + frames: framed_io::Frames<'_>, +) -> io::Result<()> { // Retry up to 2 times (3 attempts total) for reliability const MAX_RETRIES: usize = 2; @@ -1469,7 +1332,6 @@ async fn send_peer_frames( StreamType::Control | StreamType::TxSetRequest => &peer_streams.scp, StreamType::Tx => &peer_streams.tx, StreamType::TxSet => &peer_streams.txset, - StreamType::LegacyTxSetRequest => &peer_streams.legacy_txset_request, }; let mut stream_guard = stream_mutex.lock().await; @@ -1522,20 +1384,8 @@ async fn send_peer_frames( } let stream = stream_guard.as_mut().unwrap(); - if stream_type == StreamType::TxSetRequest && stream.protocol != CONTROL_PROTOCOL { - // Never send a request to an old SCP reader: it would silently - // discard it. Keep requests isolated from legacy response writes. - drop(stream_guard); - return Box::pin(send_peer_frames( - state, - peer_id, - StreamType::LegacyTxSetRequest, - frames, - )) - .await; - } - match frames.write(stream).await { - Ok(bytes) => return Ok(bytes), + match frames.write(&mut stream.stream).await { + Ok(()) => return Ok(()), Err(e) => { // Clear the broken stream *stream_guard = None; @@ -1642,14 +1492,21 @@ async fn send_inv_batch(state: &Arc, peer: PeerId, batch: InvBatch) /// Read length-prefixed frame from stream async fn read_framed(stream: &mut R) -> io::Result> { + read_framed_with_limit(stream, MAX_MESSAGE_SIZE).await +} + +async fn read_framed_with_limit( + stream: &mut R, + limit: usize, +) -> io::Result> { let mut len_buf = [0u8; 4]; stream.read_exact(&mut len_buf).await?; let len = u32::from_be_bytes(len_buf) as usize; - if len > MAX_MESSAGE_SIZE { + if len > limit { return Err(io::Error::new( io::ErrorKind::InvalidData, - format!("message too large: {} > {}", len, MAX_MESSAGE_SIZE), + format!("message too large: {} > {}", len, limit), )); } @@ -1659,11 +1516,7 @@ async fn read_framed(stream: &mut R) -> io::Resul } /// Handle inbound SCP streams from peers -async fn handle_inbound_scp_streams( - mut incoming: IncomingStreams, - state: Arc, - accepts_txset_requests: bool, -) { +async fn handle_inbound_scp_streams(mut incoming: IncomingStreams, state: Arc) { while let Some((peer_id, mut stream)) = incoming.next().await { info!("SCP_STREAM: Accepted inbound SCP stream from {}", peer_id); state @@ -1692,9 +1545,7 @@ async fn handle_inbound_scp_streams( }; let scp_envelope = match message { - stellar_xdr::StellarMessage::GetTxSet(hash) - if accepts_txset_requests => - { + stellar_xdr::StellarMessage::GetTxSet(hash) => { handle_txset_request(&state, peer_id, hash.0); continue; } @@ -2058,10 +1909,8 @@ async fn serve_getdata(state: &SharedState, peer: PeerId, hashes: Vec<[u8; 32]>) batch.extend_from_slice(part); } } - let frames = PeerFrames::Plain(framed_io::Frames::Batch(&batch)); - let result = send_peer_frames(state, peer, StreamType::Tx, frames) - .await - .map(|_| ()); + let frames = framed_io::Frames::Batch(&batch); + let result = send_peer_frames(state, peer, StreamType::Tx, frames).await; record_tx_response_write(state, peer, result, txs.len(), bytes - 4 * txs.len()) }; if !written { @@ -2223,7 +2072,7 @@ async fn handle_tx_response(state: &Arc, peer_id: &PeerId, tx: Arc< state.metrics.update_recv_transaction_max(elapsed_us); } -/// Both the control protocol and the legacy TxSet protocol accept requests. +/// Requests arrive on the control stream, separately from bulk responses. fn handle_txset_request(state: &SharedState, peer_id: PeerId, hash: [u8; 32]) { info!( "TXSET_REQ_IN: Received TxSet request for {:02x?}... from {}", @@ -2242,8 +2091,8 @@ fn handle_txset_request(state: &SharedState, peer_id: PeerId, hash: [u8; 32]) { } /// Deliver strict-decoded XDR identically for both response encodings. -async fn deliver_txset(state: &SharedState, peer_id: PeerId, txset_data: Vec) { - let hash = crate::xdr::sha256_hash(&txset_data); +async fn deliver_txset(state: &SharedState, peer_id: PeerId, txset_data: Arc) { + let hash = crate::xdr::sha256_hash(txset_data.as_slice()); // Clear pending request flag and measure fetch latency let slot = { @@ -2284,11 +2133,7 @@ async fn deliver_txset(state: &SharedState, peer_id: PeerId, txset_data: Vec } } -async fn handle_inbound_txset_streams( - mut incoming: IncomingStreams, - state: Arc, - compressed: bool, -) { +async fn handle_inbound_txset_streams(mut incoming: IncomingStreams, state: Arc) { while let Some((peer_id, mut stream)) = incoming.next().await { debug!("Accepted inbound TxSet stream from {}", peer_id); state.metrics.inbound_live.fetch_add(1, Ordering::Relaxed); @@ -2296,61 +2141,31 @@ async fn handle_inbound_txset_streams( tokio::spawn(async move { loop { - match read_framed(&mut stream).await { + match read_framed_with_limit( + &mut stream, + crate::flood::txset_encoding::max_encoded_size(), + ) + .await + { Ok(data) => { state.metrics.message_read.fetch_add(1, Ordering::Relaxed); state .metrics .byte_read .fetch_add(data.len() as u64, Ordering::Relaxed); - if compressed { - // Decode and strict-parse outside the network runtime. Each - // stream awaits completion before reading another frame. - let decoded = tokio::task::spawn_blocking(move || { - use stellar_xdr::{GeneralizedTransactionSet, Limits, ReadXdr}; - let xdr = crate::flood::txset_encoding::decode(data)?; - GeneralizedTransactionSet::from_xdr(&xdr, Limits::none()) - .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?; - Ok::<_, io::Error>(xdr) - }) - .await; - match decoded { - Ok(Ok(xdr)) => deliver_txset(&state, peer_id, xdr).await, - result => warn!("TXSET_PARSE_ERR: Dropping malformed compressed TxSet from {}: {:?}", peer_id, result), - } - continue; - } - let message = match crate::xdr::parse_stellar_message(&data) { - Ok(message) => message, - Err(e) => { - warn!( - "TXSET_PARSE_ERR: Dropping malformed TxSet stream message from {}: {}", - peer_id, e - ); - continue; - } - }; - - match message { - stellar_xdr::StellarMessage::GetTxSet(hash) => { - handle_txset_request(&state, peer_id, hash.0); - } - stellar_xdr::StellarMessage::GeneralizedTxSet(_tx_set) => { - // The message was strict-decoded above, so the - // bytes after the 4-byte discriminant are the - // canonical tx set; hash the original bytes - // rather than re-encoding. - let txset_data = data[4..].to_vec(); - deliver_txset(&state, peer_id, txset_data).await; - } - other => { - warn!( - "TXSET_PARSE_ERR: Dropping unexpected {} on TxSet stream from {}", - other.name(), - peer_id - ); - } - } + // Preserve the received encoding through verification and + // cache insertion. Forwarding never compresses it again. + let decoded = tokio::task::spawn_blocking(move || { + use stellar_xdr::{GeneralizedTransactionSet, Limits, ReadXdr}; + let data = crate::flood::txset_encoding::decode(data)?; + GeneralizedTransactionSet::from_xdr(data.as_slice(), Limits::none()) + .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?; + Ok::<_, io::Error>(Arc::new(data)) + }) + .await; + match decoded { + Ok(Ok(data)) => deliver_txset(&state, peer_id, data).await, + result => warn!("TXSET_PARSE_ERR: Dropping malformed compressed TxSet from {}: {:?}", peer_id, result), } } Err(e) => { state.metrics.error_read.fetch_add(1, Ordering::Relaxed); @@ -3106,7 +2921,7 @@ mod tests { request_received = true; // Node1 responds with TxSet data - handle1.send_txset(hash, Arc::new(txset_data.clone().into()), from).await; + handle1.send_txset(hash, Arc::new(TxSetData::from_local(txset_data.clone()).unwrap()), from).await; } } _ = tokio::time::sleep(Duration::from_millis(10)) => {} @@ -3126,7 +2941,7 @@ mod tests { Some(event) = events2.recv() => { if let OverlayEvent::TxSetReceived { hash, data, .. } = event { assert_eq!(hash, requested_hash); - assert_eq!(data, txset_data); + assert_eq!(data.as_slice(), txset_data); response_received = true; } } @@ -3890,7 +3705,7 @@ async fn test_txset_request_and_response() { Some(event) = events1.recv() => { if let OverlayEvent::TxSetRequested { hash, from } = event { assert_eq!(hash, requested_hash, "Request should have correct hash"); - handle1.send_txset(hash, Arc::new(txset_data.clone().into()), from).await; + handle1.send_txset(hash, Arc::new(TxSetData::from_local(txset_data.clone()).unwrap()), from).await; responded = true; } } @@ -3911,7 +3726,7 @@ async fn test_txset_request_and_response() { Some(event) = events2.recv() => { if let OverlayEvent::TxSetReceived { hash, data, .. } = event { assert_eq!(hash, requested_hash, "Received hash should match"); - assert_eq!(data, txset_data, "Received data should match"); + assert_eq!(data.as_slice(), txset_data, "Received data should match"); received = true; } } @@ -4007,7 +3822,7 @@ async fn test_txset_multiple_concurrent_requests() { received_hashes.insert(hash); // Respond to each request let data = format!("txset for {:?}", &hash[..4]).into_bytes(); - handle1.send_txset(hash, Arc::new(data.into()), from).await; + handle1.send_txset(hash, Arc::new(TxSetData::from_local(data).unwrap()), from).await; } } _ = tokio::time::sleep(Duration::from_millis(10)) => {} @@ -4342,7 +4157,11 @@ async fn test_concurrent_scp_and_txset_writes_to_same_peer() { let txset_task = tokio::spawn(async move { txset_started_clone.store(true, Ordering::SeqCst); handle1_txset - .send_txset(txset_hash, Arc::new(txset_data.into()), peer2_id) + .send_txset( + txset_hash, + Arc::new(TxSetData::from_local(txset_data).unwrap()), + peer2_id, + ) .await; }); @@ -4470,7 +4289,11 @@ async fn test_pending_txset_cleanup_on_disconnect() { // Now have node2 respond with the TxSet // This verifies the pending cleanup works when response is received handle2 - .send_txset(txset_hash, Arc::new(txset_data.clone().into()), peer1_id) + .send_txset( + txset_hash, + Arc::new(TxSetData::from_local(txset_data.clone()).unwrap()), + peer1_id, + ) .await; // Verify node1 receives the TxSet response @@ -4480,7 +4303,7 @@ async fn test_pending_txset_cleanup_on_disconnect() { tokio::select! { Some(event) = events1.recv() => { if let OverlayEvent::TxSetReceived { hash, data, .. } = event { - if hash == txset_hash && data == txset_data { + if hash == txset_hash && data.as_slice() == txset_data { got_response = true; } } diff --git a/overlay/src/libp2p_overlay/dispatch_tests.rs b/overlay/src/libp2p_overlay/dispatch_tests.rs index 8f5e707dde..02f75f6b2c 100644 --- a/overlay/src/libp2p_overlay/dispatch_tests.rs +++ b/overlay/src/libp2p_overlay/dispatch_tests.rs @@ -26,7 +26,9 @@ async fn dispatcher_with_blocked_write(command: &str) { match command { "txset" => { let (hash, data) = test_txset_xdr(1); - handle.send_txset(hash, Arc::new(data.into()), peer).await; + handle + .send_txset(hash, Arc::new(TxSetData::from_local(data).unwrap()), peer) + .await; } "fetch" => handle.fetch_txset([1; 32], 1).await, // Awaiting a direct send must preserve ordering within an SCP-state @@ -90,14 +92,6 @@ struct TestNode { impl TestNode { async fn start() -> Self { - Self::start_with_control(true).await - } - - async fn start_with_control(accept_control: bool) -> Self { - Self::start_with_protocols(accept_control, true).await - } - - async fn start_with_protocols(accept_control: bool, accept_compressed: bool) -> Self { let (handle, events, admissions, mut overlay) = create_test_overlay(Keypair::generate_ed25519(), Arc::new(OverlayMetrics::new())) .unwrap(); @@ -120,8 +114,7 @@ impl TestNode { }) .await .expect("listener did not start"); - let task = - tokio::spawn(overlay.run_event_loop_with_control(accept_control, accept_compressed)); + let task = tokio::spawn(overlay.run_event_loop()); Self { handle, events, @@ -593,65 +586,116 @@ async fn inv_batches_completed_by_relay_or_local_broadcast_reach_the_peer() { } #[tokio::test] -async fn txset_encoding_negotiates_with_legacy_peers_and_after_reopening() { - for (control, compressed) in [(true, true), (true, false), (false, false)] { - let mut sender = TestNode::start().await; - let mut receiver = TestNode::start_with_protocols(control, compressed).await; - sender.connect(&receiver).await; - let streams = sender.streams_to(receiver.peer).await; - let (hash, xdr) = large_txset(); - let shared = Arc::new(TxSetData::from(xdr.clone())); - for reopen in [false, true] { - if reopen { - streams.txset.lock().await.take(); +async fn txset_protocol_is_mandatory_and_survives_reopening() { + let mut sender = TestNode::start().await; + let mut receiver = TestNode::start().await; + sender.connect(&receiver).await; + let streams = sender.streams_to(receiver.peer).await; + for legacy in ["/stellar/txset/1.0.0", "/stellar/txset/zstd/1.0.0"] { + let mut control = sender.state.control.clone(); + assert!(matches!( + control + .open_stream(receiver.peer, StreamProtocol::new(legacy)) + .await, + Err(libp2p_stream::OpenStreamError::UnsupportedProtocol(_)) + )); + } + let (hash, xdr) = large_txset(); + let shared = Arc::new(TxSetData::from_local(xdr.clone()).unwrap()); + for reopen in [false, true] { + if reopen { + streams.txset.lock().await.take(); + } + send_to_peer_stream( + &sender.state, + receiver.peer, + StreamType::TxSet, + shared.encoded(), + ) + .await + .unwrap(); + assert!(shared.encoded().len() < xdr.len() / 2); + { + let guard = streams.txset.lock().await; + let outbound = guard.as_ref().unwrap(); + assert_eq!(outbound.protocol, TXSET_PROTOCOL); + assert_eq!(outbound.stream.priority().unwrap(), 1); + } + tokio::time::timeout(Duration::from_secs(10), async { + loop { + if let OverlayEvent::TxSetReceived { + hash: got, data, .. + } = receiver.events.recv().await.unwrap() + { + assert_eq!(got, hash); + assert_eq!(data.as_slice(), xdr); + assert_eq!(data.encoded(), shared.encoded()); + break; + } } - let bytes = send_peer_frames( - &sender.state, - receiver.peer, - StreamType::TxSet, - PeerFrames::TxSet(&shared), - ) - .await - .unwrap(); - if compressed { - assert!( - bytes < xdr.len() / 2, - "large responses must use compressed bytes" - ); - } else { - assert_eq!(bytes, xdr.len() + 4); + }) + .await + .expect("compressed response was not delivered intact"); + } + sender.stop().await; + receiver.stop().await; +} + +#[tokio::test] +async fn relay_forwards_original_compressed_bytes() { + let mut leader = TestNode::start().await; + let mut relay = TestNode::start().await; + let mut follower = TestNode::start().await; + leader.connect(&relay).await; + relay.connect(&follower).await; + let (hash, xdr) = large_txset(); + // A different zstd level makes accidental re-encoding detectable. + let encoded = [ + (xdr.len() as u32).to_be_bytes().as_slice(), + zstd::bulk::compress(&xdr, 7).unwrap().as_slice(), + ] + .concat(); + assert_ne!( + encoded, + TxSetData::from_local(xdr.clone()).unwrap().encoded() + ); + send_to_peer_stream(&leader.state, relay.peer, StreamType::TxSet, &encoded) + .await + .unwrap(); + let received = tokio::time::timeout(Duration::from_secs(10), async { + loop { + if let OverlayEvent::TxSetReceived { + hash: got, data, .. + } = relay.events.recv().await.unwrap() + { + assert_eq!(got, hash); + assert_eq!(data.encoded(), encoded); + break data; } + } + }) + .await + .unwrap(); + // Forward the very object a receiving application puts in its cache. + relay.handle.send_txset(hash, received, follower.peer).await; + tokio::time::timeout(Duration::from_secs(10), async { + loop { + if let OverlayEvent::TxSetReceived { + hash: got, data, .. + } = follower.events.recv().await.unwrap() { - let guard = streams.txset.lock().await; - let outbound = guard.as_ref().unwrap(); - assert_eq!( - outbound.protocol, - if compressed { - COMPRESSED_TXSET_PROTOCOL - } else { - TXSET_PROTOCOL - } - ); - assert_eq!(outbound.stream.priority().unwrap(), 1); + assert_eq!(got, hash); + assert_eq!(data.as_slice(), xdr); + assert_eq!(data.encoded(), encoded); + break; } - tokio::time::timeout(Duration::from_secs(10), async { - loop { - if let OverlayEvent::TxSetReceived { - hash: got, data, .. - } = receiver.events.recv().await.unwrap() - { - assert_eq!(got, hash); - assert_eq!(data, xdr); - break; - } - } - }) - .await - .expect("negotiated response was not delivered intact"); } - sender.stop().await; - receiver.stop().await; - } + }) + .await + .unwrap(); + leader.stop().await; + relay.stop().await; + follower.stop().await; } #[tokio::test] @@ -660,25 +704,36 @@ async fn malformed_compressed_txsets_are_dropped_without_losing_next_frame() { let mut receiver = TestNode::start().await; sender.connect(&receiver).await; // Well-formed compression is insufficient: XDR must also strict-decode. - let malformed = Arc::new(TxSetData::from(vec![0xff; 1000])); - send_peer_frames( + let malformed = Arc::new(TxSetData::from_local(vec![0xff; 1000]).unwrap()); + send_to_peer_stream( &sender.state, receiver.peer, StreamType::TxSet, - PeerFrames::TxSet(&malformed), + malformed.encoded(), ) .await .unwrap(); let (hash, xdr) = test_txset_xdr(19); - // The uncompressed representation on the new protocol is also accepted. + let valid = TxSetData::from_local(xdr.clone()).unwrap(); + // The old raw escape is rejected, as are corrupt compressed payloads. let raw = [ ((xdr.len() as u32) | (1 << 31)).to_be_bytes().as_slice(), &xdr, ] .concat(); - send_to_peer_stream(&sender.state, receiver.peer, StreamType::TxSet, &raw) - .await - .unwrap(); + for bad in [raw, vec![0xff; 20]] { + send_to_peer_stream(&sender.state, receiver.peer, StreamType::TxSet, &bad) + .await + .unwrap(); + } + send_to_peer_stream( + &sender.state, + receiver.peer, + StreamType::TxSet, + valid.encoded(), + ) + .await + .unwrap(); tokio::time::timeout(Duration::from_secs(5), async { loop { if let OverlayEvent::TxSetReceived { @@ -686,7 +741,7 @@ async fn malformed_compressed_txsets_are_dropped_without_losing_next_frame() { } = receiver.events.recv().await.unwrap() { assert_eq!(got, hash, "malformed XDR was forwarded"); - assert_eq!(data, xdr); + assert_eq!(data.as_slice(), xdr); break; } } @@ -886,7 +941,11 @@ async fn blocked_peer_does_not_delay_other_txsets_or_scp_delivery() { let (hash, data) = large_txset(); sender .handle - .send_txset(hash, Arc::new(data.clone().into()), slow.peer) + .send_txset( + hash, + Arc::new(TxSetData::from_local(data.clone()).unwrap()), + slow.peer, + ) .await; // Also exercise reopening: this write can complete only if the dispatcher @@ -895,14 +954,18 @@ async fn blocked_peer_does_not_delay_other_txsets_or_scp_delivery() { healthy_streams.txset.lock().await.take(); sender .handle - .send_txset(hash, Arc::new(data.clone().into()), healthy.peer) + .send_txset( + hash, + Arc::new(TxSetData::from_local(data.clone()).unwrap()), + healthy.peer, + ) .await; let (second_hash, second_data) = test_txset_xdr(2); sender .handle .send_txset( second_hash, - Arc::new(second_data.clone().into()), + Arc::new(TxSetData::from_local(second_data.clone()).unwrap()), healthy.peer, ) .await; @@ -924,8 +987,8 @@ async fn blocked_peer_does_not_delay_other_txsets_or_scp_delivery() { _ => {} } } - assert_eq!(received.get(&hash), Some(&data)); - assert_eq!(received.get(&second_hash), Some(&second_data)); + assert_eq!(received.get(&hash).unwrap().as_slice(), data); + assert_eq!(received.get(&second_hash).unwrap().as_slice(), second_data); loop { match slow.events.recv().await.unwrap() { OverlayEvent::ScpReceived { envelope, .. } if envelope == scp => break, @@ -949,7 +1012,7 @@ async fn blocked_peer_does_not_delay_other_txsets_or_scp_delivery() { } = slow.events.recv().await.unwrap() { assert_eq!(received_hash, hash); - assert_eq!(received_data, data); + assert_eq!(received_data.as_slice(), data); break; } } @@ -977,7 +1040,7 @@ async fn txset_fetch_reaches_peer_while_response_to_same_peer_is_blocked() { .handle .send_txset( response_hash, - Arc::new(response_data.clone().into()), + Arc::new(TxSetData::from_local(response_data.clone()).unwrap()), receiver.peer, ) .await; @@ -1025,7 +1088,7 @@ async fn txset_fetch_reaches_peer_while_response_to_same_peer_is_blocked() { receiver.events.recv().await.unwrap() { assert_eq!(hash, response_hash); - assert_eq!(data, response_data); + assert_eq!(data.as_slice(), response_data); break; } } @@ -1048,15 +1111,14 @@ async fn quic_transport_priorities_are_applied_to_each_route_and_reopening() { let guard = mutex.lock().await; assert_eq!(guard.as_ref().unwrap().stream.priority().unwrap(), expected); } - assert!(streams.legacy_txset_request.lock().await.is_none()); streams.txset.lock().await.take(); let (hash, data) = test_txset_xdr(1); // Await the actual write, rather than command enqueue, to observe reopening. - send_peer_frames( + send_to_peer_stream( &sender.state, receiver.peer, StreamType::TxSet, - PeerFrames::TxSet(&Arc::new(data.clone().into())), + TxSetData::from_local(data.clone()).unwrap().encoded(), ) .await .unwrap(); @@ -1088,83 +1150,6 @@ async fn quic_transport_priorities_are_applied_to_each_route_and_reopening() { receiver.stop().await; } -#[tokio::test] -async fn legacy_peer_receives_scp_and_fetches_on_its_supported_routes() { - let mut sender = TestNode::start().await; - // This peer advertises only the old protocols, and its SCP reader rejects - // GetTxSet. A silent send on the wrong route therefore fails this test. - let mut legacy = TestNode::start_with_control(false).await; - sender.connect(&legacy).await; - let streams = sender.streams_to(legacy.peer).await; - let blocked_response = streams.txset.lock().await; - // Legacy compatibility must preserve request isolation, including when - // negotiation and request streams need reopening during a blocked response. - for id in [17, 18] { - if id == 18 { - streams.scp.lock().await.take(); - streams.legacy_txset_request.lock().await.take(); - } - let hash = [id; 32]; - sender.handle.record_txset_source(hash, legacy.peer).await; - sender.handle.fetch_txset(hash, id as u32).await; - let scp = test_scp_envelope_xdr(id as u64); - sender.handle.broadcast_scp(scp.clone()).await; - tokio::time::timeout(Duration::from_secs(2), async { - let mut got_request = false; - let mut got_scp = false; - while !got_request || !got_scp { - match legacy.events.recv().await.unwrap() { - OverlayEvent::TxSetRequested { hash: h, from } => { - assert_eq!(h, hash); - assert_eq!(from, sender.peer); - got_request = true; - } - OverlayEvent::ScpReceived { envelope, .. } if envelope == scp => got_scp = true, - _ => {} - } - } - }) - .await - .expect("legacy SCP or fetch waited for a blocked response or used an unsupported route"); - for (mutex, protocol) in [ - (&streams.scp, SCP_PROTOCOL), - (&streams.legacy_txset_request, TXSET_PROTOCOL), - ] { - let guard = mutex.lock().await; - let stream = guard.as_ref().unwrap(); - assert_eq!(stream.protocol, protocol); - assert_eq!(stream.stream.priority().unwrap(), 2); - } - } - drop(blocked_response); - - // Updated receivers still understand requests arriving on the old route. - let hash = [17; 32]; - send_to_peer_stream( - &legacy.state, - sender.peer, - StreamType::LegacyTxSetRequest, - &crate::xdr::frame_get_tx_set(hash), - ) - .await - .unwrap(); - tokio::time::timeout(Duration::from_secs(2), async { - loop { - if let OverlayEvent::TxSetRequested { hash: h, from } = - sender.events.recv().await.unwrap() - { - assert_eq!(h, hash); - assert_eq!(from, legacy.peer); - break; - } - } - }) - .await - .unwrap(); - sender.stop().await; - legacy.stop().await; -} - async fn bulk_send_admission_is_bounded(byte_limit: bool) { let (mut handle, _events, _admissions, overlay) = create_test_overlay(Keypair::generate_ed25519(), Arc::new(OverlayMetrics::new())).unwrap(); @@ -1185,9 +1170,13 @@ async fn bulk_send_admission_is_bounded(byte_limit: bool) { handle.txset_send_bytes = Arc::new(Semaphore::new(bytes)); let mut task = tokio::spawn(async move { overlay.run("127.0.0.1", 0).await }); handle - .send_txset(hash, Arc::new(data.clone().into()), peer) + .send_txset( + hash, + Arc::new(TxSetData::from_local(data.clone()).unwrap()), + peer, + ) .await; - let waiting = handle.send_txset(hash, Arc::new(data.into()), peer); + let waiting = handle.send_txset(hash, Arc::new(TxSetData::from_local(data).unwrap()), peer); tokio::pin!(waiting); assert!(futures::poll!(&mut waiting).is_pending()); tokio::time::timeout(Duration::from_secs(1), handle.ping()) @@ -1227,7 +1216,11 @@ async fn failed_txset_send_releases_admission() { let mut task = tokio::spawn(async move { overlay.run("127.0.0.1", 0).await }); let (hash, data) = test_txset_xdr(1); handle - .send_txset(hash, Arc::new(data.into()), PeerId::random()) + .send_txset( + hash, + Arc::new(TxSetData::from_local(data).unwrap()), + PeerId::random(), + ) .await; tokio::time::timeout(Duration::from_secs(1), async { let _all = Arc::clone(&handle.txset_send_slots) @@ -1301,7 +1294,7 @@ async fn queued_peer_sends_share_payload_and_release_it_on_drop() { let (handle, _events, _admissions, mut overlay) = create_test_overlay(Keypair::generate_ed25519(), Arc::new(OverlayMetrics::new())).unwrap(); let (hash, data) = test_txset_xdr(1); - let data = Arc::new(TxSetData::from(data)); + let data = Arc::new(TxSetData::from_local(data).unwrap()); let retained = Arc::downgrade(&data); for _ in 0..29 { handle diff --git a/overlay/src/main.rs b/overlay/src/main.rs index 572a3a2183..ac6fbc5220 100644 --- a/overlay/src/main.rs +++ b/overlay/src/main.rs @@ -20,7 +20,7 @@ use tracing::{debug, error, info, warn}; use libp2p::identity::Keypair as Libp2pKeypair; use libp2p::{Multiaddr, PeerId}; use stellar_overlay::config::Config; -use stellar_overlay::flood::{CachedTxSet, Hash256, TxSetCache}; +use stellar_overlay::flood::{CachedTxSet, Hash256, TxSetCache, TxSetData}; use stellar_overlay::integrated::{Overlay, OverlayHandle}; use stellar_overlay::ipc::{CoreIpc, Message, MessageType}; use stellar_overlay::libp2p_overlay::{ @@ -375,15 +375,15 @@ fn get_cached_tx_set_xdr<'a>(tx_set_cache: &'a TxSetCache, hash: &Hash256) -> Op tx_set_cache.get(hash).map(|cached| cached.xdr.as_slice()) } -fn cache_tx_set_xdr( +fn cache_tx_set( tx_set_cache: &mut TxSetCache, current_ledger_seq: u32, hash: Hash256, - xdr: Vec, + data: Arc, ) { tx_set_cache.insert(CachedTxSet { hash, - xdr: Arc::new(xdr.into()), + xdr: data, ledger_seq: current_ledger_seq, }); } @@ -734,7 +734,7 @@ impl App { // This ensures the TxSet is available when SCP processing resumes // Stamp with the slot the set was requested for so eviction is // exact; for an unsolicited set fall back to the next slot. - cache_tx_set_xdr( + cache_tx_set( &mut self.tx_set_cache, slot.unwrap_or(self.current_ledger_seq + 1), hash, @@ -1054,13 +1054,14 @@ impl App { let mut hash = [0u8; 32]; hash.copy_from_slice(&msg.payload[0..32]); let slot = u32::from_le_bytes(msg.payload[32..36].try_into().unwrap()); - let tx_set_xdr = &msg.payload[36..]; + let mut payload = msg.payload; + let tx_set_xdr = payload.split_off(36); // Core is trusted for encoding, so we skip decoding. We still // guard the content hash cheaply: caching bytes under a hash // that peers would recompute differently makes the tx set // unfetchable network-wide. - if !xdr::tx_set_hash_matches(&hash, tx_set_xdr) { + if !xdr::tx_set_hash_matches(&hash, &tx_set_xdr) { warn!( "TXSET_CACHE_DROP: Dropping TX set {:02x?}... from Core: content hash mismatch", &hash[..4] @@ -1075,7 +1076,34 @@ impl App { tx_set_xdr.len() ); - cache_tx_set_xdr(&mut self.tx_set_cache, slot, hash, tx_set_xdr.to_vec()); + // Keep an existing received/prepared representation intact on + // repeated IPC publication of the same content hash. + let data = if let Some(cached) = self.tx_set_cache.get(&hash) { + Arc::clone(&cached.xdr) + } else { + // Core sends this before final proposal validation. Await + // completion on this task while the network and Core keep + // running. Requests queue until the ready set is cached. + let started = std::time::Instant::now(); + match tokio::task::spawn_blocking(move || TxSetData::from_local(tx_set_xdr)) + .await + { + Ok(Ok(data)) => { + info!("TXSET_COMPRESS: Prepared locally built set {:02x?}... raw_bytes={} encoded_bytes={} duration_us={}", + &hash[..4], data.len(), data.encoded().len(), started.elapsed().as_micros()); + Arc::new(data) + } + result => { + error!( + "TXSET_CACHE_DROP: Failed to encode local set {:02x?}...: {:?}", + &hash[..4], + result + ); + return true; + } + } + }; + cache_tx_set(&mut self.tx_set_cache, slot, hash, data); self.send_requested_tx_set(&hash); } @@ -2054,13 +2082,65 @@ mod tests { assert_eq!(top[0].hash(), tx.hash()); } + #[tokio::test] + async fn local_publication_is_eager_and_preserves_existing_encoding() { + let (mut app, _core) = test_app(); + let (hash, xdr) = test_txset_xdr(29); + let mut payload = request_tx_set_payload(&hash, 100); + payload.extend_from_slice(&xdr); + app.handle_core_message(Message::new(MessageType::CacheTxSet, payload.clone())) + .await; + let data = Arc::clone(&app.tx_set_cache.get(&hash).unwrap().xdr); + // No send has occurred: publication itself prepared the response. + assert_eq!( + zstd::bulk::decompress(&data.encoded()[4..], data.len()).unwrap(), + xdr + ); + app.handle_core_message(Message::new(MessageType::CacheTxSet, payload)) + .await; + assert!(Arc::ptr_eq( + &data, + &app.tx_set_cache.get(&hash).unwrap().xdr + )); + } + + #[tokio::test] + async fn received_encoding_survives_cache_and_local_duplicate() { + let (mut app, _core) = test_app(); + let (hash, xdr) = test_txset_xdr(30); + let received = Arc::new(TxSetData::from_local(xdr.clone()).unwrap()); + app.handle_libp2p_event(LibP2pOverlayEvent::TxSetReceived { + hash, + data: Arc::clone(&received), + from: PeerId::random(), + slot: Some(100), + }) + .await; + assert!(Arc::ptr_eq( + &received, + &app.tx_set_cache.get(&hash).unwrap().xdr + )); + let mut payload = request_tx_set_payload(&hash, 101); + payload.extend_from_slice(&xdr); + app.handle_core_message(Message::new(MessageType::CacheTxSet, payload)) + .await; + let cached = app.tx_set_cache.get(&hash).unwrap(); + assert!(Arc::ptr_eq(&received, &cached.xdr)); + assert_eq!(cached.ledger_seq, 101); + } + #[tokio::test] async fn peer_responses_share_cached_storage_and_survive_eviction() { // Keep the network dispatcher alive but unpolled: responses remain // queued or awaiting dispatch, as when the transport is delayed. let (mut app, _core, network) = test_app_with_network(); let (hash, data) = test_txset_xdr(7); - cache_tx_set_xdr(&mut app.tx_set_cache, 1, hash, data.clone()); + cache_tx_set( + &mut app.tx_set_cache, + 1, + hash, + Arc::new(TxSetData::from_local(data.clone()).unwrap()), + ); let cached = Arc::downgrade(&app.tx_set_cache.get(&hash).unwrap().xdr); for _ in 0..29 { app.handle_libp2p_event(LibP2pOverlayEvent::TxSetRequested { @@ -2128,7 +2208,7 @@ mod tests { let (hash, data) = test_txset_xdr(31); app.handle_libp2p_event(LibP2pOverlayEvent::TxSetReceived { hash, - data: data.clone(), + data: Arc::new(TxSetData::from_local(data.clone()).unwrap()), from: PeerId::random(), slot: Some(100), }) @@ -2168,7 +2248,7 @@ mod tests { let (other, other_data) = test_txset_xdr(33); app.handle_libp2p_event(LibP2pOverlayEvent::TxSetReceived { hash: other, - data: other_data, + data: Arc::new(TxSetData::from_local(other_data).unwrap()), from: PeerId::random(), slot: Some(101), }) @@ -2179,7 +2259,7 @@ mod tests { for arrival in 0..2 { app.handle_libp2p_event(LibP2pOverlayEvent::TxSetReceived { hash, - data: data.clone(), + data: Arc::new(TxSetData::from_local(data.clone()).unwrap()), from: PeerId::random(), slot: Some(101), }) @@ -2219,7 +2299,7 @@ mod tests { for (h, bytes) in [(hash, data.clone()), (other, other_data)] { app.handle_libp2p_event(LibP2pOverlayEvent::TxSetReceived { hash: h, - data: bytes, + data: Arc::new(TxSetData::from_local(bytes).unwrap()), from: PeerId::random(), slot: Some(100), }) @@ -2235,7 +2315,7 @@ mod tests { assert!(app.pending_core_tx_sets.contains_key(&hash)); app.handle_libp2p_event(LibP2pOverlayEvent::TxSetReceived { hash, - data: data.clone(), + data: Arc::new(TxSetData::from_local(data.clone()).unwrap()), from: PeerId::random(), slot: Some(100), }) @@ -2270,7 +2350,7 @@ mod tests { assert_eq!(app.pending_core_tx_sets.get(&future), Some(&120)); app.handle_libp2p_event(LibP2pOverlayEvent::TxSetReceived { hash: old, - data: data.clone(), + data: Arc::new(TxSetData::from_local(data.clone()).unwrap()), from: PeerId::random(), slot: Some(100), }) @@ -2315,7 +2395,7 @@ mod tests { .await; app.handle_libp2p_event(LibP2pOverlayEvent::TxSetReceived { hash, - data: data.clone(), + data: Arc::new(TxSetData::from_local(data.clone()).unwrap()), from: PeerId::random(), slot: Some(100), }) @@ -2334,7 +2414,12 @@ mod tests { // Cache the set, so if the handler wrongly accepted the legacy // format it would respond with TxSetAvailable below. - cache_tx_set_xdr(&mut app.tx_set_cache, 1, hash, xdr_bytes); + cache_tx_set( + &mut app.tx_set_cache, + 1, + hash, + Arc::new(TxSetData::from_local(xdr_bytes).unwrap()), + ); // Pre-slotSeq payload: [hash:32] only. The protocol is now // [hash:32][slotSeq:4]; the short payload must be dropped. @@ -2411,7 +2496,7 @@ mod tests { app.handle_libp2p_event(LibP2pOverlayEvent::TxSetReceived { hash, - data: xdr_bytes.clone(), + data: Arc::new(TxSetData::from_local(xdr_bytes.clone()).unwrap()), from: PeerId::random(), slot: Some(100), }) diff --git a/src/herder/HerderImpl.cpp b/src/herder/HerderImpl.cpp index 9b3dfe58ee..b7a686e0a8 100644 --- a/src/herder/HerderImpl.cpp +++ b/src/herder/HerderImpl.cpp @@ -1790,7 +1790,23 @@ HerderImpl::buildTxSet(uint32_t ledgerSeq, ConsensusTime closeTime) invalidTxPhases.resize(txPhases.size()); std::tie(proposedSet, applicableProposedSet) = makeTxSetFromTransactions( - txPhases, mApp, closeTimeOffset, invalidTxPhases); + txPhases, mApp, closeTimeOffset, invalidTxPhases +#ifdef BUILD_TESTS + , + false, {}, false +#endif + , + [&](TxSetXDRFrameConstPtr const& txSet) { + // Hand the final XDR to the overlay before the builder's remaining + // validation. Its eager compression runs concurrently in Rust. + if (txSet->isGeneralizedTxSet()) + { + GeneralizedTransactionSet xdrTxSet; + txSet->toXDR(xdrTxSet); + overlayMgr.cacheTxSet(txSet->getContentsHash(), + xdr::xdr_to_opaque(xdrTxSet), ledgerSeq); + } + }); CLOG_INFO(Herder, "Proposed TX set has {} transactions", proposedSet->sizeTxTotal()); @@ -1994,6 +2010,15 @@ HerderImpl::triggerNextLedger(uint32_t ledgerSeqToTrigger, CLOG_INFO(Herder, "Nominating overridden tx set {} for slot {}", hexAbbrev(proposedSet->getContentsHash()), lcl.header.ledgerSeq + 1); + // The overlay only cached the set built above; peers fetch this one. + if (proposedSet->isGeneralizedTxSet()) + { + GeneralizedTransactionSet xdrTxSet; + proposedSet->toXDR(xdrTxSet); + mApp.getOverlayManager().cacheTxSet( + proposedSet->getContentsHash(), xdr::xdr_to_opaque(xdrTxSet), + lcl.header.ledgerSeq + 1); + } } #endif @@ -2008,20 +2033,6 @@ HerderImpl::triggerNextLedger(uint32_t ledgerSeqToTrigger, mPendingEnvelopes.addTxSet(txSetHash, lcl.header.ledgerSeq + 1, proposedSet); - // Cache the TX set in Rust overlay so it can serve it to other peers. - // When a peer receives an SCP message referencing this TX set hash, - // they'll request it via TX set fetching, and Rust needs the XDR. - // Note: Rust overlay only supports GeneralizedTransactionSet (protocol >= - // 20) - if (proposedSet->isGeneralizedTxSet()) - { - GeneralizedTransactionSet xdrTxSet; - proposedSet->toXDR(xdrTxSet); - auto xdrBytes = xdr::xdr_to_opaque(xdrTxSet); - mApp.getOverlayManager().cacheTxSet(txSetHash, xdrBytes, - lcl.header.ledgerSeq + 1); - } - lcl = mLedgerManager.getLastClosedLedgerHeader(); // use the slot index from ledger manager here as our vote is based off // the last closed ledger stored in ledger manager diff --git a/src/herder/TxSetFrame.cpp b/src/herder/TxSetFrame.cpp index c8b514eb98..bad5528ccf 100644 --- a/src/herder/TxSetFrame.cpp +++ b/src/herder/TxSetFrame.cpp @@ -843,7 +843,8 @@ makeTxSetFromTransactions( txtest::ParallelSorobanOrder const& parallelSorobanOrder, bool disableTxValidationForLegacyScenario #endif -) + , + TxSetReadyCallback const& onTxSetReady) { releaseAssert(threadIsMain()); releaseAssert(!app.getLedgerManager().isApplying()); @@ -956,6 +957,14 @@ makeTxSetFromTransactions( } #endif + // The final XDR is available now. Start proposal encoding while the + // roundtrip and final validity checks below run; only the local builder + // supplies this callback. The callback must not nominate the set. + if (onTxSetReady) + { + onTxSetReady(outputTxSet); + } + ApplicableTxSetFrameConstPtr outputApplicableTxSet = outputTxSet->prepareForApply(app, lclHeader.header); diff --git a/src/herder/TxSetFrame.h b/src/herder/TxSetFrame.h index 66f926f70b..b2ac0e9bec 100644 --- a/src/herder/TxSetFrame.h +++ b/src/herder/TxSetFrame.h @@ -26,6 +26,7 @@ class Application; class TxSetXDRFrame; class ApplicableTxSetFrame; using TxSetXDRFrameConstPtr = std::shared_ptr; +using TxSetReadyCallback = std::function; using ApplicableTxSetFrameConstPtr = std::unique_ptr; @@ -152,7 +153,8 @@ makeTxSetFromTransactions( txtest::ParallelSorobanOrder const& parallelSorobanOrder = {}, bool disableTxValidationForLegacyScenario = false #endif -); + , + TxSetReadyCallback const& onTxSetReady = {}); #ifdef BUILD_TESTS std::pair @@ -405,7 +407,8 @@ class TxSetPhaseFrame txtest::ParallelSorobanOrder const& parallelSorobanOrder, bool disableTxValidationForLegacyScenario #endif - ); + , + TxSetReadyCallback const& onTxSetReady); #ifdef BUILD_TESTS friend std::pair makeTxSetFromTransactions( @@ -579,7 +582,8 @@ class ApplicableTxSetFrame txtest::ParallelSorobanOrder const& parallelSorobanOrder, bool disableTxValidationForLegacyScenario #endif - ); + , + TxSetReadyCallback const& onTxSetReady); #ifdef BUILD_TESTS friend std::pair makeTxSetFromTransactions( diff --git a/src/herder/test/TxSetTests.cpp b/src/herder/test/TxSetTests.cpp index 133a57ce58..3e497f48f1 100644 --- a/src/herder/test/TxSetTests.cpp +++ b/src/herder/test/TxSetTests.cpp @@ -33,6 +33,44 @@ namespace { using namespace txtest; +TEST_CASE("built tx set is available before final validation returns", + "[txset][eager-compression]") +{ + auto const protocol = GENERATE(27, 28); + auto cfg = getTestConfig(); + cfg.LEDGER_PROTOCOL_VERSION = protocol; + cfg.TESTING_UPGRADE_LEDGER_PROTOCOL_VERSION = protocol; + cfg.GENESIS_TEST_ACCOUNT_COUNT = 3; + VirtualClock clock; + auto app = createTestApplication(clock, cfg); + auto source = getGenesisAccount(*app, 0); + auto destination = getGenesisAccount(*app, 1); + auto tx = transactionFromOperations( + *app, source.getSecretKey(), source.nextSequenceNumber(), + {payment(destination.getPublicKey(), 1)}, 100); + PerPhaseTransactionList phases{{tx}, {}}; + PerPhaseTransactionList invalid(2); + TxSetXDRFrameConstPtr ready; + size_t callbacks = 0; + auto [wire, applicable] = makeTxSetFromTransactions( + phases, *app, ApplyTimeOffset{}, invalid, false, {}, false, + [&](TxSetXDRFrameConstPtr const& set) { + ++callbacks; + ready = set; + REQUIRE(set->isGeneralizedTxSet()); + REQUIRE(set->sizeTxTotal() == 1); + GeneralizedTransactionSet xdrSet; + set->toXDR(xdrSet); + REQUIRE(xdrSha256(xdrSet) == set->getContentsHash()); + }); + REQUIRE(callbacks == 1); + REQUIRE(ready == wire); + REQUIRE(invalid[0].empty()); + REQUIRE(invalid[1].empty()); + REQUIRE(applicable); + REQUIRE(applicable->checkValid(*app, 0, 0)); +} + TEST_CASE("generalized tx set XDR validation", "[txset]") { Config cfg(getTestConfig()); From e545aca8b386fe04f25be19529a781b6568dbe6d Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Thu, 17 Sep 2026 14:17:47 -0700 Subject: [PATCH 03/23] Clarify compressed transaction set delivery ownership --- overlay/src/libp2p_overlay.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/overlay/src/libp2p_overlay.rs b/overlay/src/libp2p_overlay.rs index 1150902a77..38040657a9 100644 --- a/overlay/src/libp2p_overlay.rs +++ b/overlay/src/libp2p_overlay.rs @@ -2090,7 +2090,7 @@ fn handle_txset_request(state: &SharedState, peer_id: PeerId, hash: [u8; 32]) { } } -/// Deliver strict-decoded XDR identically for both response encodings. +/// Deliver verified XDR together with its original compressed encoding. async fn deliver_txset(state: &SharedState, peer_id: PeerId, txset_data: Arc) { let hash = crate::xdr::sha256_hash(txset_data.as_slice()); From 223f00ebc7b6fa823025886671b86798e4d98264 Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Thu, 17 Sep 2026 15:45:32 -0700 Subject: [PATCH 04/23] Build local transaction sets only for nomination leaders --- docs/rust-overlay/txset-fetching.md | 9 +++ src/herder/HerderImpl.cpp | 86 ++++++++++++++++++------ src/herder/HerderImpl.h | 2 + src/herder/HerderSCPDriver.cpp | 42 ++++++++---- src/herder/HerderSCPDriver.h | 3 +- src/herder/test/HerderTests.cpp | 86 ++++++++++++++++++++++-- src/scp/NominationProtocol.cpp | 39 +++++++---- src/scp/NominationProtocol.h | 4 +- src/scp/SCP.cpp | 4 +- src/scp/SCP.h | 4 +- src/scp/SCPDriver.h | 5 ++ src/scp/Slot.cpp | 5 +- src/scp/Slot.h | 4 +- src/scp/test/SCPTests.cpp | 3 +- src/scp/test/SCPUnitTests.cpp | 100 +++++++++++++++++++++++++++- src/simulation/ApplyLoad.cpp | 9 ++- 16 files changed, 339 insertions(+), 66 deletions(-) diff --git a/docs/rust-overlay/txset-fetching.md b/docs/rust-overlay/txset-fetching.md index 2900f9529a..826bf17cfe 100644 --- a/docs/rust-overlay/txset-fetching.md +++ b/docs/rust-overlay/txset-fetching.md @@ -24,6 +24,15 @@ See [transport](transport.md). ## Encoding ownership +Only nomination leaders construct local proposals. Followers start SCP with a +lazy value supplier and vote for received leader proposals without pulling the +mempool, building a private set, or compressing it. A node promoted by a +nomination timeout builds only if SCP needs its own value; it rechecks ledger +state and chooses a current close time then. Subsequent rounds reuse that value. +First-round leaders may prepare before the trigger; later leaders do no +speculative preparation. Nomination stops on externalization even for followers +that never constructed a local value. + Core sends `CacheTxSet` as soon as a locally constructed proposal's final XDR is available, before the builder's roundtrip and final validation. Rust eagerly compresses it at zstd level 1 on a blocking worker while Core continues those diff --git a/src/herder/HerderImpl.cpp b/src/herder/HerderImpl.cpp index b7a686e0a8..36c3e4c953 100644 --- a/src/herder/HerderImpl.cpp +++ b/src/herder/HerderImpl.cpp @@ -1507,7 +1507,7 @@ HerderImpl::setupTriggerNextLedger() if (getSCP().isValidator()) { auto leaders = getSCP().predictNominationLeaders( - nextIndex, xdr::xdr_to_opaque(lcl.header.scpValue), 2); + nextIndex, xdr::xdr_to_opaque(lcl.header.scpValue), 1); if (leaders.count(getSCP().getLocalNodeID())) { // Validate against the close time we expect at the trigger, @@ -1680,6 +1680,15 @@ HerderImpl::prepareTxSet(uint32_t ledgerSeq, ConsensusTime closeTime) { return; } + auto const& lcl = mLedgerManager.getLastClosedLedgerHeader(); + if (!getSCP().isValidator() || + !getSCP() + .predictNominationLeaders( + ledgerSeq, xdr::xdr_to_opaque(lcl.header.scpValue), 1) + .count(getSCP().getLocalNodeID())) + { + return; + } mPreparedTxSet = buildTxSet(ledgerSeq, closeTime); CLOG_INFO(Herder, "Prepared TX set for ledger {} before trigger: {} transactions, " @@ -1695,6 +1704,15 @@ HerderImpl::buildTxSet(uint32_t ledgerSeq, ConsensusTime closeTime) auto const lcl = mLedgerManager.getLastClosedLedgerHeader(); releaseAssert(ledgerSeq == lcl.header.ledgerSeq + 1); releaseAssert(closeTime > getConsensusTime(lcl.header.scpValue)); + bool const activeLeader = getSCP().getNominationLeaders(ledgerSeq).count( + getSCP().getLocalNodeID()); + releaseAssert(activeLeader || + getSCP() + .predictNominationLeaders( + ledgerSeq, xdr::xdr_to_opaque(lcl.header.scpValue), 1) + .count(getSCP().getLocalNodeID())); + CLOG_INFO(Herder, "Building TX set as {} nomination leader for ledger {}", + activeLeader ? "active" : "first-round", ledgerSeq); // Apply-time offset: see the comment in triggerNextLedger auto const closeTimeOffset = closeTime.toApplyTime() - getApplyTime(lcl.header.scpValue); @@ -1948,10 +1966,50 @@ HerderImpl::triggerNextLedger(uint32_t ledgerSeqToTrigger, } // Start the trigger-to-ballot interval only once this node is going to - // build a proposal and nominate. A skipped trigger must not credit the - // time spent waiting for peers to the drift allowance. + // nominate. A skipped trigger must not credit the time spent waiting for + // peers to the drift allowance. mHerderSCPDriver.recordNominationTrigger(ledgerSeqToTrigger); + if (!getSCP().isValidator()) + { + CLOG_DEBUG(Herder, "Non-validating node, skipping nomination (SCP)."); + return; + } + + getHerderSCPDriver().recordSCPEvent(ledgerSeqToTrigger, true); + mHerderSCPDriver.nominate( + ledgerSeqToTrigger, + [this, ledgerSeqToTrigger, checkTrackingSCP]() { + return makeNominationValue(ledgerSeqToTrigger, checkTrackingSCP); + }, + lcl.header.scpValue); +} + +ValueWrapperPtr +HerderImpl::makeNominationValue(uint32_t ledgerSeqToTrigger, + bool checkTrackingSCP) +{ + // A follower can be promoted long after the trigger. Recheck the ledger + // state and select a fresh close time when SCP actually needs our value. + if ((!isTracking() && checkTrackingSCP) || !mLedgerManager.isSynced() || + mLedgerManager.isApplying()) + { + return nullptr; + } + auto lcl = mLedgerManager.getLastClosedLedgerHeader(); + if (ledgerSeqToTrigger != lcl.header.ledgerSeq + 1) + { + return nullptr; + } + auto nextCloseTime = std::max( + ConsensusTime::fromSystemTime(mApp.getClock().system_now(), + lcl.header.ledgerVersion), + getConsensusTime(lcl.header.scpValue).next(lcl.header.ledgerVersion)); + if (ctValidityOffset(nextCloseTime) != std::chrono::milliseconds::zero()) + { + return nullptr; + } + // Consume the private snapshot only for the ledger it was built against. // Keep its close time: changing it would invalidate time-bound transactions // and the cached validation result. @@ -1995,7 +2053,7 @@ HerderImpl::triggerNextLedger(uint32_t ledgerSeqToTrigger, if (!applicableProposedSet) { releaseAssert(!mApp.getConfig().FORCE_SCP); - return; + return nullptr; } // New proposed tx set must be valid, so we explicitly populate tx set @@ -2015,9 +2073,9 @@ HerderImpl::triggerNextLedger(uint32_t ledgerSeqToTrigger, { GeneralizedTransactionSet xdrTxSet; proposedSet->toXDR(xdrTxSet); - mApp.getOverlayManager().cacheTxSet( - proposedSet->getContentsHash(), xdr::xdr_to_opaque(xdrTxSet), - lcl.header.ledgerSeq + 1); + mApp.getOverlayManager().cacheTxSet(proposedSet->getContentsHash(), + xdr::xdr_to_opaque(xdrTxSet), + lcl.header.ledgerSeq + 1); } } #endif @@ -2044,7 +2102,7 @@ HerderImpl::triggerNextLedger(uint32_t ledgerSeqToTrigger, // applying if (ledgerSeqToTrigger != slotIndex || mLedgerManager.isApplying()) { - return; + return nullptr; } auto newUpgrades = emptyUpgradeSteps; @@ -2074,15 +2132,6 @@ HerderImpl::triggerNextLedger(uint32_t ledgerSeqToTrigger, } } - getHerderSCPDriver().recordSCPEvent(slotIndex, true); - - // If we are not a validating node we stop here and don't start nomination - if (!getSCP().isValidator()) - { - CLOG_DEBUG(Herder, "Non-validating node, skipping nomination (SCP)."); - return; - } - #ifdef BUILD_TESTS if (mApp.getConfig().TESTING_NOMINATE_RANDOM_VALUES && getHerderSCPDriver().protocolAllowsEmptyTxSetValues()) @@ -2097,8 +2146,7 @@ HerderImpl::triggerNextLedger(uint32_t ledgerSeqToTrigger, StellarValue newProposedValue = makeStellarValue( txSetHash, nextCloseTime, newUpgrades, mApp.getConfig().NODE_SEED); - mHerderSCPDriver.nominate(slotIndex, newProposedValue, proposedSet, - lcl.header.scpValue); + return mHerderSCPDriver.wrapStellarValue(newProposedValue); } void diff --git a/src/herder/HerderImpl.h b/src/herder/HerderImpl.h index bebbce06d6..52b28ed820 100644 --- a/src/herder/HerderImpl.h +++ b/src/herder/HerderImpl.h @@ -269,6 +269,8 @@ class HerderImpl : public Herder PreparedTxSet buildTxSet(uint32_t ledgerSeq, ConsensusTime closeTime); void prepareTxSet(uint32_t ledgerSeq, ConsensusTime closeTime); void discardPreparedTxSet(); + ValueWrapperPtr makeNominationValue(uint32_t ledgerSeq, + bool checkTrackingSCP); // Compute the trigger-timer anchor point using the local node's // prepare-start timestamp for the previous slot. Returns a pessimistic diff --git a/src/herder/HerderSCPDriver.cpp b/src/herder/HerderSCPDriver.cpp index d487c7d0bd..550e5084ae 100644 --- a/src/herder/HerderSCPDriver.cpp +++ b/src/herder/HerderSCPDriver.cpp @@ -1253,7 +1253,7 @@ HerderSCPDriver::valueExternalized(uint64_t slotIndex, Value const& value) logQuorumInformationAndUpdateMetrics(slotIndex - 2); } - if (mCurrentValue) + if (mLedgerSeqNominating != 0) { // stop nomination // this may or may not be the ledger that is currently externalizing @@ -1262,6 +1262,7 @@ HerderSCPDriver::valueExternalized(uint64_t slotIndex, Value const& value) // or we're going to trigger catchup from history mSCP.stopNomination(mLedgerSeqNominating); mCurrentValue.reset(); + mLedgerSeqNominating = 0; } if (!mHerder.isTracking()) @@ -1337,24 +1338,37 @@ HerderSCPDriver::logQuorumInformationAndUpdateMetrics(uint64_t index) } void -HerderSCPDriver::nominate(uint64_t slotIndex, StellarValue const& value, - TxSetXDRFrameConstPtr proposedSet, +HerderSCPDriver::nominate(uint64_t slotIndex, NominationValueSupplier makeValue, StellarValue const& previousValue) { ZoneScoped; - mCurrentValue = wrapStellarValue(value); + if (mLedgerSeqNominating != slotIndex) + { + mCurrentValue.reset(); + } mLedgerSeqNominating = static_cast(slotIndex); - - auto valueHash = xdrSha256(mCurrentValue->getValue()); - CLOG_DEBUG(Herder, - "HerderSCPDriver::triggerNextLedger txSet.size: {} " - "previousLedgerHash: {} value: {} slot: {}", - proposedSet->sizeTxTotal(), - hexAbbrev(proposedSet->previousLedgerHash()), - hexAbbrev(valueHash), slotIndex); - auto prevValue = xdr::xdr_to_opaque(previousValue); - mSCP.nominate(slotIndex, mCurrentValue, prevValue); + mSCP.nominate( + slotIndex, + [this, slotIndex, + makeValue = std::move(makeValue)]() -> ValueWrapperPtr { + if (mLedgerSeqNominating != slotIndex) + { + return nullptr; + } + if (!mCurrentValue) + { + auto value = makeValue(); + // Publishing the tx set may externalize a pending value. + if (mLedgerSeqNominating != slotIndex) + { + return nullptr; + } + mCurrentValue = std::move(value); + } + return mCurrentValue; + }, + prevValue); } SCPQuorumSetPtr diff --git a/src/herder/HerderSCPDriver.h b/src/herder/HerderSCPDriver.h index ec3b1bc9a2..06354c82ea 100644 --- a/src/herder/HerderSCPDriver.h +++ b/src/herder/HerderSCPDriver.h @@ -131,8 +131,7 @@ class HerderSCPDriver : public SCPDriver // Submit a value to consider for slotIndex // previousValue is the value from slotIndex-1 - void nominate(uint64_t slotIndex, StellarValue const& value, - TxSetXDRFrameConstPtr proposedSet, + void nominate(uint64_t slotIndex, NominationValueSupplier makeValue, StellarValue const& previousValue); SCPQuorumSetPtr getQSet(Hash const& qSetHash) override; diff --git a/src/herder/test/HerderTests.cpp b/src/herder/test/HerderTests.cpp index 4fc6d21658..01ab1ebb6f 100644 --- a/src/herder/test/HerderTests.cpp +++ b/src/herder/test/HerderTests.cpp @@ -6768,6 +6768,37 @@ class EarlyNominationTestAccess { herder.setupTriggerNextLedger(); } + + // These fixtures inspect a local proposal while requiring an absent peer + // to prevent externalization. Pick that peer so the local node is the + // first leader, independently of the test RNG seed and previous ledger. + static void + selectLocalFirstLeader(HerderImpl& herder) + { + auto& scp = herder.getSCP(); + auto const& lcl = + herder.mApp.getLedgerManager().getLastClosedLedgerHeader(); + auto qset = scp.getLocalQuorumSet(); + REQUIRE(qset.validators.size() == 2); + for (int i = 0; i < 100; ++i) + { + qset.validators = { + scp.getLocalNodeID(), + SecretKey::fromSeed(sha256(fmt::format("absent-peer-{}", i))) + .getPublicKey()}; + scp.updateLocalQuorumSet(qset); + if (scp.predictNominationLeaders( + lcl.header.ledgerSeq + 1, + xdr::xdr_to_opaque(lcl.header.scpValue), 1) + .count(scp.getLocalNodeID())) + { + herder.mPendingEnvelopes.addSCPQuorumSet( + scp.getLocalNode()->getQuorumSetHash(), qset); + return; + } + } + FAIL("Could not select a first-round local leader"); + } }; } @@ -6859,6 +6890,7 @@ TEST_CASE("trigger work is recorded by the proposal path", SecretKey::pseudoRandomForTesting().getPublicKey()}; auto app = createTestApplication(clock, cfg); auto& herder = static_cast(app->getHerder()); + EarlyNominationTestAccess::selectLocalFirstLeader(herder); auto& driver = herder.getHerderSCPDriver(); auto const slot = app->getLedgerManager().getLastClosedLedgerNum() + 1; herder.mGetTopTransactionsForTesting = [&](size_t) { @@ -7201,6 +7233,7 @@ TEST_CASE("prepare nomination before trigger", "[herder][early-nomination]") config.mLedgerMaxTxCount = 1; }); } + EarlyNominationTestAccess::selectLocalFirstLeader(herder); auto const lcl = app->getLedgerManager().getLastClosedLedgerHeader(); // The Soroban upgrade helper closes ledgers at its fixed test date. The // sub-second offset makes the prepared close time carry milliseconds once @@ -7342,7 +7375,7 @@ TEST_CASE("prepare nomination before trigger", "[herder][early-nomination]") herder.mGetTopTransactionsForTesting = nullptr; } -TEST_CASE("only the first two nomination leaders prepare early", +TEST_CASE("only nomination leaders construct local proposals", "[herder][early-nomination]") { // A fixed, unanimous quorum gives all three nodes the same weights and @@ -7407,7 +7440,7 @@ TEST_CASE("only the first two nomination leaders prepare early", REQUIRE(checkedRoles.insert(role).second); CAPTURE(role); EarlyNominationTestAccess::schedule(herder); - REQUIRE(EarlyNominationTestAccess::scheduled(herder) == (role < 2)); + REQUIRE(EarlyNominationTestAccess::scheduled(herder) == (role == 0)); bool done = false; VirtualTimer stop(clock); stop.expires_from_now(std::chrono::milliseconds(1)); @@ -7416,11 +7449,53 @@ TEST_CASE("only the first two nomination leaders prepare early", app, [&]() { return done; }, std::chrono::seconds(1)); REQUIRE(done); REQUIRE(clock.now() < herder.getTriggerTimer().expiry_time()); - REQUIRE(pulls == (role < 2 ? 1 : 0)); + REQUIRE(pulls == (role == 0 ? 1 : 0)); REQUIRE(bool(EarlyNominationTestAccess::prepared(herder)) == - (role < 2)); + (role == 0)); REQUIRE(scp.getNominationLeaders(seq).empty()); REQUIRE(scp.getLatestMessagesSend(seq).empty()); + auto const trigger = herder.getTriggerTimer().expiry_time(); + clock.setCurrentVirtualTime(trigger); + auto const triggerSystemTime = clock.system_now(); + testutil::crankUntil( + app, [&]() { return !scp.getNominationLeaders(seq).empty(); }, + std::chrono::seconds(1)); + REQUIRE(scp.getNominationLeaders(seq) == first); + // The first leader refreshes its empty early snapshot. Followers do + // not even pull the mempool when starting nomination. + REQUIRE(pulls == (role == 0 ? 2 : 0)); + REQUIRE(scp.getLatestMessagesSend(seq).empty() == (role != 0)); + + // With the first leader silent, real nomination timers eventually + // promote each follower. It builds exactly then, using a current close + // time, and its prepared/validated tx set is available for retrieval. + testutil::crankUntil( + app, [&]() { return !scp.getLatestMessagesSend(seq).empty(); }, + std::chrono::seconds(30)); + REQUIRE(scp.getNominationLeaders(seq).count(scp.getLocalNodeID())); + REQUIRE(pulls == (role == 0 ? 2 : 1)); + auto messages = scp.getLatestMessagesSend(seq); + auto const& votes = messages.front().statement.pledges.nominate().votes; + REQUIRE(votes.size() == 1); + StellarValue nominated; + xdr::xdr_from_opaque(votes.front(), nominated); + auto txSet = std::get( + herder.getTxSet(nominated.txSetHash)); + REQUIRE(txSet); + REQUIRE(txSet->previousLedgerHash() == lcl.hash); + REQUIRE(herder.getHerderSCPDriver().validateValue(seq, votes.front(), + true) == + SCPDriver::kFullyValidatedValue); + if (role != 0) + { + REQUIRE(getConsensusTime(nominated) > + ConsensusTime::fromSystemTime(triggerSystemTime, + lcl.header.ledgerVersion)); + } + auto const pullsAfterVote = pulls; + // Reentering the trigger for this slot cannot build a second proposal. + herder.triggerNextLedger(seq, true); + REQUIRE(pulls == pullsAfterVote); herder.mGetTopTransactionsForTesting = nullptr; } REQUIRE(checkedRoles == std::set{0, 1, 2}); @@ -7444,6 +7519,7 @@ TEST_CASE("early underfilled proposals refresh at the trigger", SecretKey::pseudoRandomForTesting().getPublicKey()}; auto app = createTestApplication(clock, cfg); auto& herder = static_cast(app->getHerder()); + EarlyNominationTestAccess::selectLocalFirstLeader(herder); auto const lcl = app->getLedgerManager().getLastClosedLedgerHeader(); auto const seq = lcl.header.ledgerSeq + 1; herder.getHerderSCPDriver().recordSCPEvent(lcl.header.ledgerSeq, false); @@ -7511,6 +7587,7 @@ TEST_CASE("early preparation respects manual and immediately due triggers", SecretKey::pseudoRandomForTesting().getPublicKey()}; auto app = createTestApplication(clock, cfg); auto& herder = static_cast(app->getHerder()); + EarlyNominationTestAccess::selectLocalFirstLeader(herder); auto const seq = app->getLedgerManager().getLastClosedLedgerNum() + 1; size_t pulls = 0; herder.mGetTopTransactionsForTesting = [&](size_t) { @@ -7525,6 +7602,7 @@ TEST_CASE("early preparation respects manual and immediately due triggers", } else { + EarlyNominationTestAccess::schedule(herder); // No previous prepare timestamp: the normal fallback triggers now. REQUIRE(herder.getTriggerTimer().expiry_time() == clock.now()); testutil::crankUntil( diff --git a/src/scp/NominationProtocol.cpp b/src/scp/NominationProtocol.cpp index fed728c4fa..015bd8f814 100644 --- a/src/scp/NominationProtocol.cpp +++ b/src/scp/NominationProtocol.cpp @@ -593,8 +593,8 @@ NominationProtocol::stripUpgrades(ValueWrapperPtr& value) const // attempts to nominate a value for consensus bool -NominationProtocol::nominate(ValueWrapperPtr value, Value const& previousValue, - bool timedout) +NominationProtocol::nominate(NominationValueSupplier const& makeValue, + Value const& previousValue, bool timedout) { ZoneScoped; @@ -608,8 +608,7 @@ NominationProtocol::nominate(ValueWrapperPtr value, Value const& previousValue, return false; } - CLOG_DEBUG(SCP, "NominationProtocol::nominate ({}) {}", mRoundNumber, - mSlot.getSCP().getValueString(value->getValue())); + CLOG_DEBUG(SCP, "NominationProtocol::nominate ({})", mRoundNumber); bool updated = false; @@ -662,6 +661,7 @@ NominationProtocol::nominate(ValueWrapperPtr value, Value const& previousValue, mSlot.getSCPDriver().getUpgradeNominationTimeoutLimit(); bool shouldVoteForValue = false; + bool shouldStripUpgrades = false; // Add our value if we haven't added any votes yet. if (mVotes.empty()) { @@ -692,19 +692,34 @@ NominationProtocol::nominate(ValueWrapperPtr value, Value const& previousValue, { // All votes have upgrades, so strip upgrades from `value` and // vote for it. - stripUpgrades(value); + shouldStripUpgrades = true; shouldVoteForValue = true; } } if (shouldVoteForValue) { - auto ins = mVotes.insert(value); - if (ins.second) + auto value = makeValue(); + // Making the value can make pending envelopes ready and reenter + // SCP, potentially externalizing this slot or creating a candidate. + // Do not vote or rearm its timer after nomination has stopped. + if (!mNominationStarted || !mCandidates.empty()) { - updated = true; - mSlot.getSCPDriver().nominatingValue(mSlot.getSlotIndex(), - value->getValue()); + return false; + } + if (value) + { + if (shouldStripUpgrades) + { + stripUpgrades(value); + } + auto ins = mVotes.insert(value); + if (ins.second) + { + updated = true; + mSlot.getSCPDriver().nominatingValue(mSlot.getSlotIndex(), + value->getValue()); + } } } } @@ -712,8 +727,8 @@ NominationProtocol::nominate(ValueWrapperPtr value, Value const& previousValue, std::shared_ptr slot = mSlot.shared_from_this(); mSlot.getSCPDriver().setupTimer( mSlot.getSlotIndex(), Slot::NOMINATION_TIMER, timeout, - [slot, value, previousValue]() { - slot->nominate(value, previousValue, true); + [slot, makeValue, previousValue]() { + slot->nominate(makeValue, previousValue, true); }); #ifdef BUILD_TESTS diff --git a/src/scp/NominationProtocol.h b/src/scp/NominationProtocol.h index 9eb32dfcc9..cf0e3656e1 100644 --- a/src/scp/NominationProtocol.h +++ b/src/scp/NominationProtocol.h @@ -105,8 +105,8 @@ class NominationProtocol static std::vector getStatementValues(SCPStatement const& st); // attempts to nominate a value for consensus - bool nominate(ValueWrapperPtr value, Value const& previousValue, - bool timedout); + bool nominate(NominationValueSupplier const& makeValue, + Value const& previousValue, bool timedout); // stops the nomination protocol void stopNomination(); diff --git a/src/scp/SCP.cpp b/src/scp/SCP.cpp index 46e9778f3f..8afbc3a6b3 100644 --- a/src/scp/SCP.cpp +++ b/src/scp/SCP.cpp @@ -34,11 +34,11 @@ SCP::receiveEnvelope(SCPEnvelopeWrapperPtr envelope) } bool -SCP::nominate(uint64 slotIndex, ValueWrapperPtr value, +SCP::nominate(uint64 slotIndex, NominationValueSupplier const& makeValue, Value const& previousValue) { dbgAssert(isValidator()); - return getSlot(slotIndex, true)->nominate(value, previousValue, false); + return getSlot(slotIndex, true)->nominate(makeValue, previousValue, false); } std::set diff --git a/src/scp/SCP.h b/src/scp/SCP.h index f55f4a9f4c..e49e3535de 100644 --- a/src/scp/SCP.h +++ b/src/scp/SCP.h @@ -51,9 +51,9 @@ class SCP // invokes the appropriate methods EnvelopeState receiveEnvelope(SCPEnvelopeWrapperPtr envelope); - // Submit a value to consider for slotIndex + // Start nomination for slotIndex, constructing a local value only if needed // previousValue is the value from slotIndex-1 - bool nominate(uint64 slotIndex, ValueWrapperPtr value, + bool nominate(uint64 slotIndex, NominationValueSupplier const& makeValue, Value const& previousValue); // stops nomination for a slot diff --git a/src/scp/SCPDriver.h b/src/scp/SCPDriver.h index 0a1a4e53a7..19fcbfc5ec 100644 --- a/src/scp/SCPDriver.h +++ b/src/scp/SCPDriver.h @@ -44,6 +44,11 @@ class ValueWrapper : public NonMovableOrCopyable typedef std::shared_ptr SCPQuorumSetPtr; typedef std::shared_ptr ValueWrapperPtr; +// Called only when the local node is a nomination leader and needs its own +// value. May return nullptr if the application can no longer propose for the +// slot. The callback must remain valid across nomination timeouts. +using NominationValueSupplier = std::function; + class WrappedValuePtrComparator { public: diff --git a/src/scp/Slot.cpp b/src/scp/Slot.cpp index bff0557579..4971fc2e27 100644 --- a/src/scp/Slot.cpp +++ b/src/scp/Slot.cpp @@ -225,9 +225,10 @@ Slot::bumpState(Value const& value, bool force) } bool -Slot::nominate(ValueWrapperPtr value, Value const& previousValue, bool timedout) +Slot::nominate(NominationValueSupplier const& makeValue, + Value const& previousValue, bool timedout) { - return mNominationProtocol.nominate(value, previousValue, timedout); + return mNominationProtocol.nominate(makeValue, previousValue, timedout); } void diff --git a/src/scp/Slot.h b/src/scp/Slot.h index ecf1e8fee5..3b556a904e 100644 --- a/src/scp/Slot.h +++ b/src/scp/Slot.h @@ -125,8 +125,8 @@ class Slot : public std::enable_shared_from_this bool bumpState(Value const& value, bool force); // attempts to nominate a value for consensus - bool nominate(ValueWrapperPtr value, Value const& previousValue, - bool timedout); + bool nominate(NominationValueSupplier const& makeValue, + Value const& previousValue, bool timedout); void stopNomination(); diff --git a/src/scp/test/SCPTests.cpp b/src/scp/test/SCPTests.cpp index 24674fe98c..8f57dda9b3 100644 --- a/src/scp/test/SCPTests.cpp +++ b/src/scp/test/SCPTests.cpp @@ -189,7 +189,8 @@ class TestSCP : public SCPDriver nominate(uint64 slotIndex, Value const& value, bool timedout) { auto wv = wrapValue(value); - return mSCP.getSlot(slotIndex, true)->nominate(wv, value, timedout); + return mSCP.getSlot(slotIndex, true) + ->nominate([wv]() { return wv; }, value, timedout); } // only used by nomination protocol diff --git a/src/scp/test/SCPUnitTests.cpp b/src/scp/test/SCPUnitTests.cpp index dff33931e9..50dbd484af 100644 --- a/src/scp/test/SCPUnitTests.cpp +++ b/src/scp/test/SCPUnitTests.cpp @@ -229,7 +229,7 @@ class LeaderPreviewTestDriver : public TestNominationSCP { return 0; } - auto winner = round < 3 ? nodes[0] : nodes[1]; + auto winner = round < 3 ? nodes[0] : round == 3 ? nodes[1] : nodes[2]; return id == winner || (tie && round < 3 && id == nodes[2]) ? 100 : 1; } @@ -275,7 +275,14 @@ TEST_CASE("nomination leader preview has no protocol side effects", REQUIRE(driver.emitted == 0); REQUIRE(driver.timers == 0); - slot->nominate(std::make_shared(value), previous, false); + size_t builds = 0; + slot->nominate( + [&]() { + ++builds; + return std::make_shared(value); + }, + previous, false); + REQUIRE(builds == 0); REQUIRE(slot->getNominationLeaders() == first); REQUIRE(driver.emitted == 0); REQUIRE(driver.timers == 1); @@ -289,6 +296,95 @@ TEST_CASE("nomination leader preview has no protocol side effects", REQUIRE(slot->getNominationLeaders() == firstTwo); REQUIRE(driver.emitted == 1); REQUIRE(driver.timers == 2); + REQUIRE(builds == 1); + timeout = std::move(driver.nominationTimeout); + REQUIRE(timeout); + timeout(); + REQUIRE(builds == 1); +} + +TEST_CASE("lazy nomination follows leaders and handles unavailable values", + "[scp][early-nomination]") +{ + SIMULATION_CREATE_NODE(0); + SIMULATION_CREATE_NODE(1); + SIMULATION_CREATE_NODE(2); + SCPQuorumSet qset; + qset.threshold = 3; + qset.validators = {v0NodeID, v1NodeID, v2NodeID}; + LeaderPreviewTestDriver driver(v1NodeID, qset); + auto& scp = driver.mSCP; + Value previous{42}, value{43}; + size_t builds = 0; + bool available = true; + bool stopWhileBuilding = false; + NominationValueSupplier makeValue = [&]() -> ValueWrapperPtr { + ++builds; + if (stopWhileBuilding) + { + scp.stopNomination(7); + } + return available ? std::make_shared(value) : nullptr; + }; + + SECTION("a follower votes for the leader without constructing a value") + { + SCPEnvelope envelope; + envelope.statement.nodeID = v0NodeID; + envelope.statement.slotIndex = 7; + envelope.statement.pledges.type(SCP_ST_NOMINATE); + auto& nom = envelope.statement.pledges.nominate(); + nom.quorumSetHash = sha256(xdr::xdr_to_opaque(qset)); + nom.votes.push_back(value); + REQUIRE(scp.receiveEnvelope(driver.wrapEnvelope(envelope)) == + SCP::VALID); + REQUIRE(scp.nominate(7, makeValue, previous)); + REQUIRE(builds == 0); + REQUIRE(driver.emitted == 1); + auto timeout = std::move(driver.nominationTimeout); + timeout(); + REQUIRE(scp.getNominationLeaders(7).count(v1NodeID)); + // Even a promoted leader needs no private value if it already follows + // a usable value from the first leader. + REQUIRE(builds == 0); + } + SECTION("an unavailable proposal is retried on the next timeout") + { + available = false; + REQUIRE(!scp.nominate(7, makeValue, previous)); + REQUIRE(builds == 0); + auto timeout = std::move(driver.nominationTimeout); + timeout(); + REQUIRE(builds == 1); + REQUIRE(driver.emitted == 0); + available = true; + timeout = std::move(driver.nominationTimeout); + REQUIRE(timeout); + timeout(); + REQUIRE(builds == 2); + REQUIRE(driver.emitted == 1); + } + SECTION("stopping nomination during construction cannot emit or rearm") + { + stopWhileBuilding = true; + scp.nominate(7, makeValue, previous); + REQUIRE(builds == 0); + auto timeout = std::move(driver.nominationTimeout); + timeout(); + REQUIRE(builds == 1); + REQUIRE(driver.emitted == 0); + REQUIRE(driver.timers == 1); + } + SECTION("a stopped follower never constructs a proposal") + { + scp.nominate(7, makeValue, previous); + scp.stopNomination(7); + auto timeout = std::move(driver.nominationTimeout); + timeout(); + REQUIRE(builds == 0); + REQUIRE(driver.emitted == 0); + REQUIRE(driver.timers == 1); + } } TEST_CASE("nomination leader preview preserves ties and zero weights", diff --git a/src/simulation/ApplyLoad.cpp b/src/simulation/ApplyLoad.cpp index b47e572655..0e98d9fe1e 100644 --- a/src/simulation/ApplyLoad.cpp +++ b/src/simulation/ApplyLoad.cpp @@ -1036,8 +1036,13 @@ ApplyLoad::closeBenchmarkLedger(std::vector const& txs, // Nomination through externalization and apply use production SCP paths. herder.getPendingEnvelopes().putTxSet(receivedTxSet->getContentsHash(), ledgerSeq, receivedTxSet); - herder.getHerderSCPDriver().nominate(ledgerSeq, nominatedValue, - receivedTxSet, lcl.header.scpValue); + auto& driver = herder.getHerderSCPDriver(); + driver.nominate( + ledgerSeq, + [&driver, nominatedValue]() { + return driver.wrapStellarValue(nominatedValue); + }, + lcl.header.scpValue); auto const deadline = std::chrono::steady_clock::now() + std::chrono::seconds(60); From 2b05be10d78e447889899da9f9c58739cf74bcea Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Mon, 9 Nov 2026 10:56:43 -0800 Subject: [PATCH 05/23] Build legacy tx sets on every validator under leader-only nomination Leader-only construction left followers without a local tx set, so they had to fetch the leader's. The Rust overlay only carries generalized tx sets, so before protocol 20 (legacy TransactionSet) a follower could not obtain the leader's set at all: it waited until nomination timeouts promoted it to leader and it built the set itself. A network created at the genesis protocol (perfnet) therefore stalled before reaching its upgrade: 22 of 30 nodes reached ledger 2, 8 stayed at ledger 1. For ledgers whose LCL is before protocol 20, every validator constructs its nomination value at the trigger again, as before leader-only construction; it is voted only if the node becomes a round leader. With an empty mempool (genesis and upgrade-only ledgers) the legacy set depends only on the previous ledger, so every validator holds the leader's set. Leader-only construction is unchanged from protocol 20 on. Add a Rust overlay simulation that starts at the genesis protocol, closes legacy-set ledgers, upgrades straight to the latest protocol and keeps closing ledgers. It fails without this change (a node stays at ledger 2 while the others close). --- docs/rust-overlay/txset-fetching.md | 6 + src/herder/HerderImpl.cpp | 26 ++++- src/herder/HerderImpl.h | 3 + src/herder/HerderSCPDriver.cpp | 16 ++- src/herder/HerderSCPDriver.h | 8 +- src/overlay/test/OverlayIPCTests.cpp | 159 +++++++++++++++++++++++++++ 6 files changed, 211 insertions(+), 7 deletions(-) diff --git a/docs/rust-overlay/txset-fetching.md b/docs/rust-overlay/txset-fetching.md index 826bf17cfe..e6e8fb5d55 100644 --- a/docs/rust-overlay/txset-fetching.md +++ b/docs/rust-overlay/txset-fetching.md @@ -33,6 +33,12 @@ First-round leaders may prepare before the trigger; later leaders do no speculative preparation. Nomination stops on externalization even for followers that never constructed a local value. +Ledgers closing on a pre-protocol-20 LCL are the exception. Their legacy +`TransactionSet`s cannot be carried by this overlay, so every validator builds +its own value at the trigger, as before leader-only construction. With an empty +mempool (genesis and the upgrade-only ledgers before protocol 20) the set depends +only on the previous ledger, so each validator already holds the leader's set. + Core sends `CacheTxSet` as soon as a locally constructed proposal's final XDR is available, before the builder's roundtrip and final validation. Rust eagerly compresses it at zstd level 1 on a blocking worker while Core continues those diff --git a/src/herder/HerderImpl.cpp b/src/herder/HerderImpl.cpp index 36c3e4c953..aa25a17fbd 100644 --- a/src/herder/HerderImpl.cpp +++ b/src/herder/HerderImpl.cpp @@ -1706,13 +1706,17 @@ HerderImpl::buildTxSet(uint32_t ledgerSeq, ConsensusTime closeTime) releaseAssert(closeTime > getConsensusTime(lcl.header.scpValue)); bool const activeLeader = getSCP().getNominationLeaders(ledgerSeq).count( getSCP().getLocalNodeID()); - releaseAssert(activeLeader || + bool const legacyTxSet = buildsLegacyTxSet(lcl.header.ledgerVersion); + releaseAssert(activeLeader || legacyTxSet || getSCP() .predictNominationLeaders( ledgerSeq, xdr::xdr_to_opaque(lcl.header.scpValue), 1) .count(getSCP().getLocalNodeID())); - CLOG_INFO(Herder, "Building TX set as {} nomination leader for ledger {}", - activeLeader ? "active" : "first-round", ledgerSeq); + CLOG_INFO(Herder, "Building TX set as {} for ledger {}", + activeLeader ? "active nomination leader" + : legacyTxSet ? "validator (legacy tx set)" + : "first-round nomination leader", + ledgerSeq); // Apply-time offset: see the comment in triggerNextLedger auto const closeTimeOffset = closeTime.toApplyTime() - getApplyTime(lcl.header.scpValue); @@ -1982,7 +1986,21 @@ HerderImpl::triggerNextLedger(uint32_t ledgerSeqToTrigger, [this, ledgerSeqToTrigger, checkTrackingSCP]() { return makeNominationValue(ledgerSeqToTrigger, checkTrackingSCP); }, - lcl.header.scpValue); + lcl.header.scpValue, + /*constructValueNow=*/buildsLegacyTxSet(lcl.header.ledgerVersion)); +} + +bool +HerderImpl::buildsLegacyTxSet(uint32_t lclLedgerVersion) +{ + // Ledgers closing on a pre-Soroban LCL use legacy (non-generalized) tx + // sets, which the Rust overlay can neither fetch nor serve: a follower + // can only obtain the leader's set by building it. Every validator + // therefore constructs its value at the trigger for these ledgers, as + // before leader-only construction. With an empty mempool (genesis and + // the upgrade-only ledgers up to protocol 20) the set depends only on the + // previous ledger, so all validators build the same set as the leader. + return protocolVersionIsBefore(lclLedgerVersion, SOROBAN_PROTOCOL_VERSION); } ValueWrapperPtr diff --git a/src/herder/HerderImpl.h b/src/herder/HerderImpl.h index 52b28ed820..ac14c4d2aa 100644 --- a/src/herder/HerderImpl.h +++ b/src/herder/HerderImpl.h @@ -271,6 +271,9 @@ class HerderImpl : public Herder void discardPreparedTxSet(); ValueWrapperPtr makeNominationValue(uint32_t ledgerSeq, bool checkTrackingSCP); + // Whether a ledger closing on an LCL with this protocol uses a legacy + // (non-generalized) tx set, which every validator builds locally. + static bool buildsLegacyTxSet(uint32_t lclLedgerVersion); // Compute the trigger-timer anchor point using the local node's // prepare-start timestamp for the previous slot. Returns a pessimistic diff --git a/src/herder/HerderSCPDriver.cpp b/src/herder/HerderSCPDriver.cpp index 550e5084ae..6d38fe72e5 100644 --- a/src/herder/HerderSCPDriver.cpp +++ b/src/herder/HerderSCPDriver.cpp @@ -1339,7 +1339,8 @@ HerderSCPDriver::logQuorumInformationAndUpdateMetrics(uint64_t index) void HerderSCPDriver::nominate(uint64_t slotIndex, NominationValueSupplier makeValue, - StellarValue const& previousValue) + StellarValue const& previousValue, + bool constructValueNow) { ZoneScoped; if (mLedgerSeqNominating != slotIndex) @@ -1347,6 +1348,19 @@ HerderSCPDriver::nominate(uint64_t slotIndex, NominationValueSupplier makeValue, mCurrentValue.reset(); } mLedgerSeqNominating = static_cast(slotIndex); + if (constructValueNow && !mCurrentValue) + { + auto value = makeValue(); + // Publishing the tx set may externalize this slot, which stops its + // nomination. Do not restart it. + if (mLedgerSeqNominating != slotIndex) + { + return; + } + // A null value is retried by the supplier below if this node becomes + // a leader. + mCurrentValue = std::move(value); + } auto prevValue = xdr::xdr_to_opaque(previousValue); mSCP.nominate( slotIndex, diff --git a/src/herder/HerderSCPDriver.h b/src/herder/HerderSCPDriver.h index 06354c82ea..047412be30 100644 --- a/src/herder/HerderSCPDriver.h +++ b/src/herder/HerderSCPDriver.h @@ -129,10 +129,14 @@ class HerderSCPDriver : public SCPDriver // value for slotIndex. void noteEmptyTxSetValueReplaced(uint64_t slotIndex) override; - // Submit a value to consider for slotIndex + // Start nomination for slotIndex. SCP calls makeValue only when the local + // node is a round leader that needs its own value, unless + // constructValueNow is set: then the value is constructed before + // nomination starts (and reused if this node becomes a leader). // previousValue is the value from slotIndex-1 void nominate(uint64_t slotIndex, NominationValueSupplier makeValue, - StellarValue const& previousValue); + StellarValue const& previousValue, + bool constructValueNow = false); SCPQuorumSetPtr getQSet(Hash const& qSetHash) override; diff --git a/src/overlay/test/OverlayIPCTests.cpp b/src/overlay/test/OverlayIPCTests.cpp index cfa0b5b7a9..196e6e2b56 100644 --- a/src/overlay/test/OverlayIPCTests.cpp +++ b/src/overlay/test/OverlayIPCTests.cpp @@ -3,6 +3,9 @@ // of this distribution or at http://www.apache.org/licenses/LICENSE-2.0 #include "herder/TxSetFrame.h" +#include "herder/Upgrades.h" +#include "ledger/LedgerHeaderUtils.h" +#include "ledger/LedgerManager.h" #include "lib/catch.hpp" #include "overlay/OverlayIPC.h" #include "rust/RustBridge.h" @@ -14,6 +17,8 @@ #include #include +#include +#include #include using namespace stellar; @@ -1600,3 +1605,157 @@ TEST_CASE("Rust overlay applies Soroban TX count upgrade", "[overlay-ipc]") LOG_INFO(DEFAULT_LOG, "✓ Soroban TX count upgrade works with Rust overlay"); } + +/** + * A network created at the genesis protocol must reach the latest protocol + * over the Rust overlay. Before generalized tx sets (protocol 20), proposals + * carry legacy `TransactionSet`s, which the Rust overlay cannot fetch or serve. + * Every validator therefore has to obtain the leader's legacy set locally: + * with an empty mempool, it builds the identical deterministic set itself. + * + * This reproduces the stall seen on perfnet with leader-only tx-set + * construction: followers that never built their own value could not obtain + * the leader's legacy set, so only nodes promoted to leader by nomination + * timeouts could externalize, one slow round at a time. + */ +TEST_CASE("Rust overlay upgrades from genesis through legacy tx sets", + "[overlay-ipc][upgrades]") +{ + requireOverlayBinary(); + + Hash networkID = sha256("Test network passphrase for genesis upgrades"); + auto simulation = std::make_shared(networkID); + + constexpr size_t NUM_NODES = 4; + std::vector keys; + SCPQuorumSet qSet; + qSet.threshold = 3; + for (size_t i = 0; i < NUM_NODES; ++i) + { + keys.push_back( + SecretKey::fromSeed(sha256(fmt::format("GENESIS_UPGRADE_{}", i)))); + qSet.validators.push_back(keys.back().getPublicKey()); + } + + auto cfgs = makeFullMeshConfigs(*simulation, NUM_NODES); + for (size_t i = 0; i < NUM_NODES; ++i) + { + auto& cfg = cfgs[i]; + // Start at the genesis protocol, like a fresh perfnet network. + cfg.USE_CONFIG_FOR_GENESIS = false; + cfg.ARTIFICIALLY_ACCELERATE_TIME_FOR_TESTING = true; + simulation->addNode(keys[i], qSet, &cfg); + } + simulation->startAllNodes(); + + auto nodes = simulation->getNodes(); + auto const expectedClose = simulation->getExpectedLedgerCloseTime(); + auto lclHeader = [](Application::pointer const& node) { + return node->getLedgerManager().getLastClosedLedgerHeader(); + }; + auto logLedgers = [&]() { + for (auto const& node : nodes) + { + auto const lcl = lclHeader(node); + UNSCOPED_INFO(fmt::format( + "node {}: ledger {} protocol {}", node->getConfig().PEER_PORT, + lcl.header.ledgerSeq, lcl.header.ledgerVersion)); + } + }; + // Simulation::crankUntil throws on timeout; report per-node state instead. + auto closesWithin = [&](std::function const& done, + std::chrono::milliseconds budget) { + try + { + simulation->crankUntil(done, budget, false); + return true; + } + catch (std::runtime_error const&) + { + logLedgers(); + return false; + } + }; + // Every node must have externalized a real, signed value (not an + // empty-tx-set replacement) whose tx set it holds, in the expected format. + auto requireRealTxSets = [&](std::optional generalized) { + for (auto const& node : nodes) + { + auto const lcl = lclHeader(node); + CAPTURE(node->getConfig().PEER_PORT, lcl.header.ledgerSeq); + REQUIRE(isSignedStellarValue(lcl.header.scpValue)); + auto txSet = + node->getHerder().getTxSet(lcl.header.scpValue.txSetHash); + REQUIRE(std::holds_alternative(txSet)); + auto const& frame = std::get(txSet); + REQUIRE(frame); + if (generalized) + { + REQUIRE(frame->isGeneralizedTxSet() == *generalized); + } + } + }; + + // Let the overlay connect and the network close its first ledger. + REQUIRE( + closesWithin([&]() { return simulation->haveAllExternalized(2, 1); }, + 30 * expectedClose)); + for (auto const& node : nodes) + { + REQUIRE(lclHeader(node).header.ledgerVersion == + LedgerManager::GENESIS_LEDGER_VERSION); + } + + // Legacy tx-set ledgers must close at the normal cadence. Without a + // locally available leader set, each one waits for nomination timeouts + // (1 s, 2 s, ...) to promote enough followers to leaders. + auto const firstLegacy = lclHeader(nodes[0]).header.ledgerSeq; + constexpr uint32_t LEGACY_LEDGERS = 4; + REQUIRE(closesWithin( + [&]() { + return simulation->haveAllExternalized(firstLegacy + LEGACY_LEDGERS, + 1); + }, + LEGACY_LEDGERS * 5 * expectedClose / 2)); + requireRealTxSets(false); + + // Upgrade straight to the latest protocol. The upgrade ledger itself still + // uses a legacy tx set; the next one is the first generalized set. + Upgrades::UpgradeParameters scheduledUpgrades; + scheduledUpgrades.mUpgradeTime = VirtualClock::from_time_t( + lclHeader(nodes[0]).header.scpValue.closeTime); + scheduledUpgrades.mProtocolVersion = + Config::CURRENT_LEDGER_PROTOCOL_VERSION; + for (auto const& node : nodes) + { + node->getHerder().setUpgrades(scheduledUpgrades); + } + REQUIRE(closesWithin( + [&]() { + return std::all_of( + nodes.begin(), nodes.end(), [&](auto const& node) { + return lclHeader(node).header.ledgerVersion == + Config::CURRENT_LEDGER_PROTOCOL_VERSION; + }); + }, + 10 * expectedClose)); + // A node may already have closed the first generalized-set ledger. + requireRealTxSets(std::nullopt); + + // Leader-only construction resumes at the latest protocol, where + // followers fetch the leader's generalized set through the overlay. + auto const firstLatest = lclHeader(nodes[0]).header.ledgerSeq; + REQUIRE(closesWithin( + [&]() { return simulation->haveAllExternalized(firstLatest + 3, 1); }, + 10 * expectedClose)); + requireRealTxSets(true); + + // Nodes that closed the same ledger agree on it. + std::map hashBySeq; + for (auto const& node : nodes) + { + auto const lcl = lclHeader(node); + auto [it, inserted] = hashBySeq.emplace(lcl.header.ledgerSeq, lcl.hash); + REQUIRE((inserted || it->second == lcl.hash)); + } +} From 8fcfe5d4d7182a9a9e905db8596baea1c481c71e Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Mon, 9 Nov 2026 10:59:40 -0800 Subject: [PATCH 06/23] Complete pending tx-set fetches with locally built sets PendingEnvelopes::addTxSet only cached the set. Envelopes waiting to fetch that hash stayed in the fetching state until the overlay delivered the set again or the sender re-sent the envelope. Upstream's ItemFetcher released them on addTxSet; this branch's IPC fetch path lost that. That matters for sets the overlay cannot deliver: a leader's legacy (pre-protocol 20) set that a validator builds itself after the leader's nomination arrived, or a promoted leader that builds the set it was fetching. For generalized sets it saves the IPC round trip back from Rust. addTxSet now completes a pending fetch the same way recvTxSet does: it updates waiting value wrappers and reprocesses the waiting envelopes, which can reenter SCP (the nomination supplier already handles that). The waiting envelopes are detached before reprocessing, so reentrant fetch changes cannot invalidate the iteration. Completing a fetch now records the overlay.fetch.txset timer, which was never updated. A redundant overlay delivery of a known set is logged at debug level. --- src/herder/PendingEnvelopes.cpp | 55 ++++++++++++++++++----- src/herder/PendingEnvelopes.h | 16 ++++--- src/herder/test/PendingEnvelopesTests.cpp | 25 +++++++++++ 3 files changed, 79 insertions(+), 17 deletions(-) diff --git a/src/herder/PendingEnvelopes.cpp b/src/herder/PendingEnvelopes.cpp index 204fa49860..4b86534f47 100644 --- a/src/herder/PendingEnvelopes.cpp +++ b/src/herder/PendingEnvelopes.cpp @@ -265,6 +265,11 @@ PendingEnvelopes::addTxSet(Hash const& hash, uint64 lastSeenSlotIndex, CLOG_TRACE(Herder, "Add TxSet {}", hexAbbrev(hash)); putTxSet(hash, lastSeenSlotIndex, txset); + // A locally built set can be one we are fetching: a promoted leader can + // build the set it was waiting for, and nobody can serve a legacy set over + // the Rust overlay. Release its waiting envelopes now. This can reenter + // SCP and externalize. + completeTxSetFetch(hash, txset); } bool @@ -274,29 +279,57 @@ PendingEnvelopes::recvTxSet(Hash const& hash, TxSetXDRFrameConstPtr txset) CLOG_INFO(Herder, "Got TxSet {}", hexAbbrev(hash)); // Only accept if we were actually fetching this - auto it = mPendingTxSetFetches.find(hash); - if (it == mPendingTxSetFetches.end()) + if (mPendingTxSetFetches.find(hash) == mPendingTxSetFetches.end()) { - CLOG_WARNING(Herder, "TxSet {} not in pending fetches - rejecting", - hexAbbrev(hash)); + if (hasTxSet(hash)) + { + // E.g. built locally after requesting it from the overlay + CLOG_DEBUG(Herder, "TxSet {} already known - ignoring", + hexAbbrev(hash)); + } + else + { + CLOG_WARNING(Herder, "TxSet {} not in pending fetches - rejecting", + hexAbbrev(hash)); + } return false; } - addTxSet(hash, 0, txset); + putTxSet(hash, 0, txset); + completeTxSetFetch(hash, txset); + return true; +} + +void +PendingEnvelopes::completeTxSetFetch(Hash const& hash, + TxSetXDRFrameConstPtr const& txset) +{ + auto it = mPendingTxSetFetches.find(hash); + if (it == mPendingTxSetFetches.end()) + { + return; + } + // Detach the waiting envelopes first: reprocessing them reenters SCP and + // can start or stop other fetches. + auto envelopes = std::move(it->second); + mPendingTxSetFetches.erase(it); + auto startIt = mTxSetFetchStartTimes.find(hash); + if (startIt != mTxSetFetchStartTimes.end()) + { + mFetchTxSetTimer.Update(mApp.getClock().now() - startIt->second); + mTxSetFetchStartTimes.erase(startIt); + } // Update any ValueWrappers that were created before this tx set was // available mHerder.getHerderSCPDriver().onTxSetReceived(hash, txset); - for (auto& env : it->second) + for (auto const& env : envelopes) { - CLOG_INFO(Herder, "Re-processing envelope after TxSet {} fetch", - hexAbbrev(hash)); + CLOG_DEBUG(Herder, "Re-processing envelope after TxSet {} fetch", + hexAbbrev(hash)); mApp.getHerder().recvSCPEnvelope(env); } - mPendingTxSetFetches.erase(hash); - mTxSetFetchStartTimes.erase(hash); - return true; } bool diff --git a/src/herder/PendingEnvelopes.h b/src/herder/PendingEnvelopes.h index 7d9210de3e..68bd319600 100644 --- a/src/herder/PendingEnvelopes.h +++ b/src/herder/PendingEnvelopes.h @@ -98,6 +98,10 @@ class PendingEnvelopes // as it is not sane QSet void discardSCPEnvelopesWithQSet(Hash const& hash); + // Hands a newly known tx set to the envelopes waiting to fetch it. + void completeTxSetFetch(Hash const& hash, + TxSetXDRFrameConstPtr const& txset); + void updateMetrics(); void envelopeReady(SCPEnvelope const& envelope); @@ -163,10 +167,10 @@ class PendingEnvelopes bool recvSCPQuorumSet(Hash const& hash, SCPQuorumSet const& qset); /** - * Add @p txset identified by @p hash to local cache. Notifies - * @see ItemFetcher about that event - it may cause calls to Herder's - * recvSCPEnvelope which in turn may cause calls to @see recvSCPEnvelope - * in PendingEnvelopes. + * Add @p txset identified by @p hash to local cache. If it was being + * fetched, completes the fetch: the envelopes waiting for it are passed + * to Herder's recvSCPEnvelope, which in turn may call @see + * recvSCPEnvelope in PendingEnvelopes, reenter SCP and externalize. */ void addTxSet(Hash const& hash, uint64 lastSeenSlotIndex, TxSetXDRFrameConstPtr txset); @@ -181,8 +185,8 @@ class PendingEnvelopes /** * Check if @p txset identified by @p hash was requested before from peers. - * If not, ignores that @p txset. If it was requested, calls - * @see addTxSet. + * If not, ignores that @p txset. If it was requested, caches it and + * completes the fetch like @see addTxSet. * * Return true if TxSet useful (was asked for). */ diff --git a/src/herder/test/PendingEnvelopesTests.cpp b/src/herder/test/PendingEnvelopesTests.cpp index b50c9a39b2..478ee74adb 100644 --- a/src/herder/test/PendingEnvelopesTests.cpp +++ b/src/herder/test/PendingEnvelopesTests.cpp @@ -201,6 +201,31 @@ TEST_CASE_VERSIONS("PendingEnvelopes recvSCPEnvelope", "[herder]") Herder::ENVELOPE_STATUS_PROCESSED); } + SECTION("process when the tx set being fetched is built locally") + { + REQUIRE(pendingEnvelopes.recvSCPQuorumSet(saneQSetHash, saneQSet)); + REQUIRE(herder.getSCP().getLatestMessage(pk) == nullptr); + auto& fetchTimer = + app->getMetrics().NewTimer({"overlay", "fetch", "txset"}); + auto const fetches = fetchTimer.count(); + + // A promoted leader or a legacy-tx-set validator can build the + // set it is fetching. No overlay delivery may ever follow, so + // adding it completes the fetch and processes the envelope. + pendingEnvelopes.addTxSet(p.second->getContentsHash(), + lcl.header.ledgerSeq + 1, p.second); + auto m = herder.getSCP().getLatestMessage(pk); + REQUIRE(m); + REQUIRE(*m == saneEnvelope); + REQUIRE(fetchTimer.count() == fetches + 1); + + // A later delivery from the overlay is redundant. + REQUIRE(!pendingEnvelopes.recvTxSet(p.second->getContentsHash(), + p.second)); + REQUIRE(pendingEnvelopes.recvSCPEnvelope(saneEnvelope) == + Herder::ENVELOPE_STATUS_PROCESSED); + } + SECTION("process when all data came (tx set first)") { REQUIRE(pendingEnvelopes.recvTxSet(p.second->getContentsHash(), From e5d8948daa7d88acefcfcdcf164f7e3b97b055da Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Mon, 9 Nov 2026 11:02:41 -0800 Subject: [PATCH 07/23] Let promoted nomination leaders propose after losing sync With leader-only construction a follower builds its value only when a nomination timeout promotes it to leader, possibly long after the trigger. makeNominationValue rechecked herder tracking at that point, so a node that lost sync while the slot was stalled (35 s without externalizing) could never propose for that slot, even once promoted. On perfnet that turned the legacy-tx-set stall into a permanent one: nodes waiting for a set they could not fetch lost sync, and then could not build it either. Tracking is checked when the trigger starts nomination, as before; a value built at the trigger kept being nominated after losing sync. The supplier now only rechecks what makes building unsafe or stale (ledger manager synced and not applying, LCL still the slot's predecessor, close time valid). Add a herder test: a follower in a stalled unanimous quorum loses sync and must still propose a valid value once nomination timeouts promote it. It fails without this change (the follower never builds). --- src/herder/HerderImpl.cpp | 14 +++--- src/herder/HerderImpl.h | 3 +- src/herder/test/HerderTests.cpp | 78 +++++++++++++++++++++++++++++++++ 3 files changed, 87 insertions(+), 8 deletions(-) diff --git a/src/herder/HerderImpl.cpp b/src/herder/HerderImpl.cpp index aa25a17fbd..3fd34453af 100644 --- a/src/herder/HerderImpl.cpp +++ b/src/herder/HerderImpl.cpp @@ -1983,8 +1983,8 @@ HerderImpl::triggerNextLedger(uint32_t ledgerSeqToTrigger, getHerderSCPDriver().recordSCPEvent(ledgerSeqToTrigger, true); mHerderSCPDriver.nominate( ledgerSeqToTrigger, - [this, ledgerSeqToTrigger, checkTrackingSCP]() { - return makeNominationValue(ledgerSeqToTrigger, checkTrackingSCP); + [this, ledgerSeqToTrigger]() { + return makeNominationValue(ledgerSeqToTrigger); }, lcl.header.scpValue, /*constructValueNow=*/buildsLegacyTxSet(lcl.header.ledgerVersion)); @@ -2004,13 +2004,15 @@ HerderImpl::buildsLegacyTxSet(uint32_t lclLedgerVersion) } ValueWrapperPtr -HerderImpl::makeNominationValue(uint32_t ledgerSeqToTrigger, - bool checkTrackingSCP) +HerderImpl::makeNominationValue(uint32_t ledgerSeqToTrigger) { // A follower can be promoted long after the trigger. Recheck the ledger // state and select a fresh close time when SCP actually needs our value. - if ((!isTracking() && checkTrackingSCP) || !mLedgerManager.isSynced() || - mLedgerManager.isApplying()) + // Herder tracking was checked at the trigger. Do not require it again: + // a node that lost sync while the slot stalled (e.g. waiting for a tx set + // it cannot fetch) must still propose once promoted, like a value built at + // the trigger would have been, or the slot can stall forever. + if (!mLedgerManager.isSynced() || mLedgerManager.isApplying()) { return nullptr; } diff --git a/src/herder/HerderImpl.h b/src/herder/HerderImpl.h index ac14c4d2aa..7e608a9cc5 100644 --- a/src/herder/HerderImpl.h +++ b/src/herder/HerderImpl.h @@ -269,8 +269,7 @@ class HerderImpl : public Herder PreparedTxSet buildTxSet(uint32_t ledgerSeq, ConsensusTime closeTime); void prepareTxSet(uint32_t ledgerSeq, ConsensusTime closeTime); void discardPreparedTxSet(); - ValueWrapperPtr makeNominationValue(uint32_t ledgerSeq, - bool checkTrackingSCP); + ValueWrapperPtr makeNominationValue(uint32_t ledgerSeq); // Whether a ledger closing on an LCL with this protocol uses a legacy // (non-generalized) tx set, which every validator builds locally. static bool buildsLegacyTxSet(uint32_t lclLedgerVersion); diff --git a/src/herder/test/HerderTests.cpp b/src/herder/test/HerderTests.cpp index 01ab1ebb6f..a5f19bf7d4 100644 --- a/src/herder/test/HerderTests.cpp +++ b/src/herder/test/HerderTests.cpp @@ -7501,6 +7501,84 @@ TEST_CASE("only nomination leaders construct local proposals", REQUIRE(checkedRoles == std::set{0, 1, 2}); } +TEST_CASE("a follower promoted after losing sync still proposes", + "[herder][early-nomination]") +{ + // Unanimous three-node quorum with silent peers: the slot cannot + // externalize, so the local follower eventually loses sync. Nomination + // timeouts must still let it propose a value of its own once promoted. + std::vector keys; + SCPQuorumSet qset; + qset.threshold = 3; + for (int i = 0; i < 3; ++i) + { + keys.push_back(SecretKey::fromSeed( + sha256(fmt::format("early-nomination-node-{}", i)))); + qset.validators.push_back(keys.back().getPublicKey()); + } + + bool checkedFollower = false; + for (int i = 0; i < 3 && !checkedFollower; ++i) + { + VirtualClock clock; + clock.setCurrentVirtualTime(VirtualClock::from_time_t(1000)); + auto cfg = getTestConfig(i); + cfg.HTTP_PORT = 0; + cfg.MANUAL_CLOSE = false; + cfg.ARTIFICIALLY_ACCELERATE_TIME_FOR_TESTING = false; + cfg.FORCE_OLD_STYLE_PREPARE_START_TRIGGER_TIMER = true; + cfg.NODE_SEED = keys[i]; + cfg.QUORUM_SET = qset; + auto app = createTestApplication(clock, cfg); + auto& herder = static_cast(app->getHerder()); + auto& scp = herder.getSCP(); + auto const lcl = app->getLedgerManager().getLastClosedLedgerHeader(); + auto const seq = lcl.header.ledgerSeq + 1; + if (scp.predictNominationLeaders( + seq, xdr::xdr_to_opaque(lcl.header.scpValue), 1) + .count(scp.getLocalNodeID())) + { + // The first leader proposes at the trigger; test a follower. + continue; + } + checkedFollower = true; + herder.getHerderSCPDriver().recordSCPEvent(lcl.header.ledgerSeq, false); + size_t pulls = 0; + herder.mGetTopTransactionsForTesting = [&](size_t) { + ++pulls; + return std::vector{}; + }; + + EarlyNominationTestAccess::schedule(herder); + clock.setCurrentVirtualTime(herder.getTriggerTimer().expiry_time()); + testutil::crankUntil( + app, [&]() { return !scp.getNominationLeaders(seq).empty(); }, + std::chrono::seconds(1)); + REQUIRE(!scp.getNominationLeaders(seq).empty()); + REQUIRE(scp.getLatestMessagesSend(seq).empty()); + REQUIRE(pulls == 0); + + // The stalled slot costs the node its sync before it is promoted. + herder.lostSync(); + REQUIRE(!herder.isTracking()); + + testutil::crankUntil( + app, [&]() { return !scp.getLatestMessagesSend(seq).empty(); }, + std::chrono::seconds(30)); + REQUIRE(scp.getNominationLeaders(seq).count(scp.getLocalNodeID())); + REQUIRE(pulls == 1); + auto messages = scp.getLatestMessagesSend(seq); + REQUIRE(!messages.empty()); + auto const& votes = messages.front().statement.pledges.nominate().votes; + REQUIRE(votes.size() == 1); + REQUIRE(herder.getHerderSCPDriver().validateValue(seq, votes.front(), + true) == + SCPDriver::kFullyValidatedValue); + herder.mGetTopTransactionsForTesting = nullptr; + } + REQUIRE(checkedFollower); +} + TEST_CASE("early underfilled proposals refresh at the trigger", "[herder][early-nomination]") { From 9b6ef061ee7ecd9c145a205482c4987b0b5cfc56 Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Mon, 9 Nov 2026 11:15:02 -0800 Subject: [PATCH 08/23] Retry stalled tx-set fetches and report sets that never arrive Core requested each missing tx set from the Rust overlay once, assuming the overlay handled timeouts and retries (stopAllOutsideRange said so), while the overlay explicitly has neither: a request to a peer that is silent or lacks the set (there is no negative response) stays reserved until that peer disconnects. A follower then waited forever, silently. Pending fetches and their envelopes were also never dropped when their slots were purged. Core: PendingEnvelopes keeps per-fetch state (start, last request, newest waiting slot, request count). A timer repeats requests that have not been answered after one second, every second, counts them in overlay.fetch.txset-retry and logs a warning on every doubling of the request count, naming the slot and how long it waited (and that legacy pre-protocol 20 sets cannot be fetched over the Rust overlay, when the LCL is legacy). Fetches whose waiting slots are purged are dropped. Rust: a RequestTxSet for a hash Core is still waiting for is a retry. It replaces the outstanding reservation and goes to another connected peer (the SCP source only if it was not the previous target, otherwise a random one), instead of being deduplicated against the stuck request. LedgerClosed prunes reservations below the retained-slot window, which also drops the prefetches of legacy sets that no peer can serve. Tests: a herder test for retry timing, completion and slot purging, and a dispatcher test for retry peer selection and pruning. --- docs/rust-overlay/txset-fetching.md | 18 ++- overlay/src/libp2p_overlay.rs | 158 ++++++++++++------- overlay/src/libp2p_overlay/dispatch_tests.rs | 71 ++++++++- overlay/src/main.rs | 22 ++- src/herder/PendingEnvelopes.cpp | 124 +++++++++++++-- src/herder/PendingEnvelopes.h | 25 ++- src/herder/test/PendingEnvelopesTests.cpp | 79 ++++++++++ 7 files changed, 414 insertions(+), 83 deletions(-) diff --git a/docs/rust-overlay/txset-fetching.md b/docs/rust-overlay/txset-fetching.md index e6e8fb5d55..a170754a98 100644 --- a/docs/rust-overlay/txset-fetching.md +++ b/docs/rust-overlay/txset-fetching.md @@ -86,8 +86,16 @@ the attempt returns without reserving the hash. A failed write removes only its own reservation. Disconnect cleanup removes reservations assigned to that peer. A received response clears its matching -reservation and records fetch latency and the requested slot. This does not -provide a timeout or automatic retry for a silent peer. +reservation and records fetch latency and the requested slot. `LedgerClosed` +drops reservations older than the retained-slot window (`sequence - 12`). + +Rust has no request timer. Core repeats a `RequestTxSet` for a set it has not +received after one second, then every second, logging a warning on every +doubling of the request count (and counting `overlay.fetch.txset-retry`). +A request for a hash Core is still waiting for is a retry: it replaces the +reservation and goes to another connected peer, preferring the SCP source only +if it was not the previous target, else a random one. Core stops fetching when +the slots waiting for the set are purged. ## Cache and externalization @@ -109,6 +117,8 @@ See [mempool](mempool.md). ## Remaining limitations -- A peer that stays connected but silent can leave a fetch pending indefinitely. -- A cache miss at the selected peer has no explicit negative response or retry. +- A cache miss at the selected peer has no explicit negative response; the + requester only notices through Core's one-second retry. - Selecting one connected peer does not guarantee it has the requested body. +- Legacy (pre-protocol 20) `TransactionSet`s cannot be fetched at all; see + encoding ownership. diff --git a/overlay/src/libp2p_overlay.rs b/overlay/src/libp2p_overlay.rs index 38040657a9..0d0eb6bed1 100644 --- a/overlay/src/libp2p_overlay.rs +++ b/overlay/src/libp2p_overlay.rs @@ -96,8 +96,15 @@ pub enum OverlayCommand { BroadcastScp(Vec), /// Broadcast a validated TX to all peers BroadcastTx(Arc), - /// Request TX set from a peer (picks best peer) - FetchTxSet { hash: [u8; 32], slot: u32 }, + /// Request TX set from a peer (picks best peer). `retry` re-requests a + /// set that a previous request has not delivered, from another peer. + FetchTxSet { + hash: [u8; 32], + slot: u32, + retry: bool, + }, + /// Drop TX set request reservations for slots below `min_slot` + PruneTxSetRequests { min_slot: u32 }, /// Send TX set to a specific peer (response to their request) SendTxSet { hash: [u8; 32], @@ -209,9 +216,20 @@ impl OverlayHandle { } pub async fn fetch_txset(&self, hash: [u8; 32], slot: u32) { + self.send_fetch_txset(hash, slot, false).await; + } + + /// Re-request a set an earlier request has not delivered. Unlike + /// `fetch_txset`, this replaces an outstanding reservation and prefers + /// another connected peer. + pub async fn refetch_txset(&self, hash: [u8; 32], slot: u32) { + self.send_fetch_txset(hash, slot, true).await; + } + + async fn send_fetch_txset(&self, hash: [u8; 32], slot: u32, retry: bool) { if let Err(e) = self .cmd_tx - .send(OverlayCommand::FetchTxSet { hash, slot }) + .send(OverlayCommand::FetchTxSet { hash, slot, retry }) .await { warn!( @@ -221,6 +239,22 @@ impl OverlayHandle { } } + /// Forget TX set requests for slots below `min_slot`. A request that is + /// never answered (e.g. a set no peer can serve) otherwise stays reserved + /// until its peer disconnects. + pub async fn prune_txset_requests(&self, min_slot: u32) { + if let Err(e) = self + .cmd_tx + .send(OverlayCommand::PruneTxSetRequests { min_slot }) + .await + { + warn!( + "Overlay command channel closed, failed to send PruneTxSetRequests: {}", + e + ); + } + } + pub async fn send_txset(&self, hash: [u8; 32], data: Arc, to: PeerId) { // Include the StellarMessage discriminant in the existing wire limit. if data.len() > MAX_MESSAGE_SIZE - 4 { @@ -574,8 +608,11 @@ impl StellarOverlay { OverlayCommand::BroadcastTx(tx) => { self.broadcast_tx(tx).await; } - OverlayCommand::FetchTxSet { hash, slot } => { - self.fetch_txset(hash, slot).await; + OverlayCommand::FetchTxSet { hash, slot, retry } => { + self.fetch_txset(hash, slot, retry).await; + } + OverlayCommand::PruneTxSetRequests { min_slot } => { + self.prune_txset_requests(min_slot).await; } OverlayCommand::SendTxSet { hash, data, to, permits } => { let state = Arc::clone(&self.state); @@ -945,67 +982,63 @@ impl StellarOverlay { queue_inv(&self.state, &peers, InvEntry { hash, fee_per_op }).await; } - /// Fetch TX set from a peer - preferring the peer who sent us the SCP message referencing it - async fn fetch_txset(&mut self, hash: [u8; 32], slot: u32) { - // Check if we're already fetching this TxSet from a connected peer (dedup) - { + /// Fetch TX set from a peer - preferring the peer who sent us the SCP message referencing it. + /// A `retry` replaces an outstanding request (which never delivered) and + /// prefers a different connected peer: the previous one may have been + /// silent or not had the set, and there is no negative response. + async fn fetch_txset(&mut self, hash: [u8; 32], slot: u32, retry: bool) { + // Read each shared map on its own; never nest these locks. + let previous_peer = { let pending = self.state.pending_txset_requests.read().await; - if let Some((pending_peer, _, _)) = pending.get(&hash) { - // Check if that peer is still connected - let streams = self.state.peer_streams.read().await; - if streams.contains_key(pending_peer) { - debug!( - "TXSET_FETCH_SKIP: TxSet {:02x?}... already being fetched from {}, skipping duplicate", - &hash[..4], pending_peer - ); - return; - } - // Otherwise, peer disconnected - we'll re-request below - } - } - - // First check if we know which peer has this TX set (from SCP message) + pending.get(&hash).map(|(peer, _, _)| *peer) + }; let known_source = { let sources = self.state.txset_sources.read().await; sources.peek(&hash).cloned() }; - - let peer = if let Some(source_peer) = known_source { - // Verify this peer is still connected - let streams = self.state.peer_streams.read().await; - if streams.contains_key(&source_peer) { - info!( - "TXSET_FETCH: Fetching TX set {:02x?}... from known source {}", - &hash[..4], - source_peer + let streams = self.state.peer_streams.read().await; + // Check if we're already fetching this TxSet from a connected peer (dedup) + if let Some(pending_peer) = previous_peer { + if !retry && streams.contains_key(&pending_peer) { + debug!( + "TXSET_FETCH_SKIP: TxSet {:02x?}... already being fetched from {}, skipping duplicate", + &hash[..4], pending_peer ); - source_peer - } else { - // Source peer disconnected, fall back to any peer - match streams.keys().next().cloned() { - Some(p) => { - info!("TXSET_FETCH: Fetching TX set {:02x?}... from fallback peer {} (source {} disconnected)", - &hash[..4], p, source_peer); - p - } - None => { - warn!( - "TXSET_FETCH_FAIL: No peers to fetch TX set {:02x?}... from", - &hash[..4] - ); - return; - } - } + return; } + // Otherwise the peer disconnected or the request is being retried. + } + // Avoid the previous peer on a retry unless it is the only one left. + let avoid = previous_peer.filter(|p| retry && streams.keys().any(|other| other != p)); + let eligible = |p: &PeerId| streams.contains_key(p) && Some(*p) != avoid; + + // Prefer the peer that referenced the set in an SCP message + let peer = if let Some(source_peer) = known_source.filter(|p| eligible(p)) { + info!( + "TXSET_FETCH: Fetching TX set {:02x?}... from known source {}{}", + &hash[..4], + source_peer, + if retry { " (retry)" } else { "" } + ); + source_peer } else { - // No known source, pick any connected peer - let streams = self.state.peer_streams.read().await; - match streams.keys().next().cloned() { + // No usable known source: pick a connected peer, at random on a + // retry so repeated retries spread over the peers. + let mut candidates = streams.keys().filter(|p| eligible(p)); + let choice = if retry { + use rand::seq::IteratorRandom; + candidates.choose(&mut rand::thread_rng()).cloned() + } else { + candidates.next().cloned() + }; + match choice { Some(p) => { info!( - "TXSET_FETCH: Fetching TX set {:02x?}... from random peer {} (no known source)", + "TXSET_FETCH: Fetching TX set {:02x?}... from peer {} (source {:?}{})", &hash[..4], - p + p, + known_source, + if retry { ", retry" } else { "" } ); p } @@ -1018,6 +1051,7 @@ impl StellarOverlay { } } }; + drop(streams); // Keep selection and reservation in the dispatcher, before spawning // the write, so repeated FetchTxSet commands cannot race past dedup. @@ -1055,6 +1089,20 @@ impl StellarOverlay { }); } + /// Forget requests for slots below `min_slot` that were never answered. + async fn prune_txset_requests(&mut self, min_slot: u32) { + let mut pending = self.state.pending_txset_requests.write().await; + let before = pending.len(); + pending.retain(|_, (_, _, slot)| *slot >= min_slot); + if pending.len() < before { + debug!( + "Pruned {} unanswered TX set requests below slot {}", + before - pending.len(), + min_slot + ); + } + } + /// Request SCP state from all connected peers pub async fn request_scp_state_from_all_peers(&mut self, ledger_seq: u32) { let streams = self.state.peer_streams.read().await; diff --git a/overlay/src/libp2p_overlay/dispatch_tests.rs b/overlay/src/libp2p_overlay/dispatch_tests.rs index 02f75f6b2c..3eddf0bb1d 100644 --- a/overlay/src/libp2p_overlay/dispatch_tests.rs +++ b/overlay/src/libp2p_overlay/dispatch_tests.rs @@ -1252,8 +1252,8 @@ async fn fetch_reservation_is_deduplicated_and_failure_preserves_reassignment() .await .insert(peer, Arc::new(PeerOutboundStreams::new())); let hash = [3; 32]; - overlay.fetch_txset(hash, 12).await; - overlay.fetch_txset(hash, 12).await; + overlay.fetch_txset(hash, 12, false).await; + overlay.fetch_txset(hash, 12, false).await; assert_eq!( overlay.sends.len(), 1, @@ -1289,6 +1289,73 @@ async fn fetch_reservation_is_deduplicated_and_failure_preserves_reassignment() } } +#[tokio::test] +async fn retried_fetch_moves_to_another_peer_and_stale_requests_are_pruned() { + let (_handle, _events, _admissions, mut overlay) = + create_test_overlay(Keypair::generate_ed25519(), Arc::new(OverlayMetrics::new())).unwrap(); + let peers = [PeerId::random(), PeerId::random()]; + for peer in peers { + overlay + .state + .peer_streams + .write() + .await + .insert(peer, Arc::new(PeerOutboundStreams::new())); + } + let hash = [5; 32]; + let requested_peer = |overlay: &StellarOverlay| { + let state = Arc::clone(&overlay.state); + async move { + state + .pending_txset_requests + .read() + .await + .get(&hash) + .map(|(peer, _, slot)| (*peer, *slot)) + } + }; + // The peer that referenced the set in SCP is asked first. + overlay + .state + .txset_sources + .write() + .await + .put(hash, peers[0]); + overlay.fetch_txset(hash, 20, false).await; + assert_eq!(requested_peer(&overlay).await, Some((peers[0], 20))); + // Further prefetches are deduplicated against the outstanding request. + overlay.fetch_txset(hash, 20, false).await; + assert_eq!(overlay.sends.len(), 1); + + // A retry replaces the unanswered request with one to another peer, + // although the SCP source still names the first. + overlay.fetch_txset(hash, 21, true).await; + assert_eq!(overlay.sends.len(), 2); + assert_eq!(requested_peer(&overlay).await, Some((peers[1], 21))); + // With no other peer left, a retry asks the remaining one again. + overlay.state.peer_streams.write().await.remove(&peers[0]); + overlay.fetch_txset(hash, 21, true).await; + assert_eq!(overlay.sends.len(), 3); + assert_eq!(requested_peer(&overlay).await, Some((peers[1], 21))); + + // Requests that are never answered expire by slot. + let other = [6; 32]; + overlay + .state + .pending_txset_requests + .write() + .await + .insert(other, (peers[1], Instant::now(), 40)); + overlay.prune_txset_requests(30).await; + assert_eq!(requested_peer(&overlay).await, None); + assert!(overlay + .state + .pending_txset_requests + .read() + .await + .contains_key(&other)); +} + #[tokio::test] async fn queued_peer_sends_share_payload_and_release_it_on_drop() { let (handle, _events, _admissions, mut overlay) = diff --git a/overlay/src/main.rs b/overlay/src/main.rs index ac6fbc5220..5b2dfa3f6a 100644 --- a/overlay/src/main.rs +++ b/overlay/src/main.rs @@ -1015,6 +1015,10 @@ impl App { hash.copy_from_slice(&msg.payload[0..32]); let slot = u32::from_le_bytes(msg.payload[32..36].try_into().unwrap()); + // Core requests a hash once per fetch and re-requests it only + // when the earlier request has not delivered. Retry that from + // another peer instead of deduplicating against the stuck one. + let retry = self.pending_core_tx_sets.contains_key(&hash); self.pending_core_tx_sets .entry(hash) .and_modify(|needed_slot| *needed_slot = (*needed_slot).max(slot)) @@ -1033,12 +1037,17 @@ impl App { // Not in local cache - request from peers. Spawn so the main // loop never awaits on the bounded libp2p cmd channel. info!( - "TXSET_FETCH_START: TX set {:02x?}... not in cache, fetching from peers", - &hash[..4] + "TXSET_FETCH_START: TX set {:02x?}... not in cache, fetching from peers{}", + &hash[..4], + if retry { " (retry)" } else { "" } ); let handle = self.libp2p_handle.clone(); tokio::spawn(async move { - handle.fetch_txset(hash, slot).await; + if retry { + handle.refetch_txset(hash, slot).await; + } else { + handle.fetch_txset(hash, slot).await; + } }); } } @@ -1177,6 +1186,13 @@ impl App { .evict_before(ledger_seq.saturating_sub(12)); self.pending_core_tx_sets .retain(|_, slot| *slot >= ledger_seq.saturating_sub(12)); + // Requests that were never answered expire with the same + // retained-slot window. + let handle = self.libp2p_handle.clone(); + let min_slot = ledger_seq.saturating_sub(12); + tokio::spawn(async move { + handle.prune_txset_requests(min_slot).await; + }); } } diff --git a/src/herder/PendingEnvelopes.cpp b/src/herder/PendingEnvelopes.cpp index 4b86534f47..cebee5f408 100644 --- a/src/herder/PendingEnvelopes.cpp +++ b/src/herder/PendingEnvelopes.cpp @@ -15,6 +15,7 @@ #include "util/GlobalChecks.h" #include "util/Logging.h" #include "util/MetricsRegistry.h" +#include "util/ProtocolVersion.h" #include "util/UnorderedSet.h" #include #include @@ -35,6 +36,7 @@ PendingEnvelopes::PendingEnvelopes(Application& app, HerderImpl& herder) , mValueSizeCache(TXSET_CACHE_SIZE + QSET_CACHE_SIZE) , mRebuildQuorum(true) , mQuorumTracker(mApp.getConfig().NODE_SEED.getPublicKey()) + , mTxSetFetchRetryTimer(app) , mProcessedCount( app.getMetrics().NewCounter({"scp", "pending", "processed"})) , mDiscardedCount( @@ -45,6 +47,8 @@ PendingEnvelopes::PendingEnvelopes(Application& app, HerderImpl& herder) , mFetchDuration(app.getMetrics().NewTimer({"scp", "fetch", "envelope"})) , mFetchTxSetTimer(app.getMetrics().NewTimer({"overlay", "fetch", "txset"})) , mFetchQsetTimer(app.getMetrics().NewTimer({"overlay", "fetch", "qset"})) + , mTxSetFetchRetries( + app.getMetrics().NewCounter({"overlay", "fetch", "txset-retry"})) , mCostPerSlot(app.getMetrics().NewHistogram({"scp", "cost", "per-slot"})) { } @@ -313,11 +317,12 @@ PendingEnvelopes::completeTxSetFetch(Hash const& hash, // can start or stop other fetches. auto envelopes = std::move(it->second); mPendingTxSetFetches.erase(it); - auto startIt = mTxSetFetchStartTimes.find(hash); - if (startIt != mTxSetFetchStartTimes.end()) + auto fetchIt = mTxSetFetches.find(hash); + if (fetchIt != mTxSetFetches.end()) { - mFetchTxSetTimer.Update(mApp.getClock().now() - startIt->second); - mTxSetFetchStartTimes.erase(startIt); + mFetchTxSetTimer.Update(mApp.getClock().now() - + fetchIt->second.mStarted); + mTxSetFetches.erase(fetchIt); } // Update any ValueWrappers that were created before this tx set was @@ -739,22 +744,26 @@ PendingEnvelopes::startFetch(SCPEnvelope const& envelope) // doesn't need fetching): nothing to do continue; } + auto const slot = envelope.statement.slotIndex; auto it = mPendingTxSetFetches.find(h2); if (it != mPendingTxSetFetches.end()) { // Already fetching - just add envelope to waiting list it->second.push_back(envelope); + auto& fetch = mTxSetFetches.at(h2); + fetch.mSlot = std::max(fetch.mSlot, slot); } else { - // Not fetching yet - start fetch + // Not fetching yet - start fetch. Repeated only if the overlay + // does not deliver it (retryStalledTxSetFetches). auto& vec = mPendingTxSetFetches[h2]; vec.push_back(envelope); - mTxSetFetchStartTimes.emplace(h2, mApp.getClock().now()); - mApp.getOverlayManager().requestTxSet( - h2, - static_cast( - envelope.statement.slotIndex)); // Only once! + auto const now = mApp.getClock().now(); + mTxSetFetches[h2] = TxSetFetchState{now, now, slot, 1}; + mApp.getOverlayManager().requestTxSet(h2, + static_cast(slot)); + scheduleTxSetFetchRetry(); } } @@ -783,7 +792,7 @@ PendingEnvelopes::stopFetch(SCPEnvelope const& envelope) if (vec.empty()) { mPendingTxSetFetches.erase(it); - mTxSetFetchStartTimes.erase(h2); + mTxSetFetches.erase(h2); } } } @@ -942,8 +951,91 @@ PendingEnvelopes::stopAllOutsideRange(std::optional minSlot, maybeRecordCost(it); } } - // Clear pending fetches for old slots - no need to track individual slots - // since Rust overlay handles timeout/retry logic + // Stop fetching tx sets that only purged slots were waiting for, so they + // are no longer re-requested. + for (auto it = mTxSetFetches.begin(); it != mTxSetFetches.end();) + { + auto const slot = it->second.mSlot; + if (slot != slotToKeep && + ((minSlot && slot < *minSlot) || (maxSlot && slot > *maxSlot))) + { + mPendingTxSetFetches.erase(it->first); + it = mTxSetFetches.erase(it); + } + else + { + ++it; + } + } +} + +void +PendingEnvelopes::scheduleTxSetFetchRetry() +{ + if (mTxSetFetchRetryScheduled || mTxSetFetches.empty()) + { + return; + } + mTxSetFetchRetryScheduled = true; + mTxSetFetchRetryTimer.expires_from_now(TX_SET_FETCH_RETRY_INTERVAL); + mTxSetFetchRetryTimer.async_wait( + [this]() { + mTxSetFetchRetryScheduled = false; + retryStalledTxSetFetches(); + }, + &VirtualTimer::onFailureNoop); +} + +void +PendingEnvelopes::retryStalledTxSetFetches() +{ + // The overlay neither times out nor retries a request: a peer can be + // silent or lack the set (there is no negative response), and nobody can + // serve a legacy (pre-protocol 20) set. Repeat requests that have not been + // answered; the overlay sends a repeated request to another peer. + auto const now = mApp.getClock().now(); + bool const legacyLcl = + protocolVersionIsBefore(mApp.getLedgerManager() + .getLastClosedLedgerHeader() + .header.ledgerVersion, + SOROBAN_PROTOCOL_VERSION); + for (auto& [hash, fetch] : mTxSetFetches) + { + if (now - fetch.mLastRequested < TX_SET_FETCH_RETRY_INTERVAL) + { + continue; + } + fetch.mLastRequested = now; + ++fetch.mRequests; + mTxSetFetchRetries.inc(); + auto const waited = + std::chrono::duration_cast( + now - fetch.mStarted); + // Warn on every doubling: a set that never arrives stays visible + // without flooding the log. + if ((fetch.mRequests & (fetch.mRequests - 1)) == 0) + { + CLOG_WARNING(Herder, + "TxSet {} for slot {} not received after {} ms, " + "requesting it again (request {}){}", + hexAbbrev(hash), fetch.mSlot, waited.count(), + fetch.mRequests, + legacyLcl ? ". The Rust overlay cannot fetch legacy " + "(pre-protocol 20) tx sets" + : ""); + } + else + { + CLOG_DEBUG(Herder, + "TxSet {} for slot {} not received after {} ms, " + "requesting it again (request {})", + hexAbbrev(hash), fetch.mSlot, waited.count(), + fetch.mRequests); + } + mApp.getOverlayManager().requestTxSet( + hash, static_cast(fetch.mSlot)); + } + scheduleTxSetFetchRetry(); } void @@ -988,13 +1080,13 @@ PendingEnvelopes::getQSet(Hash const& hash) std::optional PendingEnvelopes::getTxSetWaitingTime(Hash const& hash) const { - auto it = mTxSetFetchStartTimes.find(hash); - if (it == mTxSetFetchStartTimes.end()) + auto it = mTxSetFetches.find(hash); + if (it == mTxSetFetches.end()) { return std::nullopt; } return std::chrono::duration_cast( - mApp.getClock().now() - it->second); + mApp.getClock().now() - it->second.mStarted); } Json::Value diff --git a/src/herder/PendingEnvelopes.h b/src/herder/PendingEnvelopes.h index 68bd319600..4f9ad6e603 100644 --- a/src/herder/PendingEnvelopes.h +++ b/src/herder/PendingEnvelopes.h @@ -9,6 +9,7 @@ #include "herder/QuorumTracker.h" #include "lib/json/json.h" #include "util/RandomEvictionCache.h" +#include "util/Timer.h" #include #include #include @@ -64,9 +65,20 @@ class PendingEnvelopes // hashes of txsets/qsets we're currently fetching std::map> mPendingTxSetFetches; std::map> mPendingQSetFetches; - // when each pending tx set fetch was started, used to report how long - // we've been waiting for a tx set (see getTxSetWaitingTime) - std::map mTxSetFetchStartTimes; + // State of each pending tx set fetch: when it started (see + // getTxSetWaitingTime), the newest slot waiting for it, and its overlay + // requests. The overlay has no request timeout of its own; Core + // re-requests sets it has not delivered (retryStalledTxSetFetches). + struct TxSetFetchState + { + VirtualClock::time_point mStarted; + VirtualClock::time_point mLastRequested; + uint64 mSlot; + uint32_t mRequests; + }; + std::map mTxSetFetches; + VirtualTimer mTxSetFetchRetryTimer; + bool mTxSetFetchRetryScheduled{false}; using TxSetFramCacheItem = std::pair; // recent txsets @@ -91,6 +103,7 @@ class PendingEnvelopes medida::Timer& mFetchDuration; medida::Timer& mFetchTxSetTimer; medida::Timer& mFetchQsetTimer; + medida::Counter& mTxSetFetchRetries; // Tracked cost per slot medida::Histogram& mCostPerSlot; @@ -101,6 +114,8 @@ class PendingEnvelopes // Hands a newly known tx set to the envelopes waiting to fetch it. void completeTxSetFetch(Hash const& hash, TxSetXDRFrameConstPtr const& txset); + void scheduleTxSetFetchRetry(); + void retryStalledTxSetFetches(); void updateMetrics(); @@ -135,6 +150,10 @@ class PendingEnvelopes std::optional maxSlot, uint64 slotToKeep); public: + // How long a tx set request may stay unanswered before it is repeated + static constexpr std::chrono::milliseconds TX_SET_FETCH_RETRY_INTERVAL{ + 1000}; + PendingEnvelopes(Application& app, HerderImpl& herder); ~PendingEnvelopes(); diff --git a/src/herder/test/PendingEnvelopesTests.cpp b/src/herder/test/PendingEnvelopesTests.cpp index 478ee74adb..28ef3d9d82 100644 --- a/src/herder/test/PendingEnvelopesTests.cpp +++ b/src/herder/test/PendingEnvelopesTests.cpp @@ -800,3 +800,82 @@ TEST_CASE("PendingEnvelopes recvSCPEnvelope without parallel tx set download", REQUIRE(herder.getSCP().getLatestMessage(pk) != nullptr); } } + +TEST_CASE("PendingEnvelopes re-requests tx sets the overlay does not deliver", + "[herder]") +{ + Config cfg(getTestConfig()); + VirtualClock clock; + auto s = SecretKey::pseudoRandomForTesting(); + auto& pk = s.getPublicKey(); + cfg.QUORUM_SET.validators.emplace_back(pk); + Application::pointer app = createTestApplication(clock, cfg); + auto const lcl = app->getLedgerManager().getLastClosedLedgerHeader(); + auto& herder = static_cast(app->getHerder()); + auto& pendingEnvelopes = herder.getPendingEnvelopes(); + + auto root = app->getRoot(); + std::vector accs; + for (size_t i = 0; i < 2; i++) + { + accs.push_back(TestAccount{*app, getAccount("A" + std::to_string(i))}); + } + auto qSet = SCPQuorumSet{}; + qSet.threshold = 1; + qSet.validators.push_back(pk); + auto qSetHash = sha256(xdr::xdr_to_opaque(qSet)); + auto p = makeTxPair(herder, s, makeTransactions(*app, accs, *root, 2), 10); + auto const hash = p.second->getContentsHash(); + auto const slot = lcl.header.ledgerSeq + 1; + auto envelope = makeEnvelope(herder, s, p, qSetHash, slot); + pendingEnvelopes.addSCPQuorumSet(qSetHash, qSet); + + auto& retries = + app->getMetrics().NewCounter({"overlay", "fetch", "txset-retry"}); + auto const initialRetries = retries.count(); + auto const interval = PendingEnvelopes::TX_SET_FETCH_RETRY_INTERVAL; + // Advance virtual time by exactly `d` (crankFor can jump past it to the + // next timer). + auto crankBy = [&](VirtualClock::duration d) { + bool reached = false; + VirtualTimer sentinel(clock); + sentinel.expires_from_now(d); + sentinel.async_wait([&]() { reached = true; }, + &VirtualTimer::onFailureNoop); + while (!reached && clock.crank(false) > 0) + { + } + REQUIRE(reached); + }; + + REQUIRE(pendingEnvelopes.recvSCPEnvelope(envelope) == + Herder::ENVELOPE_STATUS_FETCHING); + REQUIRE(pendingEnvelopes.getTxSetWaitingTime(hash)); + + // Nothing is repeated before the retry interval. + crankBy(interval / 2); + REQUIRE(retries.count() == initialRetries); + + SECTION("an undelivered set is requested again until it arrives") + { + crankBy(2 * interval); + auto const retried = retries.count() - initialRetries; + REQUIRE(retried >= 1); + REQUIRE(retried <= 2); + + REQUIRE(pendingEnvelopes.recvTxSet(hash, p.second)); + REQUIRE(!pendingEnvelopes.getTxSetWaitingTime(hash)); + crankBy(3 * interval); + REQUIRE(retries.count() == initialRetries + retried); + } + + SECTION("purging the waiting slot stops the fetch") + { + pendingEnvelopes.eraseOutsideRange(slot + 1, std::nullopt, 0); + REQUIRE(!pendingEnvelopes.getTxSetWaitingTime(hash)); + crankBy(3 * interval); + REQUIRE(retries.count() == initialRetries); + // The envelope is gone with its slot, so a late delivery is unused. + REQUIRE(!pendingEnvelopes.recvTxSet(hash, p.second)); + } +} From 3630d31fd741869931e67a2d4e209188bae99f13 Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Mon, 9 Nov 2026 11:37:08 -0800 Subject: [PATCH 09/23] Avoid copying tx-set XDR on the overlay IPC paths The leader copied its set's whole GeneralizedTransactionSet (toXDR) to serialize it into a temporary vector, which CacheTxSet then copied into the IPC message. Followers copied the received payload into a vector to decode it, and makeFromWire copied the decoded set again into the frame. Several frame constructors also copied freshly built local XDR. - CacheTxSet serializes the frame's XDR directly into the IPC payload (TxSetXDRFrame::getGeneralizedXDR gives const access to it). - TX_SET_AVAILABLE decodes in place from the payload and moves the set into the frame (new rvalue makeFromWire overloads), also used by toWireTxSetFrame, makeEmpty and makeFromHistoryTransactions. - PendingEnvelopes::recvTxSet rejects a set whose recomputed content hash differs from the hash it was delivered for; Core keyed sets by the overlay's hash without checking. Add a hidden benchmark ("received tx set processing costs") for the dissemination path. For 6,000 classic payments (1.2 MB) on the laptop: leader encode 0.71 -> 0.35 ms, follower frame 1.16 -> 1.04 ms (n=5 medians). The savings are small for classic sets and grow with Soroban transactions' nested XDR. The benchmark also shows received-set validation at 67 ms with a cold signature cache vs 10.5 ms warm (4 tasks). --- src/herder/HerderImpl.cpp | 14 +-- src/herder/PendingEnvelopes.cpp | 11 ++ src/herder/TxSetFrame.cpp | 51 +++++++- src/herder/TxSetFrame.h | 9 ++ src/herder/test/PendingEnvelopesTests.cpp | 16 +++ src/herder/test/TxSetTests.cpp | 135 ++++++++++++++++++++++ src/overlay/OverlayIPC.cpp | 29 +++-- src/overlay/OverlayIPC.h | 7 +- src/overlay/RustOverlayManager.cpp | 22 ++-- src/overlay/RustOverlayManager.h | 4 +- 10 files changed, 258 insertions(+), 40 deletions(-) diff --git a/src/herder/HerderImpl.cpp b/src/herder/HerderImpl.cpp index 3fd34453af..4282315f69 100644 --- a/src/herder/HerderImpl.cpp +++ b/src/herder/HerderImpl.cpp @@ -1823,10 +1823,10 @@ HerderImpl::buildTxSet(uint32_t ledgerSeq, ConsensusTime closeTime) // validation. Its eager compression runs concurrently in Rust. if (txSet->isGeneralizedTxSet()) { - GeneralizedTransactionSet xdrTxSet; - txSet->toXDR(xdrTxSet); + // Serialized straight into the IPC message, without copying + // the set's XDR first. overlayMgr.cacheTxSet(txSet->getContentsHash(), - xdr::xdr_to_opaque(xdrTxSet), ledgerSeq); + txSet->getGeneralizedXDR(), ledgerSeq); } }); CLOG_INFO(Herder, "Proposed TX set has {} transactions", @@ -2091,11 +2091,9 @@ HerderImpl::makeNominationValue(uint32_t ledgerSeqToTrigger) // The overlay only cached the set built above; peers fetch this one. if (proposedSet->isGeneralizedTxSet()) { - GeneralizedTransactionSet xdrTxSet; - proposedSet->toXDR(xdrTxSet); - mApp.getOverlayManager().cacheTxSet(proposedSet->getContentsHash(), - xdr::xdr_to_opaque(xdrTxSet), - lcl.header.ledgerSeq + 1); + mApp.getOverlayManager().cacheTxSet( + proposedSet->getContentsHash(), + proposedSet->getGeneralizedXDR(), lcl.header.ledgerSeq + 1); } } #endif diff --git a/src/herder/PendingEnvelopes.cpp b/src/herder/PendingEnvelopes.cpp index cebee5f408..e5015cadab 100644 --- a/src/herder/PendingEnvelopes.cpp +++ b/src/herder/PendingEnvelopes.cpp @@ -299,6 +299,17 @@ PendingEnvelopes::recvTxSet(Hash const& hash, TxSetXDRFrameConstPtr txset) return false; } + // The overlay checks the content hash before delivering a set, but the + // frame recomputed it: never file a set under another hash. + if (txset->getContentsHash() != hash) + { + CLOG_WARNING(Herder, + "TxSet {} delivered with content hash {} - " + "rejecting", + hexAbbrev(hash), hexAbbrev(txset->getContentsHash())); + return false; + } + putTxSet(hash, 0, txset); completeTxSetFetch(hash, txset); return true; diff --git a/src/herder/TxSetFrame.cpp b/src/herder/TxSetFrame.cpp index bad5528ccf..43e6362d50 100644 --- a/src/herder/TxSetFrame.cpp +++ b/src/herder/TxSetFrame.cpp @@ -784,6 +784,40 @@ TxSetXDRFrame::TxSetXDRFrame(GeneralizedTransactionSet const& xdrTxSet) { } +TxSetXDRFrame::TxSetXDRFrame(TransactionSet&& xdrTxSet) + : mXDRTxSet(std::move(xdrTxSet)) + , mEncodedSize(xdr::xdr_argpack_size(std::get(mXDRTxSet))) + , mHash(computeNonGeneralizedTxSetContentsHash( + std::get(mXDRTxSet))) +{ +} + +TxSetXDRFrame::TxSetXDRFrame(GeneralizedTransactionSet&& xdrTxSet) + : mXDRTxSet(std::move(xdrTxSet)) + , mEncodedSize( + xdr::xdr_argpack_size(std::get(mXDRTxSet))) + , mHash(xdrSha256(std::get(mXDRTxSet))) +{ +} + +TxSetXDRFrameConstPtr +TxSetXDRFrame::makeFromWire(TransactionSet&& xdrTxSet) +{ + ZoneScoped; + std::shared_ptr txSet( + new TxSetXDRFrame(std::move(xdrTxSet))); + return txSet; +} + +TxSetXDRFrameConstPtr +TxSetXDRFrame::makeFromWire(GeneralizedTransactionSet&& xdrTxSet) +{ + ZoneScoped; + std::shared_ptr txSet( + new TxSetXDRFrame(std::move(xdrTxSet))); + return txSet; +} + TxSetXDRFrameConstPtr TxSetXDRFrame::makeFromWire(TransactionSet const& xdrTxSet) { @@ -1024,11 +1058,11 @@ TxSetXDRFrame::makeEmpty(Hash const& previousLedgerHash, GeneralizedTransactionSet txSet; transactionsToGeneralizedTransactionSetXDR(emptyPhases, previousLedgerHash, txSet); - return TxSetXDRFrame::makeFromWire(txSet); + return TxSetXDRFrame::makeFromWire(std::move(txSet)); } TransactionSet txSet; transactionsToTransactionSetXDR({}, previousLedgerHash, txSet); - return TxSetXDRFrame::makeFromWire(txSet); + return TxSetXDRFrame::makeFromWire(std::move(txSet)); } TxSetXDRFrameConstPtr @@ -1043,7 +1077,7 @@ TxSetXDRFrame::makeFromHistoryTransactions(Hash const& previousLedgerHash, { TransactionSet txSet; transactionsToTransactionSetXDR(txs, previousLedgerHash, txSet); - return TxSetXDRFrame::makeFromWire(txSet); + return TxSetXDRFrame::makeFromWire(std::move(txSet)); } #ifdef BUILD_TESTS @@ -1458,6 +1492,13 @@ TxSetXDRFrame::toXDR(GeneralizedTransactionSet& txSet) const txSet = std::get(mXDRTxSet); } +GeneralizedTransactionSet const& +TxSetXDRFrame::getGeneralizedXDR() const +{ + releaseAssert(isGeneralizedTxSet()); + return std::get(mXDRTxSet); +} + void TxSetXDRFrame::storeXDR(StoredTransactionSet& txSet) const { @@ -2506,13 +2547,13 @@ ApplicableTxSetFrame::toWireTxSetFrame() const { GeneralizedTransactionSet xdrTxSet; toXDR(xdrTxSet); - outputTxSet = TxSetXDRFrame::makeFromWire(xdrTxSet); + outputTxSet = TxSetXDRFrame::makeFromWire(std::move(xdrTxSet)); } else { TransactionSet xdrTxSet; toXDR(xdrTxSet); - outputTxSet = TxSetXDRFrame::makeFromWire(xdrTxSet); + outputTxSet = TxSetXDRFrame::makeFromWire(std::move(xdrTxSet)); } return outputTxSet; } diff --git a/src/herder/TxSetFrame.h b/src/herder/TxSetFrame.h index b2ac0e9bec..78ce87a3e8 100644 --- a/src/herder/TxSetFrame.h +++ b/src/herder/TxSetFrame.h @@ -199,6 +199,11 @@ class TxSetXDRFrame : public NonMovableOrCopyable static TxSetXDRFrameConstPtr makeFromWire(TransactionSet const& xdrTxSet); static TxSetXDRFrameConstPtr makeFromWire(GeneralizedTransactionSet const& xdrTxSet); + // Take ownership of the XDR instead of copying it (a large set has + // thousands of nested allocations). + static TxSetXDRFrameConstPtr makeFromWire(TransactionSet&& xdrTxSet); + static TxSetXDRFrameConstPtr + makeFromWire(GeneralizedTransactionSet&& xdrTxSet); static TxSetXDRFrameConstPtr makeFromStoredTxSet(StoredTransactionSet const& storedSet); @@ -215,6 +220,8 @@ class TxSetXDRFrame : public NonMovableOrCopyable void toXDR(TransactionSet& set) const; void toXDR(GeneralizedTransactionSet& generalizedTxSet) const; void storeXDR(StoredTransactionSet& txSet) const; + // The generalized set's XDR without copying it; the frame is immutable. + GeneralizedTransactionSet const& getGeneralizedXDR() const; ~TxSetXDRFrame() = default; @@ -282,6 +289,8 @@ class TxSetXDRFrame : public NonMovableOrCopyable private: TxSetXDRFrame(TransactionSet const& xdrTxSet); TxSetXDRFrame(GeneralizedTransactionSet const& xdrTxSet); + TxSetXDRFrame(TransactionSet&& xdrTxSet); + TxSetXDRFrame(GeneralizedTransactionSet&& xdrTxSet); std::variant mXDRTxSet; size_t mEncodedSize{}; diff --git a/src/herder/test/PendingEnvelopesTests.cpp b/src/herder/test/PendingEnvelopesTests.cpp index 28ef3d9d82..6b73958303 100644 --- a/src/herder/test/PendingEnvelopesTests.cpp +++ b/src/herder/test/PendingEnvelopesTests.cpp @@ -201,6 +201,22 @@ TEST_CASE_VERSIONS("PendingEnvelopes recvSCPEnvelope", "[herder]") Herder::ENVELOPE_STATUS_PROCESSED); } + SECTION("reject a delivered set whose content hash differs") + { + REQUIRE(pendingEnvelopes.recvSCPQuorumSet(saneQSetHash, saneQSet)); + auto other = TxSetXDRFrame::makeEmpty( + sha256("another previous ledger"), lcl.header.ledgerVersion); + REQUIRE(other->getContentsHash() != p.second->getContentsHash()); + REQUIRE(!pendingEnvelopes.recvTxSet(p.second->getContentsHash(), + other)); + REQUIRE(herder.getSCP().getLatestMessage(pk) == nullptr); + REQUIRE(pendingEnvelopes.getTxSetWaitingTime( + p.second->getContentsHash())); + REQUIRE(pendingEnvelopes.recvTxSet(p.second->getContentsHash(), + p.second)); + REQUIRE(herder.getSCP().getLatestMessage(pk)); + } + SECTION("process when the tx set being fetched is built locally") { REQUIRE(pendingEnvelopes.recvSCPQuorumSet(saneQSetHash, saneQSet)); diff --git a/src/herder/test/TxSetTests.cpp b/src/herder/test/TxSetTests.cpp index 3e497f48f1..f23037071a 100644 --- a/src/herder/test/TxSetTests.cpp +++ b/src/herder/test/TxSetTests.cpp @@ -3,6 +3,7 @@ // of this distribution or at http://www.apache.org/licenses/LICENSE-2.0 #include "crypto/SHA.h" +#include "crypto/SecretKey.h" #include "herder/ParallelTxSetBuilder.h" #include "herder/TxSetFrame.h" #include "herder/TxSetUtils.h" @@ -3693,5 +3694,139 @@ TEST_CASE("parallel tx set validation matches sequential", "[txset]") } } +// Costs on the tx-set dissemination path for a large set: the leader's +// encoding for the overlay, the follower's frame construction from the +// overlay's bytes, and the follower's validation with a cold vs warm +// signature-verification cache. Classic payments (one signature each). +TEST_CASE("received tx set processing costs", "[txset][.][benchmark]") +{ + size_t const txCount = 6000; + int const reps = 5; + VirtualClock clock; + auto cfg = getTestConfig(); + cfg.GENESIS_TEST_ACCOUNT_COUNT = txCount + 1; + cfg.TESTING_UPGRADE_MAX_TX_SET_SIZE = 2 * txCount; + Application::pointer app = createTestApplication(clock, cfg); + auto const lcl = app->getLedgerManager().getLastClosedLedgerHeader(); + auto dest = getGenesisAccount(*app, static_cast(txCount)); + PerPhaseTransactionList phases(2); + for (size_t i = 0; i < txCount; ++i) + { + auto source = getGenesisAccount(*app, static_cast(i)); + phases[0].push_back(transactionFromOperations( + *app, source.getSecretKey(), source.getLastSequenceNumber() + 1, + {payment(dest.getPublicKey(), 1)}, 100)); + } + auto [txSet, applicable] = + makeTxSetFromTransactions(phases, *app, ApplyTimeOffset{}); + REQUIRE(txSet->isGeneralizedTxSet()); + REQUIRE(txSet->sizeTxTotal() == txCount); + auto const bytes = xdr::xdr_to_opaque(txSet->getGeneralizedXDR()); + + using Clock = std::chrono::steady_clock; + auto medianMs = [](std::vector v) { + std::sort(v.begin(), v.end()); + return v[v.size() / 2]; + }; + auto timeMs = [](auto&& f) { + auto start = Clock::now(); + f(); + return std::chrono::duration(Clock::now() - start) + .count(); + }; + auto report = [&](std::string const& what, std::vector const& v) { + auto sorted = v; + std::sort(sorted.begin(), sorted.end()); + std::cout << what << ": median " << medianMs(v) << " ms (min " + << sorted.front() << ", max " << sorted.back() + << ", n=" << v.size() << ")" << std::endl; + }; + + std::cout << "=== " << txCount << " txs, " << bytes.size() + << " XDR bytes ===" << std::endl; + // Leader: hand the set to the overlay. + std::vector encodeCopy, encodeDirect; + for (int i = 0; i < reps; ++i) + { + encodeCopy.push_back(timeMs([&]() { + GeneralizedTransactionSet copy; + txSet->toXDR(copy); + auto out = xdr::xdr_to_opaque(copy); + REQUIRE(out.size() == bytes.size()); + })); + encodeDirect.push_back(timeMs([&]() { + auto const& xdrSet = txSet->getGeneralizedXDR(); + std::vector out(36 + xdr::xdr_argpack_size(xdrSet)); + xdr::xdr_put put(out.data() + 36, out.data() + out.size()); + xdr::xdr_argpack_archive(put, xdrSet); + REQUIRE(out.size() == 36 + bytes.size()); + })); + } + report("leader encode: toXDR copy + xdr_to_opaque", encodeCopy); + report("leader encode: in place from frame", encodeDirect); + + // Follower: decode the overlay's bytes into a frame. + std::vector decode, frameCopy, frameMove; + for (int i = 0; i < reps; ++i) + { + GeneralizedTransactionSet parsed; + decode.push_back( + timeMs([&]() { xdr::xdr_from_opaque(bytes, parsed); })); + frameCopy.push_back(timeMs([&]() { + auto frame = TxSetXDRFrame::makeFromWire(parsed); + REQUIRE(frame->getContentsHash() == txSet->getContentsHash()); + })); + frameMove.push_back(timeMs([&]() { + auto frame = TxSetXDRFrame::makeFromWire(std::move(parsed)); + REQUIRE(frame->getContentsHash() == txSet->getContentsHash()); + })); + } + report("follower decode bytes", decode); + report("follower frame: copy (makeFromWire const&)", frameCopy); + report("follower frame: move (makeFromWire &&)", frameMove); + + // Follower: validate the received set (what herder.txset.validate times). + for (size_t tasks : + {app->getBatchExecutor().preferredTaskCount(), size_t(4), size_t(1)}) + { + app->getBatchExecutor().setPreferredTaskCountForTesting(tasks); + std::vector cold, warm; + for (int i = 0; i < reps; ++i) + { + // A fresh frame per run, as for each received set; built outside + // the timed region. + auto validate = [&](TxSetXDRFrameConstPtr const& received) { + return timeMs([&]() { + auto prepared = received->prepareForApply(*app, lcl.header); + REQUIRE(prepared); + REQUIRE(prepared->checkValid(*app, 0, 0)); + }); + }; + auto first = TxSetXDRFrame::makeFromWire( + GeneralizedTransactionSet(txSet->getGeneralizedXDR())); + auto second = TxSetXDRFrame::makeFromWire( + GeneralizedTransactionSet(txSet->getGeneralizedXDR())); + PubKeyUtils::clearVerifySigCache(); + uint64_t hits = 0, misses = 0; + PubKeyUtils::flushVerifySigCacheCounts(hits, misses); + cold.push_back(validate(first)); + PubKeyUtils::flushVerifySigCacheCounts(hits, misses); + if (i == 0) + { + std::cout << "cold run: " << misses + << " signature verifications, " << hits + << " cache hits" << std::endl; + } + warm.push_back(validate(second)); + } + report("validate, " + std::to_string(tasks) + + " tasks, cold signature cache", + cold); + report("validate, " + std::to_string(tasks) + + " tasks, warm signature cache", + warm); + } +} + } // namespace } // namespace stellar diff --git a/src/overlay/OverlayIPC.cpp b/src/overlay/OverlayIPC.cpp index a26be0d39f..39aa870f1f 100644 --- a/src/overlay/OverlayIPC.cpp +++ b/src/overlay/OverlayIPC.cpp @@ -4,6 +4,7 @@ #include "overlay/OverlayIPC.h" #include "crypto/Hex.h" +#include "util/GlobalChecks.h" #include "util/Logging.h" #include "xdr/Stellar-ledger.h" #include @@ -414,13 +415,16 @@ OverlayIPC::handleMessage(IPCMessage const& msg) { try { + // Decode in place after the hash (offset 32 keeps the 4-byte + // alignment xdrpp requires) and hand over the decoded set. GeneralizedTransactionSet txSet; - std::vector xdrData(msg.payload.begin() + 32, - msg.payload.end()); - xdr::xdr_from_opaque(xdrData, txSet); + xdr::xdr_get get(msg.payload.data() + 32, + msg.payload.data() + msg.payload.size()); + xdr::xdr_argpack_archive(get, txSet); + get.done(); CLOG_INFO(Overlay, "Received TX set {} ({} bytes) from overlay", - hexAbbrev(hash), xdrData.size()); - mOnTxSetReceived(hash, txSet); + hexAbbrev(hash), msg.payload.size() - 32); + mOnTxSetReceived(hash, std::move(txSet)); } catch (std::exception const& e) { @@ -700,7 +704,7 @@ OverlayIPC::requestTxSet(Hash const& hash, uint32_t slotIndex) } void -OverlayIPC::cacheTxSet(Hash const& hash, std::vector const& xdr, +OverlayIPC::cacheTxSet(Hash const& hash, GeneralizedTransactionSet const& txSet, uint32_t slotIndex) { if (!mChannel || !mChannel->isConnected()) @@ -712,14 +716,19 @@ OverlayIPC::cacheTxSet(Hash const& hash, std::vector const& xdr, msg.type = IPCMessageType::CACHE_TX_SET; // Payload: [hash:32][slotSeq:4][txSetXDR...]. The slot the set is for; // used by the Rust overlay to stamp the cache entry for exact age-based - // eviction. - msg.payload.resize(36 + xdr.size()); + // eviction. The set is serialized in place (offset 36 keeps the 4-byte + // alignment xdrpp requires). + auto const xdrSize = xdr::xdr_argpack_size(txSet); + msg.payload.resize(36 + xdrSize); std::memcpy(msg.payload.data(), hash.data(), 32); std::memcpy(msg.payload.data() + 32, &slotIndex, 4); - std::memcpy(msg.payload.data() + 36, xdr.data(), xdr.size()); + xdr::xdr_put put(msg.payload.data() + 36, + msg.payload.data() + msg.payload.size()); + xdr::xdr_argpack_archive(put, txSet); + releaseAssert(put.p_ == put.e_); CLOG_DEBUG(Overlay, "Caching TX set {} for slot {} ({} bytes)", - hexAbbrev(hash), slotIndex, xdr.size()); + hexAbbrev(hash), slotIndex, xdrSize); std::lock_guard lock(mSendMutex); mChannel->send(msg); } diff --git a/src/overlay/OverlayIPC.h b/src/overlay/OverlayIPC.h index 2bd2e9a2ca..1963b6541e 100644 --- a/src/overlay/OverlayIPC.h +++ b/src/overlay/OverlayIPC.h @@ -46,8 +46,9 @@ class OverlayIPC std::function(uint32_t ledgerSeq)>; /// Callback when TX set received from peers (async fetch response) + /// (the callee may take ownership of the decoded set) using TxSetReceivedCallback = std::function; + Hash const& hash, GeneralizedTransactionSet&& txSet)>; /** * Create an OverlayIPC instance. @@ -171,10 +172,10 @@ class OverlayIPC * who request it via TX set fetching. * * @param hash The TX set hash - * @param xdr The serialized TX set XDR + * @param txSet The TX set, serialized directly into the IPC message * @param slotIndex The slot the set is for (stamps the cache entry) */ - void cacheTxSet(Hash const& hash, std::vector const& xdr, + void cacheTxSet(Hash const& hash, GeneralizedTransactionSet const& txSet, uint32_t slotIndex); /// Set callback for received SCP envelopes diff --git a/src/overlay/RustOverlayManager.cpp b/src/overlay/RustOverlayManager.cpp index 4e531a89eb..95cc418189 100644 --- a/src/overlay/RustOverlayManager.cpp +++ b/src/overlay/RustOverlayManager.cpp @@ -63,16 +63,14 @@ RustOverlayManager::start() return mApp.getHerder().getSCPStateForPeer(ledgerSeq); }); - mOverlayIPC->setOnTxSetReceived( - [this](Hash const& hash, GeneralizedTransactionSet const& txSet) { - // Called from IPC reader thread - post to main thread - auto frame = TxSetXDRFrame::makeFromWire(txSet); - mApp.postOnMainThread( - [this, hash, frame]() { - mApp.getHerder().recvTxSet(hash, frame); - }, - "RustOverlayManager: TxSetReceived"); - }); + mOverlayIPC->setOnTxSetReceived([this](Hash const& hash, + GeneralizedTransactionSet&& txSet) { + // Called from IPC reader thread - post to main thread + auto frame = TxSetXDRFrame::makeFromWire(std::move(txSet)); + mApp.postOnMainThread( + [this, hash, frame]() { mApp.getHerder().recvTxSet(hash, frame); }, + "RustOverlayManager: TxSetReceived"); + }); if (!mOverlayIPC->start()) { @@ -221,12 +219,12 @@ RustOverlayManager::requestTxSet(Hash const& txSetHash, uint32_t slotIndex) void RustOverlayManager::cacheTxSet(Hash const& txSetHash, - std::vector const& xdr, + GeneralizedTransactionSet const& txSet, uint32_t slotIndex) { if (mOverlayIPC && !mShuttingDown) { - mOverlayIPC->cacheTxSet(txSetHash, xdr, slotIndex); + mOverlayIPC->cacheTxSet(txSetHash, txSet, slotIndex); } } diff --git a/src/overlay/RustOverlayManager.h b/src/overlay/RustOverlayManager.h index d4709862eb..fc6d95ede7 100644 --- a/src/overlay/RustOverlayManager.h +++ b/src/overlay/RustOverlayManager.h @@ -71,8 +71,8 @@ class RustOverlayManager // Cache a locally-built TX set in Rust overlay. slotIndex is the slot the // set is for, used to stamp the Rust-side cache entry. - void cacheTxSet(Hash const& txSetHash, std::vector const& xdr, - uint32_t slotIndex); + void cacheTxSet(Hash const& txSetHash, + GeneralizedTransactionSet const& txSet, uint32_t slotIndex); // Get top transactions from Rust overlay's mempool for TX set building. // Blocks until the overlay responds, shuts down, or disconnects. From 260c4a7df06b38198a68c119c6eca31da0a8ba40 Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Mon, 9 Nov 2026 11:43:12 -0800 Subject: [PATCH 10/23] Pre-verify mempool signatures on followers at the trigger Before leader-only construction every validator built its own set at the trigger, validating its mempool and so populating the signature verification cache. When the leader's set arrived, its signatures were mostly cache hits. Followers now validate the leader's set cold: the PR's perfnet run saw the received-set validation timer rise from about 158 ms to 205 ms. The "received tx set processing costs" benchmark reproduces that: validating 6,000 transactions takes 67 ms with a cold signature cache and 10.5 ms warm (4 tasks, the physical cores of a perfnet node). At the trigger, a validator that is not a round-1 leader (and not on a legacy tx-set protocol, where everyone builds) pulls its mempool's top transactions once (up to a full set) and verifies their source, operation source and fee source master-key signatures on background tasks, as many as the batch executor would use. The verification goes through SignatureUtils::verify, so it fills exactly the cache entries tx-set validation looks up. Signatures by other signers need ledger state and are left to validation. The prewarm stops as soon as validation of a received set (a validity-cache miss) or a local build begins, which then verify the rest themselves on all cores. The follower's main thread does the pull while it waits for the leader's nomination; it still builds and compresses nothing. In-process simulations share the global signature cache across nodes, so they cannot show the effect; it needs a perfnet comparison. --- docs/rust-overlay/txset-fetching.md | 8 +- src/herder/HerderImpl.cpp | 172 +++++++++++++++++++++++++--- src/herder/HerderImpl.h | 13 +++ src/herder/HerderSCPDriver.cpp | 3 + src/herder/test/HerderTests.cpp | 139 +++++++++++++++++++++- 5 files changed, 313 insertions(+), 22 deletions(-) diff --git a/docs/rust-overlay/txset-fetching.md b/docs/rust-overlay/txset-fetching.md index a170754a98..a4008ca176 100644 --- a/docs/rust-overlay/txset-fetching.md +++ b/docs/rust-overlay/txset-fetching.md @@ -25,8 +25,12 @@ See [transport](transport.md). ## Encoding ownership Only nomination leaders construct local proposals. Followers start SCP with a -lazy value supplier and vote for received leader proposals without pulling the -mempool, building a private set, or compressing it. A node promoted by a +lazy value supplier and vote for received leader proposals without building a +private set or compressing it. At the trigger a follower pulls its mempool's top +transactions once and verifies their master-key signatures on background +threads, so that validating the leader's set hits the signature cache (cold, it +costs about six times as much). The prewarm stops when validation of a received +set or a local build starts. A node promoted by a nomination timeout builds only if SCP needs its own value; it rechecks ledger state and chooses a current close time then. Subsequent rounds reuse that value. First-round leaders may prepare before the trigger; later leaders do no diff --git a/src/herder/HerderImpl.cpp b/src/herder/HerderImpl.cpp index 4282315f69..03409ab83c 100644 --- a/src/herder/HerderImpl.cpp +++ b/src/herder/HerderImpl.cpp @@ -35,8 +35,10 @@ #include "scp/Slot.h" #include "simulation/LoadGenerator.h" #include "transactions/MutableTransactionResult.h" +#include "transactions/SignatureUtils.h" #include "transactions/TransactionFrameBase.h" #include "transactions/TransactionUtils.h" +#include "util/BatchExecutor.h" #include "util/DebugMetaUtils.h" #include "util/Decoder.h" #include "util/LogSlowExecution.h" @@ -62,6 +64,71 @@ using namespace std; namespace stellar { +namespace +{ +// Verifies the signatures in `env` that match the master keys of its source, +// operation source and fee source accounts. This populates the +// signature-verification cache that tx-set validation consults with the same +// (key, signature, hash). Other signers need ledger state; validation verifies +// them itself. +void +verifyMasterKeySignatures(Hash const& networkID, TransactionEnvelope const& env) +{ + auto verify = [](Hash const& contentsHash, auto const& signatures, + std::vector const& keys) { + for (auto const& sig : signatures) + { + for (auto const& key : keys) + { + if (SignatureUtils::verify(sig, key, contentsHash).valid) + { + break; + } + } + } + }; + auto keysOf = [](AccountID const& source, auto const& operations) { + std::vector keys{source}; + for (auto const& op : operations) + { + if (op.sourceAccount) + { + auto key = toAccountID(*op.sourceAccount); + if (std::find(keys.begin(), keys.end(), key) == keys.end()) + { + keys.emplace_back(std::move(key)); + } + } + } + return keys; + }; + + auto frame = TransactionFrameBase::makeTransactionFromWire(networkID, env); + switch (env.type()) + { + case ENVELOPE_TYPE_TX_V0: + verify(frame->getContentsHash(), env.v0().signatures, + keysOf(frame->getSourceID(), env.v0().tx.operations)); + break; + case ENVELOPE_TYPE_TX: + verify(frame->getContentsHash(), env.v1().signatures, + keysOf(frame->getSourceID(), env.v1().tx.operations)); + break; + case ENVELOPE_TYPE_TX_FEE_BUMP: + { + verify(frame->getContentsHash(), env.feeBump().signatures, + {frame->getFeeSourceID()}); + TransactionEnvelope inner(ENVELOPE_TYPE_TX); + inner.v1() = env.feeBump().tx.innerTx.v1(); + verifyMasterKeySignatures(networkID, inner); + break; + } + default: + break; + } +} +} // namespace + // Roughly ~10 minutes of consensus constexpr uint32 const CLOSE_TIME_DRIFT_LEDGER_WINDOW_SIZE = 120; // 10 seconds of drift threshold @@ -1729,20 +1796,9 @@ HerderImpl::buildTxSet(uint32_t ledgerSeq, ConsensusTime closeTime) // Get TXs from Rust overlay auto& overlayMgr = mApp.getOverlayManager(); - auto& lm = mApp.getLedgerManager(); - size_t maxCandidates = lm.getLastMaxTxSetSizeOps(); - if (lm.hasLastClosedSorobanNetworkConfig()) - { - maxCandidates += - lm.getLastClosedSorobanNetworkConfig().ledgerMaxTxCount(); - } - auto txEnvelopes = -#ifdef BUILD_TESTS - mGetTopTransactionsForTesting - ? mGetTopTransactionsForTesting(maxCandidates * 2) - : -#endif - overlayMgr.getTopTransactions(maxCandidates * 2); + // This build validates every candidate itself. + stopSignaturePrewarm(); + auto txEnvelopes = pullTopTransactions(maxTxSetCandidates() * 2); CLOG_INFO(Herder, "Got {} transactions from Rust overlay mempool", txEnvelopes.size()); @@ -1988,6 +2044,94 @@ HerderImpl::triggerNextLedger(uint32_t ledgerSeqToTrigger, }, lcl.header.scpValue, /*constructValueNow=*/buildsLegacyTxSet(lcl.header.ledgerVersion)); + + // A follower validates the leader's set when it arrives, and most of its + // transactions are in this node's mempool too. Verify their signatures + // meanwhile, as building our own set used to before leader-only + // construction, so that validation finds them in the cache. + if (!buildsLegacyTxSet(lcl.header.ledgerVersion) && + !getSCP() + .getNominationLeaders(ledgerSeqToTrigger) + .count(getSCP().getLocalNodeID())) + { + prewarmSignatureCache(); + } +} + +size_t +HerderImpl::maxTxSetCandidates() const +{ + auto& lm = mApp.getLedgerManager(); + size_t maxCandidates = lm.getLastMaxTxSetSizeOps(); + if (lm.hasLastClosedSorobanNetworkConfig()) + { + maxCandidates += + lm.getLastClosedSorobanNetworkConfig().ledgerMaxTxCount(); + } + return maxCandidates; +} + +std::vector +HerderImpl::pullTopTransactions(size_t count) +{ +#ifdef BUILD_TESTS + if (mGetTopTransactionsForTesting) + { + return mGetTopTransactionsForTesting(count); + } +#endif + return mApp.getOverlayManager().getTopTransactions(count); +} + +void +HerderImpl::prewarmSignatureCache() +{ + ZoneScoped; + stopSignaturePrewarm(); + // The leader's set has at most this many transactions, drawn from the + // top of a mempool much like ours. + auto envelopes = std::make_shared const>( + pullTopTransactions(maxTxSetCandidates())); + if (envelopes->empty()) + { + return; + } + auto stop = std::make_shared>(false); + mSignaturePrewarmStop = stop; + // The batch executor (validation) is idle until the leader's set + // arrives; use as many background tasks as it would. + size_t const tasks = std::max( + 1, std::min(mApp.getBatchExecutor().preferredTaskCount(), + mApp.getConfig().WORKER_THREADS)); + CLOG_DEBUG(Herder, + "Pre-verifying signatures of {} transactions in {} tasks", + envelopes->size(), tasks); + for (size_t task = 0; task < tasks; ++task) + { + mApp.postOnBackgroundThread( + [envelopes, stop, networkID = mApp.getNetworkID(), task, tasks]() { + ZoneScopedN("signature prewarm"); + for (size_t i = task; i < envelopes->size(); i += tasks) + { + if (stop->load(std::memory_order_relaxed)) + { + return; + } + verifyMasterKeySignatures(networkID, (*envelopes)[i]); + } + }, + "Herder: signature prewarm"); + } +} + +void +HerderImpl::stopSignaturePrewarm() +{ + if (mSignaturePrewarmStop) + { + mSignaturePrewarmStop->store(true, std::memory_order_relaxed); + mSignaturePrewarmStop.reset(); + } } bool diff --git a/src/herder/HerderImpl.h b/src/herder/HerderImpl.h index 7e608a9cc5..57f1eb0d4f 100644 --- a/src/herder/HerderImpl.h +++ b/src/herder/HerderImpl.h @@ -273,7 +273,20 @@ class HerderImpl : public Herder // Whether a ledger closing on an LCL with this protocol uses a legacy // (non-generalized) tx set, which every validator builds locally. static bool buildsLegacyTxSet(uint32_t lclLedgerVersion); + // Upper bound on the transactions a tx set for the next ledger can hold. + size_t maxTxSetCandidates() const; + std::vector pullTopTransactions(size_t count); + // Verify the signatures of the mempool's top transactions on background + // threads, warming the signature cache for validating the leader's set. + void prewarmSignatureCache(); + std::shared_ptr> mSignaturePrewarmStop; + public: + // Stops a running signature prewarm: called when validation or a local + // build is about to verify the signatures itself. + void stopSignaturePrewarm(); + + private: // Compute the trigger-timer anchor point using the local node's // prepare-start timestamp for the previous slot. Returns a pessimistic // estimate (now - expectedClose) if no prepare-start is recorded. diff --git a/src/herder/HerderSCPDriver.cpp b/src/herder/HerderSCPDriver.cpp index 6d38fe72e5..6fcc27624f 100644 --- a/src/herder/HerderSCPDriver.cpp +++ b/src/herder/HerderSCPDriver.cpp @@ -1959,6 +1959,9 @@ HerderSCPDriver::checkAndCacheTxSetValid(TxSetXDRFrame const& txSet, if (pRes == nullptr) { ZoneNamedN(txSetValidityMissZone, "txset validity cache miss", true); + // Validation verifies the remaining signatures itself, on all cores; + // a concurrent signature prewarm would only compete with it. + mHerder.stopSignaturePrewarm(); auto validationTime = mSCPMetrics.mTxSetValidation.TimeScope(); // The invariant here is that we only validate tx sets nominated diff --git a/src/herder/test/HerderTests.cpp b/src/herder/test/HerderTests.cpp index a5f19bf7d4..756a0ff963 100644 --- a/src/herder/test/HerderTests.cpp +++ b/src/herder/test/HerderTests.cpp @@ -7461,9 +7461,10 @@ TEST_CASE("only nomination leaders construct local proposals", app, [&]() { return !scp.getNominationLeaders(seq).empty(); }, std::chrono::seconds(1)); REQUIRE(scp.getNominationLeaders(seq) == first); - // The first leader refreshes its empty early snapshot. Followers do - // not even pull the mempool when starting nomination. - REQUIRE(pulls == (role == 0 ? 2 : 0)); + // The first leader refreshes its empty early snapshot. Followers + // pull the mempool once, only to pre-verify signatures; they do not + // build or publish a set. + REQUIRE(pulls == (role == 0 ? 2 : 1)); REQUIRE(scp.getLatestMessagesSend(seq).empty() == (role != 0)); // With the first leader silent, real nomination timers eventually @@ -7473,7 +7474,7 @@ TEST_CASE("only nomination leaders construct local proposals", app, [&]() { return !scp.getLatestMessagesSend(seq).empty(); }, std::chrono::seconds(30)); REQUIRE(scp.getNominationLeaders(seq).count(scp.getLocalNodeID())); - REQUIRE(pulls == (role == 0 ? 2 : 1)); + REQUIRE(pulls == 2); auto messages = scp.getLatestMessagesSend(seq); auto const& votes = messages.front().statement.pledges.nominate().votes; REQUIRE(votes.size() == 1); @@ -7556,7 +7557,8 @@ TEST_CASE("a follower promoted after losing sync still proposes", std::chrono::seconds(1)); REQUIRE(!scp.getNominationLeaders(seq).empty()); REQUIRE(scp.getLatestMessagesSend(seq).empty()); - REQUIRE(pulls == 0); + // Only the signature prewarm pull; no build yet. + REQUIRE(pulls == 1); // The stalled slot costs the node its sync before it is promoted. herder.lostSync(); @@ -7566,7 +7568,7 @@ TEST_CASE("a follower promoted after losing sync still proposes", app, [&]() { return !scp.getLatestMessagesSend(seq).empty(); }, std::chrono::seconds(30)); REQUIRE(scp.getNominationLeaders(seq).count(scp.getLocalNodeID())); - REQUIRE(pulls == 1); + REQUIRE(pulls == 2); auto messages = scp.getLatestMessagesSend(seq); REQUIRE(!messages.empty()); auto const& votes = messages.front().statement.pledges.nominate().votes; @@ -7579,6 +7581,131 @@ TEST_CASE("a follower promoted after losing sync still proposes", REQUIRE(checkedFollower); } +TEST_CASE("followers pre-verify mempool signatures at the trigger", + "[herder][early-nomination]") +{ + // Followers no longer validate their own mempool by building a set, so + // the leader's set would be validated with a cold signature cache. At the + // trigger they pre-verify their top transactions' signatures instead. + std::vector keys; + SCPQuorumSet qset; + qset.threshold = 3; + for (int i = 0; i < 3; ++i) + { + keys.push_back(SecretKey::fromSeed( + sha256(fmt::format("early-nomination-node-{}", i)))); + qset.validators.push_back(keys.back().getPublicKey()); + } + + std::set checkedRoles; + for (int i = 0; i < 3 && checkedRoles.size() < 2; ++i) + { + VirtualClock clock; + clock.setCurrentVirtualTime(VirtualClock::from_time_t(1000)); + auto cfg = getTestConfig(i); + cfg.HTTP_PORT = 0; + cfg.MANUAL_CLOSE = false; + cfg.ARTIFICIALLY_ACCELERATE_TIME_FOR_TESTING = false; + cfg.FORCE_OLD_STYLE_PREPARE_START_TRIGGER_TIMER = true; + cfg.NODE_SEED = keys[i]; + cfg.QUORUM_SET = qset; + cfg.GENESIS_TEST_ACCOUNT_COUNT = 41; + auto app = createTestApplication(clock, cfg); + auto& herder = static_cast(app->getHerder()); + auto& scp = herder.getSCP(); + auto const lcl = app->getLedgerManager().getLastClosedLedgerHeader(); + auto const seq = lcl.header.ledgerSeq + 1; + bool const leader = + scp.predictNominationLeaders( + seq, xdr::xdr_to_opaque(lcl.header.scpValue), 1) + .count(scp.getLocalNodeID()) != 0; + if (!checkedRoles.insert(leader).second) + { + continue; + } + CAPTURE(leader); + + // Payments signed by their sources' master keys, one by an operation + // source too, and a fee bump. + auto dest = getGenesisAccount(*app, 40); + std::vector txs; + for (uint32_t a = 0; a < 30; ++a) + { + auto source = getGenesisAccount(*app, a); + txs.push_back(source.tx({payment(dest, 1)})); + } + auto opSource = getGenesisAccount(*app, 30); + auto withOpSource = + getGenesisAccount(*app, 31).tx({opSource.op(payment(dest, 1))}); + withOpSource->addSignature(opSource.getSecretKey()); + txs.push_back(withOpSource); + auto feeSource = getGenesisAccount(*app, 32); + auto inner = getGenesisAccount(*app, 33); + txs.push_back( + feeBump(*app, feeSource, inner.tx({payment(dest, 1)}), 1000)); + std::vector envelopes; + for (auto const& tx : txs) + { + envelopes.push_back(tx->getEnvelope()); + } + herder.getHerderSCPDriver().recordSCPEvent(lcl.header.ledgerSeq, false); + herder.mGetTopTransactionsForTesting = [&](size_t) { + return envelopes; + }; + + PubKeyUtils::clearVerifySigCache(); + uint64_t hits = 0, misses = 0; + PubKeyUtils::flushVerifySigCacheCounts(hits, misses); + size_t const signatures = + txs.size() + 1 /* op source */ + 1 /* fee bump's inner tx */; + EarlyNominationTestAccess::schedule(herder); + clock.setCurrentVirtualTime(herder.getTriggerTimer().expiry_time()); + testutil::crankUntil( + app, [&]() { return !scp.getNominationLeaders(seq).empty(); }, + std::chrono::seconds(1)); + REQUIRE(!scp.getNominationLeaders(seq).empty()); + + if (leader) + { + // The leader validates its own candidates while building, so it + // does not pre-verify. Its build verified every signature. + PubKeyUtils::flushVerifySigCacheCounts(hits, misses); + REQUIRE(misses >= signatures); + herder.mGetTopTransactionsForTesting = nullptr; + continue; + } + + // Background tasks verify every signature once. Wait in real time + // without cranking: virtual nomination timeouts would promote this + // follower, whose build verifies signatures too. + uint64_t verified = 0; + auto const deadline = + std::chrono::steady_clock::now() + std::chrono::seconds(10); + while (verified < signatures && + std::chrono::steady_clock::now() < deadline) + { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + PubKeyUtils::flushVerifySigCacheCounts(hits, misses); + verified += misses; + } + REQUIRE(verified == signatures); + REQUIRE(scp.getLatestMessagesSend(seq).empty()); + + // Validating these transactions now finds every signature cached. + for (auto const& tx : txs) + { + auto ledgerView = app->getLedgerManager().getLCLView(); + REQUIRE(tx->checkValid(app->getAppConnector(), *ledgerView, 0, 0, 0) + ->isSuccess()); + } + PubKeyUtils::flushVerifySigCacheCounts(hits, misses); + REQUIRE(misses == 0); + REQUIRE(hits >= signatures); + herder.mGetTopTransactionsForTesting = nullptr; + } + REQUIRE(checkedRoles == std::set{false, true}); +} + TEST_CASE("early underfilled proposals refresh at the trigger", "[herder][early-nomination]") { From 18fa41bbb826141874ab7ca3826638c33d9d3591 Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Mon, 9 Nov 2026 12:08:25 -0800 Subject: [PATCH 11/23] Back off tx-set fetch retries and retry only undecided slots Follow-up to the fetch retries, from review: - Retries back off (1, 2, 4, then every 8 s). A slow but live transfer of a multi-MB set, under exactly the load where links are slow, was duplicated to another peer every second. - Only sets for slots after the LCL are re-requested. A fetch kept for the checkpoint slot (never purged) was re-requested every second until the checkpoint moved, and the overlay had evicted that set anyway. - overlay.fetch.txset again only times sets delivered by the overlay, not fetches a local build completed. - A Rust retry goes to a random connected peer other than the previous target. Preferring the SCP source again sent every other retry back to a source that may not answer. --- overlay/src/libp2p_overlay.rs | 10 +++-- overlay/src/libp2p_overlay/dispatch_tests.rs | 15 +++++++- src/herder/PendingEnvelopes.cpp | 37 ++++++++++++++---- src/herder/PendingEnvelopes.h | 6 ++- src/herder/test/PendingEnvelopesTests.cpp | 40 ++++++++++++++++---- 5 files changed, 86 insertions(+), 22 deletions(-) diff --git a/overlay/src/libp2p_overlay.rs b/overlay/src/libp2p_overlay.rs index 0d0eb6bed1..a46b6e56b9 100644 --- a/overlay/src/libp2p_overlay.rs +++ b/overlay/src/libp2p_overlay.rs @@ -984,8 +984,8 @@ impl StellarOverlay { /// Fetch TX set from a peer - preferring the peer who sent us the SCP message referencing it. /// A `retry` replaces an outstanding request (which never delivered) and - /// prefers a different connected peer: the previous one may have been - /// silent or not had the set, and there is no negative response. + /// goes to a random connected peer other than the previous one: that may + /// have been silent or not had the set, and there is no negative response. async fn fetch_txset(&mut self, hash: [u8; 32], slot: u32, retry: bool) { // Read each shared map on its own; never nest these locks. let previous_peer = { @@ -1012,8 +1012,10 @@ impl StellarOverlay { let avoid = previous_peer.filter(|p| retry && streams.keys().any(|other| other != p)); let eligible = |p: &PeerId| streams.contains_key(p) && Some(*p) != avoid; - // Prefer the peer that referenced the set in an SCP message - let peer = if let Some(source_peer) = known_source.filter(|p| eligible(p)) { + // Prefer the peer that referenced the set in an SCP message. A retry + // picks a random other peer instead: preferring the source again would + // send every other retry back to a source that may not answer. + let peer = if let Some(source_peer) = known_source.filter(|p| !retry && eligible(p)) { info!( "TXSET_FETCH: Fetching TX set {:02x?}... from known source {}{}", &hash[..4], diff --git a/overlay/src/libp2p_overlay/dispatch_tests.rs b/overlay/src/libp2p_overlay/dispatch_tests.rs index 3eddf0bb1d..361001c855 100644 --- a/overlay/src/libp2p_overlay/dispatch_tests.rs +++ b/overlay/src/libp2p_overlay/dispatch_tests.rs @@ -1332,10 +1332,21 @@ async fn retried_fetch_moves_to_another_peer_and_stale_requests_are_pruned() { overlay.fetch_txset(hash, 21, true).await; assert_eq!(overlay.sends.len(), 2); assert_eq!(requested_peer(&overlay).await, Some((peers[1], 21))); - // With no other peer left, a retry asks the remaining one again. + // The next retry again goes to a peer other than the previous target. + let third = PeerId::random(); + overlay + .state + .peer_streams + .write() + .await + .insert(third, Arc::new(PeerOutboundStreams::new())); overlay.state.peer_streams.write().await.remove(&peers[0]); overlay.fetch_txset(hash, 21, true).await; - assert_eq!(overlay.sends.len(), 3); + assert_eq!(requested_peer(&overlay).await, Some((third, 21))); + overlay.state.peer_streams.write().await.remove(&third); + // With no other peer left, a retry asks the remaining one again. + overlay.fetch_txset(hash, 21, true).await; + assert_eq!(overlay.sends.len(), 4); assert_eq!(requested_peer(&overlay).await, Some((peers[1], 21))); // Requests that are never answered expire by slot. diff --git a/src/herder/PendingEnvelopes.cpp b/src/herder/PendingEnvelopes.cpp index e5015cadab..c8183a5690 100644 --- a/src/herder/PendingEnvelopes.cpp +++ b/src/herder/PendingEnvelopes.cpp @@ -273,7 +273,7 @@ PendingEnvelopes::addTxSet(Hash const& hash, uint64 lastSeenSlotIndex, // build the set it was waiting for, and nobody can serve a legacy set over // the Rust overlay. Release its waiting envelopes now. This can reenter // SCP and externalize. - completeTxSetFetch(hash, txset); + completeTxSetFetch(hash, txset, /*deliveredByOverlay=*/false); } bool @@ -311,13 +311,14 @@ PendingEnvelopes::recvTxSet(Hash const& hash, TxSetXDRFrameConstPtr txset) } putTxSet(hash, 0, txset); - completeTxSetFetch(hash, txset); + completeTxSetFetch(hash, txset, /*deliveredByOverlay=*/true); return true; } void PendingEnvelopes::completeTxSetFetch(Hash const& hash, - TxSetXDRFrameConstPtr const& txset) + TxSetXDRFrameConstPtr const& txset, + bool deliveredByOverlay) { auto it = mPendingTxSetFetches.find(hash); if (it == mPendingTxSetFetches.end()) @@ -331,8 +332,13 @@ PendingEnvelopes::completeTxSetFetch(Hash const& hash, auto fetchIt = mTxSetFetches.find(hash); if (fetchIt != mTxSetFetches.end()) { - mFetchTxSetTimer.Update(mApp.getClock().now() - - fetchIt->second.mStarted); + // overlay.fetch.txset times overlay fetches only, not sets this node + // ended up building itself. + if (deliveredByOverlay) + { + mFetchTxSetTimer.Update(mApp.getClock().now() - + fetchIt->second.mStarted); + } mTxSetFetches.erase(fetchIt); } @@ -983,7 +989,13 @@ PendingEnvelopes::stopAllOutsideRange(std::optional minSlot, void PendingEnvelopes::scheduleTxSetFetchRetry() { - if (mTxSetFetchRetryScheduled || mTxSetFetches.empty()) + // Only sets for undecided slots are re-requested (see + // retryStalledTxSetFetches). + auto const lcl = mApp.getLedgerManager().getLastClosedLedgerNum(); + if (mTxSetFetchRetryScheduled || + std::none_of( + mTxSetFetches.begin(), mTxSetFetches.end(), + [&](auto const& fetch) { return fetch.second.mSlot > lcl; })) { return; } @@ -1005,6 +1017,7 @@ PendingEnvelopes::retryStalledTxSetFetches() // serve a legacy (pre-protocol 20) set. Repeat requests that have not been // answered; the overlay sends a repeated request to another peer. auto const now = mApp.getClock().now(); + auto const lcl = mApp.getLedgerManager().getLastClosedLedgerNum(); bool const legacyLcl = protocolVersionIsBefore(mApp.getLedgerManager() .getLastClosedLedgerHeader() @@ -1012,7 +1025,17 @@ PendingEnvelopes::retryStalledTxSetFetches() SOROBAN_PROTOCOL_VERSION); for (auto& [hash, fetch] : mTxSetFetches) { - if (now - fetch.mLastRequested < TX_SET_FETCH_RETRY_INTERVAL) + // A set for a slot this node already closed (e.g. kept for the + // checkpoint) is not needed for consensus; it was requested once. + if (fetch.mSlot <= lcl) + { + continue; + } + // Back off (1, 2, 4, then every 8 s): a slow but live transfer of a + // large set should not be duplicated to another peer every second. + auto const backoff = TX_SET_FETCH_RETRY_INTERVAL * + (1u << std::min(fetch.mRequests - 1, 3)); + if (now - fetch.mLastRequested < backoff) { continue; } diff --git a/src/herder/PendingEnvelopes.h b/src/herder/PendingEnvelopes.h index 4f9ad6e603..75f5973085 100644 --- a/src/herder/PendingEnvelopes.h +++ b/src/herder/PendingEnvelopes.h @@ -113,7 +113,8 @@ class PendingEnvelopes // Hands a newly known tx set to the envelopes waiting to fetch it. void completeTxSetFetch(Hash const& hash, - TxSetXDRFrameConstPtr const& txset); + TxSetXDRFrameConstPtr const& txset, + bool deliveredByOverlay); void scheduleTxSetFetchRetry(); void retryStalledTxSetFetches(); @@ -150,7 +151,8 @@ class PendingEnvelopes std::optional maxSlot, uint64 slotToKeep); public: - // How long a tx set request may stay unanswered before it is repeated + // How long a tx set request may stay unanswered before it is first + // repeated; later repeats back off up to 8 times this. static constexpr std::chrono::milliseconds TX_SET_FETCH_RETRY_INTERVAL{ 1000}; diff --git a/src/herder/test/PendingEnvelopesTests.cpp b/src/herder/test/PendingEnvelopesTests.cpp index 6b73958303..08e925ab92 100644 --- a/src/herder/test/PendingEnvelopesTests.cpp +++ b/src/herder/test/PendingEnvelopesTests.cpp @@ -233,7 +233,8 @@ TEST_CASE_VERSIONS("PendingEnvelopes recvSCPEnvelope", "[herder]") auto m = herder.getSCP().getLatestMessage(pk); REQUIRE(m); REQUIRE(*m == saneEnvelope); - REQUIRE(fetchTimer.count() == fetches + 1); + // Not an overlay fetch: overlay.fetch.txset is not updated. + REQUIRE(fetchTimer.count() == fetches); // A later delivery from the overlay is redundant. REQUIRE(!pendingEnvelopes.recvTxSet(p.second->getContentsHash(), @@ -874,15 +875,40 @@ TEST_CASE("PendingEnvelopes re-requests tx sets the overlay does not deliver", SECTION("an undelivered set is requested again until it arrives") { - crankBy(2 * interval); - auto const retried = retries.count() - initialRetries; - REQUIRE(retried >= 1); - REQUIRE(retried <= 2); + auto& fetchTimer = + app->getMetrics().NewTimer({"overlay", "fetch", "txset"}); + auto const fetches = fetchTimer.count(); + // Requests repeat after 1 s, then back off: 2 s, 4 s, ... + crankBy(interval); // t = 1.5 s + REQUIRE(retries.count() == initialRetries + 1); + crankBy(interval); // t = 2.5 s + REQUIRE(retries.count() == initialRetries + 1); + crankBy(interval); // t = 3.5 s + REQUIRE(retries.count() == initialRetries + 2); + crankBy(3 * interval); // t = 6.5 s + REQUIRE(retries.count() == initialRetries + 2); + crankBy(interval); // t = 7.5 s + REQUIRE(retries.count() == initialRetries + 3); REQUIRE(pendingEnvelopes.recvTxSet(hash, p.second)); REQUIRE(!pendingEnvelopes.getTxSetWaitingTime(hash)); - crankBy(3 * interval); - REQUIRE(retries.count() == initialRetries + retried); + REQUIRE(fetchTimer.count() == fetches + 1); + crankBy(10 * interval); + REQUIRE(retries.count() == initialRetries + 3); + } + + SECTION("a set for a closed slot is not requested again") + { + auto oldEnvelope = + makeEnvelope(herder, s, p, qSetHash, lcl.header.ledgerSeq); + // Purge the undecided slot's fetch; only the old slot's remains. + pendingEnvelopes.eraseOutsideRange(std::nullopt, slot - 1, 0); + REQUIRE(!pendingEnvelopes.getTxSetWaitingTime(hash)); + REQUIRE(pendingEnvelopes.recvSCPEnvelope(oldEnvelope) == + Herder::ENVELOPE_STATUS_FETCHING); + REQUIRE(pendingEnvelopes.getTxSetWaitingTime(hash)); + crankBy(10 * interval); + REQUIRE(retries.count() == initialRetries); } SECTION("purging the waiting slot stops the fetch") From 2798f92840cafbaa5b13d7aa0e22f21f5522afdd Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Mon, 9 Nov 2026 12:08:25 -0800 Subject: [PATCH 12/23] Bound the follower signature prewarm Follow-up to the signature prewarm, from review: - Skip it when this node already voted in the slot (it validated the leader's value cold, so the prewarm would only re-check cached signatures while balloting runs). - Stop it when a slot externalizes and on herder shutdown, not only when validation or a local build starts. - Leave two worker threads free for long background jobs (bucket merges): tasks = min(batch executor tasks, WORKER_THREADS - 2). - Cap verifications per transaction at 20 and only try keys whose hint matches, so a crafted transaction with colliding hints cannot make the prewarm expensive. - The test no longer asserts exact process-global verification counts (other code flushes them); it asserts that validation finds every signature cached. --- src/herder/HerderImpl.cpp | 32 ++++++++++++++++++++++++++------ src/herder/test/HerderTests.cpp | 4 +++- 2 files changed, 29 insertions(+), 7 deletions(-) diff --git a/src/herder/HerderImpl.cpp b/src/herder/HerderImpl.cpp index 03409ab83c..69ab037491 100644 --- a/src/herder/HerderImpl.cpp +++ b/src/herder/HerderImpl.cpp @@ -74,12 +74,25 @@ namespace void verifyMasterKeySignatures(Hash const& networkID, TransactionEnvelope const& env) { - auto verify = [](Hash const& contentsHash, auto const& signatures, - std::vector const& keys) { + // Bound the work per transaction: a signature is only verified against + // keys whose hint it matches, but colliding hints could otherwise make a + // crafted transaction cost many verifications. + size_t budget = 20; + auto verify = [&budget](Hash const& contentsHash, auto const& signatures, + std::vector const& keys) { for (auto const& sig : signatures) { for (auto const& key : keys) { + if (!SignatureUtils::doesHintMatch(key.ed25519(), sig.hint)) + { + continue; + } + if (budget == 0) + { + return; + } + --budget; if (SignatureUtils::verify(sig, key, contentsHash).valid) { break; @@ -373,6 +386,7 @@ void HerderImpl::shutdown() { discardPreparedTxSet(); + stopSignaturePrewarm(); mTrackingTimer.cancel(); mOutOfSyncTimer.cancel(); mTriggerTimer.cancel(); @@ -566,6 +580,8 @@ HerderImpl::valueExternalized(uint64 slotIndex, StellarValue const& value, { ZoneScoped; int const DUMP_SCP_TIMEOUT_SECONDS = 20; + // The prewarm only serves validating this slot's values. + stopSignaturePrewarm(); recordExternalizeAndCheckCloseTimeDrift(slotIndex, value, mDriftCTSlidingWindow); @@ -2048,11 +2064,13 @@ HerderImpl::triggerNextLedger(uint32_t ledgerSeqToTrigger, // A follower validates the leader's set when it arrives, and most of its // transactions are in this node's mempool too. Verify their signatures // meanwhile, as building our own set used to before leader-only - // construction, so that validation finds them in the cache. + // construction, so that validation finds them in the cache. Skip it if + // this node already voted, i.e. validated the leader's value. if (!buildsLegacyTxSet(lcl.header.ledgerVersion) && !getSCP() .getNominationLeaders(ledgerSeqToTrigger) - .count(getSCP().getLocalNodeID())) + .count(getSCP().getLocalNodeID()) && + getSCP().getLatestMessagesSend(ledgerSeqToTrigger).empty()) { prewarmSignatureCache(); } @@ -2099,10 +2117,12 @@ HerderImpl::prewarmSignatureCache() auto stop = std::make_shared>(false); mSignaturePrewarmStop = stop; // The batch executor (validation) is idle until the leader's set - // arrives; use as many background tasks as it would. + // arrives; use as many background tasks as it would, but leave worker + // threads for long background jobs such as bucket merges. + size_t const workers = static_cast(mApp.getConfig().WORKER_THREADS); size_t const tasks = std::max( 1, std::min(mApp.getBatchExecutor().preferredTaskCount(), - mApp.getConfig().WORKER_THREADS)); + workers > 2 ? workers - 2 : 1)); CLOG_DEBUG(Herder, "Pre-verifying signatures of {} transactions in {} tasks", envelopes->size(), tasks); diff --git a/src/herder/test/HerderTests.cpp b/src/herder/test/HerderTests.cpp index 756a0ff963..44d0401907 100644 --- a/src/herder/test/HerderTests.cpp +++ b/src/herder/test/HerderTests.cpp @@ -7688,7 +7688,9 @@ TEST_CASE("followers pre-verify mempool signatures at the trigger", PubKeyUtils::flushVerifySigCacheCounts(hits, misses); verified += misses; } - REQUIRE(verified == signatures); + // The counters are process-global and other code flushes them too, so + // they only bound the wait; the cache check below is the assertion. + INFO("verified " << verified << " of " << signatures); REQUIRE(scp.getLatestMessagesSend(seq).empty()); // Validating these transactions now finds every signature cached. From ba7ef4d9aa153780eadd567f73c9074998819201 Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Mon, 9 Nov 2026 12:11:19 -0800 Subject: [PATCH 13/23] Test externalizing inside a leader's own tx-set build Since locally built sets complete pending fetches, a leader that builds the very set a peer's ballot is waiting for reprocesses that envelope inside SCP's nomination value supplier. With the peer v-blocking, the slot externalizes before the supplier returns. Cover that path: the peer's CONFIRM waits for the (empty, hence identical) set, the local leader's trigger builds it, the slot closes with the peer's value, and nomination stops without voting or emitting a nomination. --- src/herder/test/HerderTests.cpp | 93 +++++++++++++++++++++++++++++++++ 1 file changed, 93 insertions(+) diff --git a/src/herder/test/HerderTests.cpp b/src/herder/test/HerderTests.cpp index 44d0401907..4d6d00c514 100644 --- a/src/herder/test/HerderTests.cpp +++ b/src/herder/test/HerderTests.cpp @@ -7581,6 +7581,99 @@ TEST_CASE("a follower promoted after losing sync still proposes", REQUIRE(checkedFollower); } +TEST_CASE("a leader build that completes a fetch can externalize", + "[herder][early-nomination]") +{ + // The local leader builds the very set a peer's ballot is waiting for (an + // empty set is the same on every node). Publishing it completes the fetch + // inside SCP's nomination value supplier: the peer's CONFIRM is + // reprocessed there and, the peer being v-blocking, externalizes the slot + // before the supplier returns. Nomination must then stop cleanly without + // voting or emitting. + VirtualClock clock; + clock.setCurrentVirtualTime(VirtualClock::from_time_t(1000)); + auto cfg = getTestConfig(); + cfg.HTTP_PORT = 0; + // Herder discards network envelopes under MANUAL_CLOSE. + cfg.MANUAL_CLOSE = false; + cfg.ARTIFICIALLY_ACCELERATE_TIME_FOR_TESTING = false; + cfg.FORCE_OLD_STYLE_PREPARE_START_TRIGGER_TIMER = true; + cfg.QUORUM_SET.threshold = 2; + cfg.QUORUM_SET.validators = { + cfg.NODE_SEED.getPublicKey(), + SecretKey::pseudoRandomForTesting().getPublicKey()}; + auto app = createTestApplication(clock, cfg); + auto& herder = static_cast(app->getHerder()); + auto& scp = herder.getSCP(); + EarlyNominationTestAccess::selectLocalFirstLeader(herder); + auto const qset = scp.getLocalQuorumSet(); + auto const qsetHash = scp.getLocalNode()->getQuorumSetHash(); + std::optional peer; + for (int i = 0; i < 100 && !peer; ++i) + { + auto key = + SecretKey::fromSeed(sha256(fmt::format("absent-peer-{}", i))); + if (std::find(qset.validators.begin(), qset.validators.end(), + key.getPublicKey()) != qset.validators.end()) + { + peer = key; + } + } + REQUIRE(peer); + + auto const lcl = app->getLedgerManager().getLastClosedLedgerHeader(); + auto const seq = lcl.header.ledgerSeq + 1; + herder.getHerderSCPDriver().recordSCPEvent(lcl.header.ledgerSeq, false); + herder.mGetTopTransactionsForTesting = [](size_t) { + return std::vector{}; + }; + // The set the local leader is about to build. + PerPhaseTransactionList phases(2); + auto const expected = + makeTxSetFromTransactions(phases, *app, ApplyTimeOffset{}).first; + REQUIRE( + !herder.getPendingEnvelopes().hasTxSet(expected->getContentsHash())); + + auto const peerValue = herder.makeStellarValue( + expected->getContentsHash(), + makeConsensusTime(lcl.header.scpValue.closeTime + 1), emptyUpgradeSteps, + *peer); + SCPEnvelope confirm; + confirm.statement.nodeID = peer->getPublicKey(); + confirm.statement.slotIndex = seq; + confirm.statement.pledges.type(SCP_ST_CONFIRM); + auto& conf = confirm.statement.pledges.confirm(); + conf.ballot.counter = 1; + conf.ballot.value = xdr::xdr_to_opaque(peerValue); + conf.nPrepared = 1; + conf.nCommit = 1; + conf.nH = 1; + conf.quorumSetHash = qsetHash; + herder.signEnvelope(*peer, confirm); + REQUIRE(herder.recvSCPEnvelope(confirm) == + Herder::ENVELOPE_STATUS_FETCHING); + REQUIRE(scp.getLatestMessage(peer->getPublicKey()) == nullptr); + + herder.triggerNextLedger(seq, true); + + // Processed and externalized during the leader's own build. + REQUIRE(scp.getLatestMessage(peer->getPublicKey())); + testutil::crankUntil( + app, + [&]() { + return app->getLedgerManager().getLastClosedLedgerNum() == seq; + }, + std::chrono::seconds(10)); + auto const closed = app->getLedgerManager().getLastClosedLedgerHeader(); + REQUIRE(closed.header.ledgerSeq == seq); + REQUIRE(closed.header.scpValue == peerValue); + for (auto const& env : scp.getLatestMessagesSend(seq)) + { + REQUIRE(env.statement.pledges.type() != SCP_ST_NOMINATE); + } + herder.mGetTopTransactionsForTesting = nullptr; +} + TEST_CASE("followers pre-verify mempool signatures at the trigger", "[herder][early-nomination]") { From 3c5d8851f0237b5b95a3f0c7a232bbc9ae132a36 Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Mon, 9 Nov 2026 14:15:59 -0800 Subject: [PATCH 14/23] Skip early tx-set preparation when the trigger is already due setupTriggerNextLedger arms the early-preparation timer for a predicted first-round leader at "now", next to the trigger timer. When the trigger is already due, both fire at the same instant, and VirtualClock orders equal-time events from different timers arbitrarily (event sequence numbers are per timer). If preparation ran first, the leader built its set once to prepare and again at the trigger (an underfilled prepared set is refreshed), costing a full build on exactly the late ledgers where the trigger is due immediately. "early preparation respects manual and immediately due triggers" caught it: with leader-only construction the test reschedules with both timers due, and it failed in partitioned make check (base instance 400, seed 20766: two pulls instead of one) while passing with other instances. Arm early preparation only when the trigger is still ahead; a due trigger builds itself. The test now also checks that nothing was scheduled to prepare, instead of depending on timer order. --- src/herder/HerderImpl.cpp | 7 ++++++- src/herder/test/HerderTests.cpp | 3 +++ 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/src/herder/HerderImpl.cpp b/src/herder/HerderImpl.cpp index 69ab037491..7c39290082 100644 --- a/src/herder/HerderImpl.cpp +++ b/src/herder/HerderImpl.cpp @@ -1587,7 +1587,12 @@ HerderImpl::setupTriggerNextLedger() }, &VirtualTimer::onFailureNoop); - if (getSCP().isValidator()) + // Prepare early only if the trigger is still ahead. A due trigger + // fires now and builds itself; both timers would fire at the same + // instant in an unspecified order (event sequence numbers are per + // timer), so the leader could build once to prepare and again at the + // trigger. + if (getSCP().isValidator() && !triggerDue) { auto leaders = getSCP().predictNominationLeaders( nextIndex, xdr::xdr_to_opaque(lcl.header.scpValue), 1); diff --git a/src/herder/test/HerderTests.cpp b/src/herder/test/HerderTests.cpp index 4d6d00c514..a7350e2bd7 100644 --- a/src/herder/test/HerderTests.cpp +++ b/src/herder/test/HerderTests.cpp @@ -7905,6 +7905,9 @@ TEST_CASE("early preparation respects manual and immediately due triggers", EarlyNominationTestAccess::schedule(herder); // No previous prepare timestamp: the normal fallback triggers now. REQUIRE(herder.getTriggerTimer().expiry_time() == clock.now()); + // A due trigger builds itself. Preparing too could build twice: the + // two timers would fire at the same instant in either order. + REQUIRE(!EarlyNominationTestAccess::scheduled(herder)); testutil::crankUntil( app, [&]() { From 11d416db83a0502749eedd70feb7931b9ae94abf Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Mon, 9 Nov 2026 15:26:58 -0800 Subject: [PATCH 15/23] Time tx-set build phases and add a hidden leader build benchmark Phase timers herder.txset.build-{pull,frames,trim,select,xdr,handoff, roundtrip,final-check} around HerderImpl::buildTxSet and makeTxSetFromTransactions, and a hidden benchmark ("leader tx set build costs", tags [herder][.][benchmark]) that hands the herder 15,000 SAC payments (ApplyLoad's generator) through an exact replay of the overlay IPC decode and times each phase with a cold and a warm signature cache, plus cold received-set validation for calibration against perfnet. BENCH_REPS, BENCH_TASKS, BENCH_WARM and BENCH_PULL control it; under callgrind with --instr-atstart=no only the cold builds are instrumented. --- src/herder/HerderImpl.cpp | 11 +- src/herder/TxSetFrame.cpp | 18 +++ src/herder/test/HerderTests.cpp | 197 ++++++++++++++++++++++++++++++++ src/simulation/ApplyLoad.cpp | 17 +++ src/simulation/ApplyLoad.h | 7 ++ 5 files changed, 249 insertions(+), 1 deletion(-) diff --git a/src/herder/HerderImpl.cpp b/src/herder/HerderImpl.cpp index 7c39290082..882d59568d 100644 --- a/src/herder/HerderImpl.cpp +++ b/src/herder/HerderImpl.cpp @@ -1819,7 +1819,13 @@ HerderImpl::buildTxSet(uint32_t ledgerSeq, ConsensusTime closeTime) auto& overlayMgr = mApp.getOverlayManager(); // This build validates every candidate itself. stopSignaturePrewarm(); - auto txEnvelopes = pullTopTransactions(maxTxSetCandidates() * 2); + auto& metrics = mApp.getMetrics(); + auto txEnvelopes = [&]() { + auto t = metrics.NewTimer({"herder", "txset", "build-pull"}).TimeScope(); + return pullTopTransactions(maxTxSetCandidates() * 2); + }(); + auto framesTimer = + metrics.NewTimer({"herder", "txset", "build-frames"}).TimeScope(); CLOG_INFO(Herder, "Got {} transactions from Rust overlay mempool", txEnvelopes.size()); @@ -1887,6 +1893,7 @@ HerderImpl::buildTxSet(uint32_t ledgerSeq, ConsensusTime closeTime) PerPhaseTransactionList invalidTxPhases; invalidTxPhases.resize(txPhases.size()); + framesTimer.Stop(); std::tie(proposedSet, applicableProposedSet) = makeTxSetFromTransactions( txPhases, mApp, closeTimeOffset, invalidTxPhases @@ -1896,6 +1903,8 @@ HerderImpl::buildTxSet(uint32_t ledgerSeq, ConsensusTime closeTime) #endif , [&](TxSetXDRFrameConstPtr const& txSet) { + auto t = metrics.NewTimer({"herder", "txset", "build-handoff"}) + .TimeScope(); // Hand the final XDR to the overlay before the builder's remaining // validation. Its eager compression runs concurrently in Rust. if (txSet->isGeneralizedTxSet()) diff --git a/src/herder/TxSetFrame.cpp b/src/herder/TxSetFrame.cpp index 43e6362d50..3968b1478a 100644 --- a/src/herder/TxSetFrame.cpp +++ b/src/herder/TxSetFrame.cpp @@ -914,6 +914,10 @@ makeTxSetFromTransactions( else { #endif + auto trimTimer = + app.getMetrics() + .NewTimer({"herder", "txset", "build-trim"}) + .TimeScope(); validatedTxs = TxSetUtils::trimInvalid( phaseTxs, app, accountFeeMap, closeTimeOffset.seconds(), closeTimeOffset.seconds(), invalid); @@ -936,6 +940,9 @@ makeTxSetFromTransactions( } #endif auto phaseType = static_cast(i); + auto selectTimer = app.getMetrics() + .NewTimer({"herder", "txset", "build-select"}) + .TimeScope(); auto [includedTxs, inclusionFeeMapBinding] = applySurgePricing(phaseType, validatedTxs, app #ifdef BUILD_TESTS @@ -970,6 +977,8 @@ makeTxSetFromTransactions( } auto const& lclHeader = app.getLedgerManager().getLastClosedLedgerHeader(); + auto xdrTimer = + app.getMetrics().NewTimer({"herder", "txset", "build-xdr"}).TimeScope(); // Preliminary applicable frame - we don't know the contents hash yet, but // we also don't return this. std::unique_ptr preliminaryApplicableTxSet( @@ -991,6 +1000,7 @@ makeTxSetFromTransactions( } #endif + xdrTimer.Stop(); // The final XDR is available now. Start proposal encoding while the // roundtrip and final validity checks below run; only the local builder // supplies this callback. The callback must not nominate the set. @@ -999,8 +1009,12 @@ makeTxSetFromTransactions( onTxSetReady(outputTxSet); } + auto roundtripTimer = app.getMetrics() + .NewTimer({"herder", "txset", "build-roundtrip"}) + .TimeScope(); ApplicableTxSetFrameConstPtr outputApplicableTxSet = outputTxSet->prepareForApply(app, lclHeader.header); + roundtripTimer.Stop(); if (!outputApplicableTxSet) { @@ -1029,8 +1043,12 @@ makeTxSetFromTransactions( } // We already trimmed invalid transactions in an earlier call to // `trimInvalid`, so skip transaction validation here + auto finalTimer = app.getMetrics() + .NewTimer({"herder", "txset", "build-final-check"}) + .TimeScope(); auto validationResult = outputApplicableTxSet->checkValidInternalWithResult( app, closeTimeOffset.seconds(), closeTimeOffset.seconds(), true); + finalTimer.Stop(); if (validationResult != TxSetValidationResult::VALID) { throw std::runtime_error(fmt::format( diff --git a/src/herder/test/HerderTests.cpp b/src/herder/test/HerderTests.cpp index a7350e2bd7..82cf71970c 100644 --- a/src/herder/test/HerderTests.cpp +++ b/src/herder/test/HerderTests.cpp @@ -11,11 +11,13 @@ #include "scp/LocalNode.h" #include "scp/SCP.h" #include "scp/Slot.h" +#include "simulation/ApplyLoad.h" #include "simulation/Simulation.h" #include "simulation/Topologies.h" #include "test/TestAccount.h" #include "test/TestUtils.h" #include "test/test.h" +#include "util/BatchExecutor.h" #include "util/JitterInjection.h" #include "history/HistoryArchiveManager.h" @@ -6769,6 +6771,13 @@ class EarlyNominationTestAccess herder.setupTriggerNextLedger(); } + // The leader's full build (mempool pull through final checks). + static TxSetXDRFrameConstPtr + build(HerderImpl& herder, uint32_t ledgerSeq, ConsensusTime closeTime) + { + return herder.buildTxSet(ledgerSeq, closeTime).txSet; + } + // These fixtures inspect a local proposal while requiring an absent peer // to prevent externalization. Pick that peer so the local node is the // first leader, independently of the test RNG seed and previous ledger. @@ -8301,3 +8310,191 @@ TEST_CASE("upgrade scheduling under sub-second ledgers", "[upgrades]") .createUpgradesFor(header, *ledgerView, app->getConfig()); REQUIRE(notDue.empty()); } + +#if __has_include() +#include +#else +#define CALLGRIND_START_INSTRUMENTATION +#define CALLGRIND_STOP_INSTRUMENTATION +#endif + +// A leader's tx-set build at perfnet's 3k SAC TPS scale: the mempool hands +// over twice the cap of SAC payments (15,000 here vs perfnet's 15,200), all +// valid, never validated by Core before (the Rust overlay admitted them), and +// the builder keeps 7,500 in a parallel Soroban phase. Times each phase of +// HerderImpl::buildTxSet with a cold and with a warm signature cache. +// Env: BENCH_REPS (default 5), BENCH_TASKS (validation tasks, default 4 = +// c5d.2xlarge physical cores), BENCH_WARM=0 to skip the warm runs. Under +// valgrind --tool=callgrind --instr-atstart=no only the cold builds are +// instrumented. +TEST_CASE("leader tx set build costs", "[herder][.][benchmark]") +{ + auto envInt = [](char const* name, uint32_t dflt) { + auto v = std::getenv(name); + return v ? static_cast(std::stoul(v)) : dflt; + }; + uint32_t const sorobanCap = 7500; + uint32_t const candidates = 2 * sorobanCap; + uint32_t const reps = envInt("BENCH_REPS", 5); + uint32_t const tasks = envInt("BENCH_TASKS", 4); + bool const warmRuns = envInt("BENCH_WARM", 1) != 0; + + auto cfg = getTestConfig(); + cfg.APPLY_LOAD_MODE = ApplyLoadMode::BENCHMARK_MODEL_TX; + cfg.APPLY_LOAD_MODEL_TX = ApplyLoadModelTx::SAC; + cfg.USE_CONFIG_FOR_GENESIS = true; + cfg.LEDGER_PROTOCOL_VERSION = Config::CURRENT_LEDGER_PROTOCOL_VERSION; + cfg.MANUAL_CLOSE = true; + cfg.IGNORE_MESSAGE_LIMITS_FOR_TESTING = true; + cfg.APPLY_LOAD_MAX_SOROBAN_TX_COUNT = sorobanCap; + cfg.APPLY_LOAD_BATCH_SAC_COUNT = 1; + cfg.APPLY_LOAD_LEDGER_MAX_DEPENDENT_TX_CLUSTERS = 1; + cfg.APPLY_LOAD_CLASSIC_TXS_PER_LEDGER = 0; + cfg.TESTING_UPGRADE_MAX_TX_SET_SIZE = 100; + cfg.GENESIS_TEST_ACCOUNT_COUNT = candidates + 10; + VirtualClock clock(VirtualClock::REAL_TIME); + auto app = createTestApplication(clock, cfg); + auto& herder = static_cast(app->getHerder()); + + std::vector envelopes; + { + ApplyLoad al(*app); + envelopes = al.generateSacPaymentEnvelopesForTesting(candidates); + } + REQUIRE(envelopes.size() == candidates); + app->getBatchExecutor().setPreferredTaskCountForTesting(tasks); + + // The Rust overlay's GetTopTxs response, decoded exactly as + // OverlayIPC::getTopTransactions does: [count:4]([len:4][xdr])* + std::vector payload(4); + uint32_t const count = static_cast(envelopes.size()); + std::memcpy(payload.data(), &count, 4); + for (auto const& env : envelopes) + { + auto bytes = xdr::xdr_to_opaque(env); + uint32_t const len = static_cast(bytes.size()); + auto const at = payload.size(); + payload.resize(at + 4 + len); + std::memcpy(payload.data() + at, &len, 4); + std::memcpy(payload.data() + at + 4, bytes.data(), len); + } + // BENCH_PULL: hand over only the first N candidates (a smaller pull). + uint32_t const pull = std::min(envInt("BENCH_PULL", count), count); + herder.mGetTopTransactionsForTesting = [&](size_t) { + std::vector result; + size_t offset = 4; + for (uint32_t i = 0; i < pull; ++i) + { + uint32_t len; + std::memcpy(&len, payload.data() + offset, 4); + offset += 4; + TransactionEnvelope tx; + std::vector txData(payload.begin() + offset, + payload.begin() + offset + len); + xdr::xdr_from_opaque(txData, tx); + result.push_back(std::move(tx)); + offset += len; + } + return result; + }; + + auto const lcl = app->getLedgerManager().getLastClosedLedgerHeader(); + auto const seq = lcl.header.ledgerSeq + 1; + auto const closeTime = + getConsensusTime(lcl.header.scpValue).next(lcl.header.ledgerVersion); + std::vector const phases = { + "build-pull", "build-frames", "build-trim", + "build-select", "build-xdr", "build-handoff", + "build-roundtrip", "build-final-check", "build"}; + auto& metrics = app->getMetrics(); + + std::cout << "=== leader tx set build: " << pull << " of " << candidates + << " SAC candidates, cap " << sorobanCap << ", " << tasks + << " validation tasks, IPC payload " << payload.size() + << " bytes ===" << std::endl; + for (bool cold : {true, false}) + { + if (!cold && !warmRuns) + { + continue; + } + std::map> samples; + size_t included = 0; + uint64_t misses = 0; + for (uint32_t rep = 0; rep < reps; ++rep) + { + if (cold) + { + PubKeyUtils::clearVerifySigCache(); + } + uint64_t h = 0, m = 0; + PubKeyUtils::flushVerifySigCacheCounts(h, m); + for (auto const& phase : phases) + { + metrics.NewTimer({"herder", "txset", phase}).Clear(); + } + if (cold) + { + CALLGRIND_START_INSTRUMENTATION; + } + auto txSet = + EarlyNominationTestAccess::build(herder, seq, closeTime); + if (cold) + { + CALLGRIND_STOP_INSTRUMENTATION; + } + PubKeyUtils::flushVerifySigCacheCounts(h, m); + misses = m; + included = txSet->sizeTxTotal(); + for (auto const& phase : phases) + { + samples[phase].push_back( + metrics.NewTimer({"herder", "txset", phase}).sum()); + } + // The overlay handoff's serialization into the IPC message (the + // test app has no overlay process, so time it here). + auto const start = std::chrono::steady_clock::now(); + auto const& xdrSet = txSet->getGeneralizedXDR(); + std::vector msg(36 + xdr::xdr_argpack_size(xdrSet)); + xdr::xdr_put put(msg.data() + 36, msg.data() + msg.size()); + xdr::xdr_argpack_archive(put, xdrSet); + samples["handoff-serialize"].push_back( + std::chrono::duration( + std::chrono::steady_clock::now() - start) + .count()); + } + REQUIRE(included == std::min(sorobanCap, pull)); + if (cold) + { + // Calibration against perfnet's herder.txset.validate: a + // follower validating the received set with a cold cache. + auto const& lastSet = + EarlyNominationTestAccess::build(herder, seq, closeTime); + for (uint32_t rep = 0; rep < reps; ++rep) + { + auto received = TxSetXDRFrame::makeFromWire( + GeneralizedTransactionSet(lastSet->getGeneralizedXDR())); + PubKeyUtils::clearVerifySigCache(); + auto const start = std::chrono::steady_clock::now(); + auto applicable = received->prepareForApply(*app, lcl.header); + REQUIRE(applicable); + REQUIRE(applicable->checkValid(*app, 0, 0)); + samples["received-set-validate"].push_back( + std::chrono::duration( + std::chrono::steady_clock::now() - start) + .count()); + } + } + std::cout << (cold ? "cold" : "warm") + << " signature cache (last build: " << misses + << " verifications, " << included << " txs)" << std::endl; + for (auto& [phase, v] : samples) + { + std::sort(v.begin(), v.end()); + std::cout << " " << phase << ": median " << v[v.size() / 2] + << " ms (min " << v.front() << ", max " << v.back() + << ", n=" << v.size() << ")" << std::endl; + } + } + herder.mGetTopTransactionsForTesting = nullptr; +} diff --git a/src/simulation/ApplyLoad.cpp b/src/simulation/ApplyLoad.cpp index 0e98d9fe1e..720f030d86 100644 --- a/src/simulation/ApplyLoad.cpp +++ b/src/simulation/ApplyLoad.cpp @@ -959,6 +959,23 @@ ApplyLoad::closeLedger(std::vector const& txs, stellar::txtest::closeLedger(mApp, txs, /* strictOrder */ false, upgrades); } +#ifdef BUILD_TESTS +std::vector +ApplyLoad::generateSacPaymentEnvelopesForTesting(uint32_t count) +{ + std::vector txs; + txs.reserve(count); + generateSacPayments(txs, count); + std::vector envelopes; + envelopes.reserve(txs.size()); + for (auto const& tx : txs) + { + envelopes.emplace_back(tx->getEnvelope()); + } + return envelopes; +} +#endif + void ApplyLoad::closeBenchmarkLedger(std::vector const& txs, bool recordUtilization) diff --git a/src/simulation/ApplyLoad.h b/src/simulation/ApplyLoad.h index d0fdda7043..555817047f 100644 --- a/src/simulation/ApplyLoad.h +++ b/src/simulation/ApplyLoad.h @@ -22,6 +22,13 @@ class ApplyLoad // of values is [0,1.0]. double successRate(); +#ifdef BUILD_TESTS + // Signed SAC payments from distinct sources, as envelopes the way a + // leader's mempool hands them to the herder (tx-set build benchmarks). + std::vector + generateSacPaymentEnvelopesForTesting(uint32_t count); +#endif + // Closes a setup ledger through direct externalization. Setup and upgrades // are excluded from benchmark phase timings. void closeLedger(std::vector const& txs, From 925dca9f92bc6fa990c1bc8df00157873c9e7d03 Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Mon, 9 Nov 2026 15:49:17 -0800 Subject: [PATCH 16/23] Validate only as many tx-set candidates as selection can use The leader pulls twice the tx-set capacity from the mempool and validated every candidate, although selection keeps at most the capacity. Signature verification of the surplus was most of the build's cost (15,000 SAC candidates for 7,500 slots on perfnet). Keep the same pull, but validate each phase in mempool order only until it holds 5/4 of its capacity in valid transactions of its generic surge pricing lane (TxSetUtils::trimInvalidPrefix): the first 5/4 of the capacity, then twice the shortfall if some were invalid, then everything left, so at most three passes and each candidate validated at most once. DEX-lane transactions don't count toward the target, since their lane can't fill the phase. Candidates past the validated prefix are neither selected nor reported invalid; they stay in the mempool. The selected set is the same as when validating everything unless selection would have reached past the prefix: a candidate that doesn't fit the remaining resources leaving room that only later candidates fit, a mempool order (total fee per operation) that differs from the inclusion fee order of Soroban transactions, equal fees at the cutoff (broken randomly either way), or a fee source paying for several candidates (its fees accumulate over fewer of them). Laptop benchmark (15,000 SAC candidates, 4 tasks, n=5 medians): cold signature cache 261.0 -> 183.6 ms, warm 124.3 -> 98.7 ms. --- src/herder/HerderImpl.cpp | 30 +++++- src/herder/TxSetFrame.cpp | 29 +++++- src/herder/TxSetFrame.h | 15 ++- src/herder/TxSetUtils.cpp | 45 +++++++++ src/herder/TxSetUtils.h | 16 +++ src/herder/test/HerderTests.cpp | 75 +++++++++++++++ src/herder/test/TxSetTests.cpp | 166 ++++++++++++++++++++++++++++++++ 7 files changed, 368 insertions(+), 8 deletions(-) diff --git a/src/herder/HerderImpl.cpp b/src/herder/HerderImpl.cpp index 882d59568d..56b3684d65 100644 --- a/src/herder/HerderImpl.cpp +++ b/src/herder/HerderImpl.cpp @@ -1891,6 +1891,28 @@ HerderImpl::buildTxSet(uint32_t ledgerSeq, ConsensusTime closeTime) txPhases.emplace_back(std::move(sorobanTxs)); } + // Selection only uses the best valid candidates up to each phase's + // capacity, and validating (mostly: verifying the signatures of) the rest + // of the pull is most of the build's cost. Validate each phase in mempool + // order only until it holds 5/4 of its capacity in valid transactions + // (more if some are invalid, see TxSetUtils::trimInvalidPrefix). The slack + // covers candidates that selection skips: those that don't fit the + // remaining resources, and those the mempool ranks above ones with a + // higher inclusion fee (it orders by total fee per operation). + auto validationTarget = [](size_t capacity) { + return capacity + (capacity + 3) / 4; + }; + std::vector validTxTargets{ + validationTarget(mLedgerManager.getLastMaxTxSetSizeOps())}; + if (supportsSoroban) + { + validTxTargets.push_back(validationTarget( + mLedgerManager.hasLastClosedSorobanNetworkConfig() + ? mLedgerManager.getLastClosedSorobanNetworkConfig() + .ledgerMaxTxCount() + : 0)); + } + PerPhaseTransactionList invalidTxPhases; invalidTxPhases.resize(txPhases.size()); framesTimer.Stop(); @@ -1914,7 +1936,8 @@ HerderImpl::buildTxSet(uint32_t ledgerSeq, ConsensusTime closeTime) overlayMgr.cacheTxSet(txSet->getContentsHash(), txSet->getGeneralizedXDR(), ledgerSeq); } - }); + }, + validTxTargets); CLOG_INFO(Herder, "Proposed TX set has {} transactions", proposedSet->sizeTxTotal()); @@ -1952,6 +1975,11 @@ HerderImpl::buildTxSet(uint32_t ledgerSeq, ConsensusTime closeTime) // or small snapshot doesn't prevent collecting transactions during the // timer wait. Reuse a snapshot when selection actually excluded valid // candidates. Invalid transactions do not establish excess demand. + // Candidates past a phase's validated prefix count as valid here. There + // are such candidates only when the prefix already held more valid ones + // than the phase can include, so they don't change the result (except + // in a phase that can include nothing: it validates nothing, and counts + // as capacity limited whenever it has candidates). size_t validCandidates = 0; for (size_t i = 0; i < txPhases.size(); ++i) { diff --git a/src/herder/TxSetFrame.cpp b/src/herder/TxSetFrame.cpp index 3968b1478a..8c96fa2a4d 100644 --- a/src/herder/TxSetFrame.cpp +++ b/src/herder/TxSetFrame.cpp @@ -878,11 +878,14 @@ makeTxSetFromTransactions( bool disableTxValidationForLegacyScenario #endif , - TxSetReadyCallback const& onTxSetReady) + TxSetReadyCallback const& onTxSetReady, + std::vector const& validTxTargets) { releaseAssert(threadIsMain()); releaseAssert(!app.getLedgerManager().isApplying()); releaseAssert(txPhases.size() == invalidTxs.size()); + releaseAssert(validTxTargets.empty() || + validTxTargets.size() == txPhases.size()); releaseAssert(txPhases.size() <= static_cast(TxSetPhase::PHASE_COUNT)); @@ -918,9 +921,27 @@ makeTxSetFromTransactions( app.getMetrics() .NewTimer({"herder", "txset", "build-trim"}) .TimeScope(); - validatedTxs = TxSetUtils::trimInvalid( - phaseTxs, app, accountFeeMap, closeTimeOffset.seconds(), - closeTimeOffset.seconds(), invalid); + if (validTxTargets.empty()) + { + validatedTxs = TxSetUtils::trimInvalid( + phaseTxs, app, accountFeeMap, closeTimeOffset.seconds(), + closeTimeOffset.seconds(), invalid); + } + else + { + // Transactions of limited lanes (DEX) can't fill the phase, + // so only generic lane ones count toward the target. + auto laneConfig = createSurgePricingLangeConfig( + static_cast(i), app); + validatedTxs = TxSetUtils::trimInvalidPrefix( + phaseTxs, validTxTargets[i], + [&laneConfig](TransactionFrameBase const& tx) { + return laneConfig->getLane(tx) == + SurgePricingPriorityQueue::GENERIC_LANE; + }, + app, accountFeeMap, closeTimeOffset.seconds(), + closeTimeOffset.seconds(), invalid); + } #ifdef BUILD_TESTS // In tests we shouldn't be really trying to close ledgers with // invalid transactions trimmed (which is unfortunately a very diff --git a/src/herder/TxSetFrame.h b/src/herder/TxSetFrame.h index 78ce87a3e8..8bbb4c1ac4 100644 --- a/src/herder/TxSetFrame.h +++ b/src/herder/TxSetFrame.h @@ -118,6 +118,12 @@ using PerPhaseTransactionList = std::vector; // close time. // The result is guaranteed to pass `checkValid` check with the same // arguments as in this method, so additional validation is not needed. +// With `validTxTargets` (one entry per phase), the transactions of each phase +// must be in priority order, and only the prefix of phase `i` that holds +// `validTxTargets[i]` valid transactions of its generic surge pricing lane is +// validated and offered to selection (see `TxSetUtils::trimInvalidPrefix`). +// The transactions past that prefix are left out without being validated, so +// they appear neither in the result nor in `invalidTxs`. // // **Note**: the output `ApplicableTxSetFrame` will *not* contain the input // transaction pointers. @@ -154,7 +160,8 @@ makeTxSetFromTransactions( bool disableTxValidationForLegacyScenario = false #endif , - TxSetReadyCallback const& onTxSetReady = {}); + TxSetReadyCallback const& onTxSetReady = {}, + std::vector const& validTxTargets = {}); #ifdef BUILD_TESTS std::pair @@ -417,7 +424,8 @@ class TxSetPhaseFrame bool disableTxValidationForLegacyScenario #endif , - TxSetReadyCallback const& onTxSetReady); + TxSetReadyCallback const& onTxSetReady, + std::vector const& validTxTargets); #ifdef BUILD_TESTS friend std::pair makeTxSetFromTransactions( @@ -592,7 +600,8 @@ class ApplicableTxSetFrame bool disableTxValidationForLegacyScenario #endif , - TxSetReadyCallback const& onTxSetReady); + TxSetReadyCallback const& onTxSetReady, + std::vector const& validTxTargets); #ifdef BUILD_TESTS friend std::pair makeTxSetFromTransactions( diff --git a/src/herder/TxSetUtils.cpp b/src/herder/TxSetUtils.cpp index 80df5f4d63..f2c8564f2e 100644 --- a/src/herder/TxSetUtils.cpp +++ b/src/herder/TxSetUtils.cpp @@ -333,4 +333,49 @@ TxSetUtils::trimInvalid(TxFrameList const& txs, Application& app, return removeTxs(txs, invalidTxs); } +TxFrameList +TxSetUtils::trimInvalidPrefix( + TxFrameList const& txs, size_t targetValidTxs, + std::function const& countsTowardTarget, + Application& app, UnorderedMap& accountFeeMap, + uint64_t lowerBoundCloseTimeOffset, uint64_t upperBoundCloseTimeOffset, + TxFrameList& invalidTxs) +{ + ZoneScoped; + TxFrameList validTxs; + invalidTxs.clear(); + size_t counted = 0; + size_t validated = 0; + // Each pass validates the candidates right after the previous ones, so + // fee-source totals accumulate in the same order as when validating the + // whole prefix at once. The last pass validates everything left, so + // there are at most three passes. + for (int pass = 0; + pass < 3 && counted < targetValidTxs && validated < txs.size(); ++pass) + { + size_t const missing = targetValidTxs - counted; + size_t const left = txs.size() - validated; + size_t const count = pass == 0 ? std::min(missing, left) + : pass == 1 ? std::min(2 * missing, left) + : left; + TxFrameList const batch(txs.begin() + validated, + txs.begin() + validated + count); + validated += count; + TxFrameList batchInvalid; + for (auto const& tx : + trimInvalid(batch, app, accountFeeMap, lowerBoundCloseTimeOffset, + upperBoundCloseTimeOffset, batchInvalid)) + { + if (!countsTowardTarget || countsTowardTarget(*tx)) + { + ++counted; + } + validTxs.push_back(tx); + } + invalidTxs.insert(invalidTxs.end(), batchInvalid.begin(), + batchInvalid.end()); + } + return validTxs; +} + } // namespace stellar diff --git a/src/herder/TxSetUtils.h b/src/herder/TxSetUtils.h index 160ae09eb9..8ac855ab0c 100644 --- a/src/herder/TxSetUtils.h +++ b/src/herder/TxSetUtils.h @@ -7,6 +7,7 @@ #include "herder/TxSetFrame.h" #include "util/UnorderedMap.h" #include "xdr/Stellar-types.h" +#include #include #include @@ -62,5 +63,20 @@ class TxSetUtils UnorderedMap& accountFeeMap, uint64_t lowerBoundCloseTimeOffset, uint64_t upperBoundCloseTimeOffset, TxFrameList& invalidTxs); + + // Like `trimInvalid`, for candidates in priority order when only the + // first `targetValidTxs` valid ones that `countsTowardTarget` accepts are + // needed. Validates a prefix of `txs` in at most three passes: the first + // `targetValidTxs` candidates, then twice as many more as are still + // missing, then all the rest. Returns the valid candidates of that prefix + // in order, and its invalid ones in `invalidTxs`. Candidates past the + // prefix are neither validated nor returned. + static TxFrameList trimInvalidPrefix( + TxFrameList const& txs, size_t targetValidTxs, + std::function const& + countsTowardTarget, + Application& app, UnorderedMap& accountFeeMap, + uint64_t lowerBoundCloseTimeOffset, uint64_t upperBoundCloseTimeOffset, + TxFrameList& invalidTxs); }; // class TxSetUtils } // namespace stellar diff --git a/src/herder/test/HerderTests.cpp b/src/herder/test/HerderTests.cpp index 82cf71970c..980929f8c2 100644 --- a/src/herder/test/HerderTests.cpp +++ b/src/herder/test/HerderTests.cpp @@ -6778,6 +6778,15 @@ class EarlyNominationTestAccess return herder.buildTxSet(ledgerSeq, closeTime).txSet; } + // The same, with the hashes of the invalid candidates it found. + static std::pair> + buildWithInvalid(HerderImpl& herder, uint32_t ledgerSeq, + ConsensusTime closeTime) + { + auto prepared = herder.buildTxSet(ledgerSeq, closeTime); + return {prepared.txSet, prepared.invalidTxHashes}; + } + // These fixtures inspect a local proposal while requiring an absent peer // to prevent externalization. Pick that peer so the local node is the // first leader, independently of the test RNG seed and previous ledger. @@ -8311,6 +8320,72 @@ TEST_CASE("upgrade scheduling under sub-second ledgers", "[upgrades]") REQUIRE(notDue.empty()); } +TEST_CASE("leader builds validate only the top of the mempool pull", + "[herder][txset]") +{ + // Classic capacity 10: the herder validates classic candidates until 13 + // are valid. The mempool holds 60 payments bidding 1000 - i, so its order + // is i. The top 5 and #40 have a stale sequence number (the account's + // current one), so the herder drops them from the mempool once it finds + // them invalid. + uint32_t const candidates = 60; + auto cfg = getTestConfig(); + cfg.MANUAL_CLOSE = true; + cfg.GENESIS_TEST_ACCOUNT_COUNT = candidates + 1; + cfg.TESTING_UPGRADE_MAX_TX_SET_SIZE = 10; + VirtualClock clock; + auto app = createTestApplication(clock, cfg); + auto& herder = static_cast(app->getHerder()); + auto& lm = app->getLedgerManager(); + REQUIRE(lm.getLastMaxTxSetSizeOps() == 10); + auto dest = getGenesisAccount(*app, candidates); + std::vector mempool; + std::vector hashes; + for (uint32_t i = 0; i < candidates; ++i) + { + auto source = getGenesisAccount(*app, i); + bool const badSeq = i < 5 || i == 40; + auto tx = transactionFromOperations( + *app, source.getSecretKey(), + source.getLastSequenceNumber() + (badSeq ? 0 : 1), + {payment(dest.getPublicKey(), 1)}, 1000 - i); + mempool.push_back(tx->getEnvelope()); + hashes.push_back(tx->getFullHash()); + } + size_t requested = 0; + herder.mGetTopTransactionsForTesting = [&](size_t count) { + requested = count; + return std::vector( + mempool.begin(), mempool.begin() + std::min(count, mempool.size())); + }; + + auto const lcl = lm.getLastClosedLedgerHeader(); + auto [txSet, invalid] = EarlyNominationTestAccess::buildWithInvalid( + herder, lcl.header.ledgerSeq + 1, + getConsensusTime(lcl.header.scpValue).next(lcl.header.ledgerVersion)); + herder.mGetTopTransactionsForTesting = nullptr; + + // The pull is unchanged: twice the capacity of both phases. + REQUIRE( + requested == + 2 * (10 + lm.getLastClosedSorobanNetworkConfig().ledgerMaxTxCount())); + // The invalid top candidates were replaced: the set is full, with the + // best valid ones. + auto applicable = txSet->prepareForApply(*app, lcl.header); + REQUIRE(applicable); + std::set included; + for (auto const& tx : applicable->getPhase(TxSetPhase::CLASSIC)) + { + included.insert(tx->getFullHash()); + } + REQUIRE(included == + std::set(hashes.begin() + 5, hashes.begin() + 15)); + // #40 is past the validated candidates (0-22): it stays in the mempool + // until it reaches them. + REQUIRE(std::set(invalid.begin(), invalid.end()) == + std::set(hashes.begin(), hashes.begin() + 5)); +} + #if __has_include() #include #else diff --git a/src/herder/test/TxSetTests.cpp b/src/herder/test/TxSetTests.cpp index f23037071a..d963e0420f 100644 --- a/src/herder/test/TxSetTests.cpp +++ b/src/herder/test/TxSetTests.cpp @@ -72,6 +72,172 @@ TEST_CASE("built tx set is available before final validation returns", REQUIRE(applicable->checkValid(*app, 0, 0)); } +TEST_CASE("tx set building validates only as many candidates as it needs", + "[txset]") +{ + // A classic phase of 10 operations, of which DEX transactions may use 2. + // The herder's target for it is 5/4 of that: 13 valid transactions. + uint32_t const candidates = 40; + std::vector const targets{13, 13}; + VirtualClock clock; + auto cfg = getTestConfig(); + cfg.GENESIS_TEST_ACCOUNT_COUNT = candidates + 1; + cfg.TESTING_UPGRADE_MAX_TX_SET_SIZE = 10; + cfg.MAX_DEX_TX_OPERATIONS_IN_TX_SET = 2; + auto app = createTestApplication(clock, cfg); + REQUIRE(app->getLedgerManager().getLastMaxTxSetSizeOps() == 10); + auto dest = getGenesisAccount(*app, candidates); + auto const usd = makeAsset(dest.getSecretKey(), "USD"); + + enum class Kind + { + PAYMENT, + BAD_SEQ, + DEX, + SIX_OPS + }; + // Candidate i bids 1000 - i per operation, so the input order is the + // priority order. Each one has its own source account. + auto makeCandidates = [&](std::function const& kindOf) { + TxFrameList txs; + for (uint32_t i = 0; i < candidates; ++i) + { + auto source = getGenesisAccount(*app, i); + auto const kind = kindOf(i); + std::vector ops; + if (kind == Kind::DEX) + { + ops.push_back( + manageOffer(0, makeNativeAsset(), usd, Price{1, 1}, 1)); + } + else + { + ops.resize(kind == Kind::SIX_OPS ? 6 : 1, + payment(dest.getPublicKey(), 1)); + } + auto const seq = source.getLastSequenceNumber() + + (kind == Kind::BAD_SEQ ? 0 : 1); + txs.push_back(transactionFromOperations( + *app, source.getSecretKey(), seq, ops, + static_cast((1000 - i) * ops.size()))); + } + return txs; + }; + struct Built + { + Hash contentsHash; + std::set included; + std::vector invalid; + }; + // Builds with the targets, or validating every candidate (`targets` {}). + auto build = [&](TxFrameList const& txs, + std::vector const& validTxTargets) { + std::map indexOf; + for (uint32_t i = 0; i < txs.size(); ++i) + { + indexOf.emplace(txs[i]->getFullHash(), i); + } + PerPhaseTransactionList phases{txs, {}}; + PerPhaseTransactionList invalid(2); + auto [txSet, applicable] = + makeTxSetFromTransactions(phases, *app, ApplyTimeOffset{}, invalid, + false, {}, false, {}, validTxTargets); + REQUIRE(applicable->checkValid(*app, 0, 0)); + REQUIRE(invalid[1].empty()); + Built built{txSet->getContentsHash(), {}, {}}; + for (auto const& tx : applicable->getPhase(TxSetPhase::CLASSIC)) + { + built.included.insert(indexOf.at(tx->getFullHash())); + } + for (auto const& tx : invalid[0]) + { + built.invalid.push_back(indexOf.at(tx->getFullHash())); + } + return built; + }; + auto range = [](uint32_t begin, uint32_t end) { + std::set result; + for (uint32_t i = begin; i < end; ++i) + { + result.insert(i); + } + return result; + }; + + SECTION("nothing invalid near the top: same set as validating everything") + { + // Candidate 30 is past the 13 validated ones, so the windowed build + // never finds out that it is invalid. + auto txs = makeCandidates( + [](uint32_t i) { return i == 30 ? Kind::BAD_SEQ : Kind::PAYMENT; }); + auto windowed = build(txs, targets); + auto full = build(txs, {}); + REQUIRE(windowed.included == range(0, 10)); + REQUIRE(windowed.invalid.empty()); + REQUIRE(full.invalid == std::vector{30}); + REQUIRE(windowed.contentsHash == full.contentsHash); + } + SECTION("invalid top candidates are replaced from further down") + { + // The first pass validates 0-12 and finds 8 valid, the second + // validates the next 2 * 5 (13-22). + auto txs = makeCandidates([](uint32_t i) { + return i < 5 || i == 30 ? Kind::BAD_SEQ : Kind::PAYMENT; + }); + auto windowed = build(txs, targets); + auto full = build(txs, {}); + REQUIRE(windowed.included == range(5, 15)); + REQUIRE(windowed.invalid == std::vector{0, 1, 2, 3, 4}); + REQUIRE(full.invalid == std::vector{0, 1, 2, 3, 4, 30}); + REQUIRE(windowed.contentsHash == full.contentsHash); + } + SECTION("mostly invalid: each candidate is validated once") + { + // Three passes: 0-12, 13-38, 39. Every invalid candidate is reported + // exactly once, and the set holds the two valid ones. + auto txs = makeCandidates([](uint32_t i) { + return i == 25 || i == 35 ? Kind::PAYMENT : Kind::BAD_SEQ; + }); + auto windowed = build(txs, targets); + auto full = build(txs, {}); + REQUIRE(windowed.included == std::set{25, 35}); + auto expectedInvalid = range(0, candidates); + expectedInvalid.erase(25); + expectedInvalid.erase(35); + REQUIRE(windowed.invalid == + std::vector(expectedInvalid.begin(), + expectedInvalid.end())); + REQUIRE(windowed.contentsHash == full.contentsHash); + } + SECTION("DEX transactions don't count toward the target") + { + // The DEX lane takes only 2 of the 15 DEX candidates. Had they + // counted, the 13 validated ones would have filled the target and the + // set would hold just those 2. + auto txs = makeCandidates( + [](uint32_t i) { return i < 15 ? Kind::DEX : Kind::PAYMENT; }); + auto windowed = build(txs, targets); + auto full = build(txs, {}); + auto expected = range(15, 23); + expected.insert({0, 1}); + REQUIRE(windowed.included == expected); + REQUIRE(windowed.contentsHash == full.contentsHash); + } + SECTION("where it differs: only candidates past the window fit the rest") + { + // The first six-operation transaction leaves room for four + // operations, which none of the other validated (six-operation) + // candidates fit. Validating everything fills that room with the + // one-operation candidates 13-16. + auto txs = makeCandidates( + [](uint32_t i) { return i < 13 ? Kind::SIX_OPS : Kind::PAYMENT; }); + auto windowed = build(txs, targets); + auto full = build(txs, {}); + REQUIRE(windowed.included == std::set{0}); + REQUIRE(full.included == std::set{0, 13, 14, 15, 16}); + } +} + TEST_CASE("generalized tx set XDR validation", "[txset]") { Config cfg(getTestConfig()); From 1e16ae04b430d9a01a6c0dad5431c86fc1a511f2 Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Mon, 9 Nov 2026 15:51:41 -0800 Subject: [PATCH 17/23] Hash tx-set candidates on the validation workers Building a tx set hashed every candidate's full envelope on the main thread (removing the invalid ones, then sorting the set by hash): SHA-256 of every candidate, 18% of a cold build's instructions on hosts without SHA extensions such as c5d. Compute and cache each candidate's full hash in the parallel validation task that already validates it (which also computes its contents hash for the signature checks), and skip removeTxs' lookups when nothing is invalid. Same hashes, same order: only where they are computed changes. Each frame is in exactly one task range and the batch completes before the main thread reads the cached hash. Laptop benchmark (has SHA-NI): warm build-trim 22.1 -> 18.0 ms. --- src/herder/TxSetUtils.cpp | 10 +++++++ src/herder/test/TxSetTests.cpp | 55 ++++++++++++++++++++++++++++++++++ 2 files changed, 65 insertions(+) diff --git a/src/herder/TxSetUtils.cpp b/src/herder/TxSetUtils.cpp index f2c8564f2e..60ee51e0ca 100644 --- a/src/herder/TxSetUtils.cpp +++ b/src/herder/TxSetUtils.cpp @@ -41,6 +41,10 @@ namespace TxFrameList removeTxs(TxFrameList const& txs, TxFrameList const& txsToRemove) { + if (txsToRemove.empty()) + { + return txs; + } UnorderedSet txsToRemoveSet; txsToRemoveSet.reserve(txsToRemove.size()); std::transform( @@ -238,6 +242,12 @@ TxSetUtils::getInvalidTxListWithErrors( auto diagnostics = DiagnosticEventManager::createDisabled(); for (size_t i = begin; i < end; ++i) { + // The main thread needs every candidate's full hash next + // (removing the invalid ones, sorting the set). Compute and + // cache it here, in parallel, rather than there. Each frame + // is in one range only, and the batch completes before the + // main thread reads it. + txs[i]->getFullHash(); auto res = txs[i]->checkValid(appConnector, view, 0, lowerBoundCloseTimeOffset, upperBoundCloseTimeOffset, diff --git a/src/herder/test/TxSetTests.cpp b/src/herder/test/TxSetTests.cpp index d963e0420f..781c905b7e 100644 --- a/src/herder/test/TxSetTests.cpp +++ b/src/herder/test/TxSetTests.cpp @@ -238,6 +238,61 @@ TEST_CASE("tx set building validates only as many candidates as it needs", } } +TEST_CASE("tx set validation caches candidate hashes", "[txset]") +{ + uint32_t const count = 64; + VirtualClock clock; + auto cfg = getTestConfig(); + cfg.GENESIS_TEST_ACCOUNT_COUNT = count + 1; + cfg.TESTING_UPGRADE_MAX_TX_SET_SIZE = count; + auto app = createTestApplication(clock, cfg); + // Several tasks, so most hashes are computed off the main thread. + app->getBatchExecutor().setPreferredTaskCountForTesting(4); + auto dest = getGenesisAccount(*app, count); + // Fresh frames from the envelopes, with no hash computed yet. Every + // eighth candidate has a stale sequence number. + TxFrameList txs; + std::set expectedIncluded; + for (uint32_t i = 0; i < count; ++i) + { + auto source = getGenesisAccount(*app, i); + auto signedTx = transactionFromOperations( + *app, source.getSecretKey(), + source.getLastSequenceNumber() + (i % 8 == 0 ? 0 : 1), + {payment(dest.getPublicKey(), 1)}, 100 + i); + txs.push_back(TransactionFrameBase::makeTransactionFromWire( + app->getNetworkID(), signedTx->getEnvelope())); + if (i % 8 != 0) + { + expectedIncluded.insert(xdrSha256(signedTx->getEnvelope())); + } + } + + PerPhaseTransactionList phases{txs, {}}; + PerPhaseTransactionList invalid(2); + auto [txSet, applicable] = + makeTxSetFromTransactions(phases, *app, ApplyTimeOffset{}, invalid); + REQUIRE(invalid[0].size() == count / 8); + // The cached hashes are the envelopes' hashes. + for (auto const& tx : txs) + { + REQUIRE(tx->getFullHash() == xdrSha256(tx->getEnvelope())); + } + // The set holds the valid candidates, in full hash order. + auto const& classic = + txSet->getGeneralizedXDR().v1TxSet().phases[0].v0Components(); + REQUIRE(classic.size() == 1); + std::vector setHashes; + for (auto const& env : classic[0].txsMaybeDiscountedFee().txs) + { + setHashes.push_back(xdrSha256(env)); + } + REQUIRE(std::is_sorted(setHashes.begin(), setHashes.end())); + REQUIRE(std::set(setHashes.begin(), setHashes.end()) == + expectedIncluded); + REQUIRE(applicable->checkValid(*app, 0, 0)); +} + TEST_CASE("generalized tx set XDR validation", "[txset]") { Config cfg(getTestConfig()); From f19953942481c82621b2f23f1932c10e747126d0 Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Mon, 9 Nov 2026 15:58:29 -0800 Subject: [PATCH 18/23] Precompute the parallel tx-set builder's sort keys The parallel Soroban phase builder sorts all candidates by inclusion fee rate, and each comparison looked up both transactions' inclusion fee and operation count through virtual calls (~1,450 instructions per comparison on the main thread). Look them up once per transaction and compare the cached values with the same comparator logic: TxFeeComparator gets an overload that takes the fee bids and operation counts, and the plain overload forwards to it, so both order identically (same tie-break). Laptop benchmark (15,000 SAC candidates, 9,375 validated): build-select 17.1 -> 14.0 ms cold, 17.2 -> 13.6 ms warm. --- src/herder/ParallelTxSetBuilder.cpp | 15 +++++-- src/herder/SurgePricingUtils.cpp | 32 +++++++------- src/herder/SurgePricingUtils.h | 10 ++++- src/herder/test/TxSetTests.cpp | 65 +++++++++++++++++++++++++++++ 4 files changed, 100 insertions(+), 22 deletions(-) diff --git a/src/herder/ParallelTxSetBuilder.cpp b/src/herder/ParallelTxSetBuilder.cpp index dacb0ebdf5..bbb9d552e2 100644 --- a/src/herder/ParallelTxSetBuilder.cpp +++ b/src/herder/ParallelTxSetBuilder.cpp @@ -718,15 +718,24 @@ buildSurgePricedParallelSorobanPhase( // Simplify the transactions to the minimum necessary amount of data. auto builderTxs = prepareBuilderTxs(txFrames); - // Sort transactions in decreasing inclusion fee order. + // Sort transactions in decreasing inclusion fee order. Look up each + // transaction's fee bid and operation count once, not per comparison. TxFeeComparator txComparator( /* isGreater */ true, stellar::rand_uniform(0, std::numeric_limits::max())); + std::vector> feeBids; + feeBids.reserve(txFrames.size()); + for (auto const& tx : txFrames) + { + feeBids.emplace_back(tx->getInclusionFee(), tx->getNumOperations()); + } std::vector sortedTxOrder(txFrames.size()); std::iota(sortedTxOrder.begin(), sortedTxOrder.end(), 0); std::sort(sortedTxOrder.begin(), sortedTxOrder.end(), - [&txFrames, &txComparator](size_t a, size_t b) { - return txComparator(txFrames[a], txFrames[b]); + [&txFrames, &feeBids, &txComparator](size_t a, size_t b) { + return txComparator(txFrames[a], feeBids[a].first, + feeBids[a].second, txFrames[b], + feeBids[b].first, feeBids[b].second); }); // Precompute per-transaction resources to avoid repeated virtual calls diff --git a/src/herder/SurgePricingUtils.cpp b/src/herder/SurgePricingUtils.cpp index fe9d0c17b8..edec65d71c 100644 --- a/src/herder/SurgePricingUtils.cpp +++ b/src/herder/SurgePricingUtils.cpp @@ -12,19 +12,6 @@ namespace stellar { -namespace -{ - -// Use _inclusion_ fee to order transactions -int -feeRate3WayCompare(TransactionFrameBase const& l, TransactionFrameBase const& r) -{ - return stellar::feeRate3WayCompare( - l.getInclusionFee(), l.getNumOperations(), r.getInclusionFee(), - r.getNumOperations()); -} - -} // namespace int feeRate3WayCompare(int64_t lFeeBid, uint32_t lNbOps, int64_t rFeeBid, @@ -82,7 +69,17 @@ bool TxFeeComparator::operator()(TransactionFrameBasePtr const& tx1, TransactionFrameBasePtr const& tx2) const { - return txLessThan(tx1, tx2); + // Use _inclusion_ fee to order transactions + return txLessThan(tx1, tx1->getInclusionFee(), tx1->getNumOperations(), tx2, + tx2->getInclusionFee(), tx2->getNumOperations()); +} + +bool +TxFeeComparator::operator()(TransactionFrameBasePtr const& tx1, int64_t tx1Bid, + uint32_t tx1Ops, TransactionFrameBasePtr const& tx2, + int64_t tx2Bid, uint32_t tx2Ops) const +{ + return txLessThan(tx1, tx1Bid, tx1Ops, tx2, tx2Bid, tx2Ops); } bool @@ -108,10 +105,11 @@ TxFeeComparator::isGreater() const } bool -TxFeeComparator::txLessThan(TransactionFrameBasePtr const& tx1, - TransactionFrameBasePtr const& tx2) const +TxFeeComparator::txLessThan(TransactionFrameBasePtr const& tx1, int64_t tx1Bid, + uint32_t tx1Ops, TransactionFrameBasePtr const& tx2, + int64_t tx2Bid, uint32_t tx2Ops) const { - auto cmp3 = feeRate3WayCompare(*tx1, *tx2); + auto cmp3 = feeRate3WayCompare(tx1Bid, tx1Ops, tx2Bid, tx2Ops); if (cmp3 != 0) { diff --git a/src/herder/SurgePricingUtils.h b/src/herder/SurgePricingUtils.h index 0c353dbf07..f6e7fb3b6f 100644 --- a/src/herder/SurgePricingUtils.h +++ b/src/herder/SurgePricingUtils.h @@ -34,6 +34,11 @@ class TxFeeComparator bool operator()(TransactionFrameBasePtr const& tx1, TransactionFrameBasePtr const& tx2) const; + // The same comparison, given the transactions' inclusion fee bids and + // operation counts (e.g. computed once per transaction for a sort). + bool operator()(TransactionFrameBasePtr const& tx1, int64_t tx1Bid, + uint32_t tx1Ops, TransactionFrameBasePtr const& tx2, + int64_t tx2Bid, uint32_t tx2Ops) const; bool compareFeeOnly(TransactionFrameBase const& tx1, TransactionFrameBase const& tx2) const; @@ -42,8 +47,9 @@ class TxFeeComparator bool isGreater() const; private: - bool txLessThan(TransactionFrameBasePtr const& tx1, - TransactionFrameBasePtr const& tx2) const; + bool txLessThan(TransactionFrameBasePtr const& tx1, int64_t tx1Bid, + uint32_t tx1Ops, TransactionFrameBasePtr const& tx2, + int64_t tx2Bid, uint32_t tx2Ops) const; bool const mIsGreater; #ifndef BUILD_TESTS diff --git a/src/herder/test/TxSetTests.cpp b/src/herder/test/TxSetTests.cpp index 781c905b7e..ce9871a1b4 100644 --- a/src/herder/test/TxSetTests.cpp +++ b/src/herder/test/TxSetTests.cpp @@ -5,6 +5,7 @@ #include "crypto/SHA.h" #include "crypto/SecretKey.h" #include "herder/ParallelTxSetBuilder.h" +#include "herder/SurgePricingUtils.h" #include "herder/TxSetFrame.h" #include "herder/TxSetUtils.h" #include "herder/test/TestTxSetUtils.h" @@ -28,6 +29,7 @@ #include #include #include +#include namespace stellar { namespace @@ -293,6 +295,69 @@ TEST_CASE("tx set validation caches candidate hashes", "[txset]") REQUIRE(applicable->checkValid(*app, 0, 0)); } +TEST_CASE("fee comparator with precomputed bids orders like the plain one", + "[txset]") +{ + VirtualClock clock; + auto app = createTestApplication(clock, getTestConfig()); + overrideSorobanNetworkConfigForTest(*app); + auto root = app->getRoot(); + // Classic transactions with 1-3 operations and Soroban transactions with + // varying resource fees (so their full fees don't order like their + // inclusion fees), over few fee rates, so that many compare equal. + TxFrameList txs; + for (int i = 0; i < 200; ++i) + { + uint32_t const rate = 100 * rand_uniform(1, 4); + if (i % 2 == 0) + { + uint32_t const ops = rand_uniform(1, 3); + std::vector payments(ops, + payment(root->getPublicKey(), 1)); + txs.push_back(transactionFromOperations( + *app, SecretKey::pseudoRandomForTesting(), 1, payments, + ops * rate)); + } + else + { + SorobanResources resources; + resources.instructions = 800'000; + resources.diskReadBytes = 1000; + resources.writeBytes = 1000; + auto const resourceFee = + sorobanResourceFee(*app, resources, 5000, 100) + + rand_uniform(0, 10'000); + txs.push_back(createUploadWasmTx(*app, *root, rate, resourceFee, + resources, std::nullopt, 0, + std::nullopt, i)); + } + } + for (bool isGreater : {true, false}) + { + TxFeeComparator comparator( + isGreater, + rand_uniform(0, std::numeric_limits::max())); + auto plain = txs; + std::sort(plain.begin(), plain.end(), comparator); + + std::vector> bids; + for (auto const& tx : txs) + { + bids.emplace_back(tx->getInclusionFee(), tx->getNumOperations()); + } + std::vector order(txs.size()); + std::iota(order.begin(), order.end(), 0); + std::sort(order.begin(), order.end(), [&](size_t a, size_t b) { + return comparator(txs[a], bids[a].first, bids[a].second, txs[b], + bids[b].first, bids[b].second); + }); + for (size_t i = 0; i < txs.size(); ++i) + { + REQUIRE(txs[order[i]] == plain[i]); + } + } +} + TEST_CASE("generalized tx set XDR validation", "[txset]") { Config cfg(getTestConfig()); From d03d56f2949bc7d5a419ae43b0bde5c675ce5d5a Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Mon, 9 Nov 2026 16:04:23 -0800 Subject: [PATCH 19/23] Decode mempool pulls in place from the overlay IPC payload OverlayIPC::getTopTransactions copied every transaction's XDR into a temporary vector before decoding it. Decode well-formed entries straight from the response payload (OverlayIPC::parseTopTransactions); entries that are not 4-byte aligned, which a well-formed response never has, are still decoded from an aligned copy, and entries that fail to decode are still skipped. The leader build benchmark now decodes its replayed response with the same function. Laptop benchmark (15,000 SAC candidates): build-pull 19.4 -> 10.7 ms. --- src/herder/test/HerderTests.cpp | 31 ++++---------- src/overlay/OverlayIPC.cpp | 39 ++++++++++++----- src/overlay/OverlayIPC.h | 9 ++++ src/overlay/test/OverlayIPCTests.cpp | 62 ++++++++++++++++++++++++++++ 4 files changed, 108 insertions(+), 33 deletions(-) diff --git a/src/herder/test/HerderTests.cpp b/src/herder/test/HerderTests.cpp index 980929f8c2..f2cd9ac13b 100644 --- a/src/herder/test/HerderTests.cpp +++ b/src/herder/test/HerderTests.cpp @@ -35,6 +35,7 @@ #include "lib/json/json.h" #include "main/CommandHandler.h" #include "main/PersistentState.h" +#include "overlay/OverlayIPC.h" #include "overlay/OverlayMetrics.h" #include "overlay/RustOverlayManager.h" #include "test/Catch2.h" @@ -8439,38 +8440,24 @@ TEST_CASE("leader tx set build costs", "[herder][.][benchmark]") REQUIRE(envelopes.size() == candidates); app->getBatchExecutor().setPreferredTaskCountForTesting(tasks); - // The Rust overlay's GetTopTxs response, decoded exactly as + // BENCH_PULL: hand over only the first N candidates (a smaller pull). + uint32_t const count = static_cast(envelopes.size()); + uint32_t const pull = std::min(envInt("BENCH_PULL", count), count); + // The Rust overlay's GetTopTxs response for the pull, decoded as // OverlayIPC::getTopTransactions does: [count:4]([len:4][xdr])* std::vector payload(4); - uint32_t const count = static_cast(envelopes.size()); - std::memcpy(payload.data(), &count, 4); - for (auto const& env : envelopes) + std::memcpy(payload.data(), &pull, 4); + for (uint32_t i = 0; i < pull; ++i) { - auto bytes = xdr::xdr_to_opaque(env); + auto bytes = xdr::xdr_to_opaque(envelopes[i]); uint32_t const len = static_cast(bytes.size()); auto const at = payload.size(); payload.resize(at + 4 + len); std::memcpy(payload.data() + at, &len, 4); std::memcpy(payload.data() + at + 4, bytes.data(), len); } - // BENCH_PULL: hand over only the first N candidates (a smaller pull). - uint32_t const pull = std::min(envInt("BENCH_PULL", count), count); herder.mGetTopTransactionsForTesting = [&](size_t) { - std::vector result; - size_t offset = 4; - for (uint32_t i = 0; i < pull; ++i) - { - uint32_t len; - std::memcpy(&len, payload.data() + offset, 4); - offset += 4; - TransactionEnvelope tx; - std::vector txData(payload.begin() + offset, - payload.begin() + offset + len); - xdr::xdr_from_opaque(txData, tx); - result.push_back(std::move(tx)); - offset += len; - } - return result; + return OverlayIPC::parseTopTransactions(payload); }; auto const lcl = app->getLedgerManager().getLastClosedLedgerHeader(); diff --git a/src/overlay/OverlayIPC.cpp b/src/overlay/OverlayIPC.cpp index 39aa870f1f..51c702fa74 100644 --- a/src/overlay/OverlayIPC.cpp +++ b/src/overlay/OverlayIPC.cpp @@ -608,25 +608,31 @@ OverlayIPC::getTopTransactions(size_t count) return result; } - // Parse response: list of XDR-encoded TransactionEnvelopes + return parseTopTransactions(response.payload); +} + +std::vector +OverlayIPC::parseTopTransactions(std::vector const& payload) +{ + std::vector result; // Format: [count:4][len1:4][tx1:len1][len2:4][tx2:len2]... - if (response.payload.size() < 4) + if (payload.size() < 4) { return result; } uint32_t txCount; - std::memcpy(&txCount, response.payload.data(), 4); + std::memcpy(&txCount, payload.data(), 4); + result.reserve(std::min(txCount, payload.size() / 4)); size_t offset = 4; - for (uint32_t i = 0; i < txCount && offset + 4 <= response.payload.size(); - ++i) + for (uint32_t i = 0; i < txCount && offset + 4 <= payload.size(); ++i) { uint32_t txLen; - std::memcpy(&txLen, response.payload.data() + offset, 4); + std::memcpy(&txLen, payload.data() + offset, 4); offset += 4; - if (offset + txLen > response.payload.size()) + if (txLen > payload.size() - offset) { break; } @@ -634,10 +640,21 @@ OverlayIPC::getTopTransactions(size_t count) try { TransactionEnvelope tx; - std::vector txData(response.payload.begin() + offset, - response.payload.begin() + offset + - txLen); - xdr::xdr_from_opaque(txData, tx); + uint8_t const* const start = payload.data() + offset; + // XDR is read in 4-byte words from 4-byte aligned memory. Well + // formed entries are (XDR lengths are multiples of 4), so decode + // them in place; copy anything else to aligned memory first. + if ((reinterpret_cast(start) & 3) == 0) + { + xdr::xdr_get g(start, start + txLen); + xdr::xdr_argpack_archive(g, tx); + g.done(); + } + else + { + std::vector const txData(start, start + txLen); + xdr::xdr_from_opaque(txData, tx); + } result.push_back(std::move(tx)); } catch (std::exception const& e) diff --git a/src/overlay/OverlayIPC.h b/src/overlay/OverlayIPC.h index 1963b6541e..685821ed98 100644 --- a/src/overlay/OverlayIPC.h +++ b/src/overlay/OverlayIPC.h @@ -124,6 +124,15 @@ class OverlayIPC */ std::vector getTopTransactions(size_t count); + /** + * Decode a GET_TOP_TXS response payload: + * [count:4]([len:4][TransactionEnvelope XDR:len])*. Envelopes are + * decoded in place from the payload. Entries that fail to decode are + * skipped (with a warning); a truncated payload ends the list. + */ + static std::vector + parseTopTransactions(std::vector const& payload); + /** * Submit a transaction to the overlay for flooding. * diff --git a/src/overlay/test/OverlayIPCTests.cpp b/src/overlay/test/OverlayIPCTests.cpp index 196e6e2b56..255756b354 100644 --- a/src/overlay/test/OverlayIPCTests.cpp +++ b/src/overlay/test/OverlayIPCTests.cpp @@ -17,6 +17,7 @@ #include #include +#include #include #include #include @@ -73,6 +74,67 @@ makeMockSCPEnvelope(uint64_t slotIndex, uint32_t nodeId) } // anonymous namespace +TEST_CASE("OverlayIPC decodes top transactions in place", "[overlay-ipc]") +{ + // Envelopes of different lengths (memo text is padded to 4 bytes). + std::vector envs; + for (uint32_t i = 0; i < 3; ++i) + { + TransactionEnvelope env(ENVELOPE_TYPE_TX); + env.v1().tx.fee = 100 + i; + env.v1().tx.seqNum = i + 1; + env.v1().tx.memo.type(MEMO_TEXT); + env.v1().tx.memo.text() = std::string(3 * i + 1, 'x'); + envs.push_back(env); + } + auto payloadOf = [](uint32_t count, + std::vector> const& entries) { + std::vector payload(4); + std::memcpy(payload.data(), &count, 4); + for (auto const& entry : entries) + { + uint32_t const len = static_cast(entry.size()); + auto const at = payload.size(); + payload.resize(at + 4); + std::memcpy(payload.data() + at, &len, 4); + payload.insert(payload.end(), entry.begin(), entry.end()); + } + return payload; + }; + std::vector> xdrs; + for (auto const& env : envs) + { + xdrs.push_back(xdr::xdr_to_opaque(env)); + } + + SECTION("well formed") + { + REQUIRE(OverlayIPC::parseTopTransactions(payloadOf(3, xdrs)) == envs); + } + SECTION("malformed entries are skipped") + { + // A 5-byte entry fails to decode and leaves the next ones unaligned, + // decoded from a copy, until a 3-byte one (which fails too) aligns + // them again. An aligned entry with an invalid envelope type fails + // to decode in place. + std::vector const badType(xdrs[0].size(), 0xff); + auto payload = payloadOf( + 6, + {xdrs[0], {1, 2, 3, 4, 5}, xdrs[1], {1, 2, 3}, badType, xdrs[2]}); + REQUIRE(OverlayIPC::parseTopTransactions(payload) == envs); + } + SECTION("truncated payload") + { + auto payload = payloadOf(3, xdrs); + payload.resize(payload.size() - 1); + REQUIRE(OverlayIPC::parseTopTransactions(payload) == + std::vector{envs[0], envs[1]}); + // More entries announced than present. + REQUIRE(OverlayIPC::parseTopTransactions(payloadOf(5, xdrs)) == envs); + REQUIRE(OverlayIPC::parseTopTransactions({1, 0}).empty()); + } +} + TEST_CASE("OverlayIPC connects to Rust overlay", "[overlay-ipc]") { auto overlayBinary = requireOverlayBinary(); From 547e29f55dd06665dc9212206bbe636271c7e00b Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Mon, 9 Nov 2026 16:20:06 -0800 Subject: [PATCH 20/23] Give Core's tx-set fetch metrics their own names PendingEnvelopes timed its tx-set fetches (request to overlay delivery) into overlay.fetch.txset, which RustOverlayManager also feeds with the Rust overlay's own fetch times, synced as per-batch averages: one timer mixing two measurements, with about two samples per ledger. Name Core's timer scp.fetch.txset, next to scp.fetch.envelope from the same class, and its retry counter scp.fetch.txset-retry; overlay.fetch.txset is left to the overlay. docs/metrics.md lists both. --- docs/metrics.md | 4 +++- docs/rust-overlay/txset-fetching.md | 2 +- src/herder/PendingEnvelopes.cpp | 9 +++++---- src/herder/test/PendingEnvelopesTests.cpp | 14 ++++++++++---- 4 files changed, 19 insertions(+), 10 deletions(-) diff --git a/docs/metrics.md b/docs/metrics.md index b37a5c24bc..4f9bb35dee 100644 --- a/docs/metrics.md +++ b/docs/metrics.md @@ -130,7 +130,7 @@ overlay.delay.async-write | timer | time between each messag overlay.delay.write-queue | timer | time between each message's entry and exit from peer write queue overlay.error.read | meter | error while receiving a message overlay.error.write | meter | error while sending a message -overlay.fetch.txset | timer | time to complete fetching of a txset +overlay.fetch.txset | timer | time the Rust overlay took to fetch a txset from a peer (synced from the overlay as per-batch averages) overlay.fetch.qset | timer | time to complete fetching of a qset overlay.fetch.unique-recv | meter | number of bytes of fetched messages that have not yet been received overlay.fetch.duplicate-recv | meter | number of bytes of fetched messages that have already been received @@ -181,6 +181,8 @@ scp.envelope.receive | meter | SCP message received scp.envelope.sign | meter | envelope signed scp.envelope.validsig | meter | envelope signature verified scp.fetch.envelope | timer | time to complete fetching of an envelope +scp.fetch.txset | timer | time from requesting a txset an SCP envelope needs to the overlay delivering it (not counting sets this node built itself) +scp.fetch.txset-retry | counter | txset requests repeated because the set had not arrived scp.memory.cumulative-statements | counter | number of known SCP statements known scp.nomination.combinecandidates | meter | number of candidates per call scp.pending.discarded | counter | number of discarded envelopes diff --git a/docs/rust-overlay/txset-fetching.md b/docs/rust-overlay/txset-fetching.md index a4008ca176..1e4b899022 100644 --- a/docs/rust-overlay/txset-fetching.md +++ b/docs/rust-overlay/txset-fetching.md @@ -95,7 +95,7 @@ drops reservations older than the retained-slot window (`sequence - 12`). Rust has no request timer. Core repeats a `RequestTxSet` for a set it has not received after one second, then every second, logging a warning on every -doubling of the request count (and counting `overlay.fetch.txset-retry`). +doubling of the request count (and counting `scp.fetch.txset-retry`). A request for a hash Core is still waiting for is a retry: it replaces the reservation and goes to another connected peer, preferring the SCP source only if it was not the previous target, else a random one. Core stops fetching when diff --git a/src/herder/PendingEnvelopes.cpp b/src/herder/PendingEnvelopes.cpp index c8183a5690..6c3a3b5af5 100644 --- a/src/herder/PendingEnvelopes.cpp +++ b/src/herder/PendingEnvelopes.cpp @@ -45,10 +45,10 @@ PendingEnvelopes::PendingEnvelopes(Application& app, HerderImpl& herder) app.getMetrics().NewCounter({"scp", "pending", "fetching"})) , mReadyCount(app.getMetrics().NewCounter({"scp", "pending", "ready"})) , mFetchDuration(app.getMetrics().NewTimer({"scp", "fetch", "envelope"})) - , mFetchTxSetTimer(app.getMetrics().NewTimer({"overlay", "fetch", "txset"})) + , mFetchTxSetTimer(app.getMetrics().NewTimer({"scp", "fetch", "txset"})) , mFetchQsetTimer(app.getMetrics().NewTimer({"overlay", "fetch", "qset"})) , mTxSetFetchRetries( - app.getMetrics().NewCounter({"overlay", "fetch", "txset-retry"})) + app.getMetrics().NewCounter({"scp", "fetch", "txset-retry"})) , mCostPerSlot(app.getMetrics().NewHistogram({"scp", "cost", "per-slot"})) { } @@ -332,8 +332,9 @@ PendingEnvelopes::completeTxSetFetch(Hash const& hash, auto fetchIt = mTxSetFetches.find(hash); if (fetchIt != mTxSetFetches.end()) { - // overlay.fetch.txset times overlay fetches only, not sets this node - // ended up building itself. + // scp.fetch.txset times overlay deliveries only, not sets this node + // ended up building itself. (overlay.fetch.txset is the overlay's own + // per-request fetch time, synced from Rust.) if (deliveredByOverlay) { mFetchTxSetTimer.Update(mApp.getClock().now() - diff --git a/src/herder/test/PendingEnvelopesTests.cpp b/src/herder/test/PendingEnvelopesTests.cpp index 08e925ab92..0eee4f71c6 100644 --- a/src/herder/test/PendingEnvelopesTests.cpp +++ b/src/herder/test/PendingEnvelopesTests.cpp @@ -222,7 +222,7 @@ TEST_CASE_VERSIONS("PendingEnvelopes recvSCPEnvelope", "[herder]") REQUIRE(pendingEnvelopes.recvSCPQuorumSet(saneQSetHash, saneQSet)); REQUIRE(herder.getSCP().getLatestMessage(pk) == nullptr); auto& fetchTimer = - app->getMetrics().NewTimer({"overlay", "fetch", "txset"}); + app->getMetrics().NewTimer({"scp", "fetch", "txset"}); auto const fetches = fetchTimer.count(); // A promoted leader or a legacy-tx-set validator can build the @@ -233,7 +233,7 @@ TEST_CASE_VERSIONS("PendingEnvelopes recvSCPEnvelope", "[herder]") auto m = herder.getSCP().getLatestMessage(pk); REQUIRE(m); REQUIRE(*m == saneEnvelope); - // Not an overlay fetch: overlay.fetch.txset is not updated. + // Not an overlay fetch: scp.fetch.txset is not updated. REQUIRE(fetchTimer.count() == fetches); // A later delivery from the overlay is redundant. @@ -848,7 +848,7 @@ TEST_CASE("PendingEnvelopes re-requests tx sets the overlay does not deliver", pendingEnvelopes.addSCPQuorumSet(qSetHash, qSet); auto& retries = - app->getMetrics().NewCounter({"overlay", "fetch", "txset-retry"}); + app->getMetrics().NewCounter({"scp", "fetch", "txset-retry"}); auto const initialRetries = retries.count(); auto const interval = PendingEnvelopes::TX_SET_FETCH_RETRY_INTERVAL; // Advance virtual time by exactly `d` (crankFor can jump past it to the @@ -876,8 +876,13 @@ TEST_CASE("PendingEnvelopes re-requests tx sets the overlay does not deliver", SECTION("an undelivered set is requested again until it arrives") { auto& fetchTimer = - app->getMetrics().NewTimer({"overlay", "fetch", "txset"}); + app->getMetrics().NewTimer({"scp", "fetch", "txset"}); auto const fetches = fetchTimer.count(); + // The overlay's own fetch time (synced from Rust) is a separate + // metric that Core's fetch tracking doesn't feed. + auto& overlayFetchTimer = + app->getMetrics().NewTimer({"overlay", "fetch", "txset"}); + auto const overlayFetches = overlayFetchTimer.count(); // Requests repeat after 1 s, then back off: 2 s, 4 s, ... crankBy(interval); // t = 1.5 s REQUIRE(retries.count() == initialRetries + 1); @@ -893,6 +898,7 @@ TEST_CASE("PendingEnvelopes re-requests tx sets the overlay does not deliver", REQUIRE(pendingEnvelopes.recvTxSet(hash, p.second)); REQUIRE(!pendingEnvelopes.getTxSetWaitingTime(hash)); REQUIRE(fetchTimer.count() == fetches + 1); + REQUIRE(overlayFetchTimer.count() == overlayFetches); crankBy(10 * interval); REQUIRE(retries.count() == initialRetries + 3); } From 18f84acb0df1bc9a5c671320bf3e8f90bc87bb61 Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Mon, 9 Nov 2026 16:49:23 -0800 Subject: [PATCH 21/23] Prewarm the next ledger's signatures from the ballot on every validator On perfnet (3k SAC TPS) followers still validated the leader's set with a mostly cold signature cache, and the leader built with a cold one. The follower prewarm verified each follower's own top 7,600 mempool txs at the trigger, but with equal fees the mempool orders by hash while selection breaks ties randomly, so the leader's 7,500 came from its top 15,200 and only about half were covered; the leader had no prewarm. When slot N starts balloting, every tracking validator now starts a prewarm for ledger N + 1 over exactly the candidates its build validates first: per phase, the first validTxTargets() (5/4 of the capacity) in mempool order, past the transactions of N's value, which stay in the mempool until N externalizes. The leader's set comes from the same window, so a finished prewarm covers its build and the followers' validation. It runs while N finishes balloting, externalizes and closes: externalizing N keeps it; the build or a received-set validation stops it, as before. The follower's trigger-time prewarm stays as a top-up. The main thread only does the overlay round trip (posted after the SCP step that started the ballot; OverlayIPC::getTopTransactionsPayload returns the response undecoded). Decoding, windowing and verification run in at most min(batch executor tasks, WORKER_THREADS - 2) background tasks, which also free what they allocated. Metrics, so a perfnet run shows coverage: herder.prewarm.{pull,duration} timers, herder.prewarm.{txs,verified,incomplete} meters, and signature cache lookups during a build and during received-set validation, herder.txset.{build,validate}-sig-cache-{hit,miss} (from the new non-resetting PubKeyUtils::getVerifySigCacheCounts). docs/metrics.md lists them, and the build phase timers. The leader build benchmark gets a prewarmed mode. Laptop, 15,000 SAC candidates, 4 tasks: build cold 169.2 / warm 84.1 / after a prewarm 83.0 ms; received-set validation 102.2 / 34.2 / 37.7 ms; both with no signature verified after the prewarm, which itself takes 110.8 ms in the background. --- docs/metrics.md | 17 ++ src/crypto/SecretKey.cpp | 13 ++ src/crypto/SecretKey.h | 2 + src/herder/HerderImpl.cpp | 345 ++++++++++++++++++++++++----- src/herder/HerderImpl.h | 47 +++- src/herder/HerderSCPDriver.cpp | 16 ++ src/herder/HerderUtils.cpp | 24 ++ src/herder/HerderUtils.h | 8 + src/herder/test/HerderTests.cpp | 272 ++++++++++++++++++++++- src/overlay/OverlayIPC.cpp | 10 +- src/overlay/OverlayIPC.h | 7 + src/overlay/RustOverlayManager.cpp | 10 + src/overlay/RustOverlayManager.h | 2 + 13 files changed, 705 insertions(+), 68 deletions(-) diff --git a/docs/metrics.md b/docs/metrics.md index 4f9bb35dee..098823e7bc 100644 --- a/docs/metrics.md +++ b/docs/metrics.md @@ -64,6 +64,23 @@ crypto.verify.tx-valid-hit | meter | signature cache hits tha crypto.verify.tx-valid-total | meter | sum of both hits and misses during transaction validation (outside of background signature validation) herder.txset.build | timer | time spent building the tx set proposed at nomination from the transaction queues herder.txset.validate | timer | time spent turning a received tx set into an applicable tx set and validating it on a validity-cache miss +herder.txset.validate-sig-cache-hit | meter | signature cache hits while validating a received tx set (herder.txset.validate) +herder.txset.validate-sig-cache-miss | meter | signatures verified (not in the cache) while validating a received tx set +herder.txset.build-pull | timer | tx set build phase: pulling and decoding the mempool's top transactions +herder.txset.build-frames | timer | tx set build phase: making transaction frames, splitting them into phases, one per source account +herder.txset.build-trim | timer | tx set build phase: validating candidates (each phase until it has enough valid ones) +herder.txset.build-select | timer | tx set build phase: surge pricing and building the parallel Soroban phase +herder.txset.build-xdr | timer | tx set build phase: building the set's XDR +herder.txset.build-handoff | timer | tx set build phase: handing the built set to the overlay +herder.txset.build-roundtrip | timer | tx set build phase: re-reading the built set from its XDR +herder.txset.build-final-check | timer | tx set build phase: final structural check of the built set +herder.txset.build-sig-cache-hit | meter | signature cache hits while a leader's build validates its candidates +herder.txset.build-sig-cache-miss | meter | signatures verified (not in the cache) while a leader's build validates its candidates +herder.prewarm.pull | timer | main thread time of a signature prewarm's mempool pull (the overlay round trip; decoding runs in the prewarm's tasks) +herder.prewarm.duration | timer | time from a signature prewarm's start until its background tasks finished (or it was stopped) +herder.prewarm.txs | meter | transactions whose signatures a signature prewarm checked +herder.prewarm.verified | meter | signatures a signature prewarm verified (were not in the cache yet) +herder.prewarm.incomplete | meter | signature prewarms stopped (by a build, a validation or a newer prewarm) before they finished herder.pending[-soroban]-txs.age0 | counter | number of gen0 pending transactions herder.pending[-soroban]-txs.age1 | counter | number of gen1 pending transactions herder.pending[-soroban]-txs.age2 | counter | number of gen2 pending transactions diff --git a/src/crypto/SecretKey.cpp b/src/crypto/SecretKey.cpp index ba36b1bb68..b73994c619 100644 --- a/src/crypto/SecretKey.cpp +++ b/src/crypto/SecretKey.cpp @@ -354,6 +354,19 @@ PubKeyUtils::seedVerifySigCache(unsigned int seed) } } +void +PubKeyUtils::getVerifySigCacheCounts(uint64_t& hits, uint64_t& misses) +{ + hits = 0; + misses = 0; + for (auto& shard : gVerifySigCacheShards) + { + LOCK_GUARD(shard.mMutex, guard); + hits += shard.mHits; + misses += shard.mMisses; + } +} + void PubKeyUtils::flushVerifySigCacheCounts(uint64_t& hits, uint64_t& misses) { diff --git a/src/crypto/SecretKey.h b/src/crypto/SecretKey.h index c30286e4d0..08e55ce9d8 100644 --- a/src/crypto/SecretKey.h +++ b/src/crypto/SecretKey.h @@ -165,6 +165,8 @@ VerifySigResult verifySig(PublicKey const& key, Signature const& signature, void clearVerifySigCache(); void seedVerifySigCache(unsigned int seed); void flushVerifySigCacheCounts(uint64_t& hits, uint64_t& misses); +// The lookup counts since the last flush, without resetting them. +void getVerifySigCacheCounts(uint64_t& hits, uint64_t& misses); PublicKey random(); #ifdef BUILD_TESTS diff --git a/src/herder/HerderImpl.cpp b/src/herder/HerderImpl.cpp index 56b3684d65..d1abc80732 100644 --- a/src/herder/HerderImpl.cpp +++ b/src/herder/HerderImpl.cpp @@ -29,6 +29,7 @@ #include "main/PersistentState.h" #include "medida/counter.h" #include "medida/meter.h" +#include "overlay/OverlayIPC.h" #include "overlay/RustOverlayManager.h" #include "process/ProcessManager.h" #include "scp/LocalNode.h" @@ -58,6 +59,7 @@ #include #include #include +#include #include using namespace std; @@ -70,16 +72,18 @@ namespace // operation source and fee source accounts. This populates the // signature-verification cache that tx-set validation consults with the same // (key, signature, hash). Other signers need ledger state; validation verifies -// them itself. -void +// them itself. Returns how many signatures it verified (were not cached). +size_t verifyMasterKeySignatures(Hash const& networkID, TransactionEnvelope const& env) { // Bound the work per transaction: a signature is only verified against // keys whose hint it matches, but colliding hints could otherwise make a // crafted transaction cost many verifications. size_t budget = 20; - auto verify = [&budget](Hash const& contentsHash, auto const& signatures, - std::vector const& keys) { + size_t verified = 0; + auto verify = [&budget, &verified](Hash const& contentsHash, + auto const& signatures, + std::vector const& keys) { for (auto const& sig : signatures) { for (auto const& key : keys) @@ -93,7 +97,13 @@ verifyMasterKeySignatures(Hash const& networkID, TransactionEnvelope const& env) return; } --budget; - if (SignatureUtils::verify(sig, key, contentsHash).valid) + auto const res = SignatureUtils::verify(sig, key, contentsHash); + if (res.cacheResult == + PubKeyUtils::VerifySigCacheLookupResult::MISS) + { + ++verified; + } + if (res.valid) { break; } @@ -133,13 +143,96 @@ verifyMasterKeySignatures(Hash const& networkID, TransactionEnvelope const& env) {frame->getFeeSourceID()}); TransactionEnvelope inner(ENVELOPE_TYPE_TX); inner.v1() = env.feeBump().tx.innerTx.v1(); - verifyMasterKeySignatures(networkID, inner); + verified += verifyMasterKeySignatures(networkID, inner); break; } default: break; } + return verified; +} + +// Whether an envelope's transaction goes into the Soroban phase, as +// TransactionFrame::isSoroban decides it (by the first operation). +bool +isSorobanEnvelope(TransactionEnvelope const& env) +{ + auto const* ops = env.type() == ENVELOPE_TYPE_TX_V0 + ? &env.v0().tx.operations + : env.type() == ENVELOPE_TYPE_TX ? &env.v1().tx.operations + : env.type() == ENVELOPE_TYPE_TX_FEE_BUMP + ? &env.feeBump().tx.innerTx.v1().tx.operations + : nullptr; + if (ops == nullptr || ops->empty()) + { + return false; + } + switch (ops->front().body.type()) + { + case INVOKE_HOST_FUNCTION: + case EXTEND_FOOTPRINT_TTL: + case RESTORE_FOOTPRINT: + return true; + default: + return false; + } } + +// The first `windows[phase]` envelopes of each phase (classic, then Soroban; +// a phase without a window is skipped), in mempool order. +std::vector +selectPrewarmCandidates(std::vector&& envelopes, + std::vector const& windows) +{ + std::vector selected; + std::vector taken(windows.size(), 0); + for (auto& env : envelopes) + { + size_t const phase = isSorobanEnvelope(env) ? 1 : 0; + if (phase < windows.size() && taken[phase] < windows[phase]) + { + ++taken[phase]; + selected.push_back(std::move(env)); + } + } + return selected; +} + +// The number of transactions in each phase of a generalized tx set. +std::vector +txCountPerPhase(TxSetXDRFrame const& txSet) +{ + std::vector counts; + if (!txSet.isGeneralizedTxSet()) + { + return counts; + } + for (auto const& phase : txSet.getGeneralizedXDR().v1TxSet().phases) + { + size_t count = 0; + if (phase.v() == 0) + { + for (auto const& component : phase.v0Components()) + { + count += component.txsMaybeDiscountedFee().txs.size(); + } + } + else + { + for (auto const& stage : + phase.parallelTxsComponent().executionStages) + { + for (auto const& cluster : stage) + { + count += cluster.size(); + } + } + } + counts.push_back(count); + } + return counts; +} + } // namespace // Roughly ~10 minutes of consensus @@ -580,8 +673,12 @@ HerderImpl::valueExternalized(uint64 slotIndex, StellarValue const& value, { ZoneScoped; int const DUMP_SCP_TIMEOUT_SECONDS = 20; - // The prewarm only serves validating this slot's values. - stopSignaturePrewarm(); + // A prewarm for this slot is done serving; the one for the next ledger + // (started when this slot's ballot did) keeps running. + if (mSignaturePrewarm && mSignaturePrewarm->ledgerSeq <= slotIndex) + { + stopSignaturePrewarm(); + } recordExternalizeAndCheckCloseTimeDrift(slotIndex, value, mDriftCTSlidingWindow); @@ -1891,32 +1988,17 @@ HerderImpl::buildTxSet(uint32_t ledgerSeq, ConsensusTime closeTime) txPhases.emplace_back(std::move(sorobanTxs)); } - // Selection only uses the best valid candidates up to each phase's - // capacity, and validating (mostly: verifying the signatures of) the rest - // of the pull is most of the build's cost. Validate each phase in mempool - // order only until it holds 5/4 of its capacity in valid transactions - // (more if some are invalid, see TxSetUtils::trimInvalidPrefix). The slack - // covers candidates that selection skips: those that don't fit the - // remaining resources, and those the mempool ranks above ones with a - // higher inclusion fee (it orders by total fee per operation). - auto validationTarget = [](size_t capacity) { - return capacity + (capacity + 3) / 4; - }; - std::vector validTxTargets{ - validationTarget(mLedgerManager.getLastMaxTxSetSizeOps())}; - if (supportsSoroban) - { - validTxTargets.push_back(validationTarget( - mLedgerManager.hasLastClosedSorobanNetworkConfig() - ? mLedgerManager.getLastClosedSorobanNetworkConfig() - .ledgerMaxTxCount() - : 0)); - } + // Validate each phase only until it holds enough valid transactions (see + // validTxTargets). + auto const targets = validTxTargets(lcl.header.ledgerVersion); PerPhaseTransactionList invalidTxPhases; invalidTxPhases.resize(txPhases.size()); framesTimer.Stop(); + uint64_t sigCacheHits = 0; + uint64_t sigCacheMisses = 0; + PubKeyUtils::getVerifySigCacheCounts(sigCacheHits, sigCacheMisses); std::tie(proposedSet, applicableProposedSet) = makeTxSetFromTransactions( txPhases, mApp, closeTimeOffset, invalidTxPhases #ifdef BUILD_TESTS @@ -1937,7 +2019,8 @@ HerderImpl::buildTxSet(uint32_t ledgerSeq, ConsensusTime closeTime) txSet->getGeneralizedXDR(), ledgerSeq); } }, - validTxTargets); + targets); + markSignatureCacheLookups(mApp, "build", sigCacheHits, sigCacheMisses); CLOG_INFO(Herder, "Proposed TX set has {} transactions", proposedSet->sizeTxTotal()); @@ -2104,17 +2187,18 @@ HerderImpl::triggerNextLedger(uint32_t ledgerSeqToTrigger, /*constructValueNow=*/buildsLegacyTxSet(lcl.header.ledgerVersion)); // A follower validates the leader's set when it arrives, and most of its - // transactions are in this node's mempool too. Verify their signatures - // meanwhile, as building our own set used to before leader-only - // construction, so that validation finds them in the cache. Skip it if - // this node already voted, i.e. validated the leader's value. + // transactions are in this node's mempool too. The prewarm started at the + // previous slot's ballot verified the candidates known then; verify the + // current ones (mostly cached by now) while waiting for the leader's set, + // so that validation finds them in the cache. Skip it if this node already + // voted, i.e. validated the leader's value. if (!buildsLegacyTxSet(lcl.header.ledgerVersion) && !getSCP() .getNominationLeaders(ledgerSeqToTrigger) .count(getSCP().getLocalNodeID()) && getSCP().getLatestMessagesSend(ledgerSeqToTrigger).empty()) { - prewarmSignatureCache(); + prewarmSignatureCache(ledgerSeqToTrigger, {}); } } @@ -2143,43 +2227,173 @@ HerderImpl::pullTopTransactions(size_t count) return mApp.getOverlayManager().getTopTransactions(count); } +std::vector +HerderImpl::validTxTargets(uint32_t lclLedgerVersion) const +{ + // Selection only uses the best valid candidates up to each phase's + // capacity, and validating (mostly: verifying the signatures of) the rest + // of the pull is most of the build's cost. A build validates each phase in + // mempool order only until it holds 5/4 of its capacity in valid + // transactions (more if some are invalid, see + // TxSetUtils::trimInvalidPrefix). The slack covers candidates that + // selection skips: those that don't fit the remaining resources, and those + // the mempool ranks above ones with a higher inclusion fee (it orders by + // total fee per operation). + auto validationTarget = [](size_t capacity) { + return capacity + (capacity + 3) / 4; + }; + std::vector targets{ + validationTarget(mLedgerManager.getLastMaxTxSetSizeOps())}; + if (protocolVersionStartsFrom(lclLedgerVersion, SOROBAN_PROTOCOL_VERSION)) + { + targets.push_back(validationTarget( + mLedgerManager.hasLastClosedSorobanNetworkConfig() + ? mLedgerManager.getLastClosedSorobanNetworkConfig() + .ledgerMaxTxCount() + : 0)); + } + return targets; +} + +std::vector +HerderImpl::pullTopTransactionsPayload(size_t count) +{ +#ifdef BUILD_TESTS + if (mGetTopTransactionsForTesting) + { + // Encode the test mempool's answer as the overlay does. + auto envelopes = mGetTopTransactionsForTesting(count); + std::vector payload(4); + uint32_t const n = static_cast(envelopes.size()); + std::memcpy(payload.data(), &n, 4); + for (auto const& env : envelopes) + { + auto const bytes = xdr::xdr_to_opaque(env); + uint32_t const len = static_cast(bytes.size()); + auto const at = payload.size(); + payload.resize(at + 4); + std::memcpy(payload.data() + at, &len, 4); + payload.insert(payload.end(), bytes.begin(), bytes.end()); + } + return payload; + } +#endif + return mApp.getOverlayManager().getTopTransactionsPayload(count); +} + void -HerderImpl::prewarmSignatureCache() +HerderImpl::prewarmNextLedgerSignatures(uint64_t slotIndex, + Hash const& txSetHash) +{ + // Once a slot starts balloting, its value is all but decided, and the next + // ledger's candidates are the mempool's top minus this value's + // transactions (the overlay drops them when the slot externalizes). Every + // validator verifies their signatures while the slot finishes balloting, + // externalizes and closes: the next leader builds from them, and the + // others validate the set it builds. + auto const& lcl = mLedgerManager.getLastClosedLedgerHeader(); + if (!getSCP().isValidator() || !isTracking() || + slotIndex != lcl.header.ledgerSeq + 1 || + buildsLegacyTxSet(lcl.header.ledgerVersion)) + { + return; + } + std::vector pending; + auto txSet = mPendingEnvelopes.getTxSet(txSetHash); + if (auto const* frame = std::get_if(&txSet); + frame && *frame) + { + pending = txCountPerPhase(**frame); + } + prewarmSignatureCache(static_cast(slotIndex + 1), pending); +} + +void +HerderImpl::prewarmSignatureCache(uint32_t ledgerSeq, + std::vector const& pendingPerPhase) { ZoneScoped; stopSignaturePrewarm(); - // The leader's set has at most this many transactions, drawn from the - // top of a mempool much like ours. - auto envelopes = std::make_shared const>( - pullTopTransactions(maxTxSetCandidates())); - if (envelopes->empty()) + // The build for `ledgerSeq` validates the first validTxTargets() of each + // phase of its pull (more only if some are invalid), and the leader's set + // is selected from them. + auto const& lcl = mLedgerManager.getLastClosedLedgerHeader(); + auto windows = validTxTargets(lcl.header.ledgerVersion); + size_t pending = 0; + for (size_t i = 0; i < windows.size() && i < pendingPerPhase.size(); ++i) + { + windows[i] += pendingPerPhase[i]; + pending += pendingPerPhase[i]; + } + auto& metrics = mApp.getMetrics(); + // Only the overlay round trip runs on the main thread; the tasks decode. + auto payload = [&]() { + auto timer = + metrics.NewTimer({"herder", "prewarm", "pull"}).TimeScope(); + return std::make_shared const>( + pullTopTransactionsPayload(2 * maxTxSetCandidates() + pending)); + }(); + uint32_t count = 0; + if (payload->size() >= 4) + { + std::memcpy(&count, payload->data(), 4); + } + if (count == 0) { return; } - auto stop = std::make_shared>(false); - mSignaturePrewarmStop = stop; - // The batch executor (validation) is idle until the leader's set - // arrives; use as many background tasks as it would, but leave worker - // threads for long background jobs such as bucket merges. + auto prewarm = std::make_shared(); + prewarm->ledgerSeq = ledgerSeq; + prewarm->start = std::chrono::steady_clock::now(); + // The batch executor (validation) is idle until the next build or the + // leader's set; use as many background tasks as it would, but leave + // worker threads for long background jobs such as bucket merges. size_t const workers = static_cast(mApp.getConfig().WORKER_THREADS); size_t const tasks = std::max( 1, std::min(mApp.getBatchExecutor().preferredTaskCount(), workers > 2 ? workers - 2 : 1)); + prewarm->runningTasks = tasks; + mSignaturePrewarm = prewarm; CLOG_DEBUG(Herder, - "Pre-verifying signatures of {} transactions in {} tasks", - envelopes->size(), tasks); + "Pre-verifying signatures for ledger {}: {} pulled, windows {} " + "classic / {} Soroban, {} tasks", + ledgerSeq, count, windows[0], + windows.size() > 1 ? windows[1] : 0, tasks); for (size_t task = 0; task < tasks; ++task) { mApp.postOnBackgroundThread( - [envelopes, stop, networkID = mApp.getNetworkID(), task, tasks]() { + [prewarm, payload, windows, networkID = mApp.getNetworkID(), task, + tasks]() { ZoneScopedN("signature prewarm"); - for (size_t i = task; i < envelopes->size(); i += tasks) + if (!prewarm->stop.load(std::memory_order_relaxed)) { - if (stop->load(std::memory_order_relaxed)) + std::call_once(prewarm->selected, [&]() { + prewarm->candidates = selectPrewarmCandidates( + OverlayIPC::parseTopTransactions(*payload), + windows); + }); + auto const& candidates = prewarm->candidates; + for (size_t i = task; i < candidates.size(); i += tasks) { - return; + if (prewarm->stop.load(std::memory_order_relaxed)) + { + break; + } + prewarm->verifiedSignatures += + verifyMasterKeySignatures(networkID, candidates[i]); + ++prewarm->checkedTxs; } - verifyMasterKeySignatures(networkID, (*envelopes)[i]); + } + if (prewarm->runningTasks.fetch_sub(1) == 1) + { + // The last task: free the candidates here rather than on + // the main thread when the prewarm is stopped. + std::vector().swap( + prewarm->candidates); + prewarm->finishedAfterNs = + std::chrono::duration_cast( + std::chrono::steady_clock::now() - prewarm->start) + .count(); } }, "Herder: signature prewarm"); @@ -2189,10 +2403,29 @@ HerderImpl::prewarmSignatureCache() void HerderImpl::stopSignaturePrewarm() { - if (mSignaturePrewarmStop) + if (!mSignaturePrewarm) { - mSignaturePrewarmStop->store(true, std::memory_order_relaxed); - mSignaturePrewarmStop.reset(); + return; + } + auto prewarm = std::move(mSignaturePrewarm); + mSignaturePrewarm.reset(); + prewarm->stop.store(true, std::memory_order_relaxed); + // Tasks still running stop after their current transaction; what they + // did so far is recorded. + auto const finishedAfterNs = prewarm->finishedAfterNs.load(); + auto& metrics = mApp.getMetrics(); + metrics.NewTimer({"herder", "prewarm", "duration"}) + .Update(finishedAfterNs >= 0 + ? std::chrono::nanoseconds(finishedAfterNs) + : std::chrono::duration_cast( + std::chrono::steady_clock::now() - prewarm->start)); + metrics.NewMeter({"herder", "prewarm", "txs"}, "transaction") + .Mark(prewarm->checkedTxs.load()); + metrics.NewMeter({"herder", "prewarm", "verified"}, "signature") + .Mark(prewarm->verifiedSignatures.load()); + if (finishedAfterNs < 0) + { + metrics.NewMeter({"herder", "prewarm", "incomplete"}, "prewarm").Mark(); } } diff --git a/src/herder/HerderImpl.h b/src/herder/HerderImpl.h index 57f1eb0d4f..fb29ba924b 100644 --- a/src/herder/HerderImpl.h +++ b/src/herder/HerderImpl.h @@ -15,8 +15,11 @@ #include "util/Timer.h" #include "util/UnorderedMap.h" #include "util/XDROperators.h" +#include +#include #include #include +#include #include #include @@ -275,15 +278,47 @@ class HerderImpl : public Herder static bool buildsLegacyTxSet(uint32_t lclLedgerVersion); // Upper bound on the transactions a tx set for the next ledger can hold. size_t maxTxSetCandidates() const; + // How many valid candidates a build validates per phase (classic, then + // Soroban if the protocol supports it): 5/4 of the phase's capacity. + std::vector validTxTargets(uint32_t lclLedgerVersion) const; std::vector pullTopTransactions(size_t count); - // Verify the signatures of the mempool's top transactions on background - // threads, warming the signature cache for validating the leader's set. - void prewarmSignatureCache(); - std::shared_ptr> mSignaturePrewarmStop; + // The same pull as encoded by the overlay (see OverlayIPC), to decode + // off the main thread. + std::vector pullTopTransactionsPayload(size_t count); + + // A signature prewarm: background tasks verifying the signatures of the + // candidates that the build of `ledgerSeq` validates first (and that the + // leader's set for it is selected from), warming the signature cache for + // that build and for validating the leader's set. + struct SignaturePrewarm + { + uint32_t ledgerSeq{0}; + std::chrono::steady_clock::time_point start; + std::atomic stop{false}; + // Decoded and selected once, by whichever task gets there first. + std::once_flag selected; + std::vector candidates; + std::atomic checkedTxs{0}; + std::atomic verifiedSignatures{0}; + std::atomic runningTasks{0}; + // Nanoseconds from `start` until the last task finished, or -1. + std::atomic finishedAfterNs{-1}; + }; + // Starts a prewarm for ledger `ledgerSeq`, replacing any running one. + // `pendingPerPhase` counts the transactions per phase that are still in + // the mempool but not candidates for `ledgerSeq` (those of the value being + // externalized): the prewarm looks past that many more. + void prewarmSignatureCache(uint32_t ledgerSeq, + std::vector const& pendingPerPhase); + std::shared_ptr mSignaturePrewarm; public: - // Stops a running signature prewarm: called when validation or a local - // build is about to verify the signatures itself. + // Called when slot `slotIndex` starts its ballot protocol with a value + // whose tx set is `txSetHash`: prewarms the next ledger's candidates while + // this slot finishes balloting, externalizes and closes. + void prewarmNextLedgerSignatures(uint64_t slotIndex, Hash const& txSetHash); + // Stops a running signature prewarm and records its metrics: called when + // validation or a local build is about to verify the signatures itself. void stopSignaturePrewarm(); private: diff --git a/src/herder/HerderSCPDriver.cpp b/src/herder/HerderSCPDriver.cpp index 6fcc27624f..84a2c58820 100644 --- a/src/herder/HerderSCPDriver.cpp +++ b/src/herder/HerderSCPDriver.cpp @@ -1448,6 +1448,17 @@ HerderSCPDriver::startedBallotProtocol(uint64_t slotIndex, SCPBallot const& ballot) { recordSCPEvent(slotIndex, false); + // Prewarm the next ledger's signatures, after SCP has finished processing + // (and emitting) this step: the mempool pull waits for the overlay. + StellarValue sv; + if (toStellarValue(ballot.value, sv)) + { + mApp.postOnMainThread( + [this, slotIndex, txSetHash = sv.txSetHash]() { + mHerder.prewarmNextLedgerSignatures(slotIndex, txSetHash); + }, + "Herder: prewarm next ledger signatures"); + } } void HerderSCPDriver::acceptedBallotPrepared(uint64_t slotIndex, @@ -1962,6 +1973,9 @@ HerderSCPDriver::checkAndCacheTxSetValid(TxSetXDRFrame const& txSet, // Validation verifies the remaining signatures itself, on all cores; // a concurrent signature prewarm would only compete with it. mHerder.stopSignaturePrewarm(); + uint64_t sigCacheHits = 0; + uint64_t sigCacheMisses = 0; + PubKeyUtils::getVerifySigCacheCounts(sigCacheHits, sigCacheMisses); auto validationTime = mSCPMetrics.mTxSetValidation.TimeScope(); // The invariant here is that we only validate tx sets nominated @@ -1988,6 +2002,8 @@ HerderSCPDriver::checkAndCacheTxSetValid(TxSetXDRFrame const& txSet, res = applicableTxSet->checkValid(mApp, closeTimeOffset.seconds(), closeTimeOffset.seconds()); } + markSignatureCacheLookups(mApp, "validate", sigCacheHits, + sigCacheMisses); mTxSetValidCache.put(key, res); return res; diff --git a/src/herder/HerderUtils.cpp b/src/herder/HerderUtils.cpp index 62322fe363..47d73de616 100644 --- a/src/herder/HerderUtils.cpp +++ b/src/herder/HerderUtils.cpp @@ -5,11 +5,15 @@ #include "herder/HerderUtils.h" #include "crypto/Hex.h" #include "crypto/KeyUtils.h" +#include "crypto/SecretKey.h" #include "lib/json/json.h" +#include "main/Application.h" #include "main/Config.h" +#include "medida/meter.h" #include "rust/RustVecXdrMarshal.h" #include "scp/LocalNode.h" #include "scp/Slot.h" +#include "util/MetricsRegistry.h" #include "xdr/Stellar-contract.h" #include "xdr/Stellar-ledger.h" #include "xdrpp/types.h" @@ -172,4 +176,24 @@ parseQuorumMapFromJson(std::string const& jsonPath) return qmap; } +void +markSignatureCacheLookups(Application& app, std::string const& prefix, + uint64_t hits, uint64_t misses) +{ + uint64_t hitsNow = 0; + uint64_t missesNow = 0; + PubKeyUtils::getVerifySigCacheCounts(hitsNow, missesNow); + // A flush in between (the app's metrics sync, on the main thread like + // the callers) would have reset them. + if (hitsNow >= hits && missesNow >= misses) + { + auto& metrics = app.getMetrics(); + metrics + .NewMeter({"herder", "txset", prefix + "-sig-cache-hit"}, "lookup") + .Mark(hitsNow - hits); + metrics + .NewMeter({"herder", "txset", prefix + "-sig-cache-miss"}, "lookup") + .Mark(missesNow - misses); + } +} } diff --git a/src/herder/HerderUtils.h b/src/herder/HerderUtils.h index 4274e5a788..465acffe32 100644 --- a/src/herder/HerderUtils.h +++ b/src/herder/HerderUtils.h @@ -46,4 +46,12 @@ toQuorumIntersectionMap(QuorumTracker::QuorumMap const& qmap); QuorumIntersectionChecker::QuorumSetMap parseQuorumMapFromJson(std::string const& jsonPath); + +class Application; +// Marks the signature cache lookups made since PubKeyUtils:: +// getVerifySigCacheCounts returned `hits` and `misses` on the meters +// herder.txset.-sig-cache-hit and -miss. Lookups on other threads +// in the meantime count too. +void markSignatureCacheLookups(Application& app, std::string const& prefix, + uint64_t hits, uint64_t misses); } diff --git a/src/herder/test/HerderTests.cpp b/src/herder/test/HerderTests.cpp index f2cd9ac13b..0fc00e6b43 100644 --- a/src/herder/test/HerderTests.cpp +++ b/src/herder/test/HerderTests.cpp @@ -6788,6 +6788,43 @@ class EarlyNominationTestAccess return {prepared.txSet, prepared.invalidTxHashes}; } + static size_t + maxTxSetCandidates(HerderImpl& herder) + { + return herder.maxTxSetCandidates(); + } + + // Starts a signature prewarm for `ledgerSeq`'s candidates. + static void + prewarm(HerderImpl& herder, uint32_t ledgerSeq) + { + herder.prewarmSignatureCache(ledgerSeq, {}); + } + + // The ledger the running signature prewarm is for (0 if none). + static uint32_t + prewarmLedger(HerderImpl& herder) + { + return herder.mSignaturePrewarm ? herder.mSignaturePrewarm->ledgerSeq + : 0; + } + + // Waits in real time, without cranking, until the running prewarm's + // tasks are done. Returns false if there is none or it takes too long. + static bool + waitForPrewarm(HerderImpl& herder) + { + auto prewarm = herder.mSignaturePrewarm; + auto const deadline = + std::chrono::steady_clock::now() + std::chrono::seconds(60); + while (prewarm && prewarm->finishedAfterNs.load() < 0 && + std::chrono::steady_clock::now() < deadline) + { + std::this_thread::sleep_for(std::chrono::milliseconds(1)); + } + return prewarm && prewarm->finishedAfterNs.load() >= 0; + } + // These fixtures inspect a local proposal while requiring an absent peer // to prevent externalization. Pick that peer so the local node is the // first leader, independently of the test RNG seed and previous ledger. @@ -7820,6 +7857,161 @@ TEST_CASE("followers pre-verify mempool signatures at the trigger", REQUIRE(checkedRoles == std::set{false, true}); } +TEST_CASE("signature prewarm at the ballot covers the next ledger", + "[herder][prewarm]") +{ + // When slot N starts balloting, a validator pre-verifies the signatures + // of ledger N + 1's candidates: the top of its mempool past the + // transactions of N's value, which stay there until N externalizes. The + // next build validates 20 (5/4 of the classic capacity of 16). + uint32_t const valueTxs = 16; + uint32_t const nextTxs = 32; + uint32_t const target = 20; + auto cfg = getTestConfig(); + cfg.MANUAL_CLOSE = true; + cfg.WORKER_THREADS = 4; + cfg.GENESIS_TEST_ACCOUNT_COUNT = valueTxs + nextTxs + 1; + cfg.TESTING_UPGRADE_MAX_TX_SET_SIZE = 16; + VirtualClock clock; + auto app = createTestApplication(clock, cfg); + auto& herder = static_cast(app->getHerder()); + auto& lm = app->getLedgerManager(); + auto& metrics = app->getMetrics(); + REQUIRE(lm.getLastMaxTxSetSizeOps() == 16); + REQUIRE(herder.isTracking()); + + auto dest = getGenesisAccount(*app, valueTxs + nextTxs); + TxFrameList valueTxFrames; + TxFrameList nextTxFrames; + std::vector mempool; + for (uint32_t i = 0; i < valueTxs + nextTxs; ++i) + { + auto tx = getGenesisAccount(*app, i).tx({payment(dest, 1)}); + (i < valueTxs ? valueTxFrames : nextTxFrames).push_back(tx); + mempool.push_back(tx->getEnvelope()); + } + size_t requested = 0; + herder.mGetTopTransactionsForTesting = [&](size_t count) { + requested = count; + return std::vector( + mempool.begin(), mempool.begin() + std::min(count, mempool.size())); + }; + + // Slot N's value holds the top 16. + auto const lcl = lm.getLastClosedLedgerHeader(); + auto const slot = lcl.header.ledgerSeq + 1; + auto const closeTime = makeConsensusTime(app->timeNow() + 1); + auto valueSet = + makeTxSetFromTransactions(PerPhaseTransactionList{valueTxFrames, {}}, + *app, ApplyTimeOffset{}) + .first; + REQUIRE(valueSet->sizeTxTotal() == valueTxs); + herder.getPendingEnvelopes().putTxSet(valueSet->getContentsHash(), slot, + valueSet); + auto const value = xdr::xdr_to_opaque( + herder.makeStellarValue(valueSet->getContentsHash(), closeTime, + emptyUpgradeSteps, cfg.NODE_SEED)); + + PubKeyUtils::clearVerifySigCache(); + auto& prewarmTxs = + metrics.NewMeter({"herder", "prewarm", "txs"}, "transaction"); + auto& prewarmVerified = + metrics.NewMeter({"herder", "prewarm", "verified"}, "signature"); + auto& prewarmIncomplete = + metrics.NewMeter({"herder", "prewarm", "incomplete"}, "prewarm"); + auto const txs0 = prewarmTxs.count(); + auto const verified0 = prewarmVerified.count(); + auto const incomplete0 = prewarmIncomplete.count(); + + // The prewarm starts once SCP is done with the step that started the + // ballot, pulling past N's value, and verifies in the background. + SCPBallot ballot; + ballot.counter = 1; + ballot.value = value; + herder.getHerderSCPDriver().startedBallotProtocol(slot, ballot); + REQUIRE(EarlyNominationTestAccess::prewarmLedger(herder) == 0); + testutil::crankUntil( + app, + [&]() { + return EarlyNominationTestAccess::prewarmLedger(herder) == slot + 1; + }, + std::chrono::seconds(1)); + REQUIRE(EarlyNominationTestAccess::prewarmLedger(herder) == slot + 1); + REQUIRE(requested == + 2 * EarlyNominationTestAccess::maxTxSetCandidates(herder) + + valueTxs); + REQUIRE(EarlyNominationTestAccess::waitForPrewarm(herder)); + + // N externalizes and closes; the prewarm for N + 1 is kept. The overlay + // drops N's transactions from the mempool. + herder.externalizeValue(valueSet, slot, closeTime, emptyUpgradeSteps, + cfg.NODE_SEED); + REQUIRE(lm.getLastClosedLedgerNum() == slot); + REQUIRE(EarlyNominationTestAccess::prewarmLedger(herder) == slot + 1); + mempool.erase(mempool.begin(), mempool.begin() + valueTxs); + auto const nextLcl = lm.getLastClosedLedgerHeader(); + auto const nextCloseTime = makeConsensusTime(app->timeNow() + 2); + + // No signature verified, and at least one lookup per transaction (a + // payment's operation checks its source's signature again). + auto checkLookups = [&](std::string const& prefix, uint64_t hits0, + uint64_t misses0, uint64_t txs) { + auto& hits = metrics.NewMeter( + {"herder", "txset", prefix + "-sig-cache-hit"}, "lookup"); + auto& misses = metrics.NewMeter( + {"herder", "txset", prefix + "-sig-cache-miss"}, "lookup"); + REQUIRE(misses.count() == misses0); + REQUIRE(hits.count() >= hits0 + txs); + }; + auto lookups = [&](std::string const& prefix) { + return std::make_pair( + metrics + .NewMeter({"herder", "txset", prefix + "-sig-cache-hit"}, + "lookup") + .count(), + metrics + .NewMeter({"herder", "txset", prefix + "-sig-cache-miss"}, + "lookup") + .count()); + }; + + SECTION("the next leader's build finds every signature cached") + { + auto [hits0, misses0] = lookups("build"); + auto txSet = + EarlyNominationTestAccess::build(herder, slot + 1, nextCloseTime); + REQUIRE(txSet->sizeTxTotal() == 16); + checkLookups("build", hits0, misses0, target); + } + SECTION("a follower's validation of the leader's set finds them cached") + { + // The leader's set, built elsewhere (without verifying anything + // here). + TxFrameList leaderTxs(nextTxFrames.begin(), nextTxFrames.begin() + 16); + auto leaderSet = testtxset::makeNonValidatedGeneralizedTxSet( + {{std::make_pair(std::nullopt, leaderTxs)}, {}}, + *app, nextLcl.hash) + .first; + herder.getPendingEnvelopes().putTxSet(leaderSet->getContentsHash(), + slot + 1, leaderSet); + auto leaderValue = xdr::xdr_to_opaque( + herder.makeStellarValue(leaderSet->getContentsHash(), nextCloseTime, + emptyUpgradeSteps, cfg.NODE_SEED)); + auto [hits0, misses0] = lookups("validate"); + REQUIRE(herder.getHerderSCPDriver().validateValue(slot + 1, leaderValue, + false) == + SCPDriver::kFullyValidatedValue); + checkLookups("validate", hits0, misses0, 16); + } + // Validation and the build stop the prewarm and record what it did: the + // 16 transactions of N's value and the next 20, each verified once. + REQUIRE(EarlyNominationTestAccess::prewarmLedger(herder) == 0); + REQUIRE(prewarmTxs.count() == txs0 + valueTxs + target); + REQUIRE(prewarmVerified.count() == verified0 + valueTxs + target); + REQUIRE(prewarmIncomplete.count() == incomplete0); + herder.mGetTopTransactionsForTesting = nullptr; +} + TEST_CASE("early underfilled proposals refresh at the trigger", "[herder][early-nomination]") { @@ -8428,6 +8620,8 @@ TEST_CASE("leader tx set build costs", "[herder][.][benchmark]") cfg.APPLY_LOAD_CLASSIC_TXS_PER_LEDGER = 0; cfg.TESTING_UPGRADE_MAX_TX_SET_SIZE = 100; cfg.GENESIS_TEST_ACCOUNT_COUNT = candidates + 10; + // The signature prewarm leaves 2 worker threads for other jobs. + cfg.WORKER_THREADS = static_cast(tasks) + 2; VirtualClock clock(VirtualClock::REAL_TIME); auto app = createTestApplication(clock, cfg); auto& herder = static_cast(app->getHerder()); @@ -8526,17 +8720,19 @@ TEST_CASE("leader tx set build costs", "[herder][.][benchmark]") .count()); } REQUIRE(included == std::min(sorobanCap, pull)); - if (cold) { - // Calibration against perfnet's herder.txset.validate: a - // follower validating the received set with a cold cache. + // A follower validating the received set (cold: calibration + // against perfnet's herder.txset.validate). auto const& lastSet = EarlyNominationTestAccess::build(herder, seq, closeTime); for (uint32_t rep = 0; rep < reps; ++rep) { auto received = TxSetXDRFrame::makeFromWire( GeneralizedTransactionSet(lastSet->getGeneralizedXDR())); - PubKeyUtils::clearVerifySigCache(); + if (cold) + { + PubKeyUtils::clearVerifySigCache(); + } auto const start = std::chrono::steady_clock::now(); auto applicable = received->prepareForApply(*app, lcl.header); REQUIRE(applicable); @@ -8558,5 +8754,73 @@ TEST_CASE("leader tx set build costs", "[herder][.][benchmark]") << ", n=" << v.size() << ")" << std::endl; } } + + // A signature prewarm (as from the previous slot's ballot) that finished + // before the leader's build, and before a follower validates its set. + { + std::map> samples; + auto& prewarmDuration = + metrics.NewTimer({"herder", "prewarm", "duration"}); + auto& buildMisses = metrics.NewMeter( + {"herder", "txset", "build-sig-cache-miss"}, "lookup"); + auto const lastSet = + EarlyNominationTestAccess::build(herder, seq, closeTime); + uint64_t misses = 0; + uint64_t validateMisses = 0; + for (uint32_t rep = 0; rep < reps; ++rep) + { + PubKeyUtils::clearVerifySigCache(); + auto const durationBefore = prewarmDuration.sum(); + EarlyNominationTestAccess::prewarm(herder, seq); + REQUIRE(EarlyNominationTestAccess::waitForPrewarm(herder)); + for (auto const& phase : phases) + { + metrics.NewTimer({"herder", "txset", phase}).Clear(); + } + auto const missesBefore = buildMisses.count(); + // The build stops the (finished) prewarm and records it. + auto txSet = + EarlyNominationTestAccess::build(herder, seq, closeTime); + REQUIRE(txSet->sizeTxTotal() == std::min(sorobanCap, pull)); + misses = buildMisses.count() - missesBefore; + samples["prewarm (background, before the build)"].push_back( + prewarmDuration.sum() - durationBefore); + for (auto const& phase : phases) + { + samples[phase].push_back( + metrics.NewTimer({"herder", "txset", phase}).sum()); + } + + auto received = TxSetXDRFrame::makeFromWire( + GeneralizedTransactionSet(lastSet->getGeneralizedXDR())); + PubKeyUtils::clearVerifySigCache(); + EarlyNominationTestAccess::prewarm(herder, seq); + REQUIRE(EarlyNominationTestAccess::waitForPrewarm(herder)); + uint64_t hits0 = 0, misses0 = 0, hits1 = 0, misses1 = 0; + PubKeyUtils::getVerifySigCacheCounts(hits0, misses0); + auto const start = std::chrono::steady_clock::now(); + auto applicable = received->prepareForApply(*app, lcl.header); + REQUIRE(applicable); + REQUIRE(applicable->checkValid(*app, 0, 0)); + samples["received-set-validate"].push_back( + std::chrono::duration( + std::chrono::steady_clock::now() - start) + .count()); + PubKeyUtils::getVerifySigCacheCounts(hits1, misses1); + validateMisses = misses1 - misses0; + herder.stopSignaturePrewarm(); + } + std::cout << "prewarmed signature cache (last build: " << misses + << " signature cache misses; last received-set " + "validation: " + << validateMisses << ")" << std::endl; + for (auto& [phase, v] : samples) + { + std::sort(v.begin(), v.end()); + std::cout << " " << phase << ": median " << v[v.size() / 2] + << " ms (min " << v.front() << ", max " << v.back() + << ", n=" << v.size() << ")" << std::endl; + } + } herder.mGetTopTransactionsForTesting = nullptr; } diff --git a/src/overlay/OverlayIPC.cpp b/src/overlay/OverlayIPC.cpp index 51c702fa74..284dd3db4c 100644 --- a/src/overlay/OverlayIPC.cpp +++ b/src/overlay/OverlayIPC.cpp @@ -555,7 +555,13 @@ OverlayIPC::removeTransactions(std::vector const& txHashes) std::vector OverlayIPC::getTopTransactions(size_t count) { - std::vector result; + return parseTopTransactions(getTopTransactionsPayload(count)); +} + +std::vector +OverlayIPC::getTopTransactionsPayload(size_t count) +{ + std::vector result; if (!mChannel || !mChannel->isConnected()) { @@ -608,7 +614,7 @@ OverlayIPC::getTopTransactions(size_t count) return result; } - return parseTopTransactions(response.payload); + return std::move(response.payload); } std::vector diff --git a/src/overlay/OverlayIPC.h b/src/overlay/OverlayIPC.h index 685821ed98..4fd231ba23 100644 --- a/src/overlay/OverlayIPC.h +++ b/src/overlay/OverlayIPC.h @@ -124,6 +124,13 @@ class OverlayIPC */ std::vector getTopTransactions(size_t count); + /** + * The same request, returning the response payload undecoded (empty if + * there is no response), for callers that decode it elsewhere with + * parseTopTransactions. + */ + std::vector getTopTransactionsPayload(size_t count); + /** * Decode a GET_TOP_TXS response payload: * [count:4]([len:4][TransactionEnvelope XDR:len])*. Envelopes are diff --git a/src/overlay/RustOverlayManager.cpp b/src/overlay/RustOverlayManager.cpp index 95cc418189..9326e4e08e 100644 --- a/src/overlay/RustOverlayManager.cpp +++ b/src/overlay/RustOverlayManager.cpp @@ -238,6 +238,16 @@ RustOverlayManager::getTopTransactions(size_t count) return {}; } +std::vector +RustOverlayManager::getTopTransactionsPayload(size_t count) +{ + if (mOverlayIPC && !mShuttingDown) + { + return mOverlayIPC->getTopTransactionsPayload(count); + } + return {}; +} + OverlayMetrics& RustOverlayManager::getOverlayMetrics() { diff --git a/src/overlay/RustOverlayManager.h b/src/overlay/RustOverlayManager.h index fc6d95ede7..31506106e8 100644 --- a/src/overlay/RustOverlayManager.h +++ b/src/overlay/RustOverlayManager.h @@ -77,6 +77,8 @@ class RustOverlayManager // Get top transactions from Rust overlay's mempool for TX set building. // Blocks until the overlay responds, shuts down, or disconnects. std::vector getTopTransactions(size_t count); + // The same, undecoded (see OverlayIPC::getTopTransactionsPayload). + std::vector getTopTransactionsPayload(size_t count); // Metrics and managers OverlayMetrics& getOverlayMetrics(); From ab58eae61348b546c2e842b363974230138aa359 Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Tue, 10 Nov 2026 04:06:50 +0000 Subject: [PATCH 22/23] Raise the Core-overlay IPC payload limit to 64 MiB and never exceed it Both ends of the IPC rejected payloads over 16 MiB, and Core's reader treats a rejected length as a corrupt stream: it stops reading and never recovers, so the node can no longer send or receive SCP messages. The ballot-start signature prewarm pulls 2 x the tx-set capacity plus the balloting value's transactions: 22,700 SAC payments of ~752 bytes, about 17.2 MB, once the mempool holds that many. On perfnet (3k SAC TPS, 30 validators) every validator starts that pull at the same ballot, so 80 s into the load 16 of the 30 nodes lost their overlay within 0.35 s, the rest lost quorum, and the network stalled at one ledger. - Raise the limit to 64 MiB on both sides, named once per side (ipc::MAX_PAYLOAD_BYTES in IPC.h, MAX_PAYLOAD_SIZE in messages.rs) with a note that they must match. - The overlay sends at most the longest prefix of the top transactions that fits in the limit (the highest-priority ones), with the count matching, and warns when it truncates, so a large mempool can't produce an oversized response whatever the transaction sizes. - Neither side sends a payload over the limit: CoreSender refuses it (IpcError::PayloadTooLarge), and Core's sendMessage refuses it before writing anything, keeping the connection. - Core logs an error with the message type and length when it rejects a payload, instead of only "connection closed". - Tests: a [overlay-ipc] test with the real Rust overlay where a 20 MiB top transactions response arrives whole (it fails with the old limit: the pull returns nothing) and an 80 MiB pull is truncated to the 63 highest-fee transactions while the IPC keeps working; IPC tests for a 20 MB message, an over-limit length (rejected, with a receive timeout so a regression fails instead of hanging) and an over-limit send (nothing written); Rust tests for the truncation and the send guard. - docs/rust-overlay/ipc.md: the 64 MiB limit and how each side enforces it. --- docs/rust-overlay/ipc.md | 10 ++- overlay/src/ipc/messages.rs | 11 ++- overlay/src/ipc/transport.rs | 109 +++++++++++++++++++++++---- src/overlay/IPC.cpp | 27 ++++++- src/overlay/IPC.h | 8 ++ src/overlay/test/IPCTests.cpp | 83 ++++++++++++++++++++ src/overlay/test/OverlayIPCTests.cpp | 89 ++++++++++++++++++++++ 7 files changed, 316 insertions(+), 21 deletions(-) diff --git a/docs/rust-overlay/ipc.md b/docs/rust-overlay/ipc.md index dfac36fa36..a96778308a 100644 --- a/docs/rust-overlay/ipc.md +++ b/docs/rust-overlay/ipc.md @@ -35,8 +35,14 @@ Source: | `length` | 4 | Payload length in bytes. Native-endian. | | `payload`| `length` | Type-specific bytes. May be empty. | -Maximum payload: **16 MB** (`messages.rs:154`). Frames larger than that -are rejected with `InvalidData`. +Maximum payload: **64 MiB** (`MAX_PAYLOAD_SIZE` in `messages.rs`, which must +equal `ipc::MAX_PAYLOAD_BYTES` in Core's `src/overlay/IPC.h`). Readers reject +larger frames (`InvalidData` in Rust; Core stops reading the stream), and +neither side sends one: `CoreSender::send` refuses it with +`IpcError::PayloadTooLarge`, Core's `sendMessage` returns false, and the +overlay truncates a top transactions response to the longest prefix that fits. +A mempool pull of 2x the tx-set capacity plus a pending set's transactions +(22,700 SAC payments, about 17.2 MB) exceeded the old 16 MiB limit. > Native-endian is unusual for a wire protocol but safe here because > Core and Overlay always run on the same host. The libp2p network diff --git a/overlay/src/ipc/messages.rs b/overlay/src/ipc/messages.rs index 1313186826..9930f96138 100644 --- a/overlay/src/ipc/messages.rs +++ b/overlay/src/ipc/messages.rs @@ -127,8 +127,13 @@ impl Message { } } -/// Maximum payload size (16 MB) - sanity check to prevent OOM -const MAX_PAYLOAD_SIZE: usize = 16 * 1024 * 1024; +/// Largest payload either side accepts in one message (64 MiB); a larger +/// length is treated as a corrupt stream and ends the connection. Must equal +/// `ipc::MAX_PAYLOAD_BYTES` in Core's src/overlay/IPC.h. A mempool pull (up to +/// 2x the tx-set capacity plus a pending set's transactions, e.g. 22,700 SAC +/// payments of ~750 bytes) must fit; `CoreSender` never sends a larger payload +/// and truncates top-transaction responses to this size. +pub(crate) const MAX_PAYLOAD_SIZE: usize = 64 * 1024 * 1024; /// Header size: 4 bytes type + 4 bytes length const HEADER_SIZE: usize = 8; @@ -228,7 +233,7 @@ mod tests { // Create a message with payload size > MAX_PAYLOAD_SIZE let mut buf = Vec::new(); buf.extend_from_slice(&1u32.to_ne_bytes()); // BroadcastScp - buf.extend_from_slice(&(20 * 1024 * 1024u32).to_ne_bytes()); // 20MB > 16MB limit + buf.extend_from_slice(&((MAX_PAYLOAD_SIZE + 1) as u32).to_ne_bytes()); // over the limit let mut cursor = Cursor::new(buf); let result = MessageCodec::read(&mut cursor); diff --git a/overlay/src/ipc/transport.rs b/overlay/src/ipc/transport.rs index 7c96aa613f..c62e013b96 100644 --- a/overlay/src/ipc/transport.rs +++ b/overlay/src/ipc/transport.rs @@ -6,9 +6,9 @@ use std::os::unix::net::{UnixListener, UnixStream}; use std::path::Path; use std::sync::Arc; use tokio::sync::mpsc; -use tracing::{debug, error, info}; +use tracing::{debug, error, info, warn}; -use super::messages::{Message, MessageCodec, MessageType}; +use super::messages::{Message, MessageCodec, MessageType, MAX_PAYLOAD_SIZE}; /// Error type for IPC operations #[derive(Debug)] @@ -16,6 +16,9 @@ pub enum IpcError { Io(std::io::Error), ConnectionClosed, ChannelClosed, + /// A payload over `MAX_PAYLOAD_SIZE`: Core would reject the message and + /// drop the connection, so it isn't sent. + PayloadTooLarge(usize), } impl std::fmt::Display for IpcError { @@ -24,6 +27,11 @@ impl std::fmt::Display for IpcError { IpcError::Io(e) => write!(f, "IPC I/O error: {}", e), IpcError::ConnectionClosed => write!(f, "IPC connection closed"), IpcError::ChannelClosed => write!(f, "IPC channel closed"), + IpcError::PayloadTooLarge(n) => write!( + f, + "IPC payload of {} bytes is over the {} byte limit; not sent", + n, MAX_PAYLOAD_SIZE + ), } } } @@ -47,6 +55,33 @@ impl From for IpcError { } } +/// Encode a top transactions response, [count:4] then [len:4][tx:len] per +/// transaction, from the longest prefix of `txs` whose encoding fits in +/// `max_payload` bytes. Returns the payload and how many transactions it +/// holds. +fn encode_top_txs_payload(txs: &[&[u8]], max_payload: usize) -> (Vec, usize) { + let mut size = 4; + let mut included = 0; + for tx in txs { + if size + 4 + tx.len() > max_payload { + break; + } + size += 4 + tx.len(); + included += 1; + } + let mut payload = Vec::with_capacity(size); + + // Count + payload.extend_from_slice(&(included as u32).to_le_bytes()); + + // Each TX: [len:4][data:len] + for tx in &txs[..included] { + payload.extend_from_slice(&(tx.len() as u32).to_le_bytes()); + payload.extend_from_slice(tx); + } + (payload, included) +} + /// Handle for sending messages to Core. #[derive(Clone)] pub struct CoreSender { @@ -54,8 +89,13 @@ pub struct CoreSender { } impl CoreSender { - /// Send a message to Core. Never blocks. + /// Send a message to Core. Never blocks. A payload over + /// `MAX_PAYLOAD_SIZE` is refused rather than sent: Core would treat it as + /// a corrupt stream and close the connection. pub fn send(&self, msg: Message) -> Result<(), IpcError> { + if msg.payload.len() > MAX_PAYLOAD_SIZE { + return Err(IpcError::PayloadTooLarge(msg.payload.len())); + } self.tx.send(msg).map_err(|_| IpcError::ChannelClosed) } @@ -66,19 +106,18 @@ impl CoreSender { /// Convenience: send top transactions response /// Payload: [count:4][len1:4][tx1:len1][len2:4][tx2:len2]... + /// The response holds the longest prefix of `txs` that fits in + /// `MAX_PAYLOAD_SIZE` (the highest-priority transactions come first). pub fn send_top_txs_response(&self, txs: &[&[u8]]) -> Result<(), IpcError> { - let total_size: usize = 4 + txs.iter().map(|tx| 4 + tx.len()).sum::(); - let mut payload = Vec::with_capacity(total_size); - - // Count - payload.extend_from_slice(&(txs.len() as u32).to_le_bytes()); - - // Each TX: [len:4][data:len] - for tx in txs { - payload.extend_from_slice(&(tx.len() as u32).to_le_bytes()); - payload.extend_from_slice(tx); + let (payload, included) = encode_top_txs_payload(txs, MAX_PAYLOAD_SIZE); + if included < txs.len() { + warn!( + "Top transactions response truncated to {} of {} transactions ({} bytes) to fit the IPC payload limit", + included, + txs.len(), + payload.len() + ); } - self.send(Message::new(MessageType::TopTxsResponse, payload)) } @@ -735,4 +774,46 @@ mod tests { let count = u32::from_le_bytes(received.payload[0..4].try_into().unwrap()); assert_eq!(count, 2); } + + #[test] + fn test_encode_top_txs_payload_truncates_to_limit() { + let tx1 = vec![0x11; 10]; + let tx2 = vec![0x22; 10]; + let tx3 = vec![0x33; 10]; + let txs: Vec<&[u8]> = vec![&tx1, &tx2, &tx3]; + + // Everything fits: 4 + 3 * (4 + 10) = 46 bytes. + let (payload, included) = encode_top_txs_payload(&txs, 46); + assert_eq!(included, 3); + assert_eq!(payload.len(), 46); + assert_eq!(u32::from_le_bytes(payload[0..4].try_into().unwrap()), 3); + + // One byte short: only the first two fit, and the count says so. + let (payload, included) = encode_top_txs_payload(&txs, 45); + assert_eq!(included, 2); + assert_eq!(payload.len(), 32); + assert_eq!(u32::from_le_bytes(payload[0..4].try_into().unwrap()), 2); + assert_eq!(&payload[8..18], &tx1[..]); + assert_eq!(&payload[22..32], &tx2[..]); + + // Nothing fits but the count. + let (payload, included) = encode_top_txs_payload(&txs, 17); + assert_eq!(included, 0); + assert_eq!(payload, 0u32.to_le_bytes().to_vec()); + } + + #[tokio::test] + async fn test_send_refuses_payload_over_limit() { + let (overlay_side, _core_side) = StdUnixStream::pair().unwrap(); + let ipc = CoreIpc::from_stream(overlay_side).unwrap(); + + let msg = Message::new(MessageType::ScpReceived, vec![0u8; MAX_PAYLOAD_SIZE + 1]); + match ipc.sender.send(msg) { + Err(IpcError::PayloadTooLarge(n)) => assert_eq!(n, MAX_PAYLOAD_SIZE + 1), + other => panic!("expected PayloadTooLarge, got {:?}", other.map(|_| ())), + } + // A normal payload is still sent. + let msg = Message::new(MessageType::ScpReceived, vec![1, 2, 3]); + assert!(ipc.sender.send(msg).is_ok()); + } } diff --git a/src/overlay/IPC.cpp b/src/overlay/IPC.cpp index 32827ea2ad..07f5681628 100644 --- a/src/overlay/IPC.cpp +++ b/src/overlay/IPC.cpp @@ -3,6 +3,7 @@ // of this distribution or at http://www.apache.org/licenses/LICENSE-2.0 #include "overlay/IPC.h" +#include "util/Logging.h" #include #include #include @@ -83,6 +84,17 @@ sendMessage(int socket, IPCMessage const& msg) { IgnoreSIGPIPE guard; + // The receiver would reject a larger payload and stop reading the stream. + if (msg.payload.size() > MAX_PAYLOAD_BYTES) + { + CLOG_ERROR(Overlay, + "Not sending IPC message type {}: its {} byte payload is " + "over the {} byte limit", + static_cast(msg.type), msg.payload.size(), + MAX_PAYLOAD_BYTES); + return false; + } + // Message format: [type:4 bytes][length:4 bytes][payload] uint32_t type = static_cast(msg.type); uint32_t payloadLen = static_cast(msg.payload.size()); @@ -124,9 +136,14 @@ receiveMessage(int socket) std::memcpy(&type, &header[0], 4); std::memcpy(&payloadLen, &header[4], 4); - // Sanity check payload length (16MB max) - if (payloadLen > 16 * 1024 * 1024) + // Sanity check payload length + if (payloadLen > MAX_PAYLOAD_BYTES) { + CLOG_ERROR(Overlay, + "IPC message type {} has a {} byte payload, over the {} " + "byte limit; treating the stream as corrupt and stopping " + "reading it", + type, payloadLen, MAX_PAYLOAD_BYTES); return std::nullopt; } @@ -201,6 +218,12 @@ IPCChannel::send(IPCMessage const& msg) { return false; } + // Refused before anything is written (sendMessage logs it); the + // connection stays usable. + if (msg.payload.size() > ipc::MAX_PAYLOAD_BYTES) + { + return ipc::sendMessage(mSocket, msg); + } bool result = ipc::sendMessage(mSocket, msg); if (!result) diff --git a/src/overlay/IPC.h b/src/overlay/IPC.h index a8a2c13df3..cfe81b3007 100644 --- a/src/overlay/IPC.h +++ b/src/overlay/IPC.h @@ -114,6 +114,14 @@ struct IPCMessage namespace ipc { +// Largest payload either side sends or accepts in one message; a reader +// treats a larger length as a corrupt stream and stops reading it. Must equal +// MAX_PAYLOAD_SIZE in overlay/src/ipc/messages.rs. A mempool pull (up to +// 2 x the tx-set capacity plus a pending set's transactions, e.g. 22,700 SAC +// payments of ~750 bytes) must fit, and the overlay truncates its top +// transactions response to this size. +constexpr uint32_t MAX_PAYLOAD_BYTES = 64 * 1024 * 1024; + /** * Send an IPC message over a socket. * diff --git a/src/overlay/test/IPCTests.cpp b/src/overlay/test/IPCTests.cpp index dbf72da7c9..fde1d04a8c 100644 --- a/src/overlay/test/IPCTests.cpp +++ b/src/overlay/test/IPCTests.cpp @@ -7,6 +7,7 @@ #include "util/TmpDir.h" #include #include +#include #include #include #include @@ -191,6 +192,88 @@ TEST_CASE("IPC large message", "[overlay][ipc]") close(sockets[0]); close(sockets[1]); } + + SECTION("send and receive a 20MB top transactions response") + { + // Over the old 16 MiB limit: a signature prewarm's mempool pull + // (2 x 7,600 + 7,500 SAC payments of ~752 bytes) is about 17.2 MB. + int sockets[2]; + REQUIRE(socketpair(AF_UNIX, SOCK_STREAM, 0, sockets) == 0); + + IPCMessage msg; + msg.type = IPCMessageType::TOP_TXS_RESPONSE; + msg.payload.resize(20 * 1024 * 1024); + for (size_t i = 0; i < msg.payload.size(); ++i) + { + msg.payload[i] = static_cast(i % 251); + } + + std::optional recvMsg; + std::thread receiver( + [&]() { recvMsg = ipc::receiveMessage(sockets[1]); }); + bool sent = ipc::sendMessage(sockets[0], msg); + receiver.join(); + + REQUIRE(sent); + REQUIRE(recvMsg.has_value()); + REQUIRE(recvMsg->type == IPCMessageType::TOP_TXS_RESPONSE); + REQUIRE(recvMsg->payload == msg.payload); + + close(sockets[0]); + close(sockets[1]); + } + + SECTION("reject a payload length over the limit") + { + int sockets[2]; + REQUIRE(socketpair(AF_UNIX, SOCK_STREAM, 0, sockets) == 0); + + // Only the header: the length alone must be rejected, without + // waiting for (or allocating) the payload. + uint32_t type = static_cast(IPCMessageType::TOP_TXS_RESPONSE); + uint32_t len = ipc::MAX_PAYLOAD_BYTES + 1; + uint8_t header[8]; + std::memcpy(&header[0], &type, 4); + std::memcpy(&header[4], &len, 4); + REQUIRE(write(sockets[0], header, sizeof(header)) == + static_cast(sizeof(header))); + + // If the length were accepted, the read of the missing payload would + // block: time out so that fails instead of hanging. + struct timeval timeout{}; + timeout.tv_sec = 5; + REQUIRE(setsockopt(sockets[1], SOL_SOCKET, SO_RCVTIMEO, &timeout, + sizeof(timeout)) == 0); + + REQUIRE_FALSE(ipc::receiveMessage(sockets[1]).has_value()); + + close(sockets[0]); + close(sockets[1]); + } + + SECTION("refuse to send a payload over the limit") + { + int sockets[2]; + REQUIRE(socketpair(AF_UNIX, SOCK_STREAM, 0, sockets) == 0); + + IPCMessage msg; + msg.type = IPCMessageType::CACHE_TX_SET; + msg.payload.resize(ipc::MAX_PAYLOAD_BYTES + 1); + REQUIRE_FALSE(ipc::sendMessage(sockets[0], msg)); + + // Nothing was written: the stream still carries the next message. + IPCMessage small; + small.type = IPCMessageType::LEDGER_CLOSED; + small.payload = {1, 2, 3}; + REQUIRE(ipc::sendMessage(sockets[0], small)); + auto received = ipc::receiveMessage(sockets[1]); + REQUIRE(received.has_value()); + REQUIRE(received->type == IPCMessageType::LEDGER_CLOSED); + REQUIRE(received->payload == small.payload); + + close(sockets[0]); + close(sockets[1]); + } } TEST_CASE("IPCChannel", "[overlay][ipc]") diff --git a/src/overlay/test/OverlayIPCTests.cpp b/src/overlay/test/OverlayIPCTests.cpp index 255756b354..540e2c7c73 100644 --- a/src/overlay/test/OverlayIPCTests.cpp +++ b/src/overlay/test/OverlayIPCTests.cpp @@ -516,6 +516,95 @@ makeTxEnvelope(int64_t fee, int64_t seqNum, uint8_t accountByte, return txEnv; } +/** + * A transaction envelope of roughly `wasmBytes` bytes: one + * uploadContractWasm operation carrying a filler "wasm". The overlay takes + * Core's submissions without decoding them, so this only needs to be valid + * XDR. + */ +static TransactionEnvelope +makeLargeTxEnvelope(int64_t fee, int64_t seqNum, uint8_t accountByte, + size_t wasmBytes) +{ + TransactionEnvelope txEnv; + txEnv.type(ENVELOPE_TYPE_TX); + auto& tx = txEnv.v1().tx; + tx.sourceAccount.type(KEY_TYPE_ED25519); + std::fill(tx.sourceAccount.ed25519().begin(), + tx.sourceAccount.ed25519().end(), accountByte); + tx.fee = static_cast(fee); + tx.seqNum = seqNum; + tx.cond.type(PRECOND_NONE); + tx.operations.resize(1); + tx.operations[0].body.type(INVOKE_HOST_FUNCTION); + auto& hostFn = tx.operations[0].body.invokeHostFunctionOp().hostFunction; + hostFn.type(HOST_FUNCTION_TYPE_UPLOAD_CONTRACT_WASM); + hostFn.wasm().resize(wasmBytes); + std::fill(hostFn.wasm().begin(), hostFn.wasm().end(), accountByte); + return txEnv; +} + +/** + * Top transactions responses larger than the old 16 MiB IPC limit reach Core + * (a signature prewarm's pull on perfnet was about 17.2 MB and ended Core's + * IPC reader), and a pull larger than the limit is truncated to the + * highest-priority transactions that fit instead of breaking the connection. + */ +TEST_CASE("Rust overlay returns top transactions over 16 MiB", + "[overlay-ipc]") +{ + std::string overlayBinary = requireOverlayBinary(); + TmpDir tmpDir("overlay_ipc_large_top_txs_test"); + std::string socketPath = tmpDir.getName() + "/overlay.sock"; + uint16_t peerPort = getTestConfig(7).PEER_PORT; + + auto ipc = + std::make_unique(socketPath, overlayBinary, peerPort); + REQUIRE(ipc->start()); + + size_t const txBytes = 1024 * 1024; + auto submit = [&](size_t count, uint8_t firstAccount) { + for (size_t i = 0; i < count; ++i) + { + int64_t fee = 1000 + 100 * static_cast(i); + auto account = static_cast(firstAccount + i); + ipc->submitTransaction( + makeLargeTxEnvelope(fee, 1, account, txBytes), fee, 1); + } + std::this_thread::sleep_for(std::chrono::milliseconds(500)); + }; + + SECTION("a 20 MiB response arrives whole") + { + submit(20, 0); + auto txs = ipc->getTopTransactions(20); + REQUIRE(txs.size() == 20); + for (auto const& tx : txs) + { + REQUIRE(tx.v1().tx.operations[0] + .body.invokeHostFunctionOp() + .hostFunction.wasm() + .size() == txBytes); + } + // Highest fee first. + REQUIRE(txs.front().v1().tx.fee == 1000 + 100 * 19); + } + + SECTION("a response over the limit is truncated and the IPC survives") + { + submit(80, 0); + auto txs = ipc->getTopTransactions(80); + // 64 MiB holds 63 of these (each about 1 MiB plus framing). + REQUIRE(txs.size() > 16); + REQUIRE(txs.size() < 80); + REQUIRE(txs.front().v1().tx.fee == 1000 + 100 * 79); + // The connection still works. + REQUIRE(ipc->getTopTransactions(3).size() == 3); + } + + ipc->shutdown(); +} + /** * Test TX inclusion in TX set. * From 1a52bf6af94ccacab0c263720bfb2842d3fee0b0 Mon Sep 17 00:00:00 2001 From: Garand Tyson Date: Tue, 10 Nov 2026 13:04:33 -0800 Subject: [PATCH 23/23] Run make format --- src/herder/HerderImpl.cpp | 3 ++- src/herder/TxSetFrame.cpp | 7 +++---- src/overlay/test/OverlayIPCTests.cpp | 6 +++--- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/src/herder/HerderImpl.cpp b/src/herder/HerderImpl.cpp index d1abc80732..e261256430 100644 --- a/src/herder/HerderImpl.cpp +++ b/src/herder/HerderImpl.cpp @@ -1918,7 +1918,8 @@ HerderImpl::buildTxSet(uint32_t ledgerSeq, ConsensusTime closeTime) stopSignaturePrewarm(); auto& metrics = mApp.getMetrics(); auto txEnvelopes = [&]() { - auto t = metrics.NewTimer({"herder", "txset", "build-pull"}).TimeScope(); + auto t = + metrics.NewTimer({"herder", "txset", "build-pull"}).TimeScope(); return pullTopTransactions(maxTxSetCandidates() * 2); }(); auto framesTimer = diff --git a/src/herder/TxSetFrame.cpp b/src/herder/TxSetFrame.cpp index 8c96fa2a4d..6ef86de24c 100644 --- a/src/herder/TxSetFrame.cpp +++ b/src/herder/TxSetFrame.cpp @@ -917,10 +917,9 @@ makeTxSetFromTransactions( else { #endif - auto trimTimer = - app.getMetrics() - .NewTimer({"herder", "txset", "build-trim"}) - .TimeScope(); + auto trimTimer = app.getMetrics() + .NewTimer({"herder", "txset", "build-trim"}) + .TimeScope(); if (validTxTargets.empty()) { validatedTxs = TxSetUtils::trimInvalid( diff --git a/src/overlay/test/OverlayIPCTests.cpp b/src/overlay/test/OverlayIPCTests.cpp index 540e2c7c73..12a3f5c60c 100644 --- a/src/overlay/test/OverlayIPCTests.cpp +++ b/src/overlay/test/OverlayIPCTests.cpp @@ -550,8 +550,7 @@ makeLargeTxEnvelope(int64_t fee, int64_t seqNum, uint8_t accountByte, * IPC reader), and a pull larger than the limit is truncated to the * highest-priority transactions that fit instead of breaking the connection. */ -TEST_CASE("Rust overlay returns top transactions over 16 MiB", - "[overlay-ipc]") +TEST_CASE("Rust overlay returns top transactions over 16 MiB", "[overlay-ipc]") { std::string overlayBinary = requireOverlayBinary(); TmpDir tmpDir("overlay_ipc_large_top_txs_test"); @@ -581,7 +580,8 @@ TEST_CASE("Rust overlay returns top transactions over 16 MiB", REQUIRE(txs.size() == 20); for (auto const& tx : txs) { - REQUIRE(tx.v1().tx.operations[0] + REQUIRE(tx.v1() + .tx.operations[0] .body.invokeHostFunctionOp() .hostFunction.wasm() .size() == txBytes);