_ Git - rust-lightning/blob - lightning/src/ln/functional_test_utils.rs

   1 //! A bunch of useful utilities for building networks of nodes and exchanging messages between
   2 //! nodes for functional tests.
   3
   4 use chain::chaininterface;
   5 use chain::transaction::OutPoint;
   6 use chain::keysinterface::KeysInterface;
   7 use ln::channelmonitor::{ChannelMonitor, ManyChannelMonitor};
   8 use ln::channelmanager::{ChannelManager,RAACommitmentOrder, PaymentPreimage, PaymentHash, PaymentSendFailure};
   9 use ln::router::{Route, Router};
  10 use ln::features::InitFeatures;
  11 use ln::msgs;
  12 use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler};
  13 use util::enforcing_trait_impls::EnforcingChannelKeys;
  14 use util::test_utils;
  15 use util::test_utils::TestChannelMonitor;
  16 use util::events::{Event, EventsProvider, MessageSendEvent, MessageSendEventsProvider};
  17 use util::errors::APIError;
  18 use util::logger::Logger;
  19 use util::config::UserConfig;
  20 use util::ser::ReadableArgs;
  21
  22 use bitcoin::util::hash::BitcoinHash;
  23 use bitcoin::blockdata::block::BlockHeader;
  24 use bitcoin::blockdata::transaction::{Transaction, TxOut};
  25 use bitcoin::network::constants::Network;
  26
  27 use bitcoin_hashes::sha256::Hash as Sha256;
  28 use bitcoin_hashes::sha256d::Hash as Sha256d;
  29 use bitcoin_hashes::Hash;
  30
  31 use secp256k1::Secp256k1;
  32 use secp256k1::key::PublicKey;
  33
  34 use rand::{thread_rng,Rng};
  35
  36 use std::cell::RefCell;
  37 use std::rc::Rc;
  38 use std::sync::{Arc, Mutex};
  39 use std::mem;
  40
  41 pub const CHAN_CONFIRM_DEPTH: u32 = 100;
  42 pub fn confirm_transaction<'a, 'b: 'a>(notifier: &'a chaininterface::BlockNotifierRef<'b>, chain: &chaininterface::ChainWatchInterfaceUtil, tx: &Transaction, chan_id: u32) {
  43         assert!(chain.does_match_tx(tx));
  44         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
  45         notifier.block_connected_checked(&header, 1, &[tx; 1], &[chan_id; 1]);
  46         for i in 2..CHAN_CONFIRM_DEPTH {
  47                 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
  48                 notifier.block_connected_checked(&header, i, &vec![], &[0; 0]);
  49         }
  50 }
  51
  52 pub fn connect_blocks<'a, 'b>(notifier: &'a chaininterface::BlockNotifierRef<'b>, depth: u32, height: u32, parent: bool, prev_blockhash: Sha256d) -> Sha256d {
  53         let mut header = BlockHeader { version: 0x2000000, prev_blockhash: if parent { prev_blockhash } else { Default::default() }, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
  54         notifier.block_connected_checked(&header, height + 1, &Vec::new(), &Vec::new());
  55         for i in 2..depth + 1 {
  56                 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
  57                 notifier.block_connected_checked(&header, height + i, &Vec::new(), &Vec::new());
  58         }
  59         header.bitcoin_hash()
  60 }
  61
  62 pub struct NodeCfg {
  63         pub chain_monitor: Arc<chaininterface::ChainWatchInterfaceUtil>,
  64         pub tx_broadcaster: Arc<test_utils::TestBroadcaster>,
  65         pub fee_estimator: Arc<test_utils::TestFeeEstimator>,
  66         pub chan_monitor: test_utils::TestChannelMonitor,
  67         pub keys_manager: Arc<test_utils::TestKeysInterface>,
  68         pub logger: Arc<test_utils::TestLogger>,
  69         pub node_seed: [u8; 32],
  70 }
  71
  72 pub struct Node<'a, 'b: 'a> {
  73         pub block_notifier: chaininterface::BlockNotifierRef<'b>,
  74         pub chain_monitor: Arc<chaininterface::ChainWatchInterfaceUtil>,
  75         pub tx_broadcaster: Arc<test_utils::TestBroadcaster>,
  76         pub chan_monitor: &'b test_utils::TestChannelMonitor,
  77         pub keys_manager: Arc<test_utils::TestKeysInterface>,
  78         pub node: &'a ChannelManager<EnforcingChannelKeys, &'b TestChannelMonitor>,
  79         pub router: Router,
  80         pub node_seed: [u8; 32],
  81         pub network_payment_count: Rc<RefCell<u8>>,
  82         pub network_chan_count: Rc<RefCell<u32>>,
  83         pub logger: Arc<test_utils::TestLogger>
  84 }
  85
  86 impl<'a, 'b> Drop for Node<'a, 'b> {
  87         fn drop(&mut self) {
  88                 if !::std::thread::panicking() {
  89                         // Check that we processed all pending events
  90                         assert!(self.node.get_and_clear_pending_msg_events().is_empty());
  91                         assert!(self.node.get_and_clear_pending_events().is_empty());
  92                         assert!(self.chan_monitor.added_monitors.lock().unwrap().is_empty());
  93
  94                         // Check that if we serialize and then deserialize all our channel monitors we the same
  95                         // set of outputs to watch for on chain as we have now. Note that if we write tests
  96                         // that fully close channels and remove the monitors at some point this may break.
  97                         let new_watch = Arc::new(chaininterface::ChainWatchInterfaceUtil::new(Network::Testnet, Arc::clone(&self.logger) as Arc<Logger>));
  98                         let feeest = Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 });
  99                         let new_monitor = test_utils::TestChannelMonitor::new(new_watch.clone(), self.tx_broadcaster.clone(), self.logger.clone(), feeest);
 100                         let old_monitors = self.chan_monitor.simple_monitor.monitors.lock().unwrap();
 101                         for (_, monitor) in old_monitors.iter() {
 102                                 let mut w = test_utils::TestVecWriter(Vec::new());
 103                                 monitor.write_for_disk(&mut w).unwrap();
 104                                 let (_, new_mon) = <(Sha256d, ChannelMonitor)>::read(
 105                                         &mut ::std::io::Cursor::new(&w.0), Arc::clone(&self.logger) as Arc<Logger>).unwrap();
 106                                 if let Err(_) = new_monitor.add_update_monitor(new_mon.get_funding_txo().unwrap(), new_mon) {
 107                                         panic!();
 108                                 }
 109                         }
 110
 111                         if *new_watch != *self.chain_monitor {
 112                                 panic!();
 113                         }
 114                 }
 115         }
 116 }
 117
 118 pub fn create_chan_between_nodes<'a, 'b, 'c>(node_a: &'a Node<'b, 'c>, node_b: &'a Node<'b, 'c>, a_flags: InitFeatures, b_flags: InitFeatures) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
 119         create_chan_between_nodes_with_value(node_a, node_b, 100000, 10001, a_flags, b_flags)
 120 }
 121
 122 pub fn create_chan_between_nodes_with_value<'a, 'b, 'c>(node_a: &'a Node<'b, 'c>, node_b: &'a Node<'b, 'c>, channel_value: u64, push_msat: u64, a_flags: InitFeatures, b_flags: InitFeatures) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
 123         let (funding_locked, channel_id, tx) = create_chan_between_nodes_with_value_a(node_a, node_b, channel_value, push_msat, a_flags, b_flags);
 124         let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(node_a, node_b, &funding_locked);
 125         (announcement, as_update, bs_update, channel_id, tx)
 126 }
 127
 128 macro_rules! get_revoke_commit_msgs {
 129         ($node: expr, $node_id: expr) => {
 130                 {
 131                         let events = $node.node.get_and_clear_pending_msg_events();
 132                         assert_eq!(events.len(), 2);
 133                         (match events[0] {
 134                                 MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
 135                                         assert_eq!(*node_id, $node_id);
 136                                         (*msg).clone()
 137                                 },
 138                                 _ => panic!("Unexpected event"),
 139                         }, match events[1] {
 140                                 MessageSendEvent::UpdateHTLCs { ref node_id, ref updates } => {
 141                                         assert_eq!(*node_id, $node_id);
 142                                         assert!(updates.update_add_htlcs.is_empty());
 143                                         assert!(updates.update_fulfill_htlcs.is_empty());
 144                                         assert!(updates.update_fail_htlcs.is_empty());
 145                                         assert!(updates.update_fail_malformed_htlcs.is_empty());
 146                                         assert!(updates.update_fee.is_none());
 147                                         updates.commitment_signed.clone()
 148                                 },
 149                                 _ => panic!("Unexpected event"),
 150                         })
 151                 }
 152         }
 153 }
 154
 155 macro_rules! get_event_msg {
 156         ($node: expr, $event_type: path, $node_id: expr) => {
 157                 {
 158                         let events = $node.node.get_and_clear_pending_msg_events();
 159                         assert_eq!(events.len(), 1);
 160                         match events[0] {
 161                                 $event_type { ref node_id, ref msg } => {
 162                                         assert_eq!(*node_id, $node_id);
 163                                         (*msg).clone()
 164                                 },
 165                                 _ => panic!("Unexpected event"),
 166                         }
 167                 }
 168         }
 169 }
 170
 171 macro_rules! get_htlc_update_msgs {
 172         ($node: expr, $node_id: expr) => {
 173                 {
 174                         let events = $node.node.get_and_clear_pending_msg_events();
 175                         assert_eq!(events.len(), 1);
 176                         match events[0] {
 177                                 MessageSendEvent::UpdateHTLCs { ref node_id, ref updates } => {
 178                                         assert_eq!(*node_id, $node_id);
 179                                         (*updates).clone()
 180                                 },
 181                                 _ => panic!("Unexpected event"),
 182                         }
 183                 }
 184         }
 185 }
 186
 187 macro_rules! get_feerate {
 188         ($node: expr, $channel_id: expr) => {
 189                 {
 190                         let chan_lock = $node.node.channel_state.lock().unwrap();
 191                         let chan = chan_lock.by_id.get(&$channel_id).unwrap();
 192                         chan.get_feerate()
 193                 }
 194         }
 195 }
 196
 197 macro_rules! unwrap_send_err {
 198         ($res: expr, $all_failed: expr, $type: pat, $check: expr) => {
 199                 match &$res {
 200                         &Err(PaymentSendFailure::AllFailedRetrySafe(ref fails)) if $all_failed => {
 201                                 assert_eq!(fails.len(), 1);
 202                                 match fails[0] {
 203                                         $type => { $check },
 204                                         _ => panic!(),
 205                                 }
 206                         },
 207                         &Err(PaymentSendFailure::PartialFailure(ref fails)) if !$all_failed => {
 208                                 assert_eq!(fails.len(), 1);
 209                                 match fails[0] {
 210                                         Err($type) => { $check },
 211                                         _ => panic!(),
 212                                 }
 213                         },
 214                         _ => panic!(),
 215                 }
 216         }
 217 }
 218
 219 pub fn create_funding_transaction<'a, 'b>(node: &Node<'a, 'b>, expected_chan_value: u64, expected_user_chan_id: u64) -> ([u8; 32], Transaction, OutPoint) {
 220         let chan_id = *node.network_chan_count.borrow();
 221
 222         let events = node.node.get_and_clear_pending_events();
 223         assert_eq!(events.len(), 1);
 224         match events[0] {
 225                 Event::FundingGenerationReady { ref temporary_channel_id, ref channel_value_satoshis, ref output_script, user_channel_id } => {
 226                         assert_eq!(*channel_value_satoshis, expected_chan_value);
 227                         assert_eq!(user_channel_id, expected_user_chan_id);
 228
 229                         let tx = Transaction { version: chan_id as u32, lock_time: 0, input: Vec::new(), output: vec![TxOut {
 230                                 value: *channel_value_satoshis, script_pubkey: output_script.clone(),
 231                         }]};
 232                         let funding_outpoint = OutPoint::new(tx.txid(), 0);
 233                         (*temporary_channel_id, tx, funding_outpoint)
 234                 },
 235                 _ => panic!("Unexpected event"),
 236         }
 237 }
 238
 239 pub fn create_chan_between_nodes_with_value_init<'a, 'b>(node_a: &Node<'a, 'b>, node_b: &Node<'a, 'b>, channel_value: u64, push_msat: u64, a_flags: InitFeatures, b_flags: InitFeatures) -> Transaction {
 240         node_a.node.create_channel(node_b.node.get_our_node_id(), channel_value, push_msat, 42).unwrap();
 241         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()));
 242         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()));
 243
 244         let (temporary_channel_id, tx, funding_output) = create_funding_transaction(node_a, channel_value, 42);
 245
 246         {
 247                 node_a.node.funding_transaction_generated(&temporary_channel_id, funding_output);
 248                 let mut added_monitors = node_a.chan_monitor.added_monitors.lock().unwrap();
 249                 assert_eq!(added_monitors.len(), 1);
 250                 assert_eq!(added_monitors[0].0, funding_output);
 251                 added_monitors.clear();
 252         }
 253
 254         node_b.node.handle_funding_created(&node_a.node.get_our_node_id(), &get_event_msg!(node_a, MessageSendEvent::SendFundingCreated, node_b.node.get_our_node_id()));
 255         {
 256                 let mut added_monitors = node_b.chan_monitor.added_monitors.lock().unwrap();
 257                 assert_eq!(added_monitors.len(), 1);
 258                 assert_eq!(added_monitors[0].0, funding_output);
 259                 added_monitors.clear();
 260         }
 261
 262         node_a.node.handle_funding_signed(&node_b.node.get_our_node_id(), &get_event_msg!(node_b, MessageSendEvent::SendFundingSigned, node_a.node.get_our_node_id()));
 263         {
 264                 let mut added_monitors = node_a.chan_monitor.added_monitors.lock().unwrap();
 265                 assert_eq!(added_monitors.len(), 1);
 266                 assert_eq!(added_monitors[0].0, funding_output);
 267                 added_monitors.clear();
 268         }
 269
 270         let events_4 = node_a.node.get_and_clear_pending_events();
 271         assert_eq!(events_4.len(), 1);
 272         match events_4[0] {
 273                 Event::FundingBroadcastSafe { ref funding_txo, user_channel_id } => {
 274                         assert_eq!(user_channel_id, 42);
 275                         assert_eq!(*funding_txo, funding_output);
 276                 },
 277                 _ => panic!("Unexpected event"),
 278         };
 279
 280         tx
 281 }
 282
 283 pub fn create_chan_between_nodes_with_value_confirm_first<'a, 'b, 'c>(node_recv: &'a Node<'a, 'b>, node_conf: &'a Node<'a, 'b>, tx: &Transaction) {
 284         confirm_transaction(&node_conf.block_notifier, &node_conf.chain_monitor, &tx, tx.version);
 285         node_recv.node.handle_funding_locked(&node_conf.node.get_our_node_id(), &get_event_msg!(node_conf, MessageSendEvent::SendFundingLocked, node_recv.node.get_our_node_id()));
 286 }
 287
 288 pub fn create_chan_between_nodes_with_value_confirm_second<'a, 'b>(node_recv: &Node<'a, 'b>, node_conf: &Node<'a, 'b>) -> ((msgs::FundingLocked, msgs::AnnouncementSignatures), [u8; 32]) {
 289         let channel_id;
 290         let events_6 = node_conf.node.get_and_clear_pending_msg_events();
 291         assert_eq!(events_6.len(), 2);
 292         ((match events_6[0] {
 293                 MessageSendEvent::SendFundingLocked { ref node_id, ref msg } => {
 294                         channel_id = msg.channel_id.clone();
 295                         assert_eq!(*node_id, node_recv.node.get_our_node_id());
 296                         msg.clone()
 297                 },
 298                 _ => panic!("Unexpected event"),
 299         }, match events_6[1] {
 300                 MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } => {
 301                         assert_eq!(*node_id, node_recv.node.get_our_node_id());
 302                         msg.clone()
 303                 },
 304                 _ => panic!("Unexpected event"),
 305         }), channel_id)
 306 }
 307
 308 pub fn create_chan_between_nodes_with_value_confirm<'a, 'b, 'c>(node_a: &'a Node<'b, 'c>, node_b: &'a Node<'b, 'c>, tx: &Transaction) -> ((msgs::FundingLocked, msgs::AnnouncementSignatures), [u8; 32]) {
 309         create_chan_between_nodes_with_value_confirm_first(node_a, node_b, tx);
 310         confirm_transaction(&node_a.block_notifier, &node_a.chain_monitor, &tx, tx.version);
 311         create_chan_between_nodes_with_value_confirm_second(node_b, node_a)
 312 }
 313
 314 pub fn create_chan_between_nodes_with_value_a<'a, 'b, 'c>(node_a: &'a Node<'b, 'c>, node_b: &'a Node<'b, 'c>, channel_value: u64, push_msat: u64, a_flags: InitFeatures, b_flags: InitFeatures) -> ((msgs::FundingLocked, msgs::AnnouncementSignatures), [u8; 32], Transaction) {
 315         let tx = create_chan_between_nodes_with_value_init(node_a, node_b, channel_value, push_msat, a_flags, b_flags);
 316         let (msgs, chan_id) = create_chan_between_nodes_with_value_confirm(node_a, node_b, &tx);
 317         (msgs, chan_id, tx)
 318 }
 319
 320 pub fn create_chan_between_nodes_with_value_b<'a, 'b>(node_a: &Node<'a, 'b>, node_b: &Node<'a, 'b>, as_funding_msgs: &(msgs::FundingLocked, msgs::AnnouncementSignatures)) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate) {
 321         node_b.node.handle_funding_locked(&node_a.node.get_our_node_id(), &as_funding_msgs.0);
 322         let bs_announcement_sigs = get_event_msg!(node_b, MessageSendEvent::SendAnnouncementSignatures, node_a.node.get_our_node_id());
 323         node_b.node.handle_announcement_signatures(&node_a.node.get_our_node_id(), &as_funding_msgs.1);
 324
 325         let events_7 = node_b.node.get_and_clear_pending_msg_events();
 326         assert_eq!(events_7.len(), 1);
 327         let (announcement, bs_update) = match events_7[0] {
 328                 MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } => {
 329                         (msg, update_msg)
 330                 },
 331                 _ => panic!("Unexpected event"),
 332         };
 333
 334         node_a.node.handle_announcement_signatures(&node_b.node.get_our_node_id(), &bs_announcement_sigs);
 335         let events_8 = node_a.node.get_and_clear_pending_msg_events();
 336         assert_eq!(events_8.len(), 1);
 337         let as_update = match events_8[0] {
 338                 MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } => {
 339                         assert!(*announcement == *msg);
 340                         assert_eq!(update_msg.contents.short_channel_id, announcement.contents.short_channel_id);
 341                         assert_eq!(update_msg.contents.short_channel_id, bs_update.contents.short_channel_id);
 342                         update_msg
 343                 },
 344                 _ => panic!("Unexpected event"),
 345         };
 346
 347         *node_a.network_chan_count.borrow_mut() += 1;
 348
 349         ((*announcement).clone(), (*as_update).clone(), (*bs_update).clone())
 350 }
 351
 352 pub fn create_announced_chan_between_nodes<'a, 'b, 'c>(nodes: &'a Vec<Node<'b, 'c>>, a: usize, b: usize, a_flags: InitFeatures, b_flags: InitFeatures) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
 353         create_announced_chan_between_nodes_with_value(nodes, a, b, 100000, 10001, a_flags, b_flags)
 354 }
 355
 356 pub fn create_announced_chan_between_nodes_with_value<'a, 'b, 'c>(nodes: &'a Vec<Node<'b, 'c>>, a: usize, b: usize, channel_value: u64, push_msat: u64, a_flags: InitFeatures, b_flags: InitFeatures) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
 357         let chan_announcement = create_chan_between_nodes_with_value(&nodes[a], &nodes[b], channel_value, push_msat, a_flags, b_flags);
 358
 359         nodes[a].node.broadcast_node_announcement([0, 0, 0], [0; 32], msgs::NetAddressSet::new());
 360         let a_events = nodes[a].node.get_and_clear_pending_msg_events();
 361         assert_eq!(a_events.len(), 1);
 362         let a_node_announcement = match a_events[0] {
 363                 MessageSendEvent::BroadcastNodeAnnouncement { ref msg } => {
 364                         (*msg).clone()
 365                 },
 366                 _ => panic!("Unexpected event"),
 367         };
 368
 369         nodes[b].node.broadcast_node_announcement([1, 1, 1], [1; 32], msgs::NetAddressSet::new());
 370         let b_events = nodes[b].node.get_and_clear_pending_msg_events();
 371         assert_eq!(b_events.len(), 1);
 372         let b_node_announcement = match b_events[0] {
 373                 MessageSendEvent::BroadcastNodeAnnouncement { ref msg } => {
 374                         (*msg).clone()
 375                 },
 376                 _ => panic!("Unexpected event"),
 377         };
 378
 379         for node in nodes {
 380                 assert!(node.router.handle_channel_announcement(&chan_announcement.0).unwrap());
 381                 node.router.handle_channel_update(&chan_announcement.1).unwrap();
 382                 node.router.handle_channel_update(&chan_announcement.2).unwrap();
 383                 node.router.handle_node_announcement(&a_node_announcement).unwrap();
 384                 node.router.handle_node_announcement(&b_node_announcement).unwrap();
 385         }
 386         (chan_announcement.1, chan_announcement.2, chan_announcement.3, chan_announcement.4)
 387 }
 388
 389 macro_rules! check_spends {
 390         ($tx: expr, $spends_tx: expr) => {
 391                 {
 392                         $tx.verify(|out_point| {
 393                                 if out_point.txid == $spends_tx.txid() {
 394                                         $spends_tx.output.get(out_point.vout as usize).cloned()
 395                                 } else {
 396                                         None
 397                                 }
 398                         }).unwrap();
 399                 }
 400         }
 401 }
 402
 403 macro_rules! get_closing_signed_broadcast {
 404         ($node: expr, $dest_pubkey: expr) => {
 405                 {
 406                         let events = $node.get_and_clear_pending_msg_events();
 407                         assert!(events.len() == 1 || events.len() == 2);
 408                         (match events[events.len() - 1] {
 409                                 MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
 410                                         assert_eq!(msg.contents.flags & 2, 2);
 411                                         msg.clone()
 412                                 },
 413                                 _ => panic!("Unexpected event"),
 414                         }, if events.len() == 2 {
 415                                 match events[0] {
 416                                         MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => {
 417                                                 assert_eq!(*node_id, $dest_pubkey);
 418                                                 Some(msg.clone())
 419                                         },
 420                                         _ => panic!("Unexpected event"),
 421                                 }
 422                         } else { None })
 423                 }
 424         }
 425 }
 426
 427 macro_rules! check_closed_broadcast {
 428         ($node: expr, $with_error_msg: expr) => {{
 429                 let events = $node.node.get_and_clear_pending_msg_events();
 430                 assert_eq!(events.len(), if $with_error_msg { 2 } else { 1 });
 431                 match events[0] {
 432                         MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
 433                                 assert_eq!(msg.contents.flags & 2, 2);
 434                         },
 435                         _ => panic!("Unexpected event"),
 436                 }
 437                 if $with_error_msg {
 438                         match events[1] {
 439                                 MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id: _ } => {
 440                                         // TODO: Check node_id
 441                                         Some(msg.clone())
 442                                 },
 443                                 _ => panic!("Unexpected event"),
 444                         }
 445                 } else { None }
 446         }}
 447 }
 448
 449 pub fn close_channel<'a, 'b>(outbound_node: &Node<'a, 'b>, inbound_node: &Node<'a, 'b>, channel_id: &[u8; 32], funding_tx: Transaction, close_inbound_first: bool) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, Transaction) {
 450         let (node_a, broadcaster_a, struct_a) = if close_inbound_first { (&inbound_node.node, &inbound_node.tx_broadcaster, inbound_node) } else { (&outbound_node.node, &outbound_node.tx_broadcaster, outbound_node) };
 451         let (node_b, broadcaster_b) = if close_inbound_first { (&outbound_node.node, &outbound_node.tx_broadcaster) } else { (&inbound_node.node, &inbound_node.tx_broadcaster) };
 452         let (tx_a, tx_b);
 453
 454         node_a.close_channel(channel_id).unwrap();
 455         node_b.handle_shutdown(&node_a.get_our_node_id(), &get_event_msg!(struct_a, MessageSendEvent::SendShutdown, node_b.get_our_node_id()));
 456
 457         let events_1 = node_b.get_and_clear_pending_msg_events();
 458         assert!(events_1.len() >= 1);
 459         let shutdown_b = match events_1[0] {
 460                 MessageSendEvent::SendShutdown { ref node_id, ref msg } => {
 461                         assert_eq!(node_id, &node_a.get_our_node_id());
 462                         msg.clone()
 463                 },
 464                 _ => panic!("Unexpected event"),
 465         };
 466
 467         let closing_signed_b = if !close_inbound_first {
 468                 assert_eq!(events_1.len(), 1);
 469                 None
 470         } else {
 471                 Some(match events_1[1] {
 472                         MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => {
 473                                 assert_eq!(node_id, &node_a.get_our_node_id());
 474                                 msg.clone()
 475                         },
 476                         _ => panic!("Unexpected event"),
 477                 })
 478         };
 479
 480         node_a.handle_shutdown(&node_b.get_our_node_id(), &shutdown_b);
 481         let (as_update, bs_update) = if close_inbound_first {
 482                 assert!(node_a.get_and_clear_pending_msg_events().is_empty());
 483                 node_a.handle_closing_signed(&node_b.get_our_node_id(), &closing_signed_b.unwrap());
 484                 assert_eq!(broadcaster_a.txn_broadcasted.lock().unwrap().len(), 1);
 485                 tx_a = broadcaster_a.txn_broadcasted.lock().unwrap().remove(0);
 486                 let (as_update, closing_signed_a) = get_closing_signed_broadcast!(node_a, node_b.get_our_node_id());
 487
 488                 node_b.handle_closing_signed(&node_a.get_our_node_id(), &closing_signed_a.unwrap());
 489                 let (bs_update, none_b) = get_closing_signed_broadcast!(node_b, node_a.get_our_node_id());
 490                 assert!(none_b.is_none());
 491                 assert_eq!(broadcaster_b.txn_broadcasted.lock().unwrap().len(), 1);
 492                 tx_b = broadcaster_b.txn_broadcasted.lock().unwrap().remove(0);
 493                 (as_update, bs_update)
 494         } else {
 495                 let closing_signed_a = get_event_msg!(struct_a, MessageSendEvent::SendClosingSigned, node_b.get_our_node_id());
 496
 497                 node_b.handle_closing_signed(&node_a.get_our_node_id(), &closing_signed_a);
 498                 assert_eq!(broadcaster_b.txn_broadcasted.lock().unwrap().len(), 1);
 499                 tx_b = broadcaster_b.txn_broadcasted.lock().unwrap().remove(0);
 500                 let (bs_update, closing_signed_b) = get_closing_signed_broadcast!(node_b, node_a.get_our_node_id());
 501
 502                 node_a.handle_closing_signed(&node_b.get_our_node_id(), &closing_signed_b.unwrap());
 503                 let (as_update, none_a) = get_closing_signed_broadcast!(node_a, node_b.get_our_node_id());
 504                 assert!(none_a.is_none());
 505                 assert_eq!(broadcaster_a.txn_broadcasted.lock().unwrap().len(), 1);
 506                 tx_a = broadcaster_a.txn_broadcasted.lock().unwrap().remove(0);
 507                 (as_update, bs_update)
 508         };
 509         assert_eq!(tx_a, tx_b);
 510         check_spends!(tx_a, funding_tx);
 511
 512         (as_update, bs_update, tx_a)
 513 }
 514
 515 pub struct SendEvent {
 516         pub node_id: PublicKey,
 517         pub msgs: Vec<msgs::UpdateAddHTLC>,
 518         pub commitment_msg: msgs::CommitmentSigned,
 519 }
 520 impl SendEvent {
 521         pub fn from_commitment_update(node_id: PublicKey, updates: msgs::CommitmentUpdate) -> SendEvent {
 522                 assert!(updates.update_fulfill_htlcs.is_empty());
 523                 assert!(updates.update_fail_htlcs.is_empty());
 524                 assert!(updates.update_fail_malformed_htlcs.is_empty());
 525                 assert!(updates.update_fee.is_none());
 526                 SendEvent { node_id: node_id, msgs: updates.update_add_htlcs, commitment_msg: updates.commitment_signed }
 527         }
 528
 529         pub fn from_event(event: MessageSendEvent) -> SendEvent {
 530                 match event {
 531                         MessageSendEvent::UpdateHTLCs { node_id, updates } => SendEvent::from_commitment_update(node_id, updates),
 532                         _ => panic!("Unexpected event type!"),
 533                 }
 534         }
 535
 536         pub fn from_node<'a, 'b>(node: &Node<'a, 'b>) -> SendEvent {
 537                 let mut events = node.node.get_and_clear_pending_msg_events();
 538                 assert_eq!(events.len(), 1);
 539                 SendEvent::from_event(events.pop().unwrap())
 540         }
 541 }
 542
 543 macro_rules! check_added_monitors {
 544         ($node: expr, $count: expr) => {
 545                 {
 546                         let mut added_monitors = $node.chan_monitor.added_monitors.lock().unwrap();
 547                         assert_eq!(added_monitors.len(), $count);
 548                         added_monitors.clear();
 549                 }
 550         }
 551 }
 552
 553 macro_rules! commitment_signed_dance {
 554         ($node_a: expr, $node_b: expr, $commitment_signed: expr, $fail_backwards: expr, true /* skip last step */) => {
 555                 {
 556                         check_added_monitors!($node_a, 0);
 557                         assert!($node_a.node.get_and_clear_pending_msg_events().is_empty());
 558                         $node_a.node.handle_commitment_signed(&$node_b.node.get_our_node_id(), &$commitment_signed);
 559                         check_added_monitors!($node_a, 1);
 560                         commitment_signed_dance!($node_a, $node_b, (), $fail_backwards, true, false);
 561                 }
 562         };
 563         ($node_a: expr, $node_b: expr, (), $fail_backwards: expr, true /* skip last step */, true /* return extra message */, true /* return last RAA */) => {
 564                 {
 565                         let (as_revoke_and_ack, as_commitment_signed) = get_revoke_commit_msgs!($node_a, $node_b.node.get_our_node_id());
 566                         check_added_monitors!($node_b, 0);
 567                         assert!($node_b.node.get_and_clear_pending_msg_events().is_empty());
 568                         $node_b.node.handle_revoke_and_ack(&$node_a.node.get_our_node_id(), &as_revoke_and_ack);
 569                         assert!($node_b.node.get_and_clear_pending_msg_events().is_empty());
 570                         check_added_monitors!($node_b, 1);
 571                         $node_b.node.handle_commitment_signed(&$node_a.node.get_our_node_id(), &as_commitment_signed);
 572                         let (bs_revoke_and_ack, extra_msg_option) = {
 573                                 let events = $node_b.node.get_and_clear_pending_msg_events();
 574                                 assert!(events.len() <= 2);
 575                                 (match events[0] {
 576                                         MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
 577                                                 assert_eq!(*node_id, $node_a.node.get_our_node_id());
 578                                                 (*msg).clone()
 579                                         },
 580                                         _ => panic!("Unexpected event"),
 581                                 }, events.get(1).map(|e| e.clone()))
 582                         };
 583                         check_added_monitors!($node_b, 1);
 584                         if $fail_backwards {
 585                                 assert!($node_a.node.get_and_clear_pending_events().is_empty());
 586                                 assert!($node_a.node.get_and_clear_pending_msg_events().is_empty());
 587                         }
 588                         (extra_msg_option, bs_revoke_and_ack)
 589                 }
 590         };
 591         ($node_a: expr, $node_b: expr, $commitment_signed: expr, $fail_backwards: expr, true /* skip last step */, false /* return extra message */, true /* return last RAA */) => {
 592                 {
 593                         check_added_monitors!($node_a, 0);
 594                         assert!($node_a.node.get_and_clear_pending_msg_events().is_empty());
 595                         $node_a.node.handle_commitment_signed(&$node_b.node.get_our_node_id(), &$commitment_signed);
 596                         check_added_monitors!($node_a, 1);
 597                         let (extra_msg_option, bs_revoke_and_ack) = commitment_signed_dance!($node_a, $node_b, (), $fail_backwards, true, true, true);
 598                         assert!(extra_msg_option.is_none());
 599                         bs_revoke_and_ack
 600                 }
 601         };
 602         ($node_a: expr, $node_b: expr, (), $fail_backwards: expr, true /* skip last step */, true /* return extra message */) => {
 603                 {
 604                         let (extra_msg_option, bs_revoke_and_ack) = commitment_signed_dance!($node_a, $node_b, (), $fail_backwards, true, true, true);
 605                         $node_a.node.handle_revoke_and_ack(&$node_b.node.get_our_node_id(), &bs_revoke_and_ack);
 606                         check_added_monitors!($node_a, 1);
 607                         extra_msg_option
 608                 }
 609         };
 610         ($node_a: expr, $node_b: expr, (), $fail_backwards: expr, true /* skip last step */, false /* no extra message */) => {
 611                 {
 612                         assert!(commitment_signed_dance!($node_a, $node_b, (), $fail_backwards, true, true).is_none());
 613                 }
 614         };
 615         ($node_a: expr, $node_b: expr, $commitment_signed: expr, $fail_backwards: expr) => {
 616                 {
 617                         commitment_signed_dance!($node_a, $node_b, $commitment_signed, $fail_backwards, true);
 618                         if $fail_backwards {
 619                                 expect_pending_htlcs_forwardable!($node_a);
 620                                 check_added_monitors!($node_a, 1);
 621
 622                                 let channel_state = $node_a.node.channel_state.lock().unwrap();
 623                                 assert_eq!(channel_state.pending_msg_events.len(), 1);
 624                                 if let MessageSendEvent::UpdateHTLCs { ref node_id, .. } = channel_state.pending_msg_events[0] {
 625                                         assert_ne!(*node_id, $node_b.node.get_our_node_id());
 626                                 } else { panic!("Unexpected event"); }
 627                         } else {
 628                                 assert!($node_a.node.get_and_clear_pending_msg_events().is_empty());
 629                         }
 630                 }
 631         }
 632 }
 633
 634 macro_rules! get_payment_preimage_hash {
 635         ($node: expr) => {
 636                 {
 637                         let payment_preimage = PaymentPreimage([*$node.network_payment_count.borrow(); 32]);
 638                         *$node.network_payment_count.borrow_mut() += 1;
 639                         let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0[..]).into_inner());
 640                         (payment_preimage, payment_hash)
 641                 }
 642         }
 643 }
 644
 645 macro_rules! expect_pending_htlcs_forwardable {
 646         ($node: expr) => {{
 647                 let events = $node.node.get_and_clear_pending_events();
 648                 assert_eq!(events.len(), 1);
 649                 match events[0] {
 650                         Event::PendingHTLCsForwardable { .. } => { },
 651                         _ => panic!("Unexpected event"),
 652                 };
 653                 $node.node.process_pending_htlc_forwards();
 654         }}
 655 }
 656
 657 macro_rules! expect_payment_received {
 658         ($node: expr, $expected_payment_hash: expr, $expected_recv_value: expr) => {
 659                 let events = $node.node.get_and_clear_pending_events();
 660                 assert_eq!(events.len(), 1);
 661                 match events[0] {
 662                         Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
 663                                 assert_eq!($expected_payment_hash, *payment_hash);
 664                                 assert_eq!(*payment_secret, None);
 665                                 assert_eq!($expected_recv_value, amt);
 666                         },
 667                         _ => panic!("Unexpected event"),
 668                 }
 669         }
 670 }
 671
 672 macro_rules! expect_payment_sent {
 673         ($node: expr, $expected_payment_preimage: expr) => {
 674                 let events = $node.node.get_and_clear_pending_events();
 675                 assert_eq!(events.len(), 1);
 676                 match events[0] {
 677                         Event::PaymentSent { ref payment_preimage } => {
 678                                 assert_eq!($expected_payment_preimage, *payment_preimage);
 679                         },
 680                         _ => panic!("Unexpected event"),
 681                 }
 682         }
 683 }
 684
 685 pub fn send_along_route_with_secret<'a, 'b>(origin_node: &Node<'a, 'b>, route: Route, expected_paths: &[&[&Node<'a, 'b>]], recv_value: u64, our_payment_hash: PaymentHash, our_payment_secret: Option<[u8; 32]>) {
 686         origin_node.node.send_payment(route, our_payment_hash, our_payment_secret.as_ref()).unwrap();
 687         check_added_monitors!(origin_node, expected_paths.len());
 688
 689         let mut events = origin_node.node.get_and_clear_pending_msg_events();
 690         assert_eq!(events.len(), expected_paths.len());
 691         for (path_idx, (ev, expected_route)) in events.drain(..).zip(expected_paths.iter()).enumerate() {
 692                 let mut payment_event = SendEvent::from_event(ev);
 693                 let mut prev_node = origin_node;
 694
 695                 for (idx, &node) in expected_route.iter().enumerate() {
 696                         assert_eq!(node.node.get_our_node_id(), payment_event.node_id);
 697
 698                         node.node.handle_update_add_htlc(&prev_node.node.get_our_node_id(), &payment_event.msgs[0]);
 699                         check_added_monitors!(node, 0);
 700                         commitment_signed_dance!(node, prev_node, payment_event.commitment_msg, false);
 701
 702                         expect_pending_htlcs_forwardable!(node);
 703
 704                         if idx == expected_route.len() - 1 {
 705                                 let events_2 = node.node.get_and_clear_pending_events();
 706                                 if path_idx == expected_paths.len() - 1 {
 707                                         assert_eq!(events_2.len(), 1);
 708                                         match events_2[0] {
 709                                                 Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
 710                                                         assert_eq!(our_payment_hash, *payment_hash);
 711                                                         assert_eq!(our_payment_secret, *payment_secret);
 712                                                         assert_eq!(amt, recv_value);
 713                                                 },
 714                                                 _ => panic!("Unexpected event"),
 715                                         }
 716                                 } else {
 717                                         assert!(events_2.is_empty());
 718                                 }
 719                         } else {
 720                                 let mut events_2 = node.node.get_and_clear_pending_msg_events();
 721                                 assert_eq!(events_2.len(), 1);
 722                                 check_added_monitors!(node, 1);
 723                                 payment_event = SendEvent::from_event(events_2.remove(0));
 724                                 assert_eq!(payment_event.msgs.len(), 1);
 725                         }
 726
 727                         prev_node = node;
 728                 }
 729         }
 730 }
 731
 732 pub fn send_along_route_with_hash<'a, 'b>(origin_node: &Node<'a, 'b>, route: Route, expected_route: &[&Node<'a, 'b>], recv_value: u64, our_payment_hash: PaymentHash) {
 733         send_along_route_with_secret(origin_node, route, &[expected_route], recv_value, our_payment_hash, None);
 734 }
 735
 736 pub fn send_along_route<'a, 'b>(origin_node: &Node<'a, 'b>, route: Route, expected_route: &[&Node<'a, 'b>], recv_value: u64) -> (PaymentPreimage, PaymentHash) {
 737         let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(origin_node);
 738         send_along_route_with_hash(origin_node, route, expected_route, recv_value, our_payment_hash);
 739         (our_payment_preimage, our_payment_hash)
 740 }
 741
 742 pub fn claim_payment_along_route_with_secret<'a, 'b>(origin_node: &Node<'a, 'b>, expected_paths: &[&[&Node<'a, 'b>]], skip_last: bool, our_payment_preimage: PaymentPreimage, our_payment_secret: Option<[u8; 32]>, expected_amount: u64) {
 743         for path in expected_paths.iter() {
 744                 assert_eq!(path.last().unwrap().node.get_our_node_id(), expected_paths[0].last().unwrap().node.get_our_node_id());
 745         }
 746         assert!(expected_paths[0].last().unwrap().node.claim_funds(our_payment_preimage, &our_payment_secret, expected_amount));
 747         check_added_monitors!(expected_paths[0].last().unwrap(), expected_paths.len());
 748
 749         macro_rules! msgs_from_ev {
 750                 ($ev: expr) => {
 751                         match $ev {
 752                                 &MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, ref update_fee, ref commitment_signed } } => {
 753                                         assert!(update_add_htlcs.is_empty());
 754                                         assert_eq!(update_fulfill_htlcs.len(), 1);
 755                                         assert!(update_fail_htlcs.is_empty());
 756                                         assert!(update_fail_malformed_htlcs.is_empty());
 757                                         assert!(update_fee.is_none());
 758                                         ((update_fulfill_htlcs[0].clone(), commitment_signed.clone()), node_id.clone())
 759                                 },
 760                                 _ => panic!("Unexpected event"),
 761                         }
 762                 }
 763         }
 764         let mut per_path_msgs: Vec<((msgs::UpdateFulfillHTLC, msgs::CommitmentSigned), PublicKey)> = Vec::with_capacity(expected_paths.len());
 765         let events = expected_paths[0].last().unwrap().node.get_and_clear_pending_msg_events();
 766         assert_eq!(events.len(), expected_paths.len());
 767         for ev in events.iter() {
 768                 per_path_msgs.push(msgs_from_ev!(ev));
 769         }
 770
 771         for (expected_route, (path_msgs, next_hop)) in expected_paths.iter().zip(per_path_msgs.drain(..)) {
 772                 let mut next_msgs = Some(path_msgs);
 773                 let mut expected_next_node = next_hop;
 774
 775                 macro_rules! last_update_fulfill_dance {
 776                         ($node: expr, $prev_node: expr) => {
 777                                 {
 778                                         $node.node.handle_update_fulfill_htlc(&$prev_node.node.get_our_node_id(), &next_msgs.as_ref().unwrap().0);
 779                                         check_added_monitors!($node, 0);
 780                                         assert!($node.node.get_and_clear_pending_msg_events().is_empty());
 781                                         commitment_signed_dance!($node, $prev_node, next_msgs.as_ref().unwrap().1, false);
 782                                 }
 783                         }
 784                 }
 785                 macro_rules! mid_update_fulfill_dance {
 786                         ($node: expr, $prev_node: expr, $new_msgs: expr) => {
 787                                 {
 788                                         $node.node.handle_update_fulfill_htlc(&$prev_node.node.get_our_node_id(), &next_msgs.as_ref().unwrap().0);
 789                                         check_added_monitors!($node, 1);
 790                                         let new_next_msgs = if $new_msgs {
 791                                                 let events = $node.node.get_and_clear_pending_msg_events();
 792                                                 assert_eq!(events.len(), 1);
 793                                                 let (res, nexthop) = msgs_from_ev!(&events[0]);
 794                                                 expected_next_node = nexthop;
 795                                                 Some(res)
 796                                         } else {
 797                                                 assert!($node.node.get_and_clear_pending_msg_events().is_empty());
 798                                                 None
 799                                         };
 800                                         commitment_signed_dance!($node, $prev_node, next_msgs.as_ref().unwrap().1, false);
 801                                         next_msgs = new_next_msgs;
 802                                 }
 803                         }
 804                 }
 805
 806                 let mut prev_node = expected_route.last().unwrap();
 807                 for (idx, node) in expected_route.iter().rev().enumerate().skip(1) {
 808                         assert_eq!(expected_next_node, node.node.get_our_node_id());
 809                         let update_next_msgs = !skip_last || idx != expected_route.len() - 1;
 810                         if next_msgs.is_some() {
 811                                 mid_update_fulfill_dance!(node, prev_node, update_next_msgs);
 812                         } else {
 813                                 assert!(!update_next_msgs);
 814                                 assert!(node.node.get_and_clear_pending_msg_events().is_empty());
 815                         }
 816                         if !skip_last && idx == expected_route.len() - 1 {
 817                                 assert_eq!(expected_next_node, origin_node.node.get_our_node_id());
 818                         }
 819
 820                         prev_node = node;
 821                 }
 822
 823                 if !skip_last {
 824                         last_update_fulfill_dance!(origin_node, expected_route.first().unwrap());
 825                         expect_payment_sent!(origin_node, our_payment_preimage);
 826                 }
 827         }
 828 }
 829
 830 pub fn claim_payment_along_route<'a, 'b>(origin_node: &Node<'a, 'b>, expected_route: &[&Node<'a, 'b>], skip_last: bool, our_payment_preimage: PaymentPreimage, expected_amount: u64) {
 831         claim_payment_along_route_with_secret(origin_node, &[expected_route], skip_last, our_payment_preimage, None, expected_amount);
 832 }
 833
 834 pub fn claim_payment<'a, 'b>(origin_node: &Node<'a, 'b>, expected_route: &[&Node<'a, 'b>], our_payment_preimage: PaymentPreimage, expected_amount: u64) {
 835         claim_payment_along_route(origin_node, expected_route, false, our_payment_preimage, expected_amount);
 836 }
 837
 838 pub const TEST_FINAL_CLTV: u32 = 32;
 839
 840 pub fn route_payment<'a, 'b>(origin_node: &Node<'a, 'b>, expected_route: &[&Node<'a, 'b>], recv_value: u64) -> (PaymentPreimage, PaymentHash) {
 841         let route = origin_node.router.get_route(&expected_route.last().unwrap().node.get_our_node_id(), None, &Vec::new(), recv_value, TEST_FINAL_CLTV).unwrap();
 842         assert_eq!(route.paths.len(), 1);
 843         assert_eq!(route.paths[0].len(), expected_route.len());
 844         for (node, hop) in expected_route.iter().zip(route.paths[0].iter()) {
 845                 assert_eq!(hop.pubkey, node.node.get_our_node_id());
 846         }
 847
 848         send_along_route(origin_node, route, expected_route, recv_value)
 849 }
 850
 851 pub fn route_over_limit<'a, 'b>(origin_node: &Node<'a, 'b>, expected_route: &[&Node<'a, 'b>], recv_value: u64)  {
 852         let route = origin_node.router.get_route(&expected_route.last().unwrap().node.get_our_node_id(), None, &Vec::new(), recv_value, TEST_FINAL_CLTV).unwrap();
 853         assert_eq!(route.paths.len(), 1);
 854         assert_eq!(route.paths[0].len(), expected_route.len());
 855         for (node, hop) in expected_route.iter().zip(route.paths[0].iter()) {
 856                 assert_eq!(hop.pubkey, node.node.get_our_node_id());
 857         }
 858
 859         let (_, our_payment_hash) = get_payment_preimage_hash!(origin_node);
 860         unwrap_send_err!(origin_node.node.send_payment(route, our_payment_hash, None), true, APIError::ChannelUnavailable { err },
 861                 assert_eq!(err, "Cannot send value that would put us over the max HTLC value in flight our peer will accept"));
 862 }
 863
 864 pub fn send_payment<'a, 'b>(origin: &Node<'a, 'b>, expected_route: &[&Node<'a, 'b>], recv_value: u64, expected_value: u64)  {
 865         let our_payment_preimage = route_payment(&origin, expected_route, recv_value).0;
 866         claim_payment(&origin, expected_route, our_payment_preimage, expected_value);
 867 }
 868
 869 pub fn fail_payment_along_route<'a, 'b>(origin_node: &Node<'a, 'b>, expected_route: &[&Node<'a, 'b>], skip_last: bool, our_payment_hash: PaymentHash)  {
 870         assert!(expected_route.last().unwrap().node.fail_htlc_backwards(&our_payment_hash, &None));
 871         expect_pending_htlcs_forwardable!(expected_route.last().unwrap());
 872         check_added_monitors!(expected_route.last().unwrap(), 1);
 873
 874         let mut next_msgs: Option<(msgs::UpdateFailHTLC, msgs::CommitmentSigned)> = None;
 875         macro_rules! update_fail_dance {
 876                 ($node: expr, $prev_node: expr, $last_node: expr) => {
 877                         {
 878                                 $node.node.handle_update_fail_htlc(&$prev_node.node.get_our_node_id(), &next_msgs.as_ref().unwrap().0);
 879                                 commitment_signed_dance!($node, $prev_node, next_msgs.as_ref().unwrap().1, !$last_node);
 880                                 if skip_last && $last_node {
 881                                         expect_pending_htlcs_forwardable!($node);
 882                                 }
 883                         }
 884                 }
 885         }
 886
 887         let mut expected_next_node = expected_route.last().unwrap().node.get_our_node_id();
 888         let mut prev_node = expected_route.last().unwrap();
 889         for (idx, node) in expected_route.iter().rev().enumerate() {
 890                 assert_eq!(expected_next_node, node.node.get_our_node_id());
 891                 if next_msgs.is_some() {
 892                         // We may be the "last node" for the purpose of the commitment dance if we're
 893                         // skipping the last node (implying it is disconnected) and we're the
 894                         // second-to-last node!
 895                         update_fail_dance!(node, prev_node, skip_last && idx == expected_route.len() - 1);
 896                 }
 897
 898                 let events = node.node.get_and_clear_pending_msg_events();
 899                 if !skip_last || idx != expected_route.len() - 1 {
 900                         assert_eq!(events.len(), 1);
 901                         match events[0] {
 902                                 MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, ref update_fee, ref commitment_signed } } => {
 903                                         assert!(update_add_htlcs.is_empty());
 904                                         assert!(update_fulfill_htlcs.is_empty());
 905                                         assert_eq!(update_fail_htlcs.len(), 1);
 906                                         assert!(update_fail_malformed_htlcs.is_empty());
 907                                         assert!(update_fee.is_none());
 908                                         expected_next_node = node_id.clone();
 909                                         next_msgs = Some((update_fail_htlcs[0].clone(), commitment_signed.clone()));
 910                                 },
 911                                 _ => panic!("Unexpected event"),
 912                         }
 913                 } else {
 914                         assert!(events.is_empty());
 915                 }
 916                 if !skip_last && idx == expected_route.len() - 1 {
 917                         assert_eq!(expected_next_node, origin_node.node.get_our_node_id());
 918                 }
 919
 920                 prev_node = node;
 921         }
 922
 923         if !skip_last {
 924                 update_fail_dance!(origin_node, expected_route.first().unwrap(), true);
 925
 926                 let events = origin_node.node.get_and_clear_pending_events();
 927                 assert_eq!(events.len(), 1);
 928                 match events[0] {
 929                         Event::PaymentFailed { payment_hash, rejected_by_dest, .. } => {
 930                                 assert_eq!(payment_hash, our_payment_hash);
 931                                 assert!(rejected_by_dest);
 932                         },
 933                         _ => panic!("Unexpected event"),
 934                 }
 935         }
 936 }
 937
 938 pub fn fail_payment<'a, 'b>(origin_node: &Node<'a, 'b>, expected_route: &[&Node<'a, 'b>], our_payment_hash: PaymentHash)  {
 939         fail_payment_along_route(origin_node, expected_route, false, our_payment_hash);
 940 }
 941
 942 pub fn create_node_cfgs(node_count: usize) -> Vec<NodeCfg> {
 943         let mut nodes = Vec::new();
 944         let mut rng = thread_rng();
 945
 946         for i in 0..node_count {
 947                 let logger = Arc::new(test_utils::TestLogger::with_id(format!("node {}", i)));
 948                 let fee_estimator = Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 });
 949                 let chain_monitor = Arc::new(chaininterface::ChainWatchInterfaceUtil::new(Network::Testnet, logger.clone() as Arc<Logger>));
 950                 let tx_broadcaster = Arc::new(test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new())});
 951                 let mut seed = [0; 32];
 952                 rng.fill_bytes(&mut seed);
 953                 let keys_manager = Arc::new(test_utils::TestKeysInterface::new(&seed, Network::Testnet, logger.clone() as Arc<Logger>));
 954                 let chan_monitor = test_utils::TestChannelMonitor::new(chain_monitor.clone(), tx_broadcaster.clone(), logger.clone(), fee_estimator.clone());
 955                 nodes.push(NodeCfg { chain_monitor, logger, tx_broadcaster, fee_estimator, chan_monitor, keys_manager, node_seed: seed });
 956         }
 957
 958         nodes
 959 }
 960
 961 pub fn create_node_chanmgrs<'a, 'b>(node_count: usize, cfgs: &'a Vec<NodeCfg>, node_config: &[Option<UserConfig>]) -> Vec<ChannelManager<EnforcingChannelKeys, &'a TestChannelMonitor>> {
 962         let mut chanmgrs = Vec::new();
 963         for i in 0..node_count {
 964                 let mut default_config = UserConfig::default();
 965                 default_config.channel_options.announced_channel = true;
 966                 default_config.peer_channel_config_limits.force_announced_channel_preference = false;
 967                 let node = ChannelManager::new(Network::Testnet, cfgs[i].fee_estimator.clone(), &cfgs[i].chan_monitor, cfgs[i].tx_broadcaster.clone(), cfgs[i].logger.clone(), cfgs[i].keys_manager.clone(), if node_config[i].is_some() { node_config[i].clone().unwrap() } else { default_config }, 0).unwrap();
 968                 chanmgrs.push(node);
 969         }
 970
 971         chanmgrs
 972 }
 973
 974 pub fn create_network<'a, 'b>(node_count: usize, cfgs: &'a Vec<NodeCfg>, chan_mgrs: &'b Vec<ChannelManager<EnforcingChannelKeys, &'a TestChannelMonitor>>) -> Vec<Node<'a, 'b>> {
 975         let secp_ctx = Secp256k1::new();
 976         let mut nodes = Vec::new();
 977         let chan_count = Rc::new(RefCell::new(0));
 978         let payment_count = Rc::new(RefCell::new(0));
 979
 980         for i in 0..node_count {
 981                 let block_notifier = chaininterface::BlockNotifier::new(cfgs[i].chain_monitor.clone());
 982                 block_notifier.register_listener(&cfgs[i].chan_monitor.simple_monitor as &chaininterface::ChainListener);
 983                 block_notifier.register_listener(&chan_mgrs[i] as &chaininterface::ChainListener);
 984                 let router = Router::new(PublicKey::from_secret_key(&secp_ctx, &cfgs[i].keys_manager.get_node_secret()), cfgs[i].chain_monitor.clone(), cfgs[i].logger.clone() as Arc<Logger>);
 985                 nodes.push(Node{ chain_monitor: cfgs[i].chain_monitor.clone(), block_notifier,
 986                                                                                  tx_broadcaster: cfgs[i].tx_broadcaster.clone(), chan_monitor: &cfgs[i].chan_monitor,
 987                                                                                  keys_manager: cfgs[i].keys_manager.clone(), node: &chan_mgrs[i], router,
 988                                                                                  node_seed: cfgs[i].node_seed, network_chan_count: chan_count.clone(),
 989                                                                                  network_payment_count: payment_count.clone(), logger: cfgs[i].logger.clone(),
 990                 })
 991         }
 992
 993         nodes
 994 }
 995
 996 pub const ACCEPTED_HTLC_SCRIPT_WEIGHT: usize = 138; //Here we have a diff due to HTLC CLTV expiry being < 2^15 in test
 997 pub const OFFERED_HTLC_SCRIPT_WEIGHT: usize = 133;
 998
 999 #[derive(PartialEq)]
1000 pub enum HTLCType { NONE, TIMEOUT, SUCCESS }
1001 /// Tests that the given node has broadcast transactions for the given Channel
1002 ///
1003 /// First checks that the latest local commitment tx has been broadcast, unless an explicit
1004 /// commitment_tx is provided, which may be used to test that a remote commitment tx was
1005 /// broadcast and the revoked outputs were claimed.
1006 ///
1007 /// Next tests that there is (or is not) a transaction that spends the commitment transaction
1008 /// that appears to be the type of HTLC transaction specified in has_htlc_tx.
1009 ///
1010 /// All broadcast transactions must be accounted for in one of the above three types of we'll
1011 /// also fail.
1012 pub fn test_txn_broadcast<'a, 'b>(node: &Node<'a, 'b>, chan: &(msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction), commitment_tx: Option<Transaction>, has_htlc_tx: HTLCType) -> Vec<Transaction>  {
1013         let mut node_txn = node.tx_broadcaster.txn_broadcasted.lock().unwrap();
1014         assert!(node_txn.len() >= if commitment_tx.is_some() { 0 } else { 1 } + if has_htlc_tx == HTLCType::NONE { 0 } else { 1 });
1015
1016         let mut res = Vec::with_capacity(2);
1017         node_txn.retain(|tx| {
1018                 if tx.input.len() == 1 && tx.input[0].previous_output.txid == chan.3.txid() {
1019                         check_spends!(tx, chan.3.clone());
1020                         if commitment_tx.is_none() {
1021                                 res.push(tx.clone());
1022                         }
1023                         false
1024                 } else { true }
1025         });
1026         if let Some(explicit_tx) = commitment_tx {
1027                 res.push(explicit_tx.clone());
1028         }
1029
1030         assert_eq!(res.len(), 1);
1031
1032         if has_htlc_tx != HTLCType::NONE {
1033                 node_txn.retain(|tx| {
1034                         if tx.input.len() == 1 && tx.input[0].previous_output.txid == res[0].txid() {
1035                                 check_spends!(tx, res[0].clone());
1036                                 if has_htlc_tx == HTLCType::TIMEOUT {
1037                                         assert!(tx.lock_time != 0);
1038                                 } else {
1039                                         assert!(tx.lock_time == 0);
1040                                 }
1041                                 res.push(tx.clone());
1042                                 false
1043                         } else { true }
1044                 });
1045                 assert!(res.len() == 2 || res.len() == 3);
1046                 if res.len() == 3 {
1047                         assert_eq!(res[1], res[2]);
1048                 }
1049         }
1050
1051         assert!(node_txn.is_empty());
1052         res
1053 }
1054
1055 /// Tests that the given node has broadcast a claim transaction against the provided revoked
1056 /// HTLC transaction.
1057 pub fn test_revoked_htlc_claim_txn_broadcast<'a, 'b>(node: &Node<'a, 'b>, revoked_tx: Transaction, commitment_revoked_tx: Transaction)  {
1058         let mut node_txn = node.tx_broadcaster.txn_broadcasted.lock().unwrap();
1059         // We should issue a 2nd transaction if one htlc is dropped from initial claiming tx
1060         // but sometimes not as feerate is too-low
1061         if node_txn.len() != 1 && node_txn.len() != 2 { assert!(false); }
1062         node_txn.retain(|tx| {
1063                 if tx.input.len() == 1 && tx.input[0].previous_output.txid == revoked_tx.txid() {
1064                         check_spends!(tx, revoked_tx);
1065                         false
1066                 } else { true }
1067         });
1068         node_txn.retain(|tx| {
1069                 check_spends!(tx, commitment_revoked_tx);
1070                 false
1071         });
1072         assert!(node_txn.is_empty());
1073 }
1074
1075 pub fn check_preimage_claim<'a, 'b>(node: &Node<'a, 'b>, prev_txn: &Vec<Transaction>) -> Vec<Transaction>  {
1076         let mut node_txn = node.tx_broadcaster.txn_broadcasted.lock().unwrap();
1077
1078         assert!(node_txn.len() >= 1);
1079         assert_eq!(node_txn[0].input.len(), 1);
1080         let mut found_prev = false;
1081
1082         for tx in prev_txn {
1083                 if node_txn[0].input[0].previous_output.txid == tx.txid() {
1084                         check_spends!(node_txn[0], tx.clone());
1085                         assert!(node_txn[0].input[0].witness[2].len() > 106); // must spend an htlc output
1086                         assert_eq!(tx.input.len(), 1); // must spend a commitment tx
1087
1088                         found_prev = true;
1089                         break;
1090                 }
1091         }
1092         assert!(found_prev);
1093
1094         let mut res = Vec::new();
1095         mem::swap(&mut *node_txn, &mut res);
1096         res
1097 }
1098
1099 pub fn get_announce_close_broadcast_events<'a, 'b>(nodes: &Vec<Node<'a, 'b>>, a: usize, b: usize)  {
1100         let events_1 = nodes[a].node.get_and_clear_pending_msg_events();
1101         assert_eq!(events_1.len(), 1);
1102         let as_update = match events_1[0] {
1103                 MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
1104                         msg.clone()
1105                 },
1106                 _ => panic!("Unexpected event"),
1107         };
1108
1109         let events_2 = nodes[b].node.get_and_clear_pending_msg_events();
1110         assert_eq!(events_2.len(), 1);
1111         let bs_update = match events_2[0] {
1112                 MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
1113                         msg.clone()
1114                 },
1115                 _ => panic!("Unexpected event"),
1116         };
1117
1118         for node in nodes {
1119                 node.router.handle_channel_update(&as_update).unwrap();
1120                 node.router.handle_channel_update(&bs_update).unwrap();
1121         }
1122 }
1123
1124 macro_rules! get_channel_value_stat {
1125         ($node: expr, $channel_id: expr) => {{
1126                 let chan_lock = $node.node.channel_state.lock().unwrap();
1127                 let chan = chan_lock.by_id.get(&$channel_id).unwrap();
1128                 chan.get_value_stat()
1129         }}
1130 }
1131
1132 macro_rules! get_chan_reestablish_msgs {
1133         ($src_node: expr, $dst_node: expr) => {
1134                 {
1135                         let mut res = Vec::with_capacity(1);
1136                         for msg in $src_node.node.get_and_clear_pending_msg_events() {
1137                                 if let MessageSendEvent::SendChannelReestablish { ref node_id, ref msg } = msg {
1138                                         assert_eq!(*node_id, $dst_node.node.get_our_node_id());
1139                                         res.push(msg.clone());
1140                                 } else {
1141                                         panic!("Unexpected event")
1142                                 }
1143                         }
1144                         res
1145                 }
1146         }
1147 }
1148
1149 macro_rules! handle_chan_reestablish_msgs {
1150         ($src_node: expr, $dst_node: expr) => {
1151                 {
1152                         let msg_events = $src_node.node.get_and_clear_pending_msg_events();
1153                         let mut idx = 0;
1154                         let funding_locked = if let Some(&MessageSendEvent::SendFundingLocked { ref node_id, ref msg }) = msg_events.get(0) {
1155                                 idx += 1;
1156                                 assert_eq!(*node_id, $dst_node.node.get_our_node_id());
1157                                 Some(msg.clone())
1158                         } else {
1159                                 None
1160                         };
1161
1162                         let mut revoke_and_ack = None;
1163                         let mut commitment_update = None;
1164                         let order = if let Some(ev) = msg_events.get(idx) {
1165                                 idx += 1;
1166                                 match ev {
1167                                         &MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
1168                                                 assert_eq!(*node_id, $dst_node.node.get_our_node_id());
1169                                                 revoke_and_ack = Some(msg.clone());
1170                                                 RAACommitmentOrder::RevokeAndACKFirst
1171                                         },
1172                                         &MessageSendEvent::UpdateHTLCs { ref node_id, ref updates } => {
1173                                                 assert_eq!(*node_id, $dst_node.node.get_our_node_id());
1174                                                 commitment_update = Some(updates.clone());
1175                                                 RAACommitmentOrder::CommitmentFirst
1176                                         },
1177                                         _ => panic!("Unexpected event"),
1178                                 }
1179                         } else {
1180                                 RAACommitmentOrder::CommitmentFirst
1181                         };
1182
1183                         if let Some(ev) = msg_events.get(idx) {
1184                                 match ev {
1185                                         &MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
1186                                                 assert_eq!(*node_id, $dst_node.node.get_our_node_id());
1187                                                 assert!(revoke_and_ack.is_none());
1188                                                 revoke_and_ack = Some(msg.clone());
1189                                         },
1190                                         &MessageSendEvent::UpdateHTLCs { ref node_id, ref updates } => {
1191                                                 assert_eq!(*node_id, $dst_node.node.get_our_node_id());
1192                                                 assert!(commitment_update.is_none());
1193                                                 commitment_update = Some(updates.clone());
1194                                         },
1195                                         _ => panic!("Unexpected event"),
1196                                 }
1197                         }
1198
1199                         (funding_locked, revoke_and_ack, commitment_update, order)
1200                 }
1201         }
1202 }
1203
1204 /// pending_htlc_adds includes both the holding cell and in-flight update_add_htlcs, whereas
1205 /// for claims/fails they are separated out.
1206 pub fn reconnect_nodes<'a, 'b>(node_a: &Node<'a, 'b>, node_b: &Node<'a, 'b>, send_funding_locked: (bool, bool), pending_htlc_adds: (i64, i64), pending_htlc_claims: (usize, usize), pending_cell_htlc_claims: (usize, usize), pending_cell_htlc_fails: (usize, usize), pending_raa: (bool, bool))  {
1207         node_a.node.peer_connected(&node_b.node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
1208         let reestablish_1 = get_chan_reestablish_msgs!(node_a, node_b);
1209         node_b.node.peer_connected(&node_a.node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
1210         let reestablish_2 = get_chan_reestablish_msgs!(node_b, node_a);
1211
1212         if send_funding_locked.0 {
1213                 // If a expects a funding_locked, it better not think it has received a revoke_and_ack
1214                 // from b
1215                 for reestablish in reestablish_1.iter() {
1216                         assert_eq!(reestablish.next_remote_commitment_number, 0);
1217                 }
1218         }
1219         if send_funding_locked.1 {
1220                 // If b expects a funding_locked, it better not think it has received a revoke_and_ack
1221                 // from a
1222                 for reestablish in reestablish_2.iter() {
1223                         assert_eq!(reestablish.next_remote_commitment_number, 0);
1224                 }
1225         }
1226         if send_funding_locked.0 || send_funding_locked.1 {
1227                 // If we expect any funding_locked's, both sides better have set
1228                 // next_local_commitment_number to 1
1229                 for reestablish in reestablish_1.iter() {
1230                         assert_eq!(reestablish.next_local_commitment_number, 1);
1231                 }
1232                 for reestablish in reestablish_2.iter() {
1233                         assert_eq!(reestablish.next_local_commitment_number, 1);
1234                 }
1235         }
1236
1237         let mut resp_1 = Vec::new();
1238         for msg in reestablish_1 {
1239                 node_b.node.handle_channel_reestablish(&node_a.node.get_our_node_id(), &msg);
1240                 resp_1.push(handle_chan_reestablish_msgs!(node_b, node_a));
1241         }
1242         if pending_cell_htlc_claims.0 != 0 || pending_cell_htlc_fails.0 != 0 {
1243                 check_added_monitors!(node_b, 1);
1244         } else {
1245                 check_added_monitors!(node_b, 0);
1246         }
1247
1248         let mut resp_2 = Vec::new();
1249         for msg in reestablish_2 {
1250                 node_a.node.handle_channel_reestablish(&node_b.node.get_our_node_id(), &msg);
1251                 resp_2.push(handle_chan_reestablish_msgs!(node_a, node_b));
1252         }
1253         if pending_cell_htlc_claims.1 != 0 || pending_cell_htlc_fails.1 != 0 {
1254                 check_added_monitors!(node_a, 1);
1255         } else {
1256                 check_added_monitors!(node_a, 0);
1257         }
1258
1259         // We don't yet support both needing updates, as that would require a different commitment dance:
1260         assert!((pending_htlc_adds.0 == 0 && pending_htlc_claims.0 == 0 && pending_cell_htlc_claims.0 == 0 && pending_cell_htlc_fails.0 == 0) ||
1261                         (pending_htlc_adds.1 == 0 && pending_htlc_claims.1 == 0 && pending_cell_htlc_claims.1 == 0 && pending_cell_htlc_fails.1 == 0));
1262
1263         for chan_msgs in resp_1.drain(..) {
1264                 if send_funding_locked.0 {
1265                         node_a.node.handle_funding_locked(&node_b.node.get_our_node_id(), &chan_msgs.0.unwrap());
1266                         let announcement_event = node_a.node.get_and_clear_pending_msg_events();
1267                         if !announcement_event.is_empty() {
1268                                 assert_eq!(announcement_event.len(), 1);
1269                                 if let MessageSendEvent::SendAnnouncementSignatures { .. } = announcement_event[0] {
1270                                         //TODO: Test announcement_sigs re-sending
1271                                 } else { panic!("Unexpected event!"); }
1272                         }
1273                 } else {
1274                         assert!(chan_msgs.0.is_none());
1275                 }
1276                 if pending_raa.0 {
1277                         assert!(chan_msgs.3 == RAACommitmentOrder::RevokeAndACKFirst);
1278                         node_a.node.handle_revoke_and_ack(&node_b.node.get_our_node_id(), &chan_msgs.1.unwrap());
1279                         assert!(node_a.node.get_and_clear_pending_msg_events().is_empty());
1280                         check_added_monitors!(node_a, 1);
1281                 } else {
1282                         assert!(chan_msgs.1.is_none());
1283                 }
1284                 if pending_htlc_adds.0 != 0 || pending_htlc_claims.0 != 0 || pending_cell_htlc_claims.0 != 0 || pending_cell_htlc_fails.0 != 0 {
1285                         let commitment_update = chan_msgs.2.unwrap();
1286                         if pending_htlc_adds.0 != -1 { // We use -1 to denote a response commitment_signed
1287                                 assert_eq!(commitment_update.update_add_htlcs.len(), pending_htlc_adds.0 as usize);
1288                         } else {
1289                                 assert!(commitment_update.update_add_htlcs.is_empty());
1290                         }
1291                         assert_eq!(commitment_update.update_fulfill_htlcs.len(), pending_htlc_claims.0 + pending_cell_htlc_claims.0);
1292                         assert_eq!(commitment_update.update_fail_htlcs.len(), pending_cell_htlc_fails.0);
1293                         assert!(commitment_update.update_fail_malformed_htlcs.is_empty());
1294                         for update_add in commitment_update.update_add_htlcs {
1295                                 node_a.node.handle_update_add_htlc(&node_b.node.get_our_node_id(), &update_add);
1296                         }
1297                         for update_fulfill in commitment_update.update_fulfill_htlcs {
1298                                 node_a.node.handle_update_fulfill_htlc(&node_b.node.get_our_node_id(), &update_fulfill);
1299                         }
1300                         for update_fail in commitment_update.update_fail_htlcs {
1301                                 node_a.node.handle_update_fail_htlc(&node_b.node.get_our_node_id(), &update_fail);
1302                         }
1303
1304                         if pending_htlc_adds.0 != -1 { // We use -1 to denote a response commitment_signed
1305                                 commitment_signed_dance!(node_a, node_b, commitment_update.commitment_signed, false);
1306                         } else {
1307                                 node_a.node.handle_commitment_signed(&node_b.node.get_our_node_id(), &commitment_update.commitment_signed);
1308                                 check_added_monitors!(node_a, 1);
1309                                 let as_revoke_and_ack = get_event_msg!(node_a, MessageSendEvent::SendRevokeAndACK, node_b.node.get_our_node_id());
1310                                 // No commitment_signed so get_event_msg's assert(len == 1) passes
1311                                 node_b.node.handle_revoke_and_ack(&node_a.node.get_our_node_id(), &as_revoke_and_ack);
1312                                 assert!(node_b.node.get_and_clear_pending_msg_events().is_empty());
1313                                 check_added_monitors!(node_b, 1);
1314                         }
1315                 } else {
1316                         assert!(chan_msgs.2.is_none());
1317                 }
1318         }
1319
1320         for chan_msgs in resp_2.drain(..) {
1321                 if send_funding_locked.1 {
1322                         node_b.node.handle_funding_locked(&node_a.node.get_our_node_id(), &chan_msgs.0.unwrap());
1323                         let announcement_event = node_b.node.get_and_clear_pending_msg_events();
1324                         if !announcement_event.is_empty() {
1325                                 assert_eq!(announcement_event.len(), 1);
1326                                 if let MessageSendEvent::SendAnnouncementSignatures { .. } = announcement_event[0] {
1327                                         //TODO: Test announcement_sigs re-sending
1328                                 } else { panic!("Unexpected event!"); }
1329                         }
1330                 } else {
1331                         assert!(chan_msgs.0.is_none());
1332                 }
1333                 if pending_raa.1 {
1334                         assert!(chan_msgs.3 == RAACommitmentOrder::RevokeAndACKFirst);
1335                         node_b.node.handle_revoke_and_ack(&node_a.node.get_our_node_id(), &chan_msgs.1.unwrap());
1336                         assert!(node_b.node.get_and_clear_pending_msg_events().is_empty());
1337                         check_added_monitors!(node_b, 1);
1338                 } else {
1339                         assert!(chan_msgs.1.is_none());
1340                 }
1341                 if pending_htlc_adds.1 != 0 || pending_htlc_claims.1 != 0 || pending_cell_htlc_claims.1 != 0 || pending_cell_htlc_fails.1 != 0 {
1342                         let commitment_update = chan_msgs.2.unwrap();
1343                         if pending_htlc_adds.1 != -1 { // We use -1 to denote a response commitment_signed
1344                                 assert_eq!(commitment_update.update_add_htlcs.len(), pending_htlc_adds.1 as usize);
1345                         }
1346                         assert_eq!(commitment_update.update_fulfill_htlcs.len(), pending_htlc_claims.0 + pending_cell_htlc_claims.0);
1347                         assert_eq!(commitment_update.update_fail_htlcs.len(), pending_cell_htlc_fails.0);
1348                         assert!(commitment_update.update_fail_malformed_htlcs.is_empty());
1349                         for update_add in commitment_update.update_add_htlcs {
1350                                 node_b.node.handle_update_add_htlc(&node_a.node.get_our_node_id(), &update_add);
1351                         }
1352                         for update_fulfill in commitment_update.update_fulfill_htlcs {
1353                                 node_b.node.handle_update_fulfill_htlc(&node_a.node.get_our_node_id(), &update_fulfill);
1354                         }
1355                         for update_fail in commitment_update.update_fail_htlcs {
1356                                 node_b.node.handle_update_fail_htlc(&node_a.node.get_our_node_id(), &update_fail);
1357                         }
1358
1359                         if pending_htlc_adds.1 != -1 { // We use -1 to denote a response commitment_signed
1360                                 commitment_signed_dance!(node_b, node_a, commitment_update.commitment_signed, false);
1361                         } else {
1362                                 node_b.node.handle_commitment_signed(&node_a.node.get_our_node_id(), &commitment_update.commitment_signed);
1363                                 check_added_monitors!(node_b, 1);
1364                                 let bs_revoke_and_ack = get_event_msg!(node_b, MessageSendEvent::SendRevokeAndACK, node_a.node.get_our_node_id());
1365                                 // No commitment_signed so get_event_msg's assert(len == 1) passes
1366                                 node_a.node.handle_revoke_and_ack(&node_b.node.get_our_node_id(), &bs_revoke_and_ack);
1367                                 assert!(node_a.node.get_and_clear_pending_msg_events().is_empty());
1368                                 check_added_monitors!(node_a, 1);
1369                         }
1370                 } else {
1371                         assert!(chan_msgs.2.is_none());
1372                 }
1373         }
1374 }