3 use core::sync::atomic::Ordering;
5 use bitcoin::BlockHash;
6 use bitcoin::secp256k1::PublicKey;
8 use lightning::ln::msgs::{
9 DecodeError, ErrorAction, LightningError, UnsignedChannelUpdate,
11 use lightning::routing::gossip::NetworkGraph;
12 use lightning::util::logger::Logger;
13 use lightning::{log_debug, log_warn, log_trace, log_given_level, log_gossip};
14 use lightning::util::ser::{BigSize, Readable};
17 use crate::error::GraphSyncError;
18 use crate::RapidGossipSync;
20 #[cfg(all(feature = "std", not(test)))]
21 use std::time::{SystemTime, UNIX_EPOCH};
23 #[cfg(not(feature = "std"))]
24 use alloc::{vec::Vec, borrow::ToOwned};
26 /// The purpose of this prefix is to identify the serialization format, should other rapid gossip
27 /// sync formats arise in the future.
29 /// The fourth byte is the protocol version in case our format gets updated.
30 const GOSSIP_PREFIX: [u8; 4] = [76, 68, 75, 1];
32 /// Maximum vector allocation capacity for distinct node IDs. This constraint is necessary to
33 /// avoid malicious updates being able to trigger excessive memory allocation.
34 const MAX_INITIAL_NODE_ID_VECTOR_CAPACITY: u32 = 50_000;
36 /// We disallow gossip data that's more than two weeks old, per BOLT 7's
38 const STALE_RGS_UPDATE_AGE_LIMIT_SECS: u64 = 60 * 60 * 24 * 14;
40 impl<NG: Deref<Target=NetworkGraph<L>>, L: Deref> RapidGossipSync<NG, L> where L::Target: Logger {
41 #[cfg(feature = "std")]
42 pub(crate) fn update_network_graph_from_byte_stream<R: io::Read>(
45 ) -> Result<u32, GraphSyncError> {
46 #[allow(unused_mut, unused_assignments)]
47 let mut current_time_unix = None;
50 // Note that many tests rely on being able to set arbitrarily old timestamps, thus we
51 // disable this check during tests!
52 current_time_unix = Some(SystemTime::now().duration_since(UNIX_EPOCH).expect("Time must be > 1970").as_secs());
54 self.update_network_graph_from_byte_stream_no_std(read_cursor, current_time_unix)
57 pub(crate) fn update_network_graph_from_byte_stream_no_std<R: io::Read>(
59 mut read_cursor: &mut R,
60 current_time_unix: Option<u64>
61 ) -> Result<u32, GraphSyncError> {
62 log_trace!(self.logger, "Processing RGS data...");
63 let mut prefix = [0u8; 4];
64 read_cursor.read_exact(&mut prefix)?;
66 if prefix != GOSSIP_PREFIX {
67 return Err(DecodeError::UnknownVersion.into());
70 let chain_hash: BlockHash = Readable::read(read_cursor)?;
71 let latest_seen_timestamp: u32 = Readable::read(read_cursor)?;
73 if let Some(time) = current_time_unix {
74 if (latest_seen_timestamp as u64) < time.saturating_sub(STALE_RGS_UPDATE_AGE_LIMIT_SECS) {
75 return Err(LightningError{err: "Rapid Gossip Sync data is more than two weeks old".to_owned(), action: ErrorAction::IgnoreError}.into());
79 // backdate the applied timestamp by a week
80 let backdated_timestamp = latest_seen_timestamp.saturating_sub(24 * 3600 * 7);
82 let node_id_count: u32 = Readable::read(read_cursor)?;
83 let mut node_ids: Vec<PublicKey> = Vec::with_capacity(core::cmp::min(
85 MAX_INITIAL_NODE_ID_VECTOR_CAPACITY,
87 for _ in 0..node_id_count {
88 let current_node_id = Readable::read(read_cursor)?;
89 node_ids.push(current_node_id);
92 let network_graph = &self.network_graph;
94 let mut previous_scid: u64 = 0;
95 let announcement_count: u32 = Readable::read(read_cursor)?;
96 for _ in 0..announcement_count {
97 let features = Readable::read(read_cursor)?;
100 let scid_delta: BigSize = Readable::read(read_cursor)?;
101 let short_channel_id = previous_scid
102 .checked_add(scid_delta.0)
103 .ok_or(DecodeError::InvalidValue)?;
104 previous_scid = short_channel_id;
106 let node_id_1_index: BigSize = Readable::read(read_cursor)?;
107 let node_id_2_index: BigSize = Readable::read(read_cursor)?;
109 if max(node_id_1_index.0, node_id_2_index.0) >= node_id_count as u64 {
110 return Err(DecodeError::InvalidValue.into());
112 let node_id_1 = node_ids[node_id_1_index.0 as usize];
113 let node_id_2 = node_ids[node_id_2_index.0 as usize];
115 log_gossip!(self.logger, "Adding channel {} from RGS announcement at {}",
116 short_channel_id, latest_seen_timestamp);
118 let announcement_result = network_graph.add_channel_from_partial_announcement(
120 backdated_timestamp as u64,
125 if let Err(lightning_error) = announcement_result {
126 if let ErrorAction::IgnoreDuplicateGossip = lightning_error.action {
127 // everything is fine, just a duplicate channel announcement
129 log_warn!(self.logger, "Failed to process channel announcement: {:?}", lightning_error);
130 return Err(lightning_error.into());
135 previous_scid = 0; // updates start at a new scid
137 let update_count: u32 = Readable::read(read_cursor)?;
138 log_debug!(self.logger, "Processing RGS update from {} with {} nodes, {} channel announcements and {} channel updates.",
139 latest_seen_timestamp, node_id_count, announcement_count, update_count);
140 if update_count == 0 {
141 return Ok(latest_seen_timestamp);
144 // obtain default values for non-incremental updates
145 let default_cltv_expiry_delta: u16 = Readable::read(&mut read_cursor)?;
146 let default_htlc_minimum_msat: u64 = Readable::read(&mut read_cursor)?;
147 let default_fee_base_msat: u32 = Readable::read(&mut read_cursor)?;
148 let default_fee_proportional_millionths: u32 = Readable::read(&mut read_cursor)?;
149 let default_htlc_maximum_msat: u64 = Readable::read(&mut read_cursor)?;
151 for _ in 0..update_count {
152 let scid_delta: BigSize = Readable::read(read_cursor)?;
153 let short_channel_id = previous_scid
154 .checked_add(scid_delta.0)
155 .ok_or(DecodeError::InvalidValue)?;
156 previous_scid = short_channel_id;
158 let channel_flags: u8 = Readable::read(read_cursor)?;
160 // flags are always sent in full, and hence always need updating
161 let standard_channel_flags = channel_flags & 0b_0000_0011;
163 let mut synthetic_update = UnsignedChannelUpdate {
166 timestamp: backdated_timestamp,
167 flags: standard_channel_flags,
168 cltv_expiry_delta: default_cltv_expiry_delta,
169 htlc_minimum_msat: default_htlc_minimum_msat,
170 htlc_maximum_msat: default_htlc_maximum_msat,
171 fee_base_msat: default_fee_base_msat,
172 fee_proportional_millionths: default_fee_proportional_millionths,
173 excess_data: Vec::new(),
176 let mut skip_update_for_unknown_channel = false;
178 if (channel_flags & 0b_1000_0000) != 0 {
179 // incremental update, field flags will indicate mutated values
180 let read_only_network_graph = network_graph.read_only();
181 if let Some(directional_info) =
182 read_only_network_graph.channels().get(&short_channel_id)
183 .and_then(|channel| channel.get_directional_info(channel_flags))
185 synthetic_update.cltv_expiry_delta = directional_info.cltv_expiry_delta;
186 synthetic_update.htlc_minimum_msat = directional_info.htlc_minimum_msat;
187 synthetic_update.htlc_maximum_msat = directional_info.htlc_maximum_msat;
188 synthetic_update.fee_base_msat = directional_info.fees.base_msat;
189 synthetic_update.fee_proportional_millionths = directional_info.fees.proportional_millionths;
191 log_trace!(self.logger,
192 "Skipping application of channel update for chan {} with flags {} as original data is missing.",
193 short_channel_id, channel_flags);
194 skip_update_for_unknown_channel = true;
198 if channel_flags & 0b_0100_0000 > 0 {
199 let cltv_expiry_delta: u16 = Readable::read(read_cursor)?;
200 synthetic_update.cltv_expiry_delta = cltv_expiry_delta;
203 if channel_flags & 0b_0010_0000 > 0 {
204 let htlc_minimum_msat: u64 = Readable::read(read_cursor)?;
205 synthetic_update.htlc_minimum_msat = htlc_minimum_msat;
208 if channel_flags & 0b_0001_0000 > 0 {
209 let fee_base_msat: u32 = Readable::read(read_cursor)?;
210 synthetic_update.fee_base_msat = fee_base_msat;
213 if channel_flags & 0b_0000_1000 > 0 {
214 let fee_proportional_millionths: u32 = Readable::read(read_cursor)?;
215 synthetic_update.fee_proportional_millionths = fee_proportional_millionths;
218 if channel_flags & 0b_0000_0100 > 0 {
219 let htlc_maximum_msat: u64 = Readable::read(read_cursor)?;
220 synthetic_update.htlc_maximum_msat = htlc_maximum_msat;
223 if skip_update_for_unknown_channel {
227 log_gossip!(self.logger, "Updating channel {} with flags {} from RGS announcement at {}",
228 short_channel_id, channel_flags, latest_seen_timestamp);
229 match network_graph.update_channel_unsigned(&synthetic_update) {
231 Err(LightningError { action: ErrorAction::IgnoreDuplicateGossip, .. }) => {},
232 Err(LightningError { action: ErrorAction::IgnoreAndLog(level), err }) => {
233 log_given_level!(self.logger, level, "Failed to apply channel update: {:?}", err);
235 Err(LightningError { action: ErrorAction::IgnoreError, .. }) => {},
236 Err(e) => return Err(e.into()),
240 self.network_graph.set_last_rapid_gossip_sync_timestamp(latest_seen_timestamp);
242 if let Some(time) = current_time_unix {
243 self.network_graph.remove_stale_channels_and_tracking_with_time(time)
246 self.is_initial_sync_complete.store(true, Ordering::Release);
247 log_trace!(self.logger, "Done processing RGS data from {}", latest_seen_timestamp);
248 Ok(latest_seen_timestamp)
254 use bitcoin::Network;
256 #[cfg(feature = "std")]
257 use lightning::ln::msgs::DecodeError;
259 use lightning::routing::gossip::NetworkGraph;
260 use lightning::util::test_utils::TestLogger;
262 use crate::error::GraphSyncError;
263 use crate::processing::STALE_RGS_UPDATE_AGE_LIMIT_SECS;
264 use crate::RapidGossipSync;
266 const VALID_RGS_BINARY: [u8; 300] = [
267 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
268 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
269 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
270 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
271 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
272 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
273 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
274 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
275 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
276 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
277 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,
278 0, 0, 0, 1, 0, 0, 0, 0, 29, 129, 25, 192, 255, 8, 153, 192, 0, 2, 27, 0, 0, 60, 0, 0,
279 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,
280 0, 0, 1, 0, 0, 0, 125, 0, 0, 0, 0, 58, 85, 116, 216, 255, 2, 68, 226, 0, 6, 11, 0, 1,
283 const VALID_BINARY_TIMESTAMP: u64 = 1642291930;
286 #[cfg(feature = "std")]
287 fn network_graph_fails_to_update_from_clipped_input() {
288 let logger = TestLogger::new();
289 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
291 let example_input = vec![
292 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
293 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
294 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
295 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
296 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
297 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
298 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
299 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
300 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
301 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
302 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,
303 0, 0, 2, 224, 0, 0, 0, 0, 29, 129, 25, 192, 255, 8, 153, 192, 0, 2, 27, 0, 0, 36, 0, 0,
304 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,
307 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
308 let update_result = rapid_sync.update_network_graph(&example_input[..]);
309 assert!(update_result.is_err());
310 if let Err(GraphSyncError::DecodeError(DecodeError::ShortRead)) = update_result {
311 // this is the expected error type
313 panic!("Unexpected update result: {:?}", update_result)
318 #[cfg(feature = "std")]
319 fn incremental_only_update_ignores_missing_channel() {
320 let incremental_update_input = vec![
321 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
322 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
323 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,
324 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,
325 68, 226, 0, 6, 11, 0, 1, 128,
328 let logger = TestLogger::new();
329 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
331 assert_eq!(network_graph.read_only().channels().len(), 0);
333 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
334 let update_result = rapid_sync.update_network_graph(&incremental_update_input[..]);
335 assert!(update_result.is_ok());
339 #[cfg(feature = "std")]
340 fn incremental_only_update_fails_without_prior_updates() {
341 let announced_update_input = vec![
342 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
343 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
344 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
345 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
346 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
347 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
348 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
349 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
350 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
351 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
352 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,
353 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,
354 2, 68, 226, 0, 6, 11, 0, 1, 128,
357 let logger = TestLogger::new();
358 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
360 assert_eq!(network_graph.read_only().channels().len(), 0);
362 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
363 rapid_sync.update_network_graph(&announced_update_input[..]).unwrap();
367 #[cfg(feature = "std")]
368 fn incremental_only_update_fails_without_prior_same_direction_updates() {
369 let initialization_input = vec![
370 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
371 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
372 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
373 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
374 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
375 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
376 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
377 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
378 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
379 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
380 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,
381 0, 0, 0, 1, 0, 0, 0, 0, 58, 85, 116, 216, 255, 8, 153, 192, 0, 2, 27, 0, 0, 25, 0, 0,
382 0, 1, 0, 0, 0, 125, 255, 2, 68, 226, 0, 6, 11, 0, 1, 5, 0, 0, 0, 0, 29, 129, 25, 192,
385 let logger = TestLogger::new();
386 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
388 assert_eq!(network_graph.read_only().channels().len(), 0);
390 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
391 let initialization_result = rapid_sync.update_network_graph(&initialization_input[..]);
392 if initialization_result.is_err() {
394 "Unexpected initialization result: {:?}",
395 initialization_result
399 assert_eq!(network_graph.read_only().channels().len(), 2);
400 let initialized = network_graph.to_string();
402 .contains("021607cfce19a4c5e7e6e738663dfafbbbac262e4ff76c2c9b30dbeefc35c00643"));
404 .contains("02247d9db0dfafea745ef8c9e161eb322f73ac3f8858d8730b6fd97254747ce76b"));
406 .contains("029e01f279986acc83ba235d46d80aede0b7595f410353b93a8ab540bb677f4432"));
408 .contains("02c913118a8895b9e29c89af6e20ed00d95a1f64e4952edbafa84d048f26804c61"));
409 assert!(initialized.contains("619737530008010752"));
410 assert!(initialized.contains("783241506229452801"));
412 let opposite_direction_incremental_update_input = vec![
413 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
414 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
415 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,
416 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,
417 68, 226, 0, 6, 11, 0, 1, 128,
419 rapid_sync.update_network_graph(&opposite_direction_incremental_update_input[..]).unwrap();
423 #[cfg(feature = "std")]
424 fn incremental_update_succeeds_with_prior_announcements_and_full_updates() {
425 let initialization_input = vec![
426 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
427 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
428 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
429 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
430 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
431 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
432 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
433 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
434 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
435 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
436 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,
437 0, 0, 0, 1, 0, 0, 0, 0, 58, 85, 116, 216, 255, 8, 153, 192, 0, 2, 27, 0, 0, 56, 0, 0,
438 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,
439 68, 226, 0, 6, 11, 0, 1, 4, 0, 0, 0, 0, 29, 129, 25, 192, 0, 5, 0, 0, 0, 0, 29, 129,
443 let logger = TestLogger::new();
444 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
446 assert_eq!(network_graph.read_only().channels().len(), 0);
448 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
449 let initialization_result = rapid_sync.update_network_graph(&initialization_input[..]);
450 assert!(initialization_result.is_ok());
452 let single_direction_incremental_update_input = vec![
453 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
454 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
455 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,
456 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,
457 68, 226, 0, 6, 11, 0, 1, 128,
459 let update_result = rapid_sync.update_network_graph(&single_direction_incremental_update_input[..]);
460 if update_result.is_err() {
461 panic!("Unexpected update result: {:?}", update_result)
464 assert_eq!(network_graph.read_only().channels().len(), 2);
465 let after = network_graph.to_string();
467 after.contains("021607cfce19a4c5e7e6e738663dfafbbbac262e4ff76c2c9b30dbeefc35c00643")
470 after.contains("02247d9db0dfafea745ef8c9e161eb322f73ac3f8858d8730b6fd97254747ce76b")
473 after.contains("029e01f279986acc83ba235d46d80aede0b7595f410353b93a8ab540bb677f4432")
476 after.contains("02c913118a8895b9e29c89af6e20ed00d95a1f64e4952edbafa84d048f26804c61")
478 assert!(after.contains("619737530008010752"));
479 assert!(after.contains("783241506229452801"));
483 #[cfg(feature = "std")]
484 fn update_succeeds_when_duplicate_gossip_is_applied() {
485 let initialization_input = vec![
486 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
487 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
488 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
489 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
490 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
491 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
492 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
493 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
494 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
495 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
496 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,
497 0, 0, 0, 1, 0, 0, 0, 0, 58, 85, 116, 216, 255, 8, 153, 192, 0, 2, 27, 0, 0, 56, 0, 0,
498 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,
499 68, 226, 0, 6, 11, 0, 1, 4, 0, 0, 0, 0, 29, 129, 25, 192, 0, 5, 0, 0, 0, 0, 29, 129,
503 let logger = TestLogger::new();
504 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
506 assert_eq!(network_graph.read_only().channels().len(), 0);
508 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
509 let initialization_result = rapid_sync.update_network_graph(&initialization_input[..]);
510 assert!(initialization_result.is_ok());
512 let single_direction_incremental_update_input = vec![
513 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
514 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
515 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,
516 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,
517 68, 226, 0, 6, 11, 0, 1, 128,
519 let update_result_1 = rapid_sync.update_network_graph(&single_direction_incremental_update_input[..]);
520 // Apply duplicate update
521 let update_result_2 = rapid_sync.update_network_graph(&single_direction_incremental_update_input[..]);
522 assert!(update_result_1.is_ok());
523 assert!(update_result_2.is_ok());
527 #[cfg(feature = "std")]
528 fn full_update_succeeds() {
529 let logger = TestLogger::new();
530 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
532 assert_eq!(network_graph.read_only().channels().len(), 0);
534 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
535 let update_result = rapid_sync.update_network_graph(&VALID_RGS_BINARY);
536 if update_result.is_err() {
537 panic!("Unexpected update result: {:?}", update_result)
540 assert_eq!(network_graph.read_only().channels().len(), 2);
541 let after = network_graph.to_string();
543 after.contains("021607cfce19a4c5e7e6e738663dfafbbbac262e4ff76c2c9b30dbeefc35c00643")
546 after.contains("02247d9db0dfafea745ef8c9e161eb322f73ac3f8858d8730b6fd97254747ce76b")
549 after.contains("029e01f279986acc83ba235d46d80aede0b7595f410353b93a8ab540bb677f4432")
552 after.contains("02c913118a8895b9e29c89af6e20ed00d95a1f64e4952edbafa84d048f26804c61")
554 assert!(after.contains("619737530008010752"));
555 assert!(after.contains("783241506229452801"));
559 fn full_update_succeeds_at_the_beginning_of_the_unix_era() {
560 let logger = TestLogger::new();
561 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
563 assert_eq!(network_graph.read_only().channels().len(), 0);
565 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
566 // this is mostly for checking uint underflow issues before the fuzzer does
567 let update_result = rapid_sync.update_network_graph_no_std(&VALID_RGS_BINARY, Some(0));
568 assert!(update_result.is_ok());
569 assert_eq!(network_graph.read_only().channels().len(), 2);
573 fn prunes_after_update() {
574 // this is the timestamp encoded in the binary data of valid_input below
575 let logger = TestLogger::new();
577 let latest_nonpruning_time = VALID_BINARY_TIMESTAMP + 60 * 60 * 24 * 7;
580 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
581 assert_eq!(network_graph.read_only().channels().len(), 0);
583 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
584 let update_result = rapid_sync.update_network_graph_no_std(&VALID_RGS_BINARY, Some(latest_nonpruning_time));
585 assert!(update_result.is_ok());
586 assert_eq!(network_graph.read_only().channels().len(), 2);
590 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
591 assert_eq!(network_graph.read_only().channels().len(), 0);
593 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
594 let update_result = rapid_sync.update_network_graph_no_std(&VALID_RGS_BINARY, Some(latest_nonpruning_time + 1));
595 assert!(update_result.is_ok());
596 assert_eq!(network_graph.read_only().channels().len(), 0);
601 fn timestamp_edge_cases_are_handled_correctly() {
602 // this is the timestamp encoded in the binary data of valid_input below
603 let logger = TestLogger::new();
605 let latest_succeeding_time = VALID_BINARY_TIMESTAMP + STALE_RGS_UPDATE_AGE_LIMIT_SECS;
606 let earliest_failing_time = latest_succeeding_time + 1;
609 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
610 assert_eq!(network_graph.read_only().channels().len(), 0);
612 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
613 let update_result = rapid_sync.update_network_graph_no_std(&VALID_RGS_BINARY, Some(latest_succeeding_time));
614 assert!(update_result.is_ok());
615 assert_eq!(network_graph.read_only().channels().len(), 0);
619 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
620 assert_eq!(network_graph.read_only().channels().len(), 0);
622 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
623 let update_result = rapid_sync.update_network_graph_no_std(&VALID_RGS_BINARY, Some(earliest_failing_time));
624 assert!(update_result.is_err());
625 if let Err(GraphSyncError::LightningError(lightning_error)) = update_result {
628 "Rapid Gossip Sync data is more than two weeks old"
631 panic!("Unexpected update result: {:?}", update_result)
637 #[cfg(feature = "std")]
638 pub fn update_fails_with_unknown_version() {
639 let unknown_version_input = vec![
640 76, 68, 75, 2, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
641 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
642 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
643 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
644 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
645 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
646 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
647 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
648 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
649 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
650 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,
651 0, 0, 0, 1, 0, 0, 0, 0, 29, 129, 25, 192, 255, 8, 153, 192, 0, 2, 27, 0, 0, 60, 0, 0,
652 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,
653 0, 0, 1, 0, 0, 0, 125, 0, 0, 0, 0, 58, 85, 116, 216, 255, 2, 68, 226, 0, 6, 11, 0, 1,
657 let logger = TestLogger::new();
658 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
659 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
660 let update_result = rapid_sync.update_network_graph(&unknown_version_input[..]);
662 assert!(update_result.is_err());
664 if let Err(GraphSyncError::DecodeError(DecodeError::UnknownVersion)) = update_result {
665 // this is the expected error type
667 panic!("Unexpected update result: {:?}", update_result)