_ Git - rapid-gossip-sync-server/blob - src/tests/mod.rs

   1 //! Multi-module tests that use database fixtures
   2
   3 use std::cell::RefCell;
   4 use std::sync::Arc;
   5 use std::thread;
   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};
  21
  22 const CLIENT_BACKDATE_INTERVAL: u32 = 3600 * 24 * 7; // client backdates RGS by a week
  23
  24 thread_local! {
  25         static DB_TEST_SCHEMA: RefCell<Option<String>> = RefCell::new(None);
  26         static IS_TEST_SCHEMA_CLEAN: RefCell<Option<bool>> = RefCell::new(None);
  27 }
  28
  29 fn blank_signature() -> Signature {
  30         Signature::from_compact(&[0u8; 64]).unwrap()
  31 }
  32
  33 fn genesis_hash() -> BlockHash {
  34         bitcoin::blockdata::constants::genesis_block(Network::Bitcoin).block_hash()
  35 }
  36
  37 fn current_time() -> u32 {
  38         SystemTime::now().duration_since(UNIX_EPOCH).expect("Time must be > 1970").as_secs() as u32
  39 }
  40
  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()
  45         })
  46 }
  47
  48 fn generate_announcement(short_channel_id: u64) -> ChannelAnnouncement {
  49         let secp_context = Secp256k1::new();
  50
  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);
  54
  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);
  58
  59         let announcement = UnsignedChannelAnnouncement {
  60                 features: ChannelFeatures::empty(),
  61                 chain_hash: genesis_hash(),
  62                 short_channel_id,
  63                 node_id_1,
  64                 node_id_2,
  65                 bitcoin_key_1: node_id_1,
  66                 bitcoin_key_2: node_id_2,
  67                 excess_data: vec![],
  68         };
  69
  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);
  73
  74         ChannelAnnouncement {
  75                 node_signature_1,
  76                 node_signature_2,
  77                 bitcoin_signature_1: node_signature_1,
  78                 bitcoin_signature_2: node_signature_2,
  79                 contents: announcement,
  80         }
  81 }
  82
  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 };
  85         ChannelUpdate {
  86                 signature: blank_signature(),
  87                 contents: UnsignedChannelUpdate {
  88                         chain_hash: genesis_hash(),
  89                         short_channel_id: scid,
  90                         timestamp,
  91                         flags: 0 | flag_mask,
  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,
  97                         excess_data: vec![],
  98                 },
  99         }
 100 }
 101
 102 struct SchemaSanitizer {}
 103
 104 impl SchemaSanitizer {
 105         fn new() -> Self {
 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);
 110                 });
 111
 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);
 126                 });
 127
 128                 return Self {};
 129         }
 130 }
 131
 132 impl Drop for SchemaSanitizer {
 133         fn drop(&mut self) {
 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);
 138                         }
 139                 });
 140         }
 141 }
 142
 143
 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);
 151         });
 152 }
 153
 154 #[tokio::test]
 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());
 161
 162         let short_channel_id = 1;
 163         let timestamp = current_time() - 10;
 164         println!("timestamp: {}", timestamp);
 165
 166         { // seed the db
 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);
 170
 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();
 174
 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();
 178                 drop(receiver);
 179                 persister.persist_gossip().await;
 180         }
 181
 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;
 185
 186         let channel_count = network_graph_arc.read_only().channels().len();
 187
 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);
 192
 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);
 201
 202         let timestamp_delta = timestamp - update_result;
 203         println!("timestamp delta: {}", timestamp_delta);
 204         assert!(timestamp_delta < config::snapshot_generation_interval());
 205
 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);
 210
 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);
 221 }
 222
 223 #[tokio::test]
 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);
 229
 230         let short_channel_id = 1;
 231         let timestamp = current_time();
 232         println!("timestamp: {}", timestamp);
 233
 234         { // seed the db
 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();
 239
 240                 { // direction false
 241                         { // first update
 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();
 245                         }
 246                         { // second update
 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();
 250                         }
 251                 }
 252                 { // direction true
 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();
 257                         }
 258                 }
 259
 260                 drop(receiver);
 261                 persister.persist_gossip().await;
 262         }
 263
 264         let client_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
 265         let client_graph_arc = Arc::new(client_graph);
 266
 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);
 270
 271                 let channel_count = network_graph_arc.read_only().channels().len();
 272
 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);
 277
 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);
 283
 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);
 288
 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);
 294         }
 295
 296         clean_test_db().await;
 297 }
 298
 299 #[tokio::test]
 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);
 305
 306         let short_channel_id = 1;
 307         let timestamp = current_time();
 308         println!("timestamp: {}", timestamp);
 309
 310         { // seed the db
 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();
 315
 316                 { // direction false
 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();
 321                         }
 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();
 326                         }
 327                 }
 328                 { // direction true
 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();
 333                         }
 334                 }
 335
 336                 drop(receiver);
 337                 persister.persist_gossip().await;
 338         }
 339
 340         let client_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
 341         let client_graph_arc = Arc::new(client_graph);
 342
 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);
 346
 347                 let channel_count = network_graph_arc.read_only().channels().len();
 348
 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);
 353
 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);
 359
 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);
 364
 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);
 370         }
 371
 372         clean_test_db().await;
 373 }
 374
 375 #[tokio::test]
 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);
 381
 382         let short_channel_id = 1;
 383         let timestamp = current_time();
 384         println!("timestamp: {}", timestamp);
 385
 386         { // seed the db
 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();
 391
 392                 { // direction false
 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();
 398
 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();
 402                 }
 403                 { // direction true
 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();
 408                         }
 409                 }
 410
 411                 drop(receiver);
 412                 persister.persist_gossip().await;
 413         }
 414
 415         let client_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
 416         let client_graph_arc = Arc::new(client_graph);
 417
 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);
 421
 422                 let channel_count = network_graph_arc.read_only().channels().len();
 423
 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);
 428
 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);
 434
 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);
 439
 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);
 445         }
 446
 447         clean_test_db().await;
 448 }
 449
 450 #[tokio::test]
 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);
 456
 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);
 463
 464         { // seed the db
 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();
 469
 470                 { // direction false
 471                         {
 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();
 475                         }
 476                         {
 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();
 480                         }
 481                         {
 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();
 485                         }
 486                         {
 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();
 490                         }
 491                         {
 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();
 495                         }
 496                         {
 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();
 500                         }
 501                         {
 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();
 505                         }
 506                         {
 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();
 510                         }
 511                         {
 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();
 515                         }
 516                         {
 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();
 520                         }
 521                         {
 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();
 525                         }
 526                 }
 527                 { // direction true
 528                         {
 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();
 532                         }
 533                         {
 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();
 537                         }
 538                 }
 539
 540                 drop(receiver);
 541                 persister.persist_gossip().await;
 542         }
 543
 544         let client_graph = NetworkGraph::new(Network::Bitcoin, logger.clone());
 545         let client_graph_arc = Arc::new(client_graph);
 546
 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);
 550
 551                 let channel_count = network_graph_arc.read_only().channels().len();
 552
 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);
 557
 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);
 564
 565                 let timestamp_delta = timestamp - update_result;
 566                 println!("timestamp delta: {}", timestamp_delta);
 567                 assert!(timestamp_delta < config::snapshot_generation_interval());
 568
 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);
 573
 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);
 578         }
 579
 580         clean_test_db().await;
 581 }