X-Git-Url: http://git.bitcoin.ninja/index.cgi?a=blobdiff_plain;f=lightning%2Fsrc%2Fln%2Ffunctional_test_utils.rs;h=27908ca54623a64c07bffbd3fac9815e3d703e02;hb=78c48f76d429b21dc34bcf636946b3d5a30d9a1d;hp=cb210d45d59dd112ddbcfa4833f4d1d01651e3d7;hpb=ce4de5fb52246f91d37127594f8fd7d304ab86ad;p=rust-lightning diff --git a/lightning/src/ln/functional_test_utils.rs b/lightning/src/ln/functional_test_utils.rs index cb210d45..27908ca5 100644 --- a/lightning/src/ln/functional_test_utils.rs +++ b/lightning/src/ln/functional_test_utils.rs @@ -6,7 +6,7 @@ use chain::transaction::OutPoint; use chain::keysinterface::KeysInterface; use ln::channelmanager::{ChannelManager, ChannelManagerReadArgs, RAACommitmentOrder, PaymentPreimage, PaymentHash}; use ln::channelmonitor::{ChannelMonitor, ManyChannelMonitor}; -use ln::router::{Route, Router}; +use ln::router::{Route, Router, RouterReadArgs}; use ln::features::InitFeatures; use ln::msgs; use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler}; @@ -37,7 +37,7 @@ use std::cell::RefCell; use std::rc::Rc; use std::sync::{Arc, Mutex}; use std::mem; -use std::collections::{HashSet, HashMap}; +use std::collections::HashMap; pub const CHAN_CONFIRM_DEPTH: u32 = 100; pub fn confirm_transaction<'a, 'b: 'a>(notifier: &'a chaininterface::BlockNotifierRef<'b>, chain: &chaininterface::ChainWatchInterfaceUtil, tx: &Transaction, chan_id: u32) { @@ -97,6 +97,36 @@ impl<'a, 'b, 'c> Drop for Node<'a, 'b, 'c> { assert!(self.node.get_and_clear_pending_events().is_empty()); assert!(self.chan_monitor.added_monitors.lock().unwrap().is_empty()); + // Check that if we serialize the Router, we can deserialize it again. + { + let mut w = test_utils::TestVecWriter(Vec::new()); + self.router.write(&mut w).unwrap(); + let deserialized_router = Router::read(&mut ::std::io::Cursor::new(&w.0), RouterReadArgs { + chain_monitor: Arc::clone(&self.chain_monitor) as Arc, + logger: Arc::clone(&self.logger) as Arc + }).unwrap(); + let mut chan_progress = 0; + loop { + let orig_announcements = self.router.get_next_channel_announcements(chan_progress, 255); + let deserialized_announcements = deserialized_router.get_next_channel_announcements(chan_progress, 255); + assert!(orig_announcements == deserialized_announcements); + chan_progress = match orig_announcements.last() { + Some(announcement) => announcement.0.contents.short_channel_id + 1, + None => break, + }; + } + let mut node_progress = None; + loop { + let orig_announcements = self.router.get_next_node_announcements(node_progress.as_ref(), 255); + let deserialized_announcements = deserialized_router.get_next_node_announcements(node_progress.as_ref(), 255); + assert!(orig_announcements == deserialized_announcements); + node_progress = match orig_announcements.last() { + Some(announcement) => Some(announcement.contents.node_id), + None => break, + }; + } + } + // Check that if we serialize and then deserialize all our channel monitors we get the // same set of outputs to watch for on chain as we have now. Note that if we write // tests that fully close channels and remove the monitors at some point this may break. @@ -246,7 +276,7 @@ pub fn create_funding_transaction<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, expected_ } pub fn create_chan_between_nodes_with_value_init<'a, 'b, 'c>(node_a: &Node<'a, 'b, 'c>, node_b: &Node<'a, 'b, 'c>, channel_value: u64, push_msat: u64, a_flags: InitFeatures, b_flags: InitFeatures) -> Transaction { - node_a.node.create_channel(node_b.node.get_our_node_id(), channel_value, push_msat, 42).unwrap(); + node_a.node.create_channel(node_b.node.get_our_node_id(), channel_value, push_msat, 42, None).unwrap(); node_b.node.handle_open_channel(&node_a.node.get_our_node_id(), a_flags, &get_event_msg!(node_a, MessageSendEvent::SendOpenChannel, node_b.node.get_our_node_id())); node_a.node.handle_accept_channel(&node_b.node.get_our_node_id(), b_flags, &get_event_msg!(node_b, MessageSendEvent::SendAcceptChannel, node_a.node.get_our_node_id())); @@ -364,23 +394,47 @@ pub fn create_announced_chan_between_nodes<'a, 'b, 'c, 'd>(nodes: &'a Vec(nodes: &'a Vec>, a: usize, b: usize, channel_value: u64, push_msat: u64, a_flags: InitFeatures, b_flags: InitFeatures) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) { let chan_announcement = create_chan_between_nodes_with_value(&nodes[a], &nodes[b], channel_value, push_msat, a_flags, b_flags); + + nodes[a].node.broadcast_node_announcement([0, 0, 0], [0; 32], Vec::new()); + let a_events = nodes[a].node.get_and_clear_pending_msg_events(); + assert_eq!(a_events.len(), 1); + let a_node_announcement = match a_events[0] { + MessageSendEvent::BroadcastNodeAnnouncement { ref msg } => { + (*msg).clone() + }, + _ => panic!("Unexpected event"), + }; + + nodes[b].node.broadcast_node_announcement([1, 1, 1], [1; 32], Vec::new()); + let b_events = nodes[b].node.get_and_clear_pending_msg_events(); + assert_eq!(b_events.len(), 1); + let b_node_announcement = match b_events[0] { + MessageSendEvent::BroadcastNodeAnnouncement { ref msg } => { + (*msg).clone() + }, + _ => panic!("Unexpected event"), + }; + for node in nodes { assert!(node.router.handle_channel_announcement(&chan_announcement.0).unwrap()); node.router.handle_channel_update(&chan_announcement.1).unwrap(); node.router.handle_channel_update(&chan_announcement.2).unwrap(); + node.router.handle_node_announcement(&a_node_announcement).unwrap(); + node.router.handle_node_announcement(&b_node_announcement).unwrap(); } (chan_announcement.1, chan_announcement.2, chan_announcement.3, chan_announcement.4) } macro_rules! check_spends { - ($tx: expr, $spends_tx: expr) => { + ($tx: expr, $($spends_txn: expr),*) => { { $tx.verify(|out_point| { - if out_point.txid == $spends_tx.txid() { - $spends_tx.output.get(out_point.vout as usize).cloned() - } else { - None - } + $( + if out_point.txid == $spends_txn.txid() { + return $spends_txn.output.get(out_point.vout as usize).cloned() + } + )* + None }).unwrap(); } } @@ -920,7 +974,7 @@ pub fn fail_payment<'a, 'b, 'c>(origin_node: &Node<'a, 'b, 'c>, expected_route: pub fn create_chanmon_cfgs(node_count: usize) -> Vec { let mut chan_mon_cfgs = Vec::new(); for _ in 0..node_count { - let tx_broadcaster = test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new()), broadcasted_txn: Mutex::new(HashSet::new())}; + let tx_broadcaster = test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new())}; let fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 }; chan_mon_cfgs.push(TestChanMonCfg{ tx_broadcaster, fee_estimator }); } @@ -1003,7 +1057,7 @@ pub fn test_txn_broadcast<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, chan: &(msgs::Cha let mut res = Vec::with_capacity(2); node_txn.retain(|tx| { if tx.input.len() == 1 && tx.input[0].previous_output.txid == chan.3.txid() { - check_spends!(tx, chan.3.clone()); + check_spends!(tx, chan.3); if commitment_tx.is_none() { res.push(tx.clone()); } @@ -1019,7 +1073,7 @@ pub fn test_txn_broadcast<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, chan: &(msgs::Cha if has_htlc_tx != HTLCType::NONE { node_txn.retain(|tx| { if tx.input.len() == 1 && tx.input[0].previous_output.txid == res[0].txid() { - check_spends!(tx, res[0].clone()); + check_spends!(tx, res[0]); if has_htlc_tx == HTLCType::TIMEOUT { assert!(tx.lock_time != 0); } else { @@ -1068,7 +1122,7 @@ pub fn check_preimage_claim<'a, 'b, 'c>(node: &Node<'a, 'b, 'c>, prev_txn: &Vec< for tx in prev_txn { if node_txn[0].input[0].previous_output.txid == tx.txid() { - check_spends!(node_txn[0], tx.clone()); + check_spends!(node_txn[0], tx); assert!(node_txn[0].input[0].witness[2].len() > 106); // must spend an htlc output assert_eq!(tx.input.len(), 1); // must spend a commitment tx