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 message_flags: 1, // Only must_be_one
374 channel_flags: standard_channel_flags,
375 cltv_expiry_delta: default_cltv_expiry_delta,
376 htlc_minimum_msat: default_htlc_minimum_msat,
377 htlc_maximum_msat: default_htlc_maximum_msat,
378 fee_base_msat: default_fee_base_msat,
379 fee_proportional_millionths: default_fee_proportional_millionths,
380 excess_data: Vec::new(),
383 let mut skip_update_for_unknown_channel = false;
385 if (channel_flags & 0b_1000_0000) != 0 {
386 // incremental update, field flags will indicate mutated values
387 let read_only_network_graph = network_graph.read_only();
388 if let Some(directional_info) = read_only_network_graph
390 .get(&short_channel_id)
391 .and_then(|channel| channel.get_directional_info(channel_flags))
393 synthetic_update.cltv_expiry_delta = directional_info.cltv_expiry_delta;
394 synthetic_update.htlc_minimum_msat = directional_info.htlc_minimum_msat;
395 synthetic_update.htlc_maximum_msat = directional_info.htlc_maximum_msat;
396 synthetic_update.fee_base_msat = directional_info.fees.base_msat;
397 synthetic_update.fee_proportional_millionths =
398 directional_info.fees.proportional_millionths;
400 log_trace!(self.logger,
401 "Skipping application of channel update for chan {} with flags {} as original data is missing.",
402 short_channel_id, channel_flags);
403 skip_update_for_unknown_channel = true;
407 if channel_flags & 0b_0100_0000 > 0 {
408 let cltv_expiry_delta: u16 = Readable::read(read_cursor)?;
409 synthetic_update.cltv_expiry_delta = cltv_expiry_delta;
412 if channel_flags & 0b_0010_0000 > 0 {
413 let htlc_minimum_msat: u64 = Readable::read(read_cursor)?;
414 synthetic_update.htlc_minimum_msat = htlc_minimum_msat;
417 if channel_flags & 0b_0001_0000 > 0 {
418 let fee_base_msat: u32 = Readable::read(read_cursor)?;
419 synthetic_update.fee_base_msat = fee_base_msat;
422 if channel_flags & 0b_0000_1000 > 0 {
423 let fee_proportional_millionths: u32 = Readable::read(read_cursor)?;
424 synthetic_update.fee_proportional_millionths = fee_proportional_millionths;
427 if channel_flags & 0b_0000_0100 > 0 {
428 let htlc_maximum_msat: u64 = Readable::read(read_cursor)?;
429 synthetic_update.htlc_maximum_msat = htlc_maximum_msat;
432 if skip_update_for_unknown_channel {
438 "Updating channel {} with flags {} from RGS announcement at {}",
441 latest_seen_timestamp
443 match network_graph.update_channel_unsigned(&synthetic_update) {
445 Err(LightningError { action: ErrorAction::IgnoreDuplicateGossip, .. }) => {},
446 Err(LightningError { action: ErrorAction::IgnoreAndLog(level), err }) => {
450 "Failed to apply channel update: {:?}",
454 Err(LightningError { action: ErrorAction::IgnoreError, .. }) => {},
455 Err(e) => return Err(e.into()),
459 self.network_graph.set_last_rapid_gossip_sync_timestamp(latest_seen_timestamp);
461 if let Some(time) = current_time_unix {
462 self.network_graph.remove_stale_channels_and_tracking_with_time(time)
465 self.is_initial_sync_complete.store(true, Ordering::Release);
466 log_trace!(self.logger, "Done processing RGS data from {}", latest_seen_timestamp);
467 Ok(latest_seen_timestamp)
473 use bitcoin::Network;
475 #[cfg(feature = "std")]
476 use lightning::ln::msgs::DecodeError;
478 use lightning::routing::gossip::{NetworkGraph, NodeId};
479 use lightning::util::logger::Level;
480 use lightning::util::test_utils::TestLogger;
482 use crate::processing::STALE_RGS_UPDATE_AGE_LIMIT_SECS;
483 use crate::{GraphSyncError, RapidGossipSync};
485 const VALID_RGS_BINARY: [u8; 300] = [
486 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247, 79,
487 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218, 0, 0, 0,
488 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251, 187, 172, 38,
489 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125, 157, 176, 223,
490 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136, 88, 216, 115, 11,
491 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106, 204, 131, 186, 35,
492 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138, 181, 64, 187, 103, 127,
493 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175, 110, 32, 237, 0, 217, 90,
494 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128, 76, 97, 0, 0, 0, 2, 0, 0, 255,
495 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,
496 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,
497 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,
498 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,
499 216, 255, 2, 68, 226, 0, 6, 11, 0, 1, 0, 0, 1,
501 const VALID_BINARY_TIMESTAMP: u64 = 1642291930;
504 #[cfg(feature = "std")]
505 fn network_graph_fails_to_update_from_clipped_input() {
506 let logger = TestLogger::new();
507 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
509 let example_input = vec![
510 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
511 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
512 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
513 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
514 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
515 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
516 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
517 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
518 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
519 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
520 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,
521 0, 0, 2, 224, 0, 0, 0, 0, 29, 129, 25, 192, 255, 8, 153, 192, 0, 2, 27, 0, 0, 36, 0, 0,
522 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,
525 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
526 let update_result = rapid_sync.update_network_graph(&example_input[..]);
527 assert!(update_result.is_err());
528 if let Err(GraphSyncError::DecodeError(DecodeError::ShortRead)) = update_result {
529 // this is the expected error type
531 panic!("Unexpected update result: {:?}", update_result)
536 fn node_data_update_succeeds_with_v2() {
537 let mut logger = TestLogger::new();
538 logger.enable(Level::Gossip);
539 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
541 let example_input = vec![
542 76, 68, 75, 2, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
543 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 102, 97, 206, 240,
544 0, 0, 0, 0, 2, 63, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213, 170, 186, 5,
545 101, 215, 30, 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7, 143, 5, 38, 4,
546 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,
547 1, 1, 1, 0, 2, 3, 0, 4, 7, 1, 127, 0, 0, 1, 37, 163, 14, 5, 10, 103, 111, 111, 103,
548 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,
549 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,
550 209, 54, 16, 50, 202, 155, 210, 174, 185, 217, 0, 170, 77, 69, 217, 234, 216, 10, 201,
551 66, 51, 116, 196, 81, 167, 37, 77, 7, 102, 0, 0, 2, 25, 48, 0, 0, 0, 1, 0, 0, 1, 0, 1,
552 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,
556 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
557 let update_result = rapid_sync.update_network_graph_no_std(&example_input[..], None);
558 assert!(update_result.is_ok());
560 let read_only_graph = network_graph.read_only();
561 let nodes = read_only_graph.nodes();
562 assert_eq!(nodes.len(), 2);
566 let node_id = NodeId::from_slice(&[
567 3, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213, 170, 186, 5, 101, 215, 30,
568 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7, 143,
571 let node = nodes.get(&node_id).unwrap();
572 let announcement_info = node.announcement_info.as_ref().unwrap();
573 let addresses = announcement_info.addresses();
574 assert_eq!(addresses.len(), 5);
579 let node_id = NodeId::from_slice(&[
580 2, 77, 75, 108, 209, 54, 16, 50, 202, 155, 210, 174, 185, 217, 0, 170, 77, 69, 217,
581 234, 216, 10, 201, 66, 51, 116, 196, 81, 167, 37, 77, 7, 102,
584 let node = nodes.get(&node_id).unwrap();
585 let announcement_info = node.announcement_info.as_ref().unwrap();
586 let features = announcement_info.features();
587 println!("features: {}", features);
588 // assert_eq!(addresses.len(), 5);
591 logger.assert_log_contains(
592 "lightning_rapid_gossip_sync::processing",
593 "Failed to apply node announcement",
599 fn node_date_update_succeeds_without_channels() {
600 let mut logger = TestLogger::new();
601 logger.enable(Level::Gossip);
602 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
603 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
605 let example_input = vec![
606 76, 68, 75, 2, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
607 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 102, 105, 183,
608 240, 0, 0, 0, 0, 1, 63, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213, 170, 186,
609 5, 101, 215, 30, 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7, 143, 5, 13,
610 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,
611 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,
612 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,
613 10, 103, 111, 111, 103, 108, 101, 46, 99, 111, 109, 1, 187, 0, 2, 23, 48, 0, 0, 0, 0,
617 let update_result = rapid_sync.update_network_graph_no_std(&example_input[..], None);
618 assert!(update_result.is_ok());
620 logger.assert_log_contains(
621 "lightning_rapid_gossip_sync::processing",
622 "Failed to apply node announcement: \"No existing channels for node_announcement\"",
628 fn update_ignores_v2_additional_data() {
629 let mut logger = TestLogger::new();
630 logger.enable(Level::Gossip);
631 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
632 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
634 let example_input = vec![
635 76, 68, 75, 2, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
636 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 102, 106, 12, 80,
637 1, 0, 2, 23, 48, 0, 0, 0, 3, 143, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213,
638 170, 186, 5, 101, 215, 30, 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7,
639 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,
640 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,
641 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,
642 14, 5, 10, 103, 111, 111, 103, 108, 101, 46, 99, 111, 109, 1, 187, 0, 255, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
651 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,
652 50, 202, 155, 210, 174, 185, 217, 0, 170, 77, 69, 217, 234, 216, 10, 201, 66, 51, 116,
653 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,
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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
662 0, 0, 0, 0, 0, 0, 0, 186, 83, 31, 230, 6, 129, 52, 80, 61, 39, 35, 19, 50, 39, 200,
663 103, 172, 143, 166, 200, 60, 83, 126, 154, 68, 195, 197, 189, 189, 203, 31, 227, 55, 0,
664 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,
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, 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,
673 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,
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, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
680 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,
681 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,
682 42, 42, 42, 42, 42, 42, 42, 42, 42, 42, 0, 1, 0, 1, 0, 17, 42, 42, 42, 42, 42, 42, 42,
683 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
686 let update_result = rapid_sync.update_network_graph_no_std(&example_input[..], None);
687 assert!(update_result.is_ok());
689 logger.assert_log_contains(
690 "lightning_rapid_gossip_sync::processing",
691 "Ignoring 255 bytes of additional data in node announcement",
694 logger.assert_log_contains(
695 "lightning_rapid_gossip_sync::processing",
696 "Ignoring 147 bytes of additional data in channel announcement",
699 logger.assert_log_contains(
700 "lightning_rapid_gossip_sync::processing",
701 "Ignoring 17 bytes of additional data in channel update",
707 #[cfg(feature = "std")]
708 fn incremental_only_update_ignores_missing_channel() {
709 let incremental_update_input = vec![
710 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
711 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
712 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,
713 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,
714 68, 226, 0, 6, 11, 0, 1, 128,
717 let logger = TestLogger::new();
718 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
720 assert_eq!(network_graph.read_only().channels().len(), 0);
722 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
723 let update_result = rapid_sync.update_network_graph(&incremental_update_input[..]);
724 assert!(update_result.is_ok());
728 #[cfg(feature = "std")]
729 fn incremental_only_update_fails_without_prior_updates() {
730 let announced_update_input = vec![
731 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
732 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
733 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
734 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
735 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
736 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
737 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
738 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
739 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
740 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
741 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,
742 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,
743 2, 68, 226, 0, 6, 11, 0, 1, 128,
746 let logger = TestLogger::new();
747 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
749 assert_eq!(network_graph.read_only().channels().len(), 0);
751 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
752 rapid_sync.update_network_graph(&announced_update_input[..]).unwrap();
756 #[cfg(feature = "std")]
757 fn incremental_only_update_fails_without_prior_same_direction_updates() {
758 let initialization_input = vec![
759 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
760 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
761 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
762 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
763 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
764 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
765 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
766 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
767 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
768 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
769 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,
770 0, 0, 0, 1, 0, 0, 0, 0, 58, 85, 116, 216, 255, 8, 153, 192, 0, 2, 27, 0, 0, 25, 0, 0,
771 0, 1, 0, 0, 0, 125, 255, 2, 68, 226, 0, 6, 11, 0, 1, 5, 0, 0, 0, 0, 29, 129, 25, 192,
774 let logger = TestLogger::new();
775 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
777 assert_eq!(network_graph.read_only().channels().len(), 0);
779 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
780 let initialization_result = rapid_sync.update_network_graph(&initialization_input[..]);
781 if initialization_result.is_err() {
782 panic!("Unexpected initialization result: {:?}", initialization_result)
785 assert_eq!(network_graph.read_only().channels().len(), 2);
786 let initialized = network_graph.to_string();
788 .contains("021607cfce19a4c5e7e6e738663dfafbbbac262e4ff76c2c9b30dbeefc35c00643"));
790 .contains("02247d9db0dfafea745ef8c9e161eb322f73ac3f8858d8730b6fd97254747ce76b"));
792 .contains("029e01f279986acc83ba235d46d80aede0b7595f410353b93a8ab540bb677f4432"));
794 .contains("02c913118a8895b9e29c89af6e20ed00d95a1f64e4952edbafa84d048f26804c61"));
795 assert!(initialized.contains("619737530008010752"));
796 assert!(initialized.contains("783241506229452801"));
798 let opposite_direction_incremental_update_input = vec![
799 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
800 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
801 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,
802 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,
803 68, 226, 0, 6, 11, 0, 1, 128,
805 rapid_sync.update_network_graph(&opposite_direction_incremental_update_input[..]).unwrap();
809 #[cfg(feature = "std")]
810 fn incremental_update_succeeds_with_prior_announcements_and_full_updates() {
811 let initialization_input = vec![
812 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
813 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
814 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
815 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
816 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
817 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
818 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
819 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
820 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
821 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
822 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,
823 0, 0, 0, 1, 0, 0, 0, 0, 58, 85, 116, 216, 255, 8, 153, 192, 0, 2, 27, 0, 0, 56, 0, 0,
824 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,
825 68, 226, 0, 6, 11, 0, 1, 4, 0, 0, 0, 0, 29, 129, 25, 192, 0, 5, 0, 0, 0, 0, 29, 129,
829 let logger = TestLogger::new();
830 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
832 assert_eq!(network_graph.read_only().channels().len(), 0);
834 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
835 let initialization_result = rapid_sync.update_network_graph(&initialization_input[..]);
836 assert!(initialization_result.is_ok());
838 let single_direction_incremental_update_input = vec![
839 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
840 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
841 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,
842 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,
843 68, 226, 0, 6, 11, 0, 1, 128,
846 rapid_sync.update_network_graph(&single_direction_incremental_update_input[..]);
847 if update_result.is_err() {
848 panic!("Unexpected update result: {:?}", update_result)
851 assert_eq!(network_graph.read_only().channels().len(), 2);
852 let after = network_graph.to_string();
854 after.contains("021607cfce19a4c5e7e6e738663dfafbbbac262e4ff76c2c9b30dbeefc35c00643")
857 after.contains("02247d9db0dfafea745ef8c9e161eb322f73ac3f8858d8730b6fd97254747ce76b")
860 after.contains("029e01f279986acc83ba235d46d80aede0b7595f410353b93a8ab540bb677f4432")
863 after.contains("02c913118a8895b9e29c89af6e20ed00d95a1f64e4952edbafa84d048f26804c61")
865 assert!(after.contains("619737530008010752"));
866 assert!(after.contains("783241506229452801"));
870 #[cfg(feature = "std")]
871 fn update_succeeds_when_duplicate_gossip_is_applied() {
872 let initialization_input = vec![
873 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
874 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
875 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
876 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
877 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
878 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
879 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
880 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
881 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
882 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
883 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,
884 0, 0, 0, 1, 0, 0, 0, 0, 58, 85, 116, 216, 255, 8, 153, 192, 0, 2, 27, 0, 0, 56, 0, 0,
885 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,
886 68, 226, 0, 6, 11, 0, 1, 4, 0, 0, 0, 0, 29, 129, 25, 192, 0, 5, 0, 0, 0, 0, 29, 129,
890 let logger = TestLogger::new();
891 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
893 assert_eq!(network_graph.read_only().channels().len(), 0);
895 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
896 let initialization_result = rapid_sync.update_network_graph(&initialization_input[..]);
897 assert!(initialization_result.is_ok());
899 let single_direction_incremental_update_input = vec![
900 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
901 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
902 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,
903 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,
904 68, 226, 0, 6, 11, 0, 1, 128,
906 let update_result_1 =
907 rapid_sync.update_network_graph(&single_direction_incremental_update_input[..]);
908 // Apply duplicate update
909 let update_result_2 =
910 rapid_sync.update_network_graph(&single_direction_incremental_update_input[..]);
911 assert!(update_result_1.is_ok());
912 assert!(update_result_2.is_ok());
916 #[cfg(feature = "std")]
917 fn full_update_succeeds() {
918 let logger = TestLogger::new();
919 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
921 assert_eq!(network_graph.read_only().channels().len(), 0);
923 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
924 let update_result = rapid_sync.update_network_graph(&VALID_RGS_BINARY);
925 if update_result.is_err() {
926 panic!("Unexpected update result: {:?}", update_result)
929 assert_eq!(network_graph.read_only().channels().len(), 2);
930 let after = network_graph.to_string();
932 after.contains("021607cfce19a4c5e7e6e738663dfafbbbac262e4ff76c2c9b30dbeefc35c00643")
935 after.contains("02247d9db0dfafea745ef8c9e161eb322f73ac3f8858d8730b6fd97254747ce76b")
938 after.contains("029e01f279986acc83ba235d46d80aede0b7595f410353b93a8ab540bb677f4432")
941 after.contains("02c913118a8895b9e29c89af6e20ed00d95a1f64e4952edbafa84d048f26804c61")
943 assert!(after.contains("619737530008010752"));
944 assert!(after.contains("783241506229452801"));
948 fn full_update_succeeds_at_the_beginning_of_the_unix_era() {
949 let logger = TestLogger::new();
950 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
952 assert_eq!(network_graph.read_only().channels().len(), 0);
954 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
955 // this is mostly for checking uint underflow issues before the fuzzer does
956 let update_result = rapid_sync.update_network_graph_no_std(&VALID_RGS_BINARY, Some(0));
957 assert!(update_result.is_ok());
958 assert_eq!(network_graph.read_only().channels().len(), 2);
962 fn prunes_after_update() {
963 // this is the timestamp encoded in the binary data of valid_input below
964 let logger = TestLogger::new();
966 let latest_nonpruning_time = VALID_BINARY_TIMESTAMP + 60 * 60 * 24 * 7;
969 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
970 assert_eq!(network_graph.read_only().channels().len(), 0);
972 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
973 let update_result = rapid_sync
974 .update_network_graph_no_std(&VALID_RGS_BINARY, Some(latest_nonpruning_time));
975 assert!(update_result.is_ok());
976 assert_eq!(network_graph.read_only().channels().len(), 2);
980 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
981 assert_eq!(network_graph.read_only().channels().len(), 0);
983 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
984 let update_result = rapid_sync
985 .update_network_graph_no_std(&VALID_RGS_BINARY, Some(latest_nonpruning_time + 1));
986 assert!(update_result.is_ok());
987 assert_eq!(network_graph.read_only().channels().len(), 0);
992 fn timestamp_edge_cases_are_handled_correctly() {
993 // this is the timestamp encoded in the binary data of valid_input below
994 let logger = TestLogger::new();
996 let latest_succeeding_time = VALID_BINARY_TIMESTAMP + STALE_RGS_UPDATE_AGE_LIMIT_SECS;
997 let earliest_failing_time = latest_succeeding_time + 1;
1000 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
1001 assert_eq!(network_graph.read_only().channels().len(), 0);
1003 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
1004 let update_result = rapid_sync
1005 .update_network_graph_no_std(&VALID_RGS_BINARY, Some(latest_succeeding_time));
1006 assert!(update_result.is_ok());
1007 assert_eq!(network_graph.read_only().channels().len(), 0);
1011 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
1012 assert_eq!(network_graph.read_only().channels().len(), 0);
1014 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
1015 let update_result = rapid_sync
1016 .update_network_graph_no_std(&VALID_RGS_BINARY, Some(earliest_failing_time));
1017 assert!(update_result.is_err());
1018 if let Err(GraphSyncError::LightningError(lightning_error)) = update_result {
1020 lightning_error.err,
1021 "Rapid Gossip Sync data is more than two weeks old"
1024 panic!("Unexpected update result: {:?}", update_result)
1030 #[cfg(feature = "std")]
1031 pub fn update_fails_with_unknown_version() {
1032 let unknown_version_input = vec![
1033 76, 68, 75, 3, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
1034 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
1035 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
1036 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
1037 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
1038 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
1039 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
1040 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
1041 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
1042 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
1043 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,
1044 0, 0, 0, 1, 0, 0, 0, 0, 29, 129, 25, 192, 255, 8, 153, 192, 0, 2, 27, 0, 0, 60, 0, 0,
1045 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,
1046 0, 0, 1, 0, 0, 0, 125, 0, 0, 0, 0, 58, 85, 116, 216, 255, 2, 68, 226, 0, 6, 11, 0, 1,
1050 let logger = TestLogger::new();
1051 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
1052 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
1053 let update_result = rapid_sync.update_network_graph(&unknown_version_input[..]);
1055 assert!(update_result.is_err());
1057 if let Err(GraphSyncError::DecodeError(DecodeError::UnknownVersion)) = update_result {
1058 // this is the expected error type
1060 panic!("Unexpected update result: {:?}", update_result)
1065 fn fails_early_on_chain_hash_mismatch() {
1066 let logger = TestLogger::new();
1067 // Set to testnet so that the VALID_RGS_BINARY chain hash of mainnet does not match.
1068 let network_graph = NetworkGraph::new(Network::Testnet, &logger);
1070 assert_eq!(network_graph.read_only().channels().len(), 0);
1072 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
1073 let update_result = rapid_sync.update_network_graph_no_std(&VALID_RGS_BINARY, Some(0));
1074 assert!(update_result.is_err());
1075 if let Err(GraphSyncError::LightningError(err)) = update_result {
1078 "Rapid Gossip Sync data's chain hash does not match the network graph's"
1081 panic!("Unexpected update result: {:?}", update_result)