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/docs/metrics.md b/docs/metrics.md index b37a5c24bc..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 @@ -130,7 +147,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 +198,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/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/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..1e4b899022 100644 --- a/docs/rust-overlay/txset-fetching.md +++ b/docs/rust-overlay/txset-fetching.md @@ -6,15 +6,56 @@ 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 + +Only nomination leaders construct local proposals. Followers start SCP with 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 +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 +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 @@ -49,13 +90,21 @@ 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 `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 +the slots waiting for the set are purged. ## 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. @@ -72,6 +121,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/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..95beb3c44b 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 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 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(TxSetData::from_local(vec![1, 2, 3]).unwrap()), ledger_seq: 100, }; @@ -105,12 +106,12 @@ mod tests { cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: vec![].into(), + xdr: Arc::new(TxSetData::from_local(vec![]).unwrap()), ledger_seq: 100, }); cache.insert(CachedTxSet { hash: [2u8; 32], - xdr: vec![].into(), + xdr: Arc::new(TxSetData::from_local(vec![]).unwrap()), ledger_seq: 200, }); @@ -126,12 +127,12 @@ mod tests { cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: vec![].into(), + xdr: Arc::new(TxSetData::from_local(vec![]).unwrap()), ledger_seq: 100, }); cache.insert(CachedTxSet { hash: [2u8; 32], - xdr: vec![].into(), + xdr: Arc::new(TxSetData::from_local(vec![]).unwrap()), 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(TxSetData::from_local(vec![]).unwrap()), ledger_seq: 102, }); @@ -165,14 +166,14 @@ mod tests { cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: 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: vec![4, 5, 6].into(), + xdr: Arc::new(TxSetData::from_local(vec![4, 5, 6]).unwrap()), ledger_seq: 200, }); @@ -188,7 +189,7 @@ mod tests { cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: 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"); @@ -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(TxSetData::from_local(vec![4, 5, 6]).unwrap()), 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(TxSetData::from_local(vec![1, 2, 3]).unwrap()), ledger_seq: 100, }); cache.insert(CachedTxSet { hash: [1u8; 32], - xdr: vec![4, 5, 6].into(), + xdr: Arc::new(TxSetData::from_local(vec![4, 5, 6]).unwrap()), 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(TxSetData::from_local(vec![]).unwrap()), ledger_seq: 300, }); cache.insert(CachedTxSet { hash: [3u8; 32], - xdr: 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 new file mode 100644 index 0000000000..a9bab83f9f --- /dev/null +++ b/overlay/src/flood/txset_encoding.rs @@ -0,0 +1,176 @@ +//! Immutable TX set bytes and their mandatory zstd response encoding. +//! +//! 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; + +/// 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, + encoded: Vec, +} + +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 }) + } + + 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() + } + + /// Borrow the exact cached response; sending never invokes a compressor. + pub fn encoded(&self) -> &[u8] { + &self.encoded + } +} + +/// 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_encoded_size() { + return Err(invalid()); + } + 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()); + } + 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 xdr = decoder.decompress(compressed, length)?; + if xdr.len() != length { + return Err(invalid()); + } + Ok(TxSetData { + xdr, + encoded: frame, + }) +} + +#[cfg(test)] +mod tests { + use super::*; + use rand::{RngCore, SeedableRng}; + use std::sync::Arc; + + #[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 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); + } + } + + #[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() + )); + } + } + + #[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; + assert!(decode(corrupt).is_err()); + 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()); + } + 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 raw = [19u32.to_be_bytes().as_slice(), &[19; 19]].concat(); + assert!(decode(raw).is_err()); + } + + #[test] + fn compression_does_not_allow_oversized_raw_sets() { + let oversized = vec![0; MAX_TXSET_XDR_SIZE + 1]; + assert!(TxSetData::from_local(oversized.clone()).is_err()); + let frame = [ + (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_encoded_size() + 1]).is_err()); + } +} 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/overlay/src/libp2p_overlay.rs b/overlay/src/libp2p_overlay.rs index 0e11b78647..a46b6e56b9 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; @@ -42,14 +43,14 @@ 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"); +// 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) -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. @@ -72,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). @@ -95,12 +96,19 @@ 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], - data: Arc>, + data: Arc, to: PeerId, permits: (OwnedSemaphorePermit, OwnedSemaphorePermit), }, @@ -132,15 +140,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, } @@ -150,7 +154,6 @@ impl PeerOutboundStreams { scp: Mutex::new(None), tx: Mutex::new(None), txset: Mutex::new(None), - legacy_txset_request: Mutex::new(None), } } } @@ -213,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!( @@ -225,8 +239,23 @@ impl OverlayHandle { } } - pub async fn send_txset(&self, hash: [u8; 32], data: impl Into>>, to: PeerId) { - let data = data.into(); + /// 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 { warn!( @@ -539,73 +568,21 @@ impl StellarOverlay { self.run_event_loop().await; } - pub async fn run_event_loop(self) { - self.run_event_loop_with_control( - #[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) { - #[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 - }; - - // 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())); @@ -631,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); @@ -1002,67 +982,65 @@ 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 + /// 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 = { 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. 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], + 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 } @@ -1075,6 +1053,7 @@ impl StellarOverlay { } } }; + drop(streams); // Keep selection and reservation in the dispatcher, before spawning // the write, so repeated FetchTxSet commands cannot race past dedup. @@ -1112,6 +1091,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; @@ -1150,7 +1143,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 +1152,9 @@ 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(_) => { + 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 @@ -1176,7 +1162,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 @@ -1253,7 +1239,6 @@ enum StreamType { Tx, TxSet, TxSetRequest, - LegacyTxSetRequest, } impl StreamType { @@ -1261,41 +1246,37 @@ impl StreamType { match self { StreamType::Control | StreamType::TxSetRequest => CONTROL_PROTOCOL, StreamType::Tx => TX_PROTOCOL, - StreamType::TxSet | 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 - } - 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) @@ -1318,7 +1299,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; @@ -1402,7 +1382,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; @@ -1455,18 +1434,6 @@ 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(&mut stream.stream).await { Ok(()) => return Ok(()), Err(e) => { @@ -1575,14 +1542,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), )); } @@ -1592,11 +1566,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 @@ -1625,9 +1595,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; } @@ -2154,7 +2122,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 {}", @@ -2172,7 +2140,49 @@ fn handle_txset_request(state: &SharedState, peer_id: PeerId, hash: [u8; 32]) { } } -/// Handle inbound TxSet streams from peers +/// 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()); + + // 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) { while let Some((peer_id, mut stream)) = incoming.next().await { debug!("Accepted inbound TxSet stream from {}", peer_id); @@ -2181,82 +2191,31 @@ async fn handle_inbound_txset_streams(mut incoming: IncomingStreams, state: Arc< 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); - 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(); - 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 - ); - } - } - 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); @@ -3012,7 +2971,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(TxSetData::from_local(txset_data.clone()).unwrap()), from).await; } } _ = tokio::time::sleep(Duration::from_millis(10)) => {} @@ -3032,7 +2991,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; } } @@ -3796,7 +3755,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(TxSetData::from_local(txset_data.clone()).unwrap()), from).await; responded = true; } } @@ -3817,7 +3776,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; } } @@ -3913,7 +3872,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(TxSetData::from_local(data).unwrap()), from).await; } } _ = tokio::time::sleep(Duration::from_millis(10)) => {} @@ -4248,7 +4207,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, txset_data, peer2_id) + .send_txset( + txset_hash, + Arc::new(TxSetData::from_local(txset_data).unwrap()), + peer2_id, + ) .await; }); @@ -4376,7 +4339,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, txset_data.clone(), peer1_id) + .send_txset( + txset_hash, + Arc::new(TxSetData::from_local(txset_data.clone()).unwrap()), + peer1_id, + ) .await; // Verify node1 receives the TxSet response @@ -4386,7 +4353,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 1cb00aa20e..361001c855 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, data, 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,10 +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 { let (handle, events, admissions, mut overlay) = create_test_overlay(Keypair::generate_ed25519(), Arc::new(OverlayMetrics::new())) .unwrap(); @@ -116,7 +114,7 @@ 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()); Self { handle, events, @@ -587,6 +585,173 @@ async fn inv_batches_completed_by_relay_or_local_broadcast_reach_the_peer() { receiver.stop().await; } +#[tokio::test] +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; + } + } + }) + .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() + { + assert_eq!(got, hash); + assert_eq!(data.as_slice(), xdr); + assert_eq!(data.encoded(), encoded); + break; + } + } + }) + .await + .unwrap(); + leader.stop().await; + relay.stop().await; + follower.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_local(vec![0xff; 1000]).unwrap()); + send_to_peer_stream( + &sender.state, + receiver.peer, + StreamType::TxSet, + malformed.encoded(), + ) + .await + .unwrap(); + let (hash, xdr) = test_txset_xdr(19); + 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(); + 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 { + hash: got, data, .. + } = receiver.events.recv().await.unwrap() + { + assert_eq!(got, hash, "malformed XDR was forwarded"); + assert_eq!(data.as_slice(), 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 +941,11 @@ 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(TxSetData::from_local(data.clone()).unwrap()), + slow.peer, + ) .await; // Also exercise reopening: this write can complete only if the dispatcher @@ -785,12 +954,20 @@ 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(TxSetData::from_local(data.clone()).unwrap()), + 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(TxSetData::from_local(second_data.clone()).unwrap()), + healthy.peer, + ) .await; let scp = test_scp_envelope_xdr(1234); sender.handle.broadcast_scp(scp.clone()).await; @@ -810,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, @@ -835,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; } } @@ -861,7 +1038,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(TxSetData::from_local(response_data.clone()).unwrap()), + 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. @@ -907,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; } } @@ -930,7 +1111,6 @@ 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. @@ -938,7 +1118,7 @@ async fn quic_transport_priorities_are_applied_to_each_route_and_reopening() { &sender.state, receiver.peer, StreamType::TxSet, - &crate::xdr::frame_tx_set(&data), + TxSetData::from_local(data.clone()).unwrap().encoded(), ) .await .unwrap(); @@ -970,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::TxSet, - &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(); @@ -1066,8 +1169,14 @@ 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(TxSetData::from_local(data.clone()).unwrap()), + peer, + ) + .await; + 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()) @@ -1106,7 +1215,13 @@ 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(TxSetData::from_local(data).unwrap()), + 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) @@ -1137,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, @@ -1174,12 +1289,90 @@ 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))); + // 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!(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. + 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) = 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_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 752ea0d62c..5b2dfa3f6a 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), + 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, @@ -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; + } }); } } @@ -1054,13 +1063,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 +1085,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); } @@ -1149,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; + }); } } @@ -2054,13 +2098,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 +2224,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 +2264,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 +2275,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 +2315,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 +2331,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 +2366,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 +2411,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 +2430,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 +2512,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/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 9b3dfe58ee..e261256430 100644 --- a/src/herder/HerderImpl.cpp +++ b/src/herder/HerderImpl.cpp @@ -29,14 +29,17 @@ #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" #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" @@ -56,12 +59,182 @@ #include #include #include +#include #include 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. 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; + 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) + { + if (!SignatureUtils::doesHintMatch(key.ed25519(), sig.hint)) + { + continue; + } + if (budget == 0) + { + return; + } + --budget; + auto const res = SignatureUtils::verify(sig, key, contentsHash); + if (res.cacheResult == + PubKeyUtils::VerifySigCacheLookupResult::MISS) + { + ++verified; + } + if (res.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(); + 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 constexpr uint32 const CLOSE_TIME_DRIFT_LEDGER_WINDOW_SIZE = 120; // 10 seconds of drift threshold @@ -306,6 +479,7 @@ void HerderImpl::shutdown() { discardPreparedTxSet(); + stopSignaturePrewarm(); mTrackingTimer.cancel(); mOutOfSyncTimer.cancel(); mTriggerTimer.cancel(); @@ -499,6 +673,12 @@ HerderImpl::valueExternalized(uint64 slotIndex, StellarValue const& value, { ZoneScoped; int const DUMP_SCP_TIMEOUT_SECONDS = 20; + // 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); @@ -1504,10 +1684,15 @@ 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), 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 +1865,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 +1889,19 @@ 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()); + 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 {} 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); @@ -1707,20 +1914,16 @@ 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& 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()); @@ -1786,11 +1989,39 @@ HerderImpl::buildTxSet(uint32_t ledgerSeq, ConsensusTime closeTime) txPhases.emplace_back(std::move(sorobanTxs)); } + // 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); + txPhases, mApp, closeTimeOffset, invalidTxPhases +#ifdef BUILD_TESTS + , + false, {}, false +#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()) + { + // Serialized straight into the IPC message, without copying + // the set's XDR first. + overlayMgr.cacheTxSet(txSet->getContentsHash(), + txSet->getGeneralizedXDR(), ledgerSeq); + } + }, + targets); + markSignatureCacheLookups(mApp, "build", sigCacheHits, sigCacheMisses); CLOG_INFO(Herder, "Proposed TX set has {} transactions", proposedSet->sizeTxTotal()); @@ -1828,6 +2059,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) { @@ -1932,10 +2168,308 @@ 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]() { + return makeNominationValue(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. 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(ledgerSeqToTrigger, {}); + } +} + +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); +} + +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::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 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 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 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( + [prewarm, payload, windows, networkID = mApp.getNetworkID(), task, + tasks]() { + ZoneScopedN("signature prewarm"); + if (!prewarm->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) + { + if (prewarm->stop.load(std::memory_order_relaxed)) + { + break; + } + prewarm->verifiedSignatures += + verifyMasterKeySignatures(networkID, candidates[i]); + ++prewarm->checkedTxs; + } + } + 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"); + } +} + +void +HerderImpl::stopSignaturePrewarm() +{ + if (!mSignaturePrewarm) + { + 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(); + } +} + +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 +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. + // 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; + } + 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. @@ -1979,7 +2513,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 @@ -1994,6 +2528,13 @@ 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()) + { + mApp.getOverlayManager().cacheTxSet( + proposedSet->getContentsHash(), + proposedSet->getGeneralizedXDR(), lcl.header.ledgerSeq + 1); + } } #endif @@ -2008,20 +2549,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 @@ -2033,7 +2560,7 @@ HerderImpl::triggerNextLedger(uint32_t ledgerSeqToTrigger, // applying if (ledgerSeqToTrigger != slotIndex || mLedgerManager.isApplying()) { - return; + return nullptr; } auto newUpgrades = emptyUpgradeSteps; @@ -2063,15 +2590,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()) @@ -2086,8 +2604,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..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 @@ -269,7 +272,56 @@ 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); + // 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; + // 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); + // 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: + // 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: // 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 d487c7d0bd..84a2c58820 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,51 @@ HerderSCPDriver::logQuorumInformationAndUpdateMetrics(uint64_t index) } void -HerderSCPDriver::nominate(uint64_t slotIndex, StellarValue const& value, - TxSetXDRFrameConstPtr proposedSet, - StellarValue const& previousValue) +HerderSCPDriver::nominate(uint64_t slotIndex, NominationValueSupplier makeValue, + StellarValue const& previousValue, + bool constructValueNow) { 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); - + 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, 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 @@ -1420,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, @@ -1931,6 +1970,12 @@ 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(); + 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 @@ -1957,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/HerderSCPDriver.h b/src/herder/HerderSCPDriver.h index ec3b1bc9a2..047412be30 100644 --- a/src/herder/HerderSCPDriver.h +++ b/src/herder/HerderSCPDriver.h @@ -129,11 +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, StellarValue const& value, - TxSetXDRFrameConstPtr proposedSet, - StellarValue const& previousValue); + void nominate(uint64_t slotIndex, NominationValueSupplier makeValue, + StellarValue const& previousValue, + bool constructValueNow = false); SCPQuorumSetPtr getQSet(Hash const& qSetHash) override; 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/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/PendingEnvelopes.cpp b/src/herder/PendingEnvelopes.cpp index 204fa49860..6c3a3b5af5 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( @@ -43,8 +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({"scp", "fetch", "txset-retry"})) , mCostPerSlot(app.getMetrics().NewHistogram({"scp", "cost", "per-slot"})) { } @@ -265,6 +269,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, /*deliveredByOverlay=*/false); } bool @@ -274,29 +283,76 @@ 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); + // 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, /*deliveredByOverlay=*/true); + return true; +} + +void +PendingEnvelopes::completeTxSetFetch(Hash const& hash, + TxSetXDRFrameConstPtr const& txset, + bool deliveredByOverlay) +{ + 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 fetchIt = mTxSetFetches.find(hash); + if (fetchIt != mTxSetFetches.end()) + { + // 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() - + fetchIt->second.mStarted); + } + mTxSetFetches.erase(fetchIt); + } // 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 @@ -706,22 +762,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(); } } @@ -750,7 +810,7 @@ PendingEnvelopes::stopFetch(SCPEnvelope const& envelope) if (vec.empty()) { mPendingTxSetFetches.erase(it); - mTxSetFetchStartTimes.erase(h2); + mTxSetFetches.erase(h2); } } } @@ -909,8 +969,108 @@ 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() +{ + // 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; + } + 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(); + auto const lcl = mApp.getLedgerManager().getLastClosedLedgerNum(); + bool const legacyLcl = + protocolVersionIsBefore(mApp.getLedgerManager() + .getLastClosedLedgerHeader() + .header.ledgerVersion, + SOROBAN_PROTOCOL_VERSION); + for (auto& [hash, fetch] : mTxSetFetches) + { + // 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; + } + 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 @@ -955,13 +1115,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 7d9210de3e..75f5973085 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; @@ -98,6 +111,13 @@ 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, + bool deliveredByOverlay); + void scheduleTxSetFetchRetry(); + void retryStalledTxSetFetches(); + void updateMetrics(); void envelopeReady(SCPEnvelope const& envelope); @@ -131,6 +151,11 @@ class PendingEnvelopes std::optional maxSlot, uint64 slotToKeep); public: + // 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}; + PendingEnvelopes(Application& app, HerderImpl& herder); ~PendingEnvelopes(); @@ -163,10 +188,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 +206,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/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/TxSetFrame.cpp b/src/herder/TxSetFrame.cpp index c8b514eb98..6ef86de24c 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) { @@ -843,11 +877,15 @@ makeTxSetFromTransactions( txtest::ParallelSorobanOrder const& parallelSorobanOrder, bool disableTxValidationForLegacyScenario #endif -) + , + 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)); @@ -879,9 +917,30 @@ makeTxSetFromTransactions( else { #endif - validatedTxs = TxSetUtils::trimInvalid( - phaseTxs, app, accountFeeMap, closeTimeOffset.seconds(), - closeTimeOffset.seconds(), invalid); + auto trimTimer = app.getMetrics() + .NewTimer({"herder", "txset", "build-trim"}) + .TimeScope(); + 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 @@ -901,6 +960,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 @@ -935,6 +997,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( @@ -956,8 +1020,21 @@ 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. + if (onTxSetReady) + { + onTxSetReady(outputTxSet); + } + + auto roundtripTimer = app.getMetrics() + .NewTimer({"herder", "txset", "build-roundtrip"}) + .TimeScope(); ApplicableTxSetFrameConstPtr outputApplicableTxSet = outputTxSet->prepareForApply(app, lclHeader.header); + roundtripTimer.Stop(); if (!outputApplicableTxSet) { @@ -986,8 +1063,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( @@ -1015,11 +1096,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 @@ -1034,7 +1115,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 @@ -1449,6 +1530,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 { @@ -2497,13 +2585,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 66f926f70b..8bbb4c1ac4 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; @@ -117,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. @@ -152,7 +159,9 @@ makeTxSetFromTransactions( txtest::ParallelSorobanOrder const& parallelSorobanOrder = {}, bool disableTxValidationForLegacyScenario = false #endif -); + , + TxSetReadyCallback const& onTxSetReady = {}, + std::vector const& validTxTargets = {}); #ifdef BUILD_TESTS std::pair @@ -197,6 +206,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); @@ -213,6 +227,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; @@ -280,6 +296,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{}; @@ -405,7 +423,9 @@ class TxSetPhaseFrame txtest::ParallelSorobanOrder const& parallelSorobanOrder, bool disableTxValidationForLegacyScenario #endif - ); + , + TxSetReadyCallback const& onTxSetReady, + std::vector const& validTxTargets); #ifdef BUILD_TESTS friend std::pair makeTxSetFromTransactions( @@ -579,7 +599,9 @@ class ApplicableTxSetFrame txtest::ParallelSorobanOrder const& parallelSorobanOrder, bool disableTxValidationForLegacyScenario #endif - ); + , + 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..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, @@ -333,4 +343,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 4fc6d21658..0fc00e6b43 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" @@ -33,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" @@ -6768,6 +6771,90 @@ 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; + } + + // 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}; + } + + 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. + 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 +6946,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 +7289,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 +7431,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 +7496,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,16 +7505,513 @@ 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 + // 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 + // 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 == 2); + 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}); } +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()); + // 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(); + REQUIRE(!herder.isTracking()); + + testutil::crankUntil( + app, [&]() { return !scp.getLatestMessagesSend(seq).empty(); }, + std::chrono::seconds(30)); + REQUIRE(scp.getNominationLeaders(seq).count(scp.getLocalNodeID())); + REQUIRE(pulls == 2); + 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("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]") +{ + // 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; + } + // 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. + 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("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]") { @@ -7444,6 +8030,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 +8098,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,8 +8113,12 @@ 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()); + // 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, [&]() { @@ -7920,3 +8512,315 @@ TEST_CASE("upgrade scheduling under sub-second ledgers", "[upgrades]") .createUpgradesFor(header, *ledgerView, app->getConfig()); 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 +#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; + // 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()); + + std::vector envelopes; + { + ApplyLoad al(*app); + envelopes = al.generateSacPaymentEnvelopesForTesting(candidates); + } + REQUIRE(envelopes.size() == candidates); + app->getBatchExecutor().setPreferredTaskCountForTesting(tasks); + + // 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); + std::memcpy(payload.data(), &pull, 4); + for (uint32_t i = 0; i < pull; ++i) + { + 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); + } + herder.mGetTopTransactionsForTesting = [&](size_t) { + return OverlayIPC::parseTopTransactions(payload); + }; + + 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)); + { + // 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())); + if (cold) + { + 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; + } + } + + // 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/herder/test/PendingEnvelopesTests.cpp b/src/herder/test/PendingEnvelopesTests.cpp index b50c9a39b2..0eee4f71c6 100644 --- a/src/herder/test/PendingEnvelopesTests.cpp +++ b/src/herder/test/PendingEnvelopesTests.cpp @@ -201,6 +201,48 @@ 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)); + REQUIRE(herder.getSCP().getLatestMessage(pk) == nullptr); + auto& fetchTimer = + app->getMetrics().NewTimer({"scp", "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); + // Not an overlay fetch: scp.fetch.txset is not updated. + REQUIRE(fetchTimer.count() == fetches); + + // 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(), @@ -775,3 +817,113 @@ 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({"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 + // 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") + { + auto& fetchTimer = + 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); + 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)); + REQUIRE(fetchTimer.count() == fetches + 1); + REQUIRE(overlayFetchTimer.count() == overlayFetches); + 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") + { + 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)); + } +} diff --git a/src/herder/test/TxSetTests.cpp b/src/herder/test/TxSetTests.cpp index 133a57ce58..ce9871a1b4 100644 --- a/src/herder/test/TxSetTests.cpp +++ b/src/herder/test/TxSetTests.cpp @@ -3,7 +3,9 @@ // 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/SurgePricingUtils.h" #include "herder/TxSetFrame.h" #include "herder/TxSetUtils.h" #include "herder/test/TestTxSetUtils.h" @@ -27,12 +29,335 @@ #include #include #include +#include namespace stellar { 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("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("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("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()); @@ -3655,5 +3980,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/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/OverlayIPC.cpp b/src/overlay/OverlayIPC.cpp index a26be0d39f..284dd3db4c 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) { @@ -551,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()) { @@ -604,25 +614,31 @@ OverlayIPC::getTopTransactions(size_t count) return result; } - // Parse response: list of XDR-encoded TransactionEnvelopes + return std::move(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; } @@ -630,10 +646,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) @@ -700,7 +727,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 +739,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..4fd231ba23 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. @@ -123,6 +124,22 @@ 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 + * 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. * @@ -171,10 +188,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..9326e4e08e 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); } } @@ -240,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 d4709862eb..31506106e8 100644 --- a/src/overlay/RustOverlayManager.h +++ b/src/overlay/RustOverlayManager.h @@ -71,12 +71,14 @@ 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. std::vector getTopTransactions(size_t count); + // The same, undecoded (see OverlayIPC::getTopTransactionsPayload). + std::vector getTopTransactionsPayload(size_t count); // Metrics and managers OverlayMetrics& getOverlayMetrics(); 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 cfa0b5b7a9..12a3f5c60c 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,9 @@ #include #include +#include +#include +#include #include using namespace stellar; @@ -68,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(); @@ -449,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. * @@ -1600,3 +1756,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)); + } +} 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..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) @@ -1036,8 +1053,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); 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,