3 use core::sync::atomic::Ordering;
5 use bitcoin::blockdata::constants::ChainHash;
6 use bitcoin::secp256k1::PublicKey;
8 use lightning::ln::msgs::{DecodeError, ErrorAction, LightningError, SocketAddress, UnsignedChannelUpdate, UnsignedNodeAnnouncement};
9 use lightning::routing::gossip::{NetworkGraph, NodeAlias, NodeId};
10 use lightning::util::logger::Logger;
11 use lightning::{log_debug, log_warn, log_trace, log_given_level, log_gossip};
12 use lightning::util::ser::{BigSize, FixedLengthReader, Readable};
15 use crate::{GraphSyncError, RapidGossipSync};
17 #[cfg(all(feature = "std", not(test)))]
18 use std::time::{SystemTime, UNIX_EPOCH};
20 #[cfg(all(not(feature = "std"), not(test)))]
21 use alloc::{vec::Vec, borrow::ToOwned};
22 use lightning::ln::features::NodeFeatures;
24 /// The purpose of this prefix is to identify the serialization format, should other rapid gossip
25 /// sync formats arise in the future.
27 /// The fourth byte is the protocol version in case our format gets updated.
28 const GOSSIP_PREFIX: [u8; 3] = [76, 68, 75];
30 /// Maximum vector allocation capacity for distinct node IDs. This constraint is necessary to
31 /// avoid malicious updates being able to trigger excessive memory allocation.
32 const MAX_INITIAL_NODE_ID_VECTOR_CAPACITY: u32 = 50_000;
34 /// We disallow gossip data that's more than two weeks old, per BOLT 7's
36 const STALE_RGS_UPDATE_AGE_LIMIT_SECS: u64 = 60 * 60 * 24 * 14;
38 impl<NG: Deref<Target=NetworkGraph<L>>, L: Deref> RapidGossipSync<NG, L> where L::Target: Logger {
39 #[cfg(feature = "std")]
40 pub(crate) fn update_network_graph_from_byte_stream<R: io::Read>(
43 ) -> Result<u32, GraphSyncError> {
44 #[allow(unused_mut, unused_assignments)]
45 let mut current_time_unix = None;
48 // Note that many tests rely on being able to set arbitrarily old timestamps, thus we
49 // disable this check during tests!
50 current_time_unix = Some(SystemTime::now().duration_since(UNIX_EPOCH).expect("Time must be > 1970").as_secs());
52 self.update_network_graph_from_byte_stream_no_std(read_cursor, current_time_unix)
55 pub(crate) fn update_network_graph_from_byte_stream_no_std<R: io::Read>(
57 mut read_cursor: &mut R,
58 current_time_unix: Option<u64>
59 ) -> Result<u32, GraphSyncError> {
60 log_trace!(self.logger, "Processing RGS data...");
61 let mut protocol_prefix = [0u8; 3];
63 read_cursor.read_exact(&mut protocol_prefix)?;
64 if protocol_prefix != GOSSIP_PREFIX {
65 return Err(DecodeError::UnknownVersion.into());
68 let version: u8 = Readable::read(&mut read_cursor)?;
69 if version != 1 && version != 2 {
70 return Err(DecodeError::UnknownVersion.into());
73 let parse_node_details = version == 2;
75 let chain_hash: ChainHash = Readable::read(read_cursor)?;
76 let ng_chain_hash = self.network_graph.get_chain_hash();
77 if chain_hash != ng_chain_hash {
80 err: "Rapid Gossip Sync data's chain hash does not match the network graph's".to_owned(),
81 action: ErrorAction::IgnoreError,
86 let latest_seen_timestamp: u32 = Readable::read(read_cursor)?;
88 if let Some(time) = current_time_unix {
89 if (latest_seen_timestamp as u64) < time.saturating_sub(STALE_RGS_UPDATE_AGE_LIMIT_SECS) {
90 return Err(LightningError{err: "Rapid Gossip Sync data is more than two weeks old".to_owned(), action: ErrorAction::IgnoreError}.into());
94 // backdate the applied timestamp by a week
95 let backdated_timestamp = latest_seen_timestamp.saturating_sub(24 * 3600 * 7);
97 let mut default_node_features = Vec::new();
98 if parse_node_details {
99 let default_feature_count: u8 = Readable::read(read_cursor)?;
100 for _ in 0..default_feature_count {
101 let current_default_feature: NodeFeatures = Readable::read(read_cursor)?;
102 default_node_features.push(current_default_feature);
106 let node_id_count: u32 = Readable::read(read_cursor)?;
107 let mut node_ids: Vec<PublicKey> = Vec::with_capacity(core::cmp::min(
109 MAX_INITIAL_NODE_ID_VECTOR_CAPACITY,
112 let network_graph = &self.network_graph;
113 let mut node_modifications: Vec<UnsignedNodeAnnouncement> = Vec::new();
115 if parse_node_details {
116 let read_only_network_graph = network_graph.read_only();
117 for _ in 0..node_id_count {
118 let mut pubkey_bytes = [0u8; 33];
119 read_cursor.read_exact(&mut pubkey_bytes)?;
122 We encode additional information in the pubkey parity byte with the following mapping:
124 7: expect extra data after the pubkey
125 6: use this as a reminder without altering anything
126 5-3: index of new features among default (1-6). If index is 7 (all 3 bits are set, it's
127 outside the present default range). 0 means no feature changes.
128 2: addresses have changed
133 let node_detail_flag = pubkey_bytes.first().ok_or(DecodeError::ShortRead)?;
135 let has_address_details = (node_detail_flag & (1 << 2)) > 0;
136 let feature_detail_marker = (node_detail_flag & (0b111 << 3)) >> 3;
137 let is_reminder = (node_detail_flag & (1 << 6)) > 0;
138 let has_additional_data = (node_detail_flag & (1 << 7)) > 0;
140 // extract the relevant bits for pubkey parity
141 let key_parity = node_detail_flag & 0b_0000_0011;
142 pubkey_bytes[0] = key_parity;
144 let current_pubkey = PublicKey::from_slice(&pubkey_bytes)?;
145 let current_node_id = NodeId::from_pubkey(¤t_pubkey);
146 node_ids.push(current_pubkey);
148 if is_reminder || has_address_details || feature_detail_marker > 0 {
149 let mut synthetic_node_announcement = UnsignedNodeAnnouncement {
150 features: NodeFeatures::empty(),
151 timestamp: backdated_timestamp,
152 node_id: current_node_id,
154 alias: NodeAlias([0u8; 32]),
155 addresses: Vec::new(),
156 excess_address_data: Vec::new(),
157 excess_data: Vec::new(),
160 read_only_network_graph.nodes()
161 .get(¤t_node_id)
162 .and_then(|node| node.announcement_info.as_ref())
164 synthetic_node_announcement.features = info.features().clone();
165 synthetic_node_announcement.rgb = info.rgb().clone();
166 synthetic_node_announcement.alias = info.alias().clone();
167 synthetic_node_announcement.addresses = info.addresses().clone();
170 if has_address_details {
171 let address_count: u8 = Readable::read(read_cursor)?;
172 let mut node_addresses: Vec<SocketAddress> = Vec::new();
173 for address_index in 0..address_count {
174 let current_byte_count: u8 = Readable::read(read_cursor)?;
175 let mut address_reader = FixedLengthReader::new(&mut read_cursor, current_byte_count as u64);
176 if let Ok(current_address) = Readable::read(&mut address_reader) {
177 node_addresses.push(current_address);
178 if address_reader.bytes_remain() {
179 return Err(DecodeError::ShortRead.into());
182 // Do not crash to allow future socket address forwards compatibility
185 "Failure to parse address at index {} for node ID {}",
186 address_index, current_node_id
188 address_reader.eat_remaining()?;
191 synthetic_node_announcement.addresses = node_addresses;
194 if feature_detail_marker > 0 {
195 if feature_detail_marker < 7 {
196 let feature_index = (feature_detail_marker - 1) as usize;
197 synthetic_node_announcement.features = default_node_features
199 .ok_or(DecodeError::InvalidValue)?
202 let node_features: NodeFeatures = Readable::read(read_cursor)?;
203 synthetic_node_announcement.features = node_features;
207 node_modifications.push(synthetic_node_announcement);
210 if has_additional_data {
211 let additional_data: Vec<u8> = Readable::read(read_cursor)?;
212 log_gossip!(self.logger, "Ignoring {} bytes of additional data in node announcement", additional_data.len());
216 for _ in 0..node_id_count {
217 let current_node_id = Readable::read(read_cursor)?;
218 node_ids.push(current_node_id);
222 let mut previous_scid: u64 = 0;
223 let announcement_count: u32 = Readable::read(read_cursor)?;
224 for _ in 0..announcement_count {
225 let features = Readable::read(read_cursor)?;
228 let scid_delta: BigSize = Readable::read(read_cursor)?;
229 let short_channel_id = previous_scid
230 .checked_add(scid_delta.0)
231 .ok_or(DecodeError::InvalidValue)?;
232 previous_scid = short_channel_id;
234 let node_id_1_index: BigSize = Readable::read(read_cursor)?;
235 let mut node_id_2_index: BigSize = Readable::read(read_cursor)?;
236 let has_additional_data = (node_id_2_index.0 & (1 << 63)) > 0;
237 node_id_2_index.0 &= !(1 << 63); // ensure 63rd bit isn't set
239 if max(node_id_1_index.0, node_id_2_index.0) >= node_id_count as u64 {
240 return Err(DecodeError::InvalidValue.into());
242 let node_id_1 = node_ids[node_id_1_index.0 as usize];
243 let node_id_2 = node_ids[node_id_2_index.0 as usize];
245 log_gossip!(self.logger, "Adding channel {} from RGS announcement at {}",
246 short_channel_id, latest_seen_timestamp);
248 let announcement_result = network_graph.add_channel_from_partial_announcement(
250 backdated_timestamp as u64,
255 if let Err(lightning_error) = announcement_result {
256 if let ErrorAction::IgnoreDuplicateGossip = lightning_error.action {
257 // everything is fine, just a duplicate channel announcement
259 log_warn!(self.logger, "Failed to process channel announcement: {:?}", lightning_error);
260 return Err(lightning_error.into());
264 if version >= 2 && has_additional_data {
265 // forwards compatibility
266 let additional_data: Vec<u8> = Readable::read(read_cursor)?;
267 log_gossip!(self.logger, "Ignoring {} bytes of additional data in channel announcement", additional_data.len());
271 for modification in node_modifications {
272 match network_graph.update_node_from_unsigned_announcement(&modification) {
274 Err(LightningError { action: ErrorAction::IgnoreDuplicateGossip, .. }) => {}
275 Err(LightningError { action: ErrorAction::IgnoreAndLog(level), err }) => {
276 log_given_level!(self.logger, level, "Failed to apply node announcement: {:?}", err);
278 Err(LightningError { action: ErrorAction::IgnoreError, err }) => {
279 log_gossip!(self.logger, "Failed to apply node announcement: {:?}", err);
281 Err(e) => return Err(e.into()),
285 previous_scid = 0; // updates start at a new scid
287 let update_count: u32 = Readable::read(read_cursor)?;
288 log_debug!(self.logger, "Processing RGS update from {} with {} nodes, {} channel announcements and {} channel updates.",
289 latest_seen_timestamp, node_id_count, announcement_count, update_count);
290 if update_count == 0 {
291 return Ok(latest_seen_timestamp);
294 // obtain default values for non-incremental updates
295 let default_cltv_expiry_delta: u16 = Readable::read(&mut read_cursor)?;
296 let default_htlc_minimum_msat: u64 = Readable::read(&mut read_cursor)?;
297 let default_fee_base_msat: u32 = Readable::read(&mut read_cursor)?;
298 let default_fee_proportional_millionths: u32 = Readable::read(&mut read_cursor)?;
299 let default_htlc_maximum_msat: u64 = Readable::read(&mut read_cursor)?;
301 let mut previous_channel_direction = None;
303 for _ in 0..update_count {
304 let scid_delta: BigSize = Readable::read(read_cursor)?;
305 let short_channel_id = previous_scid
306 .checked_add(scid_delta.0)
307 .ok_or(DecodeError::InvalidValue)?;
308 previous_scid = short_channel_id;
310 let channel_flags: u8 = Readable::read(read_cursor)?;
313 let direction = (channel_flags & 1) == 1;
314 let is_same_direction_update = Some(direction) == previous_channel_direction;
315 previous_channel_direction = Some(direction);
317 if scid_delta.0 == 0 && is_same_direction_update {
318 // this is additional data for forwards compatibility
319 let additional_data: Vec<u8> = Readable::read(read_cursor)?;
320 log_gossip!(self.logger, "Ignoring {} bytes of additional data in channel update", additional_data.len());
325 // flags are always sent in full, and hence always need updating
326 let standard_channel_flags = channel_flags & 0b_0000_0011;
328 let mut synthetic_update = UnsignedChannelUpdate {
331 timestamp: backdated_timestamp,
332 flags: standard_channel_flags,
333 cltv_expiry_delta: default_cltv_expiry_delta,
334 htlc_minimum_msat: default_htlc_minimum_msat,
335 htlc_maximum_msat: default_htlc_maximum_msat,
336 fee_base_msat: default_fee_base_msat,
337 fee_proportional_millionths: default_fee_proportional_millionths,
338 excess_data: Vec::new(),
341 let mut skip_update_for_unknown_channel = false;
343 if (channel_flags & 0b_1000_0000) != 0 {
344 // incremental update, field flags will indicate mutated values
345 let read_only_network_graph = network_graph.read_only();
346 if let Some(directional_info) =
347 read_only_network_graph.channels().get(&short_channel_id)
348 .and_then(|channel| channel.get_directional_info(channel_flags))
350 synthetic_update.cltv_expiry_delta = directional_info.cltv_expiry_delta;
351 synthetic_update.htlc_minimum_msat = directional_info.htlc_minimum_msat;
352 synthetic_update.htlc_maximum_msat = directional_info.htlc_maximum_msat;
353 synthetic_update.fee_base_msat = directional_info.fees.base_msat;
354 synthetic_update.fee_proportional_millionths = directional_info.fees.proportional_millionths;
356 log_trace!(self.logger,
357 "Skipping application of channel update for chan {} with flags {} as original data is missing.",
358 short_channel_id, channel_flags);
359 skip_update_for_unknown_channel = true;
363 if channel_flags & 0b_0100_0000 > 0 {
364 let cltv_expiry_delta: u16 = Readable::read(read_cursor)?;
365 synthetic_update.cltv_expiry_delta = cltv_expiry_delta;
368 if channel_flags & 0b_0010_0000 > 0 {
369 let htlc_minimum_msat: u64 = Readable::read(read_cursor)?;
370 synthetic_update.htlc_minimum_msat = htlc_minimum_msat;
373 if channel_flags & 0b_0001_0000 > 0 {
374 let fee_base_msat: u32 = Readable::read(read_cursor)?;
375 synthetic_update.fee_base_msat = fee_base_msat;
378 if channel_flags & 0b_0000_1000 > 0 {
379 let fee_proportional_millionths: u32 = Readable::read(read_cursor)?;
380 synthetic_update.fee_proportional_millionths = fee_proportional_millionths;
383 if channel_flags & 0b_0000_0100 > 0 {
384 let htlc_maximum_msat: u64 = Readable::read(read_cursor)?;
385 synthetic_update.htlc_maximum_msat = htlc_maximum_msat;
388 if skip_update_for_unknown_channel {
392 log_gossip!(self.logger, "Updating channel {} with flags {} from RGS announcement at {}",
393 short_channel_id, channel_flags, latest_seen_timestamp);
394 match network_graph.update_channel_unsigned(&synthetic_update) {
396 Err(LightningError { action: ErrorAction::IgnoreDuplicateGossip, .. }) => {},
397 Err(LightningError { action: ErrorAction::IgnoreAndLog(level), err }) => {
398 log_given_level!(self.logger, level, "Failed to apply channel update: {:?}", err);
400 Err(LightningError { action: ErrorAction::IgnoreError, .. }) => {},
401 Err(e) => return Err(e.into()),
405 self.network_graph.set_last_rapid_gossip_sync_timestamp(latest_seen_timestamp);
407 if let Some(time) = current_time_unix {
408 self.network_graph.remove_stale_channels_and_tracking_with_time(time)
411 self.is_initial_sync_complete.store(true, Ordering::Release);
412 log_trace!(self.logger, "Done processing RGS data from {}", latest_seen_timestamp);
413 Ok(latest_seen_timestamp)
419 use bitcoin::Network;
421 #[cfg(feature = "std")]
422 use lightning::ln::msgs::DecodeError;
424 use lightning::routing::gossip::{NetworkGraph, NodeId};
425 use lightning::util::logger::Level;
426 use lightning::util::test_utils::TestLogger;
428 use crate::processing::STALE_RGS_UPDATE_AGE_LIMIT_SECS;
429 use crate::{GraphSyncError, RapidGossipSync};
431 const VALID_RGS_BINARY: [u8; 300] = [
432 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
433 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
434 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
435 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
436 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
437 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
438 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
439 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
440 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
441 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
442 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,
443 0, 0, 0, 1, 0, 0, 0, 0, 29, 129, 25, 192, 255, 8, 153, 192, 0, 2, 27, 0, 0, 60, 0, 0,
444 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,
445 0, 0, 1, 0, 0, 0, 125, 0, 0, 0, 0, 58, 85, 116, 216, 255, 2, 68, 226, 0, 6, 11, 0, 1,
448 const VALID_BINARY_TIMESTAMP: u64 = 1642291930;
451 #[cfg(feature = "std")]
452 fn network_graph_fails_to_update_from_clipped_input() {
453 let logger = TestLogger::new();
454 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
456 let example_input = vec![
457 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
458 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
459 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
460 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
461 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
462 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
463 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
464 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
465 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
466 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
467 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,
468 0, 0, 2, 224, 0, 0, 0, 0, 29, 129, 25, 192, 255, 8, 153, 192, 0, 2, 27, 0, 0, 36, 0, 0,
469 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,
472 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
473 let update_result = rapid_sync.update_network_graph(&example_input[..]);
474 assert!(update_result.is_err());
475 if let Err(GraphSyncError::DecodeError(DecodeError::ShortRead)) = update_result {
476 // this is the expected error type
478 panic!("Unexpected update result: {:?}", update_result)
483 fn node_data_update_succeeds_with_v2() {
484 let mut logger = TestLogger::new();
485 logger.enable(Level::Gossip);
486 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
488 let example_input = vec![
489 76, 68, 75, 2, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
490 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 102, 97, 206, 240,
491 0, 0, 0, 0, 2, 63, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213, 170, 186, 5,
492 101, 215, 30, 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7, 143, 5, 38, 4, 1,
493 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,
494 1, 1, 0, 2, 3, 0, 4, 7, 1, 127, 0, 0, 1, 37, 163, 14, 5, 10, 103, 111, 111, 103, 108,
495 101, 46, 99, 111, 109, 1, 187, 19, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5,
496 57, 13, 3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 0, 2, 23, 48, 62, 77, 75, 108, 209,
497 54, 16, 50, 202, 155, 210, 174, 185, 217, 0, 170, 77, 69, 217, 234, 216, 10, 201, 66,
498 51, 116, 196, 81, 167, 37, 77, 7, 102, 0, 0, 2, 25, 48, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0,
499 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, 0, 1,
503 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
504 let update_result = rapid_sync.update_network_graph_no_std(&example_input[..], None);
505 assert!(update_result.is_ok());
507 let read_only_graph = network_graph.read_only();
508 let nodes = read_only_graph.nodes();
509 assert_eq!(nodes.len(), 2);
513 let node_id = NodeId::from_slice(&[3, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213, 170, 186, 5, 101, 215, 30, 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7, 143]).unwrap();
514 let node = nodes.get(&node_id).unwrap();
515 let announcement_info = node.announcement_info.as_ref().unwrap();
516 let addresses = announcement_info.addresses();
517 assert_eq!(addresses.len(), 5);
522 let node_id = NodeId::from_slice(&[2, 77, 75, 108, 209, 54, 16, 50, 202, 155, 210, 174, 185, 217, 0, 170, 77, 69, 217, 234, 216, 10, 201, 66, 51, 116, 196, 81, 167, 37, 77, 7, 102]).unwrap();
523 let node = nodes.get(&node_id).unwrap();
524 let announcement_info = node.announcement_info.as_ref().unwrap();
525 let features = announcement_info.features();
526 println!("features: {}", features);
527 // assert_eq!(addresses.len(), 5);
530 logger.assert_log_contains("lightning_rapid_gossip_sync::processing", "Failed to apply node announcement", 0);
534 fn node_date_update_succeeds_without_channels() {
535 let mut logger = TestLogger::new();
536 logger.enable(Level::Gossip);
537 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
538 let rapid_sync = RapidGossipSync::new(&network_graph, &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, 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 102, 105, 183, 240, 0, 0, 0, 0, 1, 63, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213, 170, 186, 5, 101, 215, 30, 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7, 143, 5, 13, 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, 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, 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, 10, 103, 111, 111, 103, 108, 101, 46, 99, 111, 109, 1, 187, 0, 2, 23, 48, 0, 0, 0, 0, 0, 0, 0, 0,
544 let update_result = rapid_sync.update_network_graph_no_std(&example_input[..], None);
545 assert!(update_result.is_ok());
547 logger.assert_log_contains("lightning_rapid_gossip_sync::processing", "Failed to apply node announcement: \"No existing channels for node_announcement\"", 1);
551 fn update_ignores_v2_additional_data() {
552 let mut logger = TestLogger::new();
553 logger.enable(Level::Gossip);
554 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
555 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
557 let example_input = vec![
558 76, 68, 75, 2, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
559 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 102, 106, 12, 80,
560 1, 0, 2, 23, 48, 0, 0, 0, 3, 143, 27, 132, 197, 86, 123, 18, 100, 64, 153, 93, 62, 213,
561 170, 186, 5, 101, 215, 30, 24, 52, 96, 72, 25, 255, 156, 23, 245, 233, 213, 221, 7, 143,
562 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, 1, 1,
563 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, 1, 1,
564 5, 57, 13, 3, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 7, 1, 127, 0, 0, 1, 37, 163, 14, 5,
565 10, 103, 111, 111, 103, 108, 101, 46, 99, 111, 109, 1, 187, 0, 255, 0, 0, 0, 0, 0, 0, 0,
566 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,
567 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,
568 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,
569 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,
570 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,
571 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,
572 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,
573 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,
574 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 138, 77, 75, 108, 209, 54, 16, 50, 202,
575 155, 210, 174, 185, 217, 0, 170, 77, 69, 217, 234, 216, 10, 201, 66, 51, 116, 196, 81,
576 167, 37, 77, 7, 102, 0, 255, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
577 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,
578 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,
579 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,
580 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,
581 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,
582 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,
583 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,
584 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,
585 0, 0, 0, 186, 83, 31, 230, 6, 129, 52, 80, 61, 39, 35, 19, 50, 39, 200, 103, 172, 143,
586 166, 200, 60, 83, 126, 154, 68, 195, 197, 189, 189, 203, 31, 227, 55, 0, 2, 22, 49, 0,
587 255, 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,
588 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,
589 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,
590 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,
591 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,
592 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,
593 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,
594 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,
595 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, 1,
596 0, 0, 1, 0, 255, 128, 0, 0, 0, 0, 0, 0, 1, 0, 147, 23, 23, 23, 23, 23, 23, 23, 23, 23,
597 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
598 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
599 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
600 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
601 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
602 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,
603 23, 23, 23, 23, 23, 23, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0,
604 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 17, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
605 42, 42, 42, 42, 42, 42, 42, 0, 1, 0, 1, 0, 17, 42, 42, 42, 42, 42, 42, 42, 42, 42, 42,
606 42, 42, 42, 42, 42, 42, 42
609 let update_result = rapid_sync.update_network_graph_no_std(&example_input[..], None);
610 assert!(update_result.is_ok());
612 logger.assert_log_contains("lightning_rapid_gossip_sync::processing", "Ignoring 255 bytes of additional data in node announcement", 3);
613 logger.assert_log_contains("lightning_rapid_gossip_sync::processing", "Ignoring 147 bytes of additional data in channel announcement", 1);
614 logger.assert_log_contains("lightning_rapid_gossip_sync::processing", "Ignoring 17 bytes of additional data in channel update", 1);
618 #[cfg(feature = "std")]
619 fn incremental_only_update_ignores_missing_channel() {
620 let incremental_update_input = vec![
621 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
622 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
623 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,
624 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,
625 68, 226, 0, 6, 11, 0, 1, 128,
628 let logger = TestLogger::new();
629 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
631 assert_eq!(network_graph.read_only().channels().len(), 0);
633 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
634 let update_result = rapid_sync.update_network_graph(&incremental_update_input[..]);
635 assert!(update_result.is_ok());
639 #[cfg(feature = "std")]
640 fn incremental_only_update_fails_without_prior_updates() {
641 let announced_update_input = vec![
642 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
643 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
644 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
645 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
646 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
647 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
648 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
649 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
650 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
651 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
652 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,
653 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,
654 2, 68, 226, 0, 6, 11, 0, 1, 128,
657 let logger = TestLogger::new();
658 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
660 assert_eq!(network_graph.read_only().channels().len(), 0);
662 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
663 rapid_sync.update_network_graph(&announced_update_input[..]).unwrap();
667 #[cfg(feature = "std")]
668 fn incremental_only_update_fails_without_prior_same_direction_updates() {
669 let initialization_input = vec![
670 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
671 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
672 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
673 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
674 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
675 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
676 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
677 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
678 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
679 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
680 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,
681 0, 0, 0, 1, 0, 0, 0, 0, 58, 85, 116, 216, 255, 8, 153, 192, 0, 2, 27, 0, 0, 25, 0, 0,
682 0, 1, 0, 0, 0, 125, 255, 2, 68, 226, 0, 6, 11, 0, 1, 5, 0, 0, 0, 0, 29, 129, 25, 192,
685 let logger = TestLogger::new();
686 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
688 assert_eq!(network_graph.read_only().channels().len(), 0);
690 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
691 let initialization_result = rapid_sync.update_network_graph(&initialization_input[..]);
692 if initialization_result.is_err() {
694 "Unexpected initialization result: {:?}",
695 initialization_result
699 assert_eq!(network_graph.read_only().channels().len(), 2);
700 let initialized = network_graph.to_string();
702 .contains("021607cfce19a4c5e7e6e738663dfafbbbac262e4ff76c2c9b30dbeefc35c00643"));
704 .contains("02247d9db0dfafea745ef8c9e161eb322f73ac3f8858d8730b6fd97254747ce76b"));
706 .contains("029e01f279986acc83ba235d46d80aede0b7595f410353b93a8ab540bb677f4432"));
708 .contains("02c913118a8895b9e29c89af6e20ed00d95a1f64e4952edbafa84d048f26804c61"));
709 assert!(initialized.contains("619737530008010752"));
710 assert!(initialized.contains("783241506229452801"));
712 let opposite_direction_incremental_update_input = vec![
713 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
714 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
715 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,
716 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,
717 68, 226, 0, 6, 11, 0, 1, 128,
719 rapid_sync.update_network_graph(&opposite_direction_incremental_update_input[..]).unwrap();
723 #[cfg(feature = "std")]
724 fn incremental_update_succeeds_with_prior_announcements_and_full_updates() {
725 let initialization_input = vec![
726 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
727 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
728 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
729 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
730 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
731 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
732 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
733 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
734 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
735 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
736 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,
737 0, 0, 0, 1, 0, 0, 0, 0, 58, 85, 116, 216, 255, 8, 153, 192, 0, 2, 27, 0, 0, 56, 0, 0,
738 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,
739 68, 226, 0, 6, 11, 0, 1, 4, 0, 0, 0, 0, 29, 129, 25, 192, 0, 5, 0, 0, 0, 0, 29, 129,
743 let logger = TestLogger::new();
744 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
746 assert_eq!(network_graph.read_only().channels().len(), 0);
748 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
749 let initialization_result = rapid_sync.update_network_graph(&initialization_input[..]);
750 assert!(initialization_result.is_ok());
752 let single_direction_incremental_update_input = vec![
753 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
754 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
755 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,
756 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,
757 68, 226, 0, 6, 11, 0, 1, 128,
759 let update_result = rapid_sync.update_network_graph(&single_direction_incremental_update_input[..]);
760 if update_result.is_err() {
761 panic!("Unexpected update result: {:?}", update_result)
764 assert_eq!(network_graph.read_only().channels().len(), 2);
765 let after = network_graph.to_string();
767 after.contains("021607cfce19a4c5e7e6e738663dfafbbbac262e4ff76c2c9b30dbeefc35c00643")
770 after.contains("02247d9db0dfafea745ef8c9e161eb322f73ac3f8858d8730b6fd97254747ce76b")
773 after.contains("029e01f279986acc83ba235d46d80aede0b7595f410353b93a8ab540bb677f4432")
776 after.contains("02c913118a8895b9e29c89af6e20ed00d95a1f64e4952edbafa84d048f26804c61")
778 assert!(after.contains("619737530008010752"));
779 assert!(after.contains("783241506229452801"));
783 #[cfg(feature = "std")]
784 fn update_succeeds_when_duplicate_gossip_is_applied() {
785 let initialization_input = vec![
786 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
787 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
788 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
789 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
790 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
791 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
792 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
793 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
794 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
795 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
796 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,
797 0, 0, 0, 1, 0, 0, 0, 0, 58, 85, 116, 216, 255, 8, 153, 192, 0, 2, 27, 0, 0, 56, 0, 0,
798 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,
799 68, 226, 0, 6, 11, 0, 1, 4, 0, 0, 0, 0, 29, 129, 25, 192, 0, 5, 0, 0, 0, 0, 29, 129,
803 let logger = TestLogger::new();
804 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
806 assert_eq!(network_graph.read_only().channels().len(), 0);
808 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
809 let initialization_result = rapid_sync.update_network_graph(&initialization_input[..]);
810 assert!(initialization_result.is_ok());
812 let single_direction_incremental_update_input = vec![
813 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
814 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
815 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,
816 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,
817 68, 226, 0, 6, 11, 0, 1, 128,
819 let update_result_1 = rapid_sync.update_network_graph(&single_direction_incremental_update_input[..]);
820 // Apply duplicate update
821 let update_result_2 = rapid_sync.update_network_graph(&single_direction_incremental_update_input[..]);
822 assert!(update_result_1.is_ok());
823 assert!(update_result_2.is_ok());
827 #[cfg(feature = "std")]
828 fn full_update_succeeds() {
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 update_result = rapid_sync.update_network_graph(&VALID_RGS_BINARY);
836 if update_result.is_err() {
837 panic!("Unexpected update result: {:?}", update_result)
840 assert_eq!(network_graph.read_only().channels().len(), 2);
841 let after = network_graph.to_string();
843 after.contains("021607cfce19a4c5e7e6e738663dfafbbbac262e4ff76c2c9b30dbeefc35c00643")
846 after.contains("02247d9db0dfafea745ef8c9e161eb322f73ac3f8858d8730b6fd97254747ce76b")
849 after.contains("029e01f279986acc83ba235d46d80aede0b7595f410353b93a8ab540bb677f4432")
852 after.contains("02c913118a8895b9e29c89af6e20ed00d95a1f64e4952edbafa84d048f26804c61")
854 assert!(after.contains("619737530008010752"));
855 assert!(after.contains("783241506229452801"));
859 fn full_update_succeeds_at_the_beginning_of_the_unix_era() {
860 let logger = TestLogger::new();
861 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
863 assert_eq!(network_graph.read_only().channels().len(), 0);
865 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
866 // this is mostly for checking uint underflow issues before the fuzzer does
867 let update_result = rapid_sync.update_network_graph_no_std(&VALID_RGS_BINARY, Some(0));
868 assert!(update_result.is_ok());
869 assert_eq!(network_graph.read_only().channels().len(), 2);
873 fn prunes_after_update() {
874 // this is the timestamp encoded in the binary data of valid_input below
875 let logger = TestLogger::new();
877 let latest_nonpruning_time = VALID_BINARY_TIMESTAMP + 60 * 60 * 24 * 7;
880 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
881 assert_eq!(network_graph.read_only().channels().len(), 0);
883 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
884 let update_result = rapid_sync.update_network_graph_no_std(&VALID_RGS_BINARY, Some(latest_nonpruning_time));
885 assert!(update_result.is_ok());
886 assert_eq!(network_graph.read_only().channels().len(), 2);
890 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
891 assert_eq!(network_graph.read_only().channels().len(), 0);
893 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
894 let update_result = rapid_sync.update_network_graph_no_std(&VALID_RGS_BINARY, Some(latest_nonpruning_time + 1));
895 assert!(update_result.is_ok());
896 assert_eq!(network_graph.read_only().channels().len(), 0);
901 fn timestamp_edge_cases_are_handled_correctly() {
902 // this is the timestamp encoded in the binary data of valid_input below
903 let logger = TestLogger::new();
905 let latest_succeeding_time = VALID_BINARY_TIMESTAMP + STALE_RGS_UPDATE_AGE_LIMIT_SECS;
906 let earliest_failing_time = latest_succeeding_time + 1;
909 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
910 assert_eq!(network_graph.read_only().channels().len(), 0);
912 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
913 let update_result = rapid_sync.update_network_graph_no_std(&VALID_RGS_BINARY, Some(latest_succeeding_time));
914 assert!(update_result.is_ok());
915 assert_eq!(network_graph.read_only().channels().len(), 0);
919 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_no_std(&VALID_RGS_BINARY, Some(earliest_failing_time));
924 assert!(update_result.is_err());
925 if let Err(GraphSyncError::LightningError(lightning_error)) = update_result {
928 "Rapid Gossip Sync data is more than two weeks old"
931 panic!("Unexpected update result: {:?}", update_result)
937 #[cfg(feature = "std")]
938 pub fn update_fails_with_unknown_version() {
939 let unknown_version_input = vec![
940 76, 68, 75, 3, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
941 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
942 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
943 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
944 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
945 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
946 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
947 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
948 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
949 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
950 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,
951 0, 0, 0, 1, 0, 0, 0, 0, 29, 129, 25, 192, 255, 8, 153, 192, 0, 2, 27, 0, 0, 60, 0, 0,
952 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,
953 0, 0, 1, 0, 0, 0, 125, 0, 0, 0, 0, 58, 85, 116, 216, 255, 2, 68, 226, 0, 6, 11, 0, 1,
957 let logger = TestLogger::new();
958 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
959 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
960 let update_result = rapid_sync.update_network_graph(&unknown_version_input[..]);
962 assert!(update_result.is_err());
964 if let Err(GraphSyncError::DecodeError(DecodeError::UnknownVersion)) = update_result {
965 // this is the expected error type
967 panic!("Unexpected update result: {:?}", update_result)
972 fn fails_early_on_chain_hash_mismatch() {
973 let logger = TestLogger::new();
974 // Set to testnet so that the VALID_RGS_BINARY chain hash of mainnet does not match.
975 let network_graph = NetworkGraph::new(Network::Testnet, &logger);
977 assert_eq!(network_graph.read_only().channels().len(), 0);
979 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
980 let update_result = rapid_sync.update_network_graph_no_std(&VALID_RGS_BINARY, Some(0));
981 assert!(update_result.is_err());
982 if let Err(GraphSyncError::LightningError(err)) = update_result {
983 assert_eq!(err.err, "Rapid Gossip Sync data's chain hash does not match the network graph's");
985 panic!("Unexpected update result: {:?}", update_result)