1 //! Multi-module tests that use database fixtures
3 use std::cell::RefCell;
6 use std::time::{SystemTime, UNIX_EPOCH};
7 use bitcoin::{BlockHash, Network};
8 use bitcoin::secp256k1::ecdsa::Signature;
9 use bitcoin::secp256k1::{Secp256k1, SecretKey};
10 use bitcoin::hashes::Hash;
11 use bitcoin::hashes::hex::ToHex;
12 use bitcoin::hashes::sha256d::Hash as Sha256dHash;
13 use lightning::ln::features::ChannelFeatures;
14 use lightning::ln::msgs::{ChannelAnnouncement, ChannelUpdate, UnsignedChannelAnnouncement, UnsignedChannelUpdate};
15 use lightning::routing::gossip::{NetworkGraph, NodeId};
16 use lightning::util::ser::Writeable;
17 use lightning_rapid_gossip_sync::RapidGossipSync;
18 use crate::{config, serialize_delta};
19 use crate::persistence::GossipPersister;
20 use crate::types::{GossipMessage, tests::TestLogger};
22 const CLIENT_BACKDATE_INTERVAL: u32 = 3600 * 24 * 7; // client backdates RGS by a week
25 static DB_TEST_SCHEMA: RefCell<Option<String>> = RefCell::new(None);
26 static IS_TEST_SCHEMA_CLEAN: RefCell<Option<bool>> = RefCell::new(None);
29 fn blank_signature() -> Signature {
30 Signature::from_compact(&[0u8; 64]).unwrap()
33 fn genesis_hash() -> BlockHash {
34 bitcoin::blockdata::constants::genesis_block(Network::Bitcoin).block_hash()
37 fn current_time() -> u32 {
38 SystemTime::now().duration_since(UNIX_EPOCH).expect("Time must be > 1970").as_secs() as u32
41 pub(crate) fn db_test_schema() -> String {
42 DB_TEST_SCHEMA.with(|suffix_reference| {
43 let suffix_option = suffix_reference.borrow();
44 suffix_option.as_ref().unwrap().clone()
48 fn generate_announcement(short_channel_id: u64) -> ChannelAnnouncement {
49 let secp_context = Secp256k1::new();
51 let random_private_key_1 = SecretKey::from_slice(&[1; 32]).unwrap();
52 let random_public_key_1 = random_private_key_1.public_key(&secp_context);
53 let node_id_1 = NodeId::from_pubkey(&random_public_key_1);
55 let random_private_key_2 = SecretKey::from_slice(&[2; 32]).unwrap();
56 let random_public_key_2 = random_private_key_2.public_key(&secp_context);
57 let node_id_2 = NodeId::from_pubkey(&random_public_key_2);
59 let announcement = UnsignedChannelAnnouncement {
60 features: ChannelFeatures::empty(),
61 chain_hash: genesis_hash(),
65 bitcoin_key_1: node_id_1,
66 bitcoin_key_2: node_id_2,
70 let msg_hash = bitcoin::secp256k1::Message::from_slice(&Sha256dHash::hash(&announcement.encode()[..])[..]).unwrap();
71 let node_signature_1 = secp_context.sign_ecdsa(&msg_hash, &random_private_key_1);
72 let node_signature_2 = secp_context.sign_ecdsa(&msg_hash, &random_private_key_2);
77 bitcoin_signature_1: node_signature_1,
78 bitcoin_signature_2: node_signature_2,
79 contents: announcement,
83 fn generate_update(scid: u64, direction: bool, timestamp: u32, expiry_delta: u16, min_msat: u64, max_msat: u64, base_msat: u32, fee_rate: u32) -> ChannelUpdate {
84 let flag_mask = if direction { 1 } else { 0 };
86 signature: blank_signature(),
87 contents: UnsignedChannelUpdate {
88 chain_hash: genesis_hash(),
89 short_channel_id: scid,
92 cltv_expiry_delta: expiry_delta,
93 htlc_minimum_msat: min_msat,
94 htlc_maximum_msat: max_msat,
95 fee_base_msat: base_msat,
96 fee_proportional_millionths: fee_rate,
102 struct SchemaSanitizer {}
104 impl SchemaSanitizer {
106 IS_TEST_SCHEMA_CLEAN.with(|cleanliness_reference| {
107 let mut is_clean_option = cleanliness_reference.borrow_mut();
108 assert!(is_clean_option.is_none());
109 *is_clean_option = Some(false);
112 DB_TEST_SCHEMA.with(|suffix_reference| {
113 let mut suffix_option = suffix_reference.borrow_mut();
114 let current_time = SystemTime::now();
115 let unix_time = current_time.duration_since(UNIX_EPOCH).expect("Time went backwards");
116 let timestamp_seconds = unix_time.as_secs();
117 let timestamp_nanos = unix_time.as_nanos();
118 // sometimes Rust thinks two tests start at the same nanosecond, causing a schema conflict
119 let thread_id = thread::current().id();
120 let preimage = format!("{:?}-{}", thread_id, timestamp_nanos);
121 println!("test schema preimage: {}", preimage);
122 let suffix = Sha256dHash::hash(preimage.as_bytes()).into_inner().to_hex();
123 // the schema must start with a letter
124 let schema = format!("test_{}_{}", timestamp_seconds, suffix);
125 *suffix_option = Some(schema);
132 impl Drop for SchemaSanitizer {
134 IS_TEST_SCHEMA_CLEAN.with(|cleanliness_reference| {
135 let is_clean_option = cleanliness_reference.borrow();
136 if let Some(is_clean) = *is_clean_option {
137 assert_eq!(is_clean, true);
144 async fn clean_test_db() {
145 let client = crate::connect_to_db().await;
146 let schema = db_test_schema();
147 client.execute(&format!("DROP SCHEMA IF EXISTS {} CASCADE", schema), &[]).await.unwrap();
148 IS_TEST_SCHEMA_CLEAN.with(|cleanliness_reference| {
149 let mut is_clean_option = cleanliness_reference.borrow_mut();
150 *is_clean_option = Some(true);
155 async fn test_trivial_setup() {
156 let _sanitizer = SchemaSanitizer::new();
157 let logger = Arc::new(TestLogger::new());
158 let network_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
159 let network_graph_arc = Arc::new(network_graph);
160 let (mut persister, receiver) = GossipPersister::new(network_graph_arc.clone(), logger.clone());
162 let short_channel_id = 1;
163 let timestamp = current_time() - 10;
164 println!("timestamp: {}", timestamp);
167 let announcement = generate_announcement(short_channel_id);
168 let update_1 = generate_update(short_channel_id, false, timestamp, 0, 0, 0, 5, 0);
169 let update_2 = generate_update(short_channel_id, true, timestamp, 0, 0, 0, 10, 0);
171 network_graph_arc.update_channel_from_announcement_no_lookup(&announcement).unwrap();
172 network_graph_arc.update_channel_unsigned(&update_1.contents).unwrap();
173 network_graph_arc.update_channel_unsigned(&update_2.contents).unwrap();
175 receiver.send(GossipMessage::ChannelAnnouncement(announcement, None)).await.unwrap();
176 receiver.send(GossipMessage::ChannelUpdate(update_1, None)).await.unwrap();
177 receiver.send(GossipMessage::ChannelUpdate(update_2, None)).await.unwrap();
179 persister.persist_gossip().await;
182 let serialization = serialize_delta(network_graph_arc.clone(), 0, logger.clone()).await;
183 logger.assert_log_contains("rapid_gossip_sync_server", "announcement channel count: 1", 1);
184 clean_test_db().await;
186 let channel_count = network_graph_arc.read_only().channels().len();
188 assert_eq!(channel_count, 1);
189 assert_eq!(serialization.message_count, 3);
190 assert_eq!(serialization.announcement_count, 1);
191 assert_eq!(serialization.update_count, 2);
193 let client_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
194 let client_graph_arc = Arc::new(client_graph);
195 let rgs = RapidGossipSync::new(client_graph_arc.clone(), logger.clone());
196 let update_result = rgs.update_network_graph(&serialization.data).unwrap();
197 println!("update result: {}", update_result);
198 // the update result must be a multiple of our snapshot granularity
199 assert_eq!(update_result % config::snapshot_generation_interval(), 0);
200 assert!(update_result < timestamp);
202 let timestamp_delta = timestamp - update_result;
203 println!("timestamp delta: {}", timestamp_delta);
204 assert!(timestamp_delta < config::snapshot_generation_interval());
206 let readonly_graph = client_graph_arc.read_only();
207 let channels = readonly_graph.channels();
208 let client_channel_count = channels.len();
209 assert_eq!(client_channel_count, 1);
211 let first_channel = channels.get(&short_channel_id).unwrap();
212 assert!(&first_channel.announcement_message.is_none());
213 assert_eq!(first_channel.one_to_two.as_ref().unwrap().fees.base_msat, 5);
214 assert_eq!(first_channel.two_to_one.as_ref().unwrap().fees.base_msat, 10);
215 let last_update_seen_a = first_channel.one_to_two.as_ref().unwrap().last_update;
216 let last_update_seen_b = first_channel.two_to_one.as_ref().unwrap().last_update;
217 println!("last update a: {}", last_update_seen_a);
218 println!("last update b: {}", last_update_seen_b);
219 assert_eq!(last_update_seen_a, update_result - CLIENT_BACKDATE_INTERVAL);
220 assert_eq!(last_update_seen_b, update_result - CLIENT_BACKDATE_INTERVAL);
224 async fn test_full_snapshot_recency() {
225 let _sanitizer = SchemaSanitizer::new();
226 let logger = Arc::new(TestLogger::new());
227 let network_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
228 let network_graph_arc = Arc::new(network_graph);
230 let short_channel_id = 1;
231 let timestamp = current_time();
232 println!("timestamp: {}", timestamp);
235 let (mut persister, receiver) = GossipPersister::new(network_graph_arc.clone(), logger.clone());
236 let announcement = generate_announcement(short_channel_id);
237 network_graph_arc.update_channel_from_announcement_no_lookup(&announcement).unwrap();
238 receiver.send(GossipMessage::ChannelAnnouncement(announcement, None)).await.unwrap();
242 let update = generate_update(short_channel_id, false, timestamp - 1, 0, 0, 0, 0, 38);
243 network_graph_arc.update_channel_unsigned(&update.contents).unwrap();
244 receiver.send(GossipMessage::ChannelUpdate(update, None)).await.unwrap();
247 let update = generate_update(short_channel_id, false, timestamp, 0, 0, 0, 0, 39);
248 network_graph_arc.update_channel_unsigned(&update.contents).unwrap();
249 receiver.send(GossipMessage::ChannelUpdate(update, None)).await.unwrap();
253 { // first and only update
254 let update = generate_update(short_channel_id, true, timestamp, 0, 0, 0, 0, 10);
255 network_graph_arc.update_channel_unsigned(&update.contents).unwrap();
256 receiver.send(GossipMessage::ChannelUpdate(update, None)).await.unwrap();
261 persister.persist_gossip().await;
264 let client_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
265 let client_graph_arc = Arc::new(client_graph);
267 { // sync after initial seed
268 let serialization = serialize_delta(network_graph_arc.clone(), 0, logger.clone()).await;
269 logger.assert_log_contains("rapid_gossip_sync_server", "announcement channel count: 1", 1);
271 let channel_count = network_graph_arc.read_only().channels().len();
273 assert_eq!(channel_count, 1);
274 assert_eq!(serialization.message_count, 3);
275 assert_eq!(serialization.announcement_count, 1);
276 assert_eq!(serialization.update_count, 2);
278 let rgs = RapidGossipSync::new(client_graph_arc.clone(), logger.clone());
279 let update_result = rgs.update_network_graph(&serialization.data).unwrap();
280 // the update result must be a multiple of our snapshot granularity
281 assert_eq!(update_result % config::snapshot_generation_interval(), 0);
282 assert!(update_result < timestamp);
284 let readonly_graph = client_graph_arc.read_only();
285 let channels = readonly_graph.channels();
286 let client_channel_count = channels.len();
287 assert_eq!(client_channel_count, 1);
289 let first_channel = channels.get(&short_channel_id).unwrap();
290 assert!(&first_channel.announcement_message.is_none());
291 // ensure the update in one direction shows the latest fee
292 assert_eq!(first_channel.one_to_two.as_ref().unwrap().fees.proportional_millionths, 39);
293 assert_eq!(first_channel.two_to_one.as_ref().unwrap().fees.proportional_millionths, 10);
296 clean_test_db().await;
300 async fn test_full_snapshot_recency_with_wrong_seen_order() {
301 let _sanitizer = SchemaSanitizer::new();
302 let logger = Arc::new(TestLogger::new());
303 let network_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
304 let network_graph_arc = Arc::new(network_graph);
306 let short_channel_id = 1;
307 let timestamp = current_time();
308 println!("timestamp: {}", timestamp);
311 let (mut persister, receiver) = GossipPersister::new(network_graph_arc.clone(), logger.clone());
312 let announcement = generate_announcement(short_channel_id);
313 network_graph_arc.update_channel_from_announcement_no_lookup(&announcement).unwrap();
314 receiver.send(GossipMessage::ChannelAnnouncement(announcement, None)).await.unwrap();
317 { // first update, seen latest
318 let update = generate_update(short_channel_id, false, timestamp - 1, 0, 0, 0, 0, 38);
319 network_graph_arc.update_channel_unsigned(&update.contents).unwrap();
320 receiver.send(GossipMessage::ChannelUpdate(update, Some(timestamp))).await.unwrap();
322 { // second update, seen first
323 let update = generate_update(short_channel_id, false, timestamp, 0, 0, 0, 0, 39);
324 network_graph_arc.update_channel_unsigned(&update.contents).unwrap();
325 receiver.send(GossipMessage::ChannelUpdate(update, Some(timestamp - 1))).await.unwrap();
329 { // first and only update
330 let update = generate_update(short_channel_id, true, timestamp, 0, 0, 0, 0, 10);
331 network_graph_arc.update_channel_unsigned(&update.contents).unwrap();
332 receiver.send(GossipMessage::ChannelUpdate(update, None)).await.unwrap();
337 persister.persist_gossip().await;
340 let client_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
341 let client_graph_arc = Arc::new(client_graph);
343 { // sync after initial seed
344 let serialization = serialize_delta(network_graph_arc.clone(), 0, logger.clone()).await;
345 logger.assert_log_contains("rapid_gossip_sync_server", "announcement channel count: 1", 1);
347 let channel_count = network_graph_arc.read_only().channels().len();
349 assert_eq!(channel_count, 1);
350 assert_eq!(serialization.message_count, 3);
351 assert_eq!(serialization.announcement_count, 1);
352 assert_eq!(serialization.update_count, 2);
354 let rgs = RapidGossipSync::new(client_graph_arc.clone(), logger.clone());
355 let update_result = rgs.update_network_graph(&serialization.data).unwrap();
356 // the update result must be a multiple of our snapshot granularity
357 assert_eq!(update_result % config::snapshot_generation_interval(), 0);
358 assert!(update_result < timestamp);
360 let readonly_graph = client_graph_arc.read_only();
361 let channels = readonly_graph.channels();
362 let client_channel_count = channels.len();
363 assert_eq!(client_channel_count, 1);
365 let first_channel = channels.get(&short_channel_id).unwrap();
366 assert!(&first_channel.announcement_message.is_none());
367 // ensure the update in one direction shows the latest fee
368 assert_eq!(first_channel.one_to_two.as_ref().unwrap().fees.proportional_millionths, 39);
369 assert_eq!(first_channel.two_to_one.as_ref().unwrap().fees.proportional_millionths, 10);
372 clean_test_db().await;
376 async fn test_full_snapshot_recency_with_wrong_propagation_order() {
377 let _sanitizer = SchemaSanitizer::new();
378 let logger = Arc::new(TestLogger::new());
379 let network_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
380 let network_graph_arc = Arc::new(network_graph);
382 let short_channel_id = 1;
383 let timestamp = current_time();
384 println!("timestamp: {}", timestamp);
387 let (mut persister, receiver) = GossipPersister::new(network_graph_arc.clone(), logger.clone());
388 let announcement = generate_announcement(short_channel_id);
389 network_graph_arc.update_channel_from_announcement_no_lookup(&announcement).unwrap();
390 receiver.send(GossipMessage::ChannelAnnouncement(announcement, None)).await.unwrap();
393 // apply updates in their timestamp order
394 let update_1 = generate_update(short_channel_id, false, timestamp - 1, 0, 0, 0, 0, 38);
395 let update_2 = generate_update(short_channel_id, false, timestamp, 0, 0, 0, 0, 39);
396 network_graph_arc.update_channel_unsigned(&update_1.contents).unwrap();
397 network_graph_arc.update_channel_unsigned(&update_2.contents).unwrap();
399 // propagate updates in their seen order
400 receiver.send(GossipMessage::ChannelUpdate(update_2, Some(timestamp - 1))).await.unwrap();
401 receiver.send(GossipMessage::ChannelUpdate(update_1, Some(timestamp))).await.unwrap();
404 { // first and only update
405 let update = generate_update(short_channel_id, true, timestamp, 0, 0, 0, 0, 10);
406 network_graph_arc.update_channel_unsigned(&update.contents).unwrap();
407 receiver.send(GossipMessage::ChannelUpdate(update, None)).await.unwrap();
412 persister.persist_gossip().await;
415 let client_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
416 let client_graph_arc = Arc::new(client_graph);
418 { // sync after initial seed
419 let serialization = serialize_delta(network_graph_arc.clone(), 0, logger.clone()).await;
420 logger.assert_log_contains("rapid_gossip_sync_server", "announcement channel count: 1", 1);
422 let channel_count = network_graph_arc.read_only().channels().len();
424 assert_eq!(channel_count, 1);
425 assert_eq!(serialization.message_count, 3);
426 assert_eq!(serialization.announcement_count, 1);
427 assert_eq!(serialization.update_count, 2);
429 let rgs = RapidGossipSync::new(client_graph_arc.clone(), logger.clone());
430 let update_result = rgs.update_network_graph(&serialization.data).unwrap();
431 // the update result must be a multiple of our snapshot granularity
432 assert_eq!(update_result % config::snapshot_generation_interval(), 0);
433 assert!(update_result < timestamp);
435 let readonly_graph = client_graph_arc.read_only();
436 let channels = readonly_graph.channels();
437 let client_channel_count = channels.len();
438 assert_eq!(client_channel_count, 1);
440 let first_channel = channels.get(&short_channel_id).unwrap();
441 assert!(&first_channel.announcement_message.is_none());
442 // ensure the update in one direction shows the latest fee
443 assert_eq!(first_channel.one_to_two.as_ref().unwrap().fees.proportional_millionths, 39);
444 assert_eq!(first_channel.two_to_one.as_ref().unwrap().fees.proportional_millionths, 10);
447 clean_test_db().await;
451 async fn test_full_snapshot_mutiny_scenario() {
452 let _sanitizer = SchemaSanitizer::new();
453 let logger = Arc::new(TestLogger::new());
454 let network_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
455 let network_graph_arc = Arc::new(network_graph);
457 let short_channel_id = 873706024403271681;
458 let timestamp = current_time();
459 // let oldest_simulation_timestamp = 1693300588;
460 let latest_simulation_timestamp = 1695909301;
461 let timestamp_offset = timestamp - latest_simulation_timestamp;
462 println!("timestamp: {}", timestamp);
465 let (mut persister, receiver) = GossipPersister::new(network_graph_arc.clone(), logger.clone());
466 let announcement = generate_announcement(short_channel_id);
467 network_graph_arc.update_channel_from_announcement_no_lookup(&announcement).unwrap();
468 receiver.send(GossipMessage::ChannelAnnouncement(announcement, None)).await.unwrap();
472 let update = generate_update(short_channel_id, false, 1693507369 + timestamp_offset, 0, 0, 0, 0, 38);
473 network_graph_arc.update_channel_unsigned(&update.contents).unwrap();
474 receiver.send(GossipMessage::ChannelUpdate(update, None)).await.unwrap();
477 let update = generate_update(short_channel_id, false, 1693680390 + timestamp_offset, 0, 0, 0, 0, 38);
478 network_graph_arc.update_channel_unsigned(&update.contents).unwrap();
479 receiver.send(GossipMessage::ChannelUpdate(update, None)).await.unwrap();
482 let update = generate_update(short_channel_id, false, 1693749109 + timestamp_offset, 0, 0, 0, 0, 200);
483 network_graph_arc.update_channel_unsigned(&update.contents).unwrap();
484 receiver.send(GossipMessage::ChannelUpdate(update, None)).await.unwrap();
487 let update = generate_update(short_channel_id, false, 1693925190 + timestamp_offset, 0, 0, 0, 0, 200);
488 network_graph_arc.update_channel_unsigned(&update.contents).unwrap();
489 receiver.send(GossipMessage::ChannelUpdate(update, None)).await.unwrap();
492 let update = generate_update(short_channel_id, false, 1694008323 + timestamp_offset, 0, 0, 0, 0, 209);
493 network_graph_arc.update_channel_unsigned(&update.contents).unwrap();
494 receiver.send(GossipMessage::ChannelUpdate(update, None)).await.unwrap();
497 let update = generate_update(short_channel_id, false, 1694219924 + timestamp_offset, 0, 0, 0, 0, 209);
498 network_graph_arc.update_channel_unsigned(&update.contents).unwrap();
499 receiver.send(GossipMessage::ChannelUpdate(update, None)).await.unwrap();
502 let update = generate_update(short_channel_id, false, 1694267536 + timestamp_offset, 0, 0, 0, 0, 210);
503 network_graph_arc.update_channel_unsigned(&update.contents).unwrap();
504 receiver.send(GossipMessage::ChannelUpdate(update, None)).await.unwrap();
507 let update = generate_update(short_channel_id, false, 1694458808 + timestamp_offset, 0, 0, 0, 0, 210);
508 network_graph_arc.update_channel_unsigned(&update.contents).unwrap();
509 receiver.send(GossipMessage::ChannelUpdate(update, None)).await.unwrap();
512 let update = generate_update(short_channel_id, false, 1694526734 + timestamp_offset, 0, 0, 0, 0, 200);
513 network_graph_arc.update_channel_unsigned(&update.contents).unwrap();
514 receiver.send(GossipMessage::ChannelUpdate(update, None)).await.unwrap();
517 let update = generate_update(short_channel_id, false, 1694794765 + timestamp_offset, 0, 0, 0, 0, 200);
518 network_graph_arc.update_channel_unsigned(&update.contents).unwrap();
519 receiver.send(GossipMessage::ChannelUpdate(update, Some(1695909301 + 2 * config::SYMLINK_GRANULARITY_INTERVAL + timestamp_offset))).await.unwrap();
522 let update = generate_update(short_channel_id, false, 1695909301 + timestamp_offset, 0, 0, 0, 0, 130);
523 // network_graph_arc.update_channel_unsigned(&update.contents).unwrap();
524 receiver.send(GossipMessage::ChannelUpdate(update, None)).await.unwrap();
529 let update = generate_update(short_channel_id, true, 1693300588 + timestamp_offset, 0, 0, 0, 0, 10);
530 network_graph_arc.update_channel_unsigned(&update.contents).unwrap();
531 receiver.send(GossipMessage::ChannelUpdate(update, None)).await.unwrap();
534 let update = generate_update(short_channel_id, true, 1695003621 + timestamp_offset, 0, 0, 0, 0, 10);
535 network_graph_arc.update_channel_unsigned(&update.contents).unwrap();
536 receiver.send(GossipMessage::ChannelUpdate(update, None)).await.unwrap();
541 persister.persist_gossip().await;
544 let client_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
545 let client_graph_arc = Arc::new(client_graph);
547 { // sync after initial seed
548 let serialization = serialize_delta(network_graph_arc.clone(), 0, logger.clone()).await;
549 logger.assert_log_contains("rapid_gossip_sync_server", "announcement channel count: 1", 1);
551 let channel_count = network_graph_arc.read_only().channels().len();
553 assert_eq!(channel_count, 1);
554 assert_eq!(serialization.message_count, 3);
555 assert_eq!(serialization.announcement_count, 1);
556 assert_eq!(serialization.update_count, 2);
558 let rgs = RapidGossipSync::new(client_graph_arc.clone(), logger.clone());
559 let update_result = rgs.update_network_graph(&serialization.data).unwrap();
560 println!("update result: {}", update_result);
561 // the update result must be a multiple of our snapshot granularity
562 assert_eq!(update_result % config::snapshot_generation_interval(), 0);
563 assert!(update_result < timestamp);
565 let timestamp_delta = timestamp - update_result;
566 println!("timestamp delta: {}", timestamp_delta);
567 assert!(timestamp_delta < config::snapshot_generation_interval());
569 let readonly_graph = client_graph_arc.read_only();
570 let channels = readonly_graph.channels();
571 let client_channel_count = channels.len();
572 assert_eq!(client_channel_count, 1);
574 let first_channel = channels.get(&short_channel_id).unwrap();
575 assert!(&first_channel.announcement_message.is_none());
576 assert_eq!(first_channel.one_to_two.as_ref().unwrap().fees.proportional_millionths, 130);
577 assert_eq!(first_channel.two_to_one.as_ref().unwrap().fees.proportional_millionths, 10);
580 clean_test_db().await;