3 use core::sync::atomic::Ordering;
5 use bitcoin::blockdata::constants::ChainHash;
6 use bitcoin::secp256k1::PublicKey;
9 use lightning::ln::msgs::{
10 DecodeError, ErrorAction, LightningError, SocketAddress, UnsignedChannelUpdate,
11 UnsignedNodeAnnouncement,
13 use lightning::routing::gossip::{NetworkGraph, NodeAlias, NodeId};
14 use lightning::util::logger::Logger;
15 use lightning::util::ser::{BigSize, FixedLengthReader, Readable};
16 use lightning::{log_debug, log_given_level, log_gossip, log_trace, log_warn};
18 use crate::{GraphSyncError, RapidGossipSync};
20 #[cfg(all(feature = "std", not(test)))]
21 use std::time::{SystemTime, UNIX_EPOCH};
23 #[cfg(all(not(feature = "std"), not(test)))]
24 use alloc::{borrow::ToOwned, vec::Vec};
25 use lightning::ln::features::NodeFeatures;
27 /// The purpose of this prefix is to identify the serialization format, should other rapid gossip
28 /// sync formats arise in the future.
30 /// The fourth byte is the protocol version in case our format gets updated.
31 const GOSSIP_PREFIX: [u8; 3] = [76, 68, 75];
33 /// Maximum vector allocation capacity for distinct node IDs. This constraint is necessary to
34 /// avoid malicious updates being able to trigger excessive memory allocation.
35 const MAX_INITIAL_NODE_ID_VECTOR_CAPACITY: u32 = 50_000;
37 /// We disallow gossip data that's more than two weeks old, per BOLT 7's
39 const STALE_RGS_UPDATE_AGE_LIMIT_SECS: u64 = 60 * 60 * 24 * 14;
41 impl<NG: Deref<Target = NetworkGraph<L>>, L: Deref> RapidGossipSync<NG, L>
45 #[cfg(feature = "std")]
46 pub(crate) fn update_network_graph_from_byte_stream<R: io::Read>(
47 &self, read_cursor: &mut R,
48 ) -> Result<u32, GraphSyncError> {
49 #[allow(unused_mut, unused_assignments)]
50 let mut current_time_unix = None;
53 // Note that many tests rely on being able to set arbitrarily old timestamps, thus we
54 // disable this check during tests!
55 current_time_unix = Some(
57 .duration_since(UNIX_EPOCH)
58 .expect("Time must be > 1970")
62 self.update_network_graph_from_byte_stream_no_std(read_cursor, current_time_unix)
65 pub(crate) fn update_network_graph_from_byte_stream_no_std<R: io::Read>(
66 &self, mut read_cursor: &mut R, current_time_unix: Option<u64>,
67 ) -> Result<u32, GraphSyncError> {
68 log_trace!(self.logger, "Processing RGS data...");
69 let mut protocol_prefix = [0u8; 3];
71 read_cursor.read_exact(&mut protocol_prefix)?;
72 if protocol_prefix != GOSSIP_PREFIX {
73 return Err(DecodeError::UnknownVersion.into());
76 let version: u8 = Readable::read(&mut read_cursor)?;
77 if version != 1 && version != 2 {
78 return Err(DecodeError::UnknownVersion.into());
81 let parse_node_details = version == 2;
83 let chain_hash: ChainHash = Readable::read(read_cursor)?;
84 let ng_chain_hash = self.network_graph.get_chain_hash();
85 if chain_hash != ng_chain_hash {
86 return Err(LightningError {
87 err: "Rapid Gossip Sync data's chain hash does not match the network graph's"
89 action: ErrorAction::IgnoreError,
94 let latest_seen_timestamp: u32 = Readable::read(read_cursor)?;
96 if let Some(time) = current_time_unix {
97 if (latest_seen_timestamp as u64) < time.saturating_sub(STALE_RGS_UPDATE_AGE_LIMIT_SECS)
99 return Err(LightningError {
100 err: "Rapid Gossip Sync data is more than two weeks old".to_owned(),
101 action: ErrorAction::IgnoreError,
107 // backdate the applied timestamp by a week
108 let backdated_timestamp = latest_seen_timestamp.saturating_sub(24 * 3600 * 7);
110 let mut default_node_features = Vec::new();
111 if parse_node_details {
112 let default_feature_count: u8 = Readable::read(read_cursor)?;
113 for _ in 0..default_feature_count {
114 let current_default_feature: NodeFeatures = Readable::read(read_cursor)?;
115 default_node_features.push(current_default_feature);
119 let node_id_count: u32 = Readable::read(read_cursor)?;
120 let mut node_ids: Vec<PublicKey> = Vec::with_capacity(core::cmp::min(
122 MAX_INITIAL_NODE_ID_VECTOR_CAPACITY,
125 let network_graph = &self.network_graph;
126 let mut node_modifications: Vec<UnsignedNodeAnnouncement> = Vec::new();
128 if parse_node_details {
129 let read_only_network_graph = network_graph.read_only();
130 for _ in 0..node_id_count {
131 let mut pubkey_bytes = [0u8; 33];
132 read_cursor.read_exact(&mut pubkey_bytes)?;
135 We encode additional information in the pubkey parity byte with the following mapping:
137 7: expect extra data after the pubkey
138 6: use this as a reminder without altering anything
139 5-3: index of new features among default (1-6). If index is 7 (all 3 bits are set, it's
140 outside the present default range). 0 means no feature changes.
141 2: addresses have changed
146 let node_detail_flag = pubkey_bytes.first().ok_or(DecodeError::ShortRead)?;
148 let has_address_details = (node_detail_flag & (1 << 2)) > 0;
149 let feature_detail_marker = (node_detail_flag & (0b111 << 3)) >> 3;
150 let is_reminder = (node_detail_flag & (1 << 6)) > 0;
151 let has_additional_data = (node_detail_flag & (1 << 7)) > 0;
153 // extract the relevant bits for pubkey parity
154 let key_parity = node_detail_flag & 0b_0000_0011;
155 pubkey_bytes[0] = key_parity;
157 let current_pubkey = PublicKey::from_slice(&pubkey_bytes)?;
158 let current_node_id = NodeId::from_pubkey(¤t_pubkey);
159 node_ids.push(current_pubkey);
161 if is_reminder || has_address_details || feature_detail_marker > 0 {
162 let mut synthetic_node_announcement = UnsignedNodeAnnouncement {
163 features: NodeFeatures::empty(),
164 timestamp: backdated_timestamp,
165 node_id: current_node_id,
167 alias: NodeAlias([0u8; 32]),
168 addresses: Vec::new(),
169 excess_address_data: Vec::new(),
170 excess_data: Vec::new(),
173 read_only_network_graph
175 .get(¤t_node_id)
176 .and_then(|node| node.announcement_info.as_ref())
178 synthetic_node_announcement.features = info.features().clone();
179 synthetic_node_announcement.rgb = info.rgb().clone();
180 synthetic_node_announcement.alias = info.alias().clone();
181 synthetic_node_announcement.addresses = info.addresses().clone();
184 if has_address_details {
185 let address_count: u8 = Readable::read(read_cursor)?;
186 let mut node_addresses: Vec<SocketAddress> = Vec::new();
187 for address_index in 0..address_count {
188 let current_byte_count: u8 = Readable::read(read_cursor)?;
189 let mut address_reader =
190 FixedLengthReader::new(&mut read_cursor, current_byte_count as u64);
191 if let Ok(current_address) = Readable::read(&mut address_reader) {
192 node_addresses.push(current_address);
193 if address_reader.bytes_remain() {
194 return Err(DecodeError::ShortRead.into());
197 // Do not crash to allow future socket address forwards compatibility
200 "Failure to parse address at index {} for node ID {}",
204 address_reader.eat_remaining()?;
207 synthetic_node_announcement.addresses = node_addresses;
210 if feature_detail_marker > 0 {
211 if feature_detail_marker < 7 {
212 let feature_index = (feature_detail_marker - 1) as usize;
213 synthetic_node_announcement.features = default_node_features
215 .ok_or(DecodeError::InvalidValue)?
218 let node_features: NodeFeatures = Readable::read(read_cursor)?;
219 synthetic_node_announcement.features = node_features;
223 node_modifications.push(synthetic_node_announcement);
226 if has_additional_data {
227 let additional_data: Vec<u8> = Readable::read(read_cursor)?;
230 "Ignoring {} bytes of additional data in node announcement",
231 additional_data.len()
236 for _ in 0..node_id_count {
237 let current_node_id = Readable::read(read_cursor)?;
238 node_ids.push(current_node_id);
242 let mut previous_scid: u64 = 0;
243 let announcement_count: u32 = Readable::read(read_cursor)?;
244 for _ in 0..announcement_count {
245 let features = Readable::read(read_cursor)?;
248 let scid_delta: BigSize = Readable::read(read_cursor)?;
249 let short_channel_id =
250 previous_scid.checked_add(scid_delta.0).ok_or(DecodeError::InvalidValue)?;
251 previous_scid = short_channel_id;
253 let node_id_1_index: BigSize = Readable::read(read_cursor)?;
254 let mut node_id_2_index: BigSize = Readable::read(read_cursor)?;
255 let has_additional_data = (node_id_2_index.0 & (1 << 63)) > 0;
256 // ensure 63rd bit isn't set
257 node_id_2_index.0 &= !(1 << 63);
259 if max(node_id_1_index.0, node_id_2_index.0) >= node_id_count as u64 {
260 return Err(DecodeError::InvalidValue.into());
262 let node_id_1 = node_ids[node_id_1_index.0 as usize];
263 let node_id_2 = node_ids[node_id_2_index.0 as usize];
267 "Adding channel {} from RGS announcement at {}",
269 latest_seen_timestamp
272 let announcement_result = network_graph.add_channel_from_partial_announcement(
274 backdated_timestamp as u64,
279 if let Err(lightning_error) = announcement_result {
280 if let ErrorAction::IgnoreDuplicateGossip = lightning_error.action {
281 // everything is fine, just a duplicate channel announcement
285 "Failed to process channel announcement: {:?}",
288 return Err(lightning_error.into());
292 if version >= 2 && has_additional_data {
293 // forwards compatibility
294 let additional_data: Vec<u8> = Readable::read(read_cursor)?;
297 "Ignoring {} bytes of additional data in channel announcement",
298 additional_data.len()
303 for modification in node_modifications {
304 match network_graph.update_node_from_unsigned_announcement(&modification) {
306 Err(LightningError { action: ErrorAction::IgnoreDuplicateGossip, .. }) => {},
307 Err(LightningError { action: ErrorAction::IgnoreAndLog(level), err }) => {
311 "Failed to apply node announcement: {:?}",
315 Err(LightningError { action: ErrorAction::IgnoreError, err }) => {
316 log_gossip!(self.logger, "Failed to apply node announcement: {:?}", err);
318 Err(e) => return Err(e.into()),
322 // updates start at a new scid
325 let update_count: u32 = Readable::read(read_cursor)?;
326 log_debug!(self.logger, "Processing RGS update from {} with {} nodes, {} channel announcements and {} channel updates.",
327 latest_seen_timestamp, node_id_count, announcement_count, update_count);
328 if update_count == 0 {
329 return Ok(latest_seen_timestamp);
332 // obtain default values for non-incremental updates
333 let default_cltv_expiry_delta: u16 = Readable::read(&mut read_cursor)?;
334 let default_htlc_minimum_msat: u64 = Readable::read(&mut read_cursor)?;
335 let default_fee_base_msat: u32 = Readable::read(&mut read_cursor)?;
336 let default_fee_proportional_millionths: u32 = Readable::read(&mut read_cursor)?;
337 let default_htlc_maximum_msat: u64 = Readable::read(&mut read_cursor)?;
339 let mut previous_channel_direction = None;
341 for _ in 0..update_count {
342 let scid_delta: BigSize = Readable::read(read_cursor)?;
343 let short_channel_id =
344 previous_scid.checked_add(scid_delta.0).ok_or(DecodeError::InvalidValue)?;
345 previous_scid = short_channel_id;
347 let channel_flags: u8 = Readable::read(read_cursor)?;
350 let direction = (channel_flags & 1) == 1;
351 let is_same_direction_update = Some(direction) == previous_channel_direction;
352 previous_channel_direction = Some(direction);
354 if scid_delta.0 == 0 && is_same_direction_update {
355 // this is additional data for forwards compatibility
356 let additional_data: Vec<u8> = Readable::read(read_cursor)?;
359 "Ignoring {} bytes of additional data in channel update",
360 additional_data.len()
366 // flags are always sent in full, and hence always need updating
367 let standard_channel_flags = channel_flags & 0b_0000_0011;
369 let mut synthetic_update = UnsignedChannelUpdate {
372 timestamp: backdated_timestamp,
373 flags: standard_channel_flags,
374 cltv_expiry_delta: default_cltv_expiry_delta,
375 htlc_minimum_msat: default_htlc_minimum_msat,
376 htlc_maximum_msat: default_htlc_maximum_msat,
377 fee_base_msat: default_fee_base_msat,
378 fee_proportional_millionths: default_fee_proportional_millionths,
379 excess_data: Vec::new(),
382 let mut skip_update_for_unknown_channel = false;
384 if (channel_flags & 0b_1000_0000) != 0 {
385 // incremental update, field flags will indicate mutated values
386 let read_only_network_graph = network_graph.read_only();
387 if let Some(directional_info) = read_only_network_graph
389 .get(&short_channel_id)
390 .and_then(|channel| channel.get_directional_info(channel_flags))
392 synthetic_update.cltv_expiry_delta = directional_info.cltv_expiry_delta;
393 synthetic_update.htlc_minimum_msat = directional_info.htlc_minimum_msat;
394 synthetic_update.htlc_maximum_msat = directional_info.htlc_maximum_msat;
395 synthetic_update.fee_base_msat = directional_info.fees.base_msat;
396 synthetic_update.fee_proportional_millionths =
397 directional_info.fees.proportional_millionths;
399 log_trace!(self.logger,
400 "Skipping application of channel update for chan {} with flags {} as original data is missing.",
401 short_channel_id, channel_flags);
402 skip_update_for_unknown_channel = true;
406 if channel_flags & 0b_0100_0000 > 0 {
407 let cltv_expiry_delta: u16 = Readable::read(read_cursor)?;
408 synthetic_update.cltv_expiry_delta = cltv_expiry_delta;
411 if channel_flags & 0b_0010_0000 > 0 {
412 let htlc_minimum_msat: u64 = Readable::read(read_cursor)?;
413 synthetic_update.htlc_minimum_msat = htlc_minimum_msat;
416 if channel_flags & 0b_0001_0000 > 0 {
417 let fee_base_msat: u32 = Readable::read(read_cursor)?;
418 synthetic_update.fee_base_msat = fee_base_msat;
421 if channel_flags & 0b_0000_1000 > 0 {
422 let fee_proportional_millionths: u32 = Readable::read(read_cursor)?;
423 synthetic_update.fee_proportional_millionths = fee_proportional_millionths;
426 if channel_flags & 0b_0000_0100 > 0 {
427 let htlc_maximum_msat: u64 = Readable::read(read_cursor)?;
428 synthetic_update.htlc_maximum_msat = htlc_maximum_msat;
431 if skip_update_for_unknown_channel {
437 "Updating channel {} with flags {} from RGS announcement at {}",
440 latest_seen_timestamp
442 match network_graph.update_channel_unsigned(&synthetic_update) {
444 Err(LightningError { action: ErrorAction::IgnoreDuplicateGossip, .. }) => {},
445 Err(LightningError { action: ErrorAction::IgnoreAndLog(level), err }) => {
449 "Failed to apply channel update: {:?}",
453 Err(LightningError { action: ErrorAction::IgnoreError, .. }) => {},
454 Err(e) => return Err(e.into()),
458 self.network_graph.set_last_rapid_gossip_sync_timestamp(latest_seen_timestamp);
460 if let Some(time) = current_time_unix {
461 self.network_graph.remove_stale_channels_and_tracking_with_time(time)
464 self.is_initial_sync_complete.store(true, Ordering::Release);
465 log_trace!(self.logger, "Done processing RGS data from {}", latest_seen_timestamp);
466 Ok(latest_seen_timestamp)
472 use bitcoin::Network;
474 #[cfg(feature = "std")]
475 use lightning::ln::msgs::DecodeError;
477 use lightning::routing::gossip::{NetworkGraph, NodeId};
478 use lightning::util::logger::Level;
479 use lightning::util::test_utils::TestLogger;
481 use crate::processing::STALE_RGS_UPDATE_AGE_LIMIT_SECS;
482 use crate::{GraphSyncError, RapidGossipSync};
484 const VALID_RGS_BINARY: [u8; 300] = [
485 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247, 79,
486 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218, 0, 0, 0,
487 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251, 187, 172, 38,
488 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125, 157, 176, 223,
489 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136, 88, 216, 115, 11,
490 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106, 204, 131, 186, 35,
491 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138, 181, 64, 187, 103, 127,
492 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175, 110, 32, 237, 0, 217, 90,
493 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128, 76, 97, 0, 0, 0, 2, 0, 0, 255,
494 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68, 226, 0, 6, 11, 0, 1, 2, 3, 0, 0, 0, 4,
495 0, 40, 0, 0, 0, 0, 0, 0, 3, 232, 0, 0, 3, 232, 0, 0, 0, 1, 0, 0, 0, 0, 29, 129, 25, 192,
496 255, 8, 153, 192, 0, 2, 27, 0, 0, 60, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 100, 0, 0, 2, 224,
497 0, 0, 0, 0, 58, 85, 116, 216, 0, 29, 0, 0, 0, 1, 0, 0, 0, 125, 0, 0, 0, 0, 58, 85, 116,
498 216, 255, 2, 68, 226, 0, 6, 11, 0, 1, 0, 0, 1,
500 const VALID_BINARY_TIMESTAMP: u64 = 1642291930;
503 #[cfg(feature = "std")]
504 fn network_graph_fails_to_update_from_clipped_input() {
505 let logger = TestLogger::new();
506 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
508 let example_input = vec![
509 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
510 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
511 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
512 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
513 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
514 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
515 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
516 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
517 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
518 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
519 226, 0, 6, 11, 0, 1, 2, 3, 0, 0, 0, 2, 0, 40, 0, 0, 0, 0, 0, 0, 3, 232, 0, 0, 0, 100,
520 0, 0, 2, 224, 0, 0, 0, 0, 29, 129, 25, 192, 255, 8, 153, 192, 0, 2, 27, 0, 0, 36, 0, 0,
521 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 58, 85, 116, 216, 255, 2, 68, 226, 0, 6, 11, 0, 1, 24, 0,
524 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
525 let update_result = rapid_sync.update_network_graph(&example_input[..]);
526 assert!(update_result.is_err());
527 if let Err(GraphSyncError::DecodeError(DecodeError::ShortRead)) = update_result {
528 // this is the expected error type
530 panic!("Unexpected update result: {:?}", update_result)
535 fn node_data_update_succeeds_with_v2() {
536 let mut logger = TestLogger::new();
537 logger.enable(Level::Gossip);
538 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
540 let example_input = vec![
541 76, 68, 75, 2, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
542 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 102, 97, 206, 240,
543 0, 0, 0, 0, 2, 63, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213, 170, 186, 5,
544 101, 215, 30, 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7, 143, 5, 38, 4,
545 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
546 1, 1, 1, 0, 2, 3, 0, 4, 7, 1, 127, 0, 0, 1, 37, 163, 14, 5, 10, 103, 111, 111, 103,
547 108, 101, 46, 99, 111, 109, 1, 187, 19, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
548 1, 5, 57, 13, 3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 0, 2, 23, 48, 62, 77, 75, 108,
549 209, 54, 16, 50, 202, 155, 210, 174, 185, 217, 0, 170, 77, 69, 217, 234, 216, 10, 201,
550 66, 51, 116, 196, 81, 167, 37, 77, 7, 102, 0, 0, 2, 25, 48, 0, 0, 0, 1, 0, 0, 1, 0, 1,
551 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
555 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
556 let update_result = rapid_sync.update_network_graph_no_std(&example_input[..], None);
557 assert!(update_result.is_ok());
559 let read_only_graph = network_graph.read_only();
560 let nodes = read_only_graph.nodes();
561 assert_eq!(nodes.len(), 2);
565 let node_id = NodeId::from_slice(&[
566 3, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213, 170, 186, 5, 101, 215, 30,
567 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7, 143,
570 let node = nodes.get(&node_id).unwrap();
571 let announcement_info = node.announcement_info.as_ref().unwrap();
572 let addresses = announcement_info.addresses();
573 assert_eq!(addresses.len(), 5);
578 let node_id = NodeId::from_slice(&[
579 2, 77, 75, 108, 209, 54, 16, 50, 202, 155, 210, 174, 185, 217, 0, 170, 77, 69, 217,
580 234, 216, 10, 201, 66, 51, 116, 196, 81, 167, 37, 77, 7, 102,
583 let node = nodes.get(&node_id).unwrap();
584 let announcement_info = node.announcement_info.as_ref().unwrap();
585 let features = announcement_info.features();
586 println!("features: {}", features);
587 // assert_eq!(addresses.len(), 5);
590 logger.assert_log_contains(
591 "lightning_rapid_gossip_sync::processing",
592 "Failed to apply node announcement",
598 fn node_date_update_succeeds_without_channels() {
599 let mut logger = TestLogger::new();
600 logger.enable(Level::Gossip);
601 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
602 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
604 let example_input = vec![
605 76, 68, 75, 2, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
606 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 102, 105, 183,
607 240, 0, 0, 0, 0, 1, 63, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213, 170, 186,
608 5, 101, 215, 30, 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7, 143, 5, 13,
609 3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 7, 1, 127, 0, 0, 1, 37, 163, 19, 2, 1, 1, 1,
610 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 57, 38, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
611 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 2, 3, 0, 4, 14, 5,
612 10, 103, 111, 111, 103, 108, 101, 46, 99, 111, 109, 1, 187, 0, 2, 23, 48, 0, 0, 0, 0,
616 let update_result = rapid_sync.update_network_graph_no_std(&example_input[..], None);
617 assert!(update_result.is_ok());
619 logger.assert_log_contains(
620 "lightning_rapid_gossip_sync::processing",
621 "Failed to apply node announcement: \"No existing channels for node_announcement\"",
627 fn update_ignores_v2_additional_data() {
628 let mut logger = TestLogger::new();
629 logger.enable(Level::Gossip);
630 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
631 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
633 let example_input = vec![
634 76, 68, 75, 2, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
635 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 102, 106, 12, 80,
636 1, 0, 2, 23, 48, 0, 0, 0, 3, 143, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213,
637 170, 186, 5, 101, 215, 30, 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7,
638 143, 5, 38, 4, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
639 1, 1, 1, 1, 1, 1, 1, 1, 0, 2, 3, 0, 4, 19, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
640 1, 1, 5, 57, 13, 3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 7, 1, 127, 0, 0, 1, 37, 163,
641 14, 5, 10, 103, 111, 111, 103, 108, 101, 46, 99, 111, 109, 1, 187, 0, 255, 0, 0, 0, 0,
642 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
643 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
644 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
645 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
646 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
647 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
648 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
649 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
650 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 138, 77, 75, 108, 209, 54, 16,
651 50, 202, 155, 210, 174, 185, 217, 0, 170, 77, 69, 217, 234, 216, 10, 201, 66, 51, 116,
652 196, 81, 167, 37, 77, 7, 102, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
653 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
654 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
655 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
656 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
657 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
658 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
659 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
660 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
661 0, 0, 0, 0, 0, 0, 0, 186, 83, 31, 230, 6, 129, 52, 80, 61, 39, 35, 19, 50, 39, 200,
662 103, 172, 143, 166, 200, 60, 83, 126, 154, 68, 195, 197, 189, 189, 203, 31, 227, 55, 0,
663 2, 22, 49, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
664 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
665 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
666 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
667 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
668 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
669 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
670 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
671 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
672 0, 0, 0, 1, 0, 0, 1, 0, 255, 128, 0, 0, 0, 0, 0, 0, 1, 0, 147, 23, 23, 23, 23, 23, 23,
673 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
674 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
675 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
676 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
677 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
678 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
679 23, 23, 23, 23, 23, 23, 23, 23, 23, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
680 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 17, 42, 42, 42, 42, 42, 42, 42,
681 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 1, 0, 1, 0, 17, 42, 42, 42, 42, 42, 42, 42,
682 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
685 let update_result = rapid_sync.update_network_graph_no_std(&example_input[..], None);
686 assert!(update_result.is_ok());
688 logger.assert_log_contains(
689 "lightning_rapid_gossip_sync::processing",
690 "Ignoring 255 bytes of additional data in node announcement",
693 logger.assert_log_contains(
694 "lightning_rapid_gossip_sync::processing",
695 "Ignoring 147 bytes of additional data in channel announcement",
698 logger.assert_log_contains(
699 "lightning_rapid_gossip_sync::processing",
700 "Ignoring 17 bytes of additional data in channel update",
706 #[cfg(feature = "std")]
707 fn incremental_only_update_ignores_missing_channel() {
708 let incremental_update_input = vec![
709 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
710 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
711 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
712 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 136, 0, 0, 0, 221, 255, 2,
713 68, 226, 0, 6, 11, 0, 1, 128,
716 let logger = TestLogger::new();
717 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
719 assert_eq!(network_graph.read_only().channels().len(), 0);
721 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
722 let update_result = rapid_sync.update_network_graph(&incremental_update_input[..]);
723 assert!(update_result.is_ok());
727 #[cfg(feature = "std")]
728 fn incremental_only_update_fails_without_prior_updates() {
729 let announced_update_input = vec![
730 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
731 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
732 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
733 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
734 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
735 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
736 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
737 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
738 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
739 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
740 226, 0, 6, 11, 0, 1, 2, 3, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
741 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 136, 0, 0, 0, 221, 255,
742 2, 68, 226, 0, 6, 11, 0, 1, 128,
745 let logger = TestLogger::new();
746 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
748 assert_eq!(network_graph.read_only().channels().len(), 0);
750 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
751 rapid_sync.update_network_graph(&announced_update_input[..]).unwrap();
755 #[cfg(feature = "std")]
756 fn incremental_only_update_fails_without_prior_same_direction_updates() {
757 let initialization_input = vec![
758 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
759 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
760 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
761 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
762 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
763 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
764 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
765 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
766 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
767 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
768 226, 0, 6, 11, 0, 1, 2, 3, 0, 0, 0, 2, 0, 40, 0, 0, 0, 0, 0, 0, 3, 232, 0, 0, 3, 232,
769 0, 0, 0, 1, 0, 0, 0, 0, 58, 85, 116, 216, 255, 8, 153, 192, 0, 2, 27, 0, 0, 25, 0, 0,
770 0, 1, 0, 0, 0, 125, 255, 2, 68, 226, 0, 6, 11, 0, 1, 5, 0, 0, 0, 0, 29, 129, 25, 192,
773 let logger = TestLogger::new();
774 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
776 assert_eq!(network_graph.read_only().channels().len(), 0);
778 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
779 let initialization_result = rapid_sync.update_network_graph(&initialization_input[..]);
780 if initialization_result.is_err() {
781 panic!("Unexpected initialization result: {:?}", initialization_result)
784 assert_eq!(network_graph.read_only().channels().len(), 2);
785 let initialized = network_graph.to_string();
787 .contains("021607cfce19a4c5e7e6e738663dfafbbbac262e4ff76c2c9b30dbeefc35c00643"));
789 .contains("02247d9db0dfafea745ef8c9e161eb322f73ac3f8858d8730b6fd97254747ce76b"));
791 .contains("029e01f279986acc83ba235d46d80aede0b7595f410353b93a8ab540bb677f4432"));
793 .contains("02c913118a8895b9e29c89af6e20ed00d95a1f64e4952edbafa84d048f26804c61"));
794 assert!(initialized.contains("619737530008010752"));
795 assert!(initialized.contains("783241506229452801"));
797 let opposite_direction_incremental_update_input = vec![
798 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
799 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
800 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
801 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 136, 0, 0, 0, 221, 255, 2,
802 68, 226, 0, 6, 11, 0, 1, 128,
804 rapid_sync.update_network_graph(&opposite_direction_incremental_update_input[..]).unwrap();
808 #[cfg(feature = "std")]
809 fn incremental_update_succeeds_with_prior_announcements_and_full_updates() {
810 let initialization_input = vec![
811 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
812 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
813 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
814 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
815 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
816 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
817 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
818 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
819 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
820 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
821 226, 0, 6, 11, 0, 1, 2, 3, 0, 0, 0, 4, 0, 40, 0, 0, 0, 0, 0, 0, 3, 232, 0, 0, 3, 232,
822 0, 0, 0, 1, 0, 0, 0, 0, 58, 85, 116, 216, 255, 8, 153, 192, 0, 2, 27, 0, 0, 56, 0, 0,
823 0, 0, 0, 0, 0, 1, 0, 0, 0, 100, 0, 0, 2, 224, 0, 25, 0, 0, 0, 1, 0, 0, 0, 125, 255, 2,
824 68, 226, 0, 6, 11, 0, 1, 4, 0, 0, 0, 0, 29, 129, 25, 192, 0, 5, 0, 0, 0, 0, 29, 129,
828 let logger = TestLogger::new();
829 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
831 assert_eq!(network_graph.read_only().channels().len(), 0);
833 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
834 let initialization_result = rapid_sync.update_network_graph(&initialization_input[..]);
835 assert!(initialization_result.is_ok());
837 let single_direction_incremental_update_input = vec![
838 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
839 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
840 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
841 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 136, 0, 0, 0, 221, 255, 2,
842 68, 226, 0, 6, 11, 0, 1, 128,
845 rapid_sync.update_network_graph(&single_direction_incremental_update_input[..]);
846 if update_result.is_err() {
847 panic!("Unexpected update result: {:?}", update_result)
850 assert_eq!(network_graph.read_only().channels().len(), 2);
851 let after = network_graph.to_string();
853 after.contains("021607cfce19a4c5e7e6e738663dfafbbbac262e4ff76c2c9b30dbeefc35c00643")
856 after.contains("02247d9db0dfafea745ef8c9e161eb322f73ac3f8858d8730b6fd97254747ce76b")
859 after.contains("029e01f279986acc83ba235d46d80aede0b7595f410353b93a8ab540bb677f4432")
862 after.contains("02c913118a8895b9e29c89af6e20ed00d95a1f64e4952edbafa84d048f26804c61")
864 assert!(after.contains("619737530008010752"));
865 assert!(after.contains("783241506229452801"));
869 #[cfg(feature = "std")]
870 fn update_succeeds_when_duplicate_gossip_is_applied() {
871 let initialization_input = vec![
872 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
873 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
874 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
875 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
876 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
877 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
878 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
879 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
880 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
881 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
882 226, 0, 6, 11, 0, 1, 2, 3, 0, 0, 0, 4, 0, 40, 0, 0, 0, 0, 0, 0, 3, 232, 0, 0, 3, 232,
883 0, 0, 0, 1, 0, 0, 0, 0, 58, 85, 116, 216, 255, 8, 153, 192, 0, 2, 27, 0, 0, 56, 0, 0,
884 0, 0, 0, 0, 0, 1, 0, 0, 0, 100, 0, 0, 2, 224, 0, 25, 0, 0, 0, 1, 0, 0, 0, 125, 255, 2,
885 68, 226, 0, 6, 11, 0, 1, 4, 0, 0, 0, 0, 29, 129, 25, 192, 0, 5, 0, 0, 0, 0, 29, 129,
889 let logger = TestLogger::new();
890 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
892 assert_eq!(network_graph.read_only().channels().len(), 0);
894 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
895 let initialization_result = rapid_sync.update_network_graph(&initialization_input[..]);
896 assert!(initialization_result.is_ok());
898 let single_direction_incremental_update_input = vec![
899 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
900 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
901 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
902 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 136, 0, 0, 0, 221, 255, 2,
903 68, 226, 0, 6, 11, 0, 1, 128,
905 let update_result_1 =
906 rapid_sync.update_network_graph(&single_direction_incremental_update_input[..]);
907 // Apply duplicate update
908 let update_result_2 =
909 rapid_sync.update_network_graph(&single_direction_incremental_update_input[..]);
910 assert!(update_result_1.is_ok());
911 assert!(update_result_2.is_ok());
915 #[cfg(feature = "std")]
916 fn full_update_succeeds() {
917 let logger = TestLogger::new();
918 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
920 assert_eq!(network_graph.read_only().channels().len(), 0);
922 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
923 let update_result = rapid_sync.update_network_graph(&VALID_RGS_BINARY);
924 if update_result.is_err() {
925 panic!("Unexpected update result: {:?}", update_result)
928 assert_eq!(network_graph.read_only().channels().len(), 2);
929 let after = network_graph.to_string();
931 after.contains("021607cfce19a4c5e7e6e738663dfafbbbac262e4ff76c2c9b30dbeefc35c00643")
934 after.contains("02247d9db0dfafea745ef8c9e161eb322f73ac3f8858d8730b6fd97254747ce76b")
937 after.contains("029e01f279986acc83ba235d46d80aede0b7595f410353b93a8ab540bb677f4432")
940 after.contains("02c913118a8895b9e29c89af6e20ed00d95a1f64e4952edbafa84d048f26804c61")
942 assert!(after.contains("619737530008010752"));
943 assert!(after.contains("783241506229452801"));
947 fn full_update_succeeds_at_the_beginning_of_the_unix_era() {
948 let logger = TestLogger::new();
949 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
951 assert_eq!(network_graph.read_only().channels().len(), 0);
953 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
954 // this is mostly for checking uint underflow issues before the fuzzer does
955 let update_result = rapid_sync.update_network_graph_no_std(&VALID_RGS_BINARY, Some(0));
956 assert!(update_result.is_ok());
957 assert_eq!(network_graph.read_only().channels().len(), 2);
961 fn prunes_after_update() {
962 // this is the timestamp encoded in the binary data of valid_input below
963 let logger = TestLogger::new();
965 let latest_nonpruning_time = VALID_BINARY_TIMESTAMP + 60 * 60 * 24 * 7;
968 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
969 assert_eq!(network_graph.read_only().channels().len(), 0);
971 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
972 let update_result = rapid_sync
973 .update_network_graph_no_std(&VALID_RGS_BINARY, Some(latest_nonpruning_time));
974 assert!(update_result.is_ok());
975 assert_eq!(network_graph.read_only().channels().len(), 2);
979 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
980 assert_eq!(network_graph.read_only().channels().len(), 0);
982 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
983 let update_result = rapid_sync
984 .update_network_graph_no_std(&VALID_RGS_BINARY, Some(latest_nonpruning_time + 1));
985 assert!(update_result.is_ok());
986 assert_eq!(network_graph.read_only().channels().len(), 0);
991 fn timestamp_edge_cases_are_handled_correctly() {
992 // this is the timestamp encoded in the binary data of valid_input below
993 let logger = TestLogger::new();
995 let latest_succeeding_time = VALID_BINARY_TIMESTAMP + STALE_RGS_UPDATE_AGE_LIMIT_SECS;
996 let earliest_failing_time = latest_succeeding_time + 1;
999 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
1000 assert_eq!(network_graph.read_only().channels().len(), 0);
1002 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
1003 let update_result = rapid_sync
1004 .update_network_graph_no_std(&VALID_RGS_BINARY, Some(latest_succeeding_time));
1005 assert!(update_result.is_ok());
1006 assert_eq!(network_graph.read_only().channels().len(), 0);
1010 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
1011 assert_eq!(network_graph.read_only().channels().len(), 0);
1013 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
1014 let update_result = rapid_sync
1015 .update_network_graph_no_std(&VALID_RGS_BINARY, Some(earliest_failing_time));
1016 assert!(update_result.is_err());
1017 if let Err(GraphSyncError::LightningError(lightning_error)) = update_result {
1019 lightning_error.err,
1020 "Rapid Gossip Sync data is more than two weeks old"
1023 panic!("Unexpected update result: {:?}", update_result)
1029 #[cfg(feature = "std")]
1030 pub fn update_fails_with_unknown_version() {
1031 let unknown_version_input = vec![
1032 76, 68, 75, 3, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
1033 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
1034 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
1035 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
1036 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
1037 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
1038 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
1039 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
1040 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
1041 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
1042 226, 0, 6, 11, 0, 1, 2, 3, 0, 0, 0, 4, 0, 40, 0, 0, 0, 0, 0, 0, 3, 232, 0, 0, 3, 232,
1043 0, 0, 0, 1, 0, 0, 0, 0, 29, 129, 25, 192, 255, 8, 153, 192, 0, 2, 27, 0, 0, 60, 0, 0,
1044 0, 0, 0, 0, 0, 1, 0, 0, 0, 100, 0, 0, 2, 224, 0, 0, 0, 0, 58, 85, 116, 216, 0, 29, 0,
1045 0, 0, 1, 0, 0, 0, 125, 0, 0, 0, 0, 58, 85, 116, 216, 255, 2, 68, 226, 0, 6, 11, 0, 1,
1049 let logger = TestLogger::new();
1050 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
1051 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
1052 let update_result = rapid_sync.update_network_graph(&unknown_version_input[..]);
1054 assert!(update_result.is_err());
1056 if let Err(GraphSyncError::DecodeError(DecodeError::UnknownVersion)) = update_result {
1057 // this is the expected error type
1059 panic!("Unexpected update result: {:?}", update_result)
1064 fn fails_early_on_chain_hash_mismatch() {
1065 let logger = TestLogger::new();
1066 // Set to testnet so that the VALID_RGS_BINARY chain hash of mainnet does not match.
1067 let network_graph = NetworkGraph::new(Network::Testnet, &logger);
1069 assert_eq!(network_graph.read_only().channels().len(), 0);
1071 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
1072 let update_result = rapid_sync.update_network_graph_no_std(&VALID_RGS_BINARY, Some(0));
1073 assert!(update_result.is_err());
1074 if let Err(GraphSyncError::LightningError(err)) = update_result {
1077 "Rapid Gossip Sync data's chain hash does not match the network graph's"
1080 panic!("Unexpected update result: {:?}", update_result)