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_warn, log_trace, log_given_level};
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 pub(crate) fn update_network_graph_from_byte_stream<R: io::Read>(
44 ) -> Result<u32, GraphSyncError> {
45 #[allow(unused_mut, unused_assignments)]
46 let mut current_time_unix = None;
47 #[cfg(all(feature = "std", not(test)))]
49 // Note that many tests rely on being able to set arbitrarily old timestamps, thus we
50 // disable this check during tests!
51 current_time_unix = Some(SystemTime::now().duration_since(UNIX_EPOCH).expect("Time must be > 1970").as_secs());
53 self.update_network_graph_from_byte_stream_no_std(read_cursor, current_time_unix)
56 pub(crate) fn update_network_graph_from_byte_stream_no_std<R: io::Read>(
58 mut read_cursor: &mut R,
59 current_time_unix: Option<u64>
60 ) -> Result<u32, GraphSyncError> {
61 let mut prefix = [0u8; 4];
62 read_cursor.read_exact(&mut prefix)?;
64 if prefix != GOSSIP_PREFIX {
65 return Err(DecodeError::UnknownVersion.into());
68 let chain_hash: BlockHash = Readable::read(read_cursor)?;
69 let latest_seen_timestamp: u32 = Readable::read(read_cursor)?;
71 if let Some(time) = current_time_unix {
72 if (latest_seen_timestamp as u64) < time.saturating_sub(STALE_RGS_UPDATE_AGE_LIMIT_SECS) {
73 return Err(LightningError{err: "Rapid Gossip Sync data is more than two weeks old".to_owned(), action: ErrorAction::IgnoreError}.into());
77 // backdate the applied timestamp by a week
78 let backdated_timestamp = latest_seen_timestamp.saturating_sub(24 * 3600 * 7);
80 let node_id_count: u32 = Readable::read(read_cursor)?;
81 let mut node_ids: Vec<PublicKey> = Vec::with_capacity(core::cmp::min(
83 MAX_INITIAL_NODE_ID_VECTOR_CAPACITY,
85 for _ in 0..node_id_count {
86 let current_node_id = Readable::read(read_cursor)?;
87 node_ids.push(current_node_id);
90 let network_graph = &self.network_graph;
92 let mut previous_scid: u64 = 0;
93 let announcement_count: u32 = Readable::read(read_cursor)?;
94 for _ in 0..announcement_count {
95 let features = Readable::read(read_cursor)?;
98 let scid_delta: BigSize = Readable::read(read_cursor)?;
99 let short_channel_id = previous_scid
100 .checked_add(scid_delta.0)
101 .ok_or(DecodeError::InvalidValue)?;
102 previous_scid = short_channel_id;
104 let node_id_1_index: BigSize = Readable::read(read_cursor)?;
105 let node_id_2_index: BigSize = Readable::read(read_cursor)?;
107 if max(node_id_1_index.0, node_id_2_index.0) >= node_id_count as u64 {
108 return Err(DecodeError::InvalidValue.into());
110 let node_id_1 = node_ids[node_id_1_index.0 as usize];
111 let node_id_2 = node_ids[node_id_2_index.0 as usize];
113 let announcement_result = network_graph.add_channel_from_partial_announcement(
115 backdated_timestamp as u64,
120 if let Err(lightning_error) = announcement_result {
121 if let ErrorAction::IgnoreDuplicateGossip = lightning_error.action {
122 // everything is fine, just a duplicate channel announcement
124 log_warn!(self.logger, "Failed to process channel announcement: {:?}", lightning_error);
125 return Err(lightning_error.into());
130 previous_scid = 0; // updates start at a new scid
132 let update_count: u32 = Readable::read(read_cursor)?;
133 if update_count == 0 {
134 return Ok(latest_seen_timestamp);
137 // obtain default values for non-incremental updates
138 let default_cltv_expiry_delta: u16 = Readable::read(&mut read_cursor)?;
139 let default_htlc_minimum_msat: u64 = Readable::read(&mut read_cursor)?;
140 let default_fee_base_msat: u32 = Readable::read(&mut read_cursor)?;
141 let default_fee_proportional_millionths: u32 = Readable::read(&mut read_cursor)?;
142 let default_htlc_maximum_msat: u64 = Readable::read(&mut read_cursor)?;
144 for _ in 0..update_count {
145 let scid_delta: BigSize = Readable::read(read_cursor)?;
146 let short_channel_id = previous_scid
147 .checked_add(scid_delta.0)
148 .ok_or(DecodeError::InvalidValue)?;
149 previous_scid = short_channel_id;
151 let channel_flags: u8 = Readable::read(read_cursor)?;
153 // flags are always sent in full, and hence always need updating
154 let standard_channel_flags = channel_flags & 0b_0000_0011;
156 let mut synthetic_update = UnsignedChannelUpdate {
159 timestamp: backdated_timestamp,
160 flags: standard_channel_flags,
161 cltv_expiry_delta: default_cltv_expiry_delta,
162 htlc_minimum_msat: default_htlc_minimum_msat,
163 htlc_maximum_msat: default_htlc_maximum_msat,
164 fee_base_msat: default_fee_base_msat,
165 fee_proportional_millionths: default_fee_proportional_millionths,
166 excess_data: Vec::new(),
169 let mut skip_update_for_unknown_channel = false;
171 if (channel_flags & 0b_1000_0000) != 0 {
172 // incremental update, field flags will indicate mutated values
173 let read_only_network_graph = network_graph.read_only();
174 if let Some(directional_info) =
175 read_only_network_graph.channels().get(&short_channel_id)
176 .and_then(|channel| channel.get_directional_info(channel_flags))
178 synthetic_update.cltv_expiry_delta = directional_info.cltv_expiry_delta;
179 synthetic_update.htlc_minimum_msat = directional_info.htlc_minimum_msat;
180 synthetic_update.htlc_maximum_msat = directional_info.htlc_maximum_msat;
181 synthetic_update.fee_base_msat = directional_info.fees.base_msat;
182 synthetic_update.fee_proportional_millionths = directional_info.fees.proportional_millionths;
184 log_trace!(self.logger,
185 "Skipping application of channel update for chan {} with flags {} as original data is missing.",
186 short_channel_id, channel_flags);
187 skip_update_for_unknown_channel = true;
191 if channel_flags & 0b_0100_0000 > 0 {
192 let cltv_expiry_delta: u16 = Readable::read(read_cursor)?;
193 synthetic_update.cltv_expiry_delta = cltv_expiry_delta;
196 if channel_flags & 0b_0010_0000 > 0 {
197 let htlc_minimum_msat: u64 = Readable::read(read_cursor)?;
198 synthetic_update.htlc_minimum_msat = htlc_minimum_msat;
201 if channel_flags & 0b_0001_0000 > 0 {
202 let fee_base_msat: u32 = Readable::read(read_cursor)?;
203 synthetic_update.fee_base_msat = fee_base_msat;
206 if channel_flags & 0b_0000_1000 > 0 {
207 let fee_proportional_millionths: u32 = Readable::read(read_cursor)?;
208 synthetic_update.fee_proportional_millionths = fee_proportional_millionths;
211 if channel_flags & 0b_0000_0100 > 0 {
212 let htlc_maximum_msat: u64 = Readable::read(read_cursor)?;
213 synthetic_update.htlc_maximum_msat = htlc_maximum_msat;
216 if skip_update_for_unknown_channel {
220 match network_graph.update_channel_unsigned(&synthetic_update) {
222 Err(LightningError { action: ErrorAction::IgnoreDuplicateGossip, .. }) => {},
223 Err(LightningError { action: ErrorAction::IgnoreAndLog(level), err }) => {
224 log_given_level!(self.logger, level, "Failed to apply channel update: {:?}", err);
226 Err(LightningError { action: ErrorAction::IgnoreError, .. }) => {},
227 Err(e) => return Err(e.into()),
231 self.network_graph.set_last_rapid_gossip_sync_timestamp(latest_seen_timestamp);
232 self.is_initial_sync_complete.store(true, Ordering::Release);
233 Ok(latest_seen_timestamp)
239 use bitcoin::Network;
241 use lightning::ln::msgs::DecodeError;
242 use lightning::routing::gossip::NetworkGraph;
243 use lightning::util::test_utils::TestLogger;
245 use crate::error::GraphSyncError;
246 use crate::processing::STALE_RGS_UPDATE_AGE_LIMIT_SECS;
247 use crate::RapidGossipSync;
249 const VALID_RGS_BINARY: [u8; 300] = [
250 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
251 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
252 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
253 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
254 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
255 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
256 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
257 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
258 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
259 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
260 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,
261 0, 0, 0, 1, 0, 0, 0, 0, 29, 129, 25, 192, 255, 8, 153, 192, 0, 2, 27, 0, 0, 60, 0, 0,
262 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,
263 0, 0, 1, 0, 0, 0, 125, 0, 0, 0, 0, 58, 85, 116, 216, 255, 2, 68, 226, 0, 6, 11, 0, 1,
266 const VALID_BINARY_TIMESTAMP: u64 = 1642291930;
269 fn network_graph_fails_to_update_from_clipped_input() {
270 let logger = TestLogger::new();
271 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
273 let example_input = vec![
274 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
275 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
276 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
277 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
278 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
279 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
280 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
281 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
282 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
283 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
284 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,
285 0, 0, 2, 224, 0, 0, 0, 0, 29, 129, 25, 192, 255, 8, 153, 192, 0, 2, 27, 0, 0, 36, 0, 0,
286 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,
289 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
290 let update_result = rapid_sync.update_network_graph(&example_input[..]);
291 assert!(update_result.is_err());
292 if let Err(GraphSyncError::DecodeError(DecodeError::ShortRead)) = update_result {
293 // this is the expected error type
295 panic!("Unexpected update result: {:?}", update_result)
300 fn incremental_only_update_ignores_missing_channel() {
301 let incremental_update_input = vec![
302 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
303 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
304 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,
305 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,
306 68, 226, 0, 6, 11, 0, 1, 128,
309 let logger = TestLogger::new();
310 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
312 assert_eq!(network_graph.read_only().channels().len(), 0);
314 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
315 let update_result = rapid_sync.update_network_graph(&incremental_update_input[..]);
316 assert!(update_result.is_ok());
320 fn incremental_only_update_fails_without_prior_updates() {
321 let announced_update_input = vec![
322 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
323 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
324 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
325 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
326 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
327 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
328 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
329 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
330 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
331 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
332 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,
333 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,
334 2, 68, 226, 0, 6, 11, 0, 1, 128,
337 let logger = TestLogger::new();
338 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
340 assert_eq!(network_graph.read_only().channels().len(), 0);
342 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
343 rapid_sync.update_network_graph(&announced_update_input[..]).unwrap();
347 fn incremental_only_update_fails_without_prior_same_direction_updates() {
348 let initialization_input = vec![
349 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
350 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
351 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
352 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
353 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
354 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
355 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
356 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
357 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
358 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
359 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,
360 0, 0, 0, 1, 0, 0, 0, 0, 58, 85, 116, 216, 255, 8, 153, 192, 0, 2, 27, 0, 0, 25, 0, 0,
361 0, 1, 0, 0, 0, 125, 255, 2, 68, 226, 0, 6, 11, 0, 1, 5, 0, 0, 0, 0, 29, 129, 25, 192,
364 let logger = TestLogger::new();
365 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
367 assert_eq!(network_graph.read_only().channels().len(), 0);
369 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
370 let initialization_result = rapid_sync.update_network_graph(&initialization_input[..]);
371 if initialization_result.is_err() {
373 "Unexpected initialization result: {:?}",
374 initialization_result
378 assert_eq!(network_graph.read_only().channels().len(), 2);
379 let initialized = network_graph.to_string();
381 .contains("021607cfce19a4c5e7e6e738663dfafbbbac262e4ff76c2c9b30dbeefc35c00643"));
383 .contains("02247d9db0dfafea745ef8c9e161eb322f73ac3f8858d8730b6fd97254747ce76b"));
385 .contains("029e01f279986acc83ba235d46d80aede0b7595f410353b93a8ab540bb677f4432"));
387 .contains("02c913118a8895b9e29c89af6e20ed00d95a1f64e4952edbafa84d048f26804c61"));
388 assert!(initialized.contains("619737530008010752"));
389 assert!(initialized.contains("783241506229452801"));
391 let opposite_direction_incremental_update_input = vec![
392 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
393 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
394 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,
395 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,
396 68, 226, 0, 6, 11, 0, 1, 128,
398 rapid_sync.update_network_graph(&opposite_direction_incremental_update_input[..]).unwrap();
402 fn incremental_update_succeeds_with_prior_announcements_and_full_updates() {
403 let initialization_input = vec![
404 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
405 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
406 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
407 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
408 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
409 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
410 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
411 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
412 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
413 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
414 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,
415 0, 0, 0, 1, 0, 0, 0, 0, 58, 85, 116, 216, 255, 8, 153, 192, 0, 2, 27, 0, 0, 56, 0, 0,
416 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,
417 68, 226, 0, 6, 11, 0, 1, 4, 0, 0, 0, 0, 29, 129, 25, 192, 0, 5, 0, 0, 0, 0, 29, 129,
421 let logger = TestLogger::new();
422 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
424 assert_eq!(network_graph.read_only().channels().len(), 0);
426 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
427 let initialization_result = rapid_sync.update_network_graph(&initialization_input[..]);
428 assert!(initialization_result.is_ok());
430 let single_direction_incremental_update_input = vec![
431 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
432 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
433 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,
434 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,
435 68, 226, 0, 6, 11, 0, 1, 128,
437 let update_result = rapid_sync.update_network_graph(&single_direction_incremental_update_input[..]);
438 if update_result.is_err() {
439 panic!("Unexpected update result: {:?}", update_result)
442 assert_eq!(network_graph.read_only().channels().len(), 2);
443 let after = network_graph.to_string();
445 after.contains("021607cfce19a4c5e7e6e738663dfafbbbac262e4ff76c2c9b30dbeefc35c00643")
448 after.contains("02247d9db0dfafea745ef8c9e161eb322f73ac3f8858d8730b6fd97254747ce76b")
451 after.contains("029e01f279986acc83ba235d46d80aede0b7595f410353b93a8ab540bb677f4432")
454 after.contains("02c913118a8895b9e29c89af6e20ed00d95a1f64e4952edbafa84d048f26804c61")
456 assert!(after.contains("619737530008010752"));
457 assert!(after.contains("783241506229452801"));
461 fn update_succeeds_when_duplicate_gossip_is_applied() {
462 let initialization_input = vec![
463 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
464 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
465 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
466 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
467 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
468 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
469 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
470 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
471 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
472 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
473 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,
474 0, 0, 0, 1, 0, 0, 0, 0, 58, 85, 116, 216, 255, 8, 153, 192, 0, 2, 27, 0, 0, 56, 0, 0,
475 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,
476 68, 226, 0, 6, 11, 0, 1, 4, 0, 0, 0, 0, 29, 129, 25, 192, 0, 5, 0, 0, 0, 0, 29, 129,
480 let logger = TestLogger::new();
481 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
483 assert_eq!(network_graph.read_only().channels().len(), 0);
485 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
486 let initialization_result = rapid_sync.update_network_graph(&initialization_input[..]);
487 assert!(initialization_result.is_ok());
489 let single_direction_incremental_update_input = vec![
490 76, 68, 75, 1, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
491 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 229, 183, 167,
492 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,
493 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,
494 68, 226, 0, 6, 11, 0, 1, 128,
496 let update_result_1 = rapid_sync.update_network_graph(&single_direction_incremental_update_input[..]);
497 // Apply duplicate update
498 let update_result_2 = rapid_sync.update_network_graph(&single_direction_incremental_update_input[..]);
499 assert!(update_result_1.is_ok());
500 assert!(update_result_2.is_ok());
504 fn full_update_succeeds() {
505 let logger = TestLogger::new();
506 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
508 assert_eq!(network_graph.read_only().channels().len(), 0);
510 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
511 let update_result = rapid_sync.update_network_graph(&VALID_RGS_BINARY);
512 if update_result.is_err() {
513 panic!("Unexpected update result: {:?}", update_result)
516 assert_eq!(network_graph.read_only().channels().len(), 2);
517 let after = network_graph.to_string();
519 after.contains("021607cfce19a4c5e7e6e738663dfafbbbac262e4ff76c2c9b30dbeefc35c00643")
522 after.contains("02247d9db0dfafea745ef8c9e161eb322f73ac3f8858d8730b6fd97254747ce76b")
525 after.contains("029e01f279986acc83ba235d46d80aede0b7595f410353b93a8ab540bb677f4432")
528 after.contains("02c913118a8895b9e29c89af6e20ed00d95a1f64e4952edbafa84d048f26804c61")
530 assert!(after.contains("619737530008010752"));
531 assert!(after.contains("783241506229452801"));
535 fn full_update_succeeds_at_the_beginning_of_the_unix_era() {
536 let logger = TestLogger::new();
537 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
539 assert_eq!(network_graph.read_only().channels().len(), 0);
541 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
542 // this is mostly for checking uint underflow issues before the fuzzer does
543 let update_result = rapid_sync.update_network_graph_no_std(&VALID_RGS_BINARY, Some(0));
544 assert!(update_result.is_ok());
545 assert_eq!(network_graph.read_only().channels().len(), 2);
549 fn timestamp_edge_cases_are_handled_correctly() {
550 // this is the timestamp encoded in the binary data of valid_input below
551 let logger = TestLogger::new();
553 let latest_succeeding_time = VALID_BINARY_TIMESTAMP + STALE_RGS_UPDATE_AGE_LIMIT_SECS;
554 let earliest_failing_time = latest_succeeding_time + 1;
557 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
558 assert_eq!(network_graph.read_only().channels().len(), 0);
560 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
561 let update_result = rapid_sync.update_network_graph_no_std(&VALID_RGS_BINARY, Some(latest_succeeding_time));
562 assert!(update_result.is_ok());
563 assert_eq!(network_graph.read_only().channels().len(), 2);
567 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
568 assert_eq!(network_graph.read_only().channels().len(), 0);
570 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
571 let update_result = rapid_sync.update_network_graph_no_std(&VALID_RGS_BINARY, Some(earliest_failing_time));
572 assert!(update_result.is_err());
573 if let Err(GraphSyncError::LightningError(lightning_error)) = update_result {
576 "Rapid Gossip Sync data is more than two weeks old"
579 panic!("Unexpected update result: {:?}", update_result)
585 pub fn update_fails_with_unknown_version() {
586 let unknown_version_input = vec![
587 76, 68, 75, 2, 111, 226, 140, 10, 182, 241, 179, 114, 193, 166, 162, 70, 174, 99, 247,
588 79, 147, 30, 131, 101, 225, 90, 8, 156, 104, 214, 25, 0, 0, 0, 0, 0, 97, 227, 98, 218,
589 0, 0, 0, 4, 2, 22, 7, 207, 206, 25, 164, 197, 231, 230, 231, 56, 102, 61, 250, 251,
590 187, 172, 38, 46, 79, 247, 108, 44, 155, 48, 219, 238, 252, 53, 192, 6, 67, 2, 36, 125,
591 157, 176, 223, 175, 234, 116, 94, 248, 201, 225, 97, 235, 50, 47, 115, 172, 63, 136,
592 88, 216, 115, 11, 111, 217, 114, 84, 116, 124, 231, 107, 2, 158, 1, 242, 121, 152, 106,
593 204, 131, 186, 35, 93, 70, 216, 10, 237, 224, 183, 89, 95, 65, 3, 83, 185, 58, 138,
594 181, 64, 187, 103, 127, 68, 50, 2, 201, 19, 17, 138, 136, 149, 185, 226, 156, 137, 175,
595 110, 32, 237, 0, 217, 90, 31, 100, 228, 149, 46, 219, 175, 168, 77, 4, 143, 38, 128,
596 76, 97, 0, 0, 0, 2, 0, 0, 255, 8, 153, 192, 0, 2, 27, 0, 0, 0, 1, 0, 0, 255, 2, 68,
597 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,
598 0, 0, 0, 1, 0, 0, 0, 0, 29, 129, 25, 192, 255, 8, 153, 192, 0, 2, 27, 0, 0, 60, 0, 0,
599 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,
600 0, 0, 1, 0, 0, 0, 125, 0, 0, 0, 0, 58, 85, 116, 216, 255, 2, 68, 226, 0, 6, 11, 0, 1,
604 let logger = TestLogger::new();
605 let network_graph = NetworkGraph::new(Network::Bitcoin, &logger);
606 let rapid_sync = RapidGossipSync::new(&network_graph, &logger);
607 let update_result = rapid_sync.update_network_graph(&unknown_version_input[..]);
609 assert!(update_result.is_err());
611 if let Err(GraphSyncError::DecodeError(DecodeError::UnknownVersion)) = update_result {
612 // this is the expected error type
614 panic!("Unexpected update result: {:?}", update_result)