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

   1 //! Tests that test standing up a network of ChannelManagers, creating channels, sending
   2 //! payments/messages between them, and often checking the resulting ChannelMonitors are able to
   3 //! claim outputs on-chain.
   4
   5 use chain::chaininterface;
   6 use chain::transaction::OutPoint;
   7 use chain::chaininterface::{ChainListener, ChainWatchInterface};
   8 use chain::keysinterface::{KeysInterface, SpendableOutputDescriptor};
   9 use chain::keysinterface;
  10 use ln::channel::{COMMITMENT_TX_BASE_WEIGHT, COMMITMENT_TX_WEIGHT_PER_HTLC};
  11 use ln::channelmanager::{ChannelManager,ChannelManagerReadArgs,RAACommitmentOrder, PaymentPreimage, PaymentHash};
  12 use ln::channelmonitor::{ChannelMonitor, ChannelMonitorUpdateErr, CLTV_CLAIM_BUFFER, HTLC_FAIL_TIMEOUT_BLOCKS, ManyChannelMonitor};
  13 use ln::channel::{ACCEPTED_HTLC_SCRIPT_WEIGHT, OFFERED_HTLC_SCRIPT_WEIGHT};
  14 use ln::onion_utils;
  15 use ln::router::{Route, RouteHop, Router};
  16 use ln::msgs;
  17 use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler,HTLCFailChannelUpdate};
  18 use util::test_utils;
  19 use util::events::{Event, EventsProvider, MessageSendEvent, MessageSendEventsProvider};
  20 use util::errors::APIError;
  21 use util::logger::Logger;
  22 use util::ser::{Writeable, Writer, ReadableArgs};
  23 use util::config::UserConfig;
  24
  25 use bitcoin::util::hash::{BitcoinHash, Sha256dHash};
  26 use bitcoin::util::bip143;
  27 use bitcoin::util::address::Address;
  28 use bitcoin::util::bip32::{ChildNumber, ExtendedPubKey, ExtendedPrivKey};
  29 use bitcoin::blockdata::block::{Block, BlockHeader};
  30 use bitcoin::blockdata::transaction::{Transaction, TxOut, TxIn, SigHashType};
  31 use bitcoin::blockdata::script::{Builder, Script};
  32 use bitcoin::blockdata::opcodes;
  33 use bitcoin::blockdata::constants::genesis_block;
  34 use bitcoin::network::constants::Network;
  35
  36 use bitcoin_hashes::sha256::Hash as Sha256;
  37 use bitcoin_hashes::Hash;
  38
  39 use secp256k1::{Secp256k1, Message};
  40 use secp256k1::key::{PublicKey,SecretKey};
  41
  42 use rand::{thread_rng,Rng};
  43
  44 use std::cell::RefCell;
  45 use std::collections::{BTreeSet, HashMap, HashSet};
  46 use std::default::Default;
  47 use std::rc::Rc;
  48 use std::sync::{Arc, Mutex};
  49 use std::sync::atomic::Ordering;
  50 use std::time::Instant;
  51 use std::mem;
  52
  53 fn confirm_transaction(chain: &chaininterface::ChainWatchInterfaceUtil, tx: &Transaction, chan_id: u32) {
  54         assert!(chain.does_match_tx(tx));
  55         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
  56         chain.block_connected_checked(&header, 1, &[tx; 1], &[chan_id; 1]);
  57         for i in 2..100 {
  58                 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
  59                 chain.block_connected_checked(&header, i, &[tx; 0], &[0; 0]);
  60         }
  61 }
  62
  63 struct Node {
  64         chain_monitor: Arc<chaininterface::ChainWatchInterfaceUtil>,
  65         tx_broadcaster: Arc<test_utils::TestBroadcaster>,
  66         chan_monitor: Arc<test_utils::TestChannelMonitor>,
  67         keys_manager: Arc<test_utils::TestKeysInterface>,
  68         node: Arc<ChannelManager>,
  69         router: Router,
  70         node_seed: [u8; 32],
  71         network_payment_count: Rc<RefCell<u8>>,
  72         network_chan_count: Rc<RefCell<u32>>,
  73 }
  74 impl Drop for Node {
  75         fn drop(&mut self) {
  76                 if !::std::thread::panicking() {
  77                         // Check that we processed all pending events
  78                         assert_eq!(self.node.get_and_clear_pending_msg_events().len(), 0);
  79                         assert_eq!(self.node.get_and_clear_pending_events().len(), 0);
  80                         assert_eq!(self.chan_monitor.added_monitors.lock().unwrap().len(), 0);
  81                 }
  82         }
  83 }
  84
  85 fn create_chan_between_nodes(node_a: &Node, node_b: &Node) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
  86         create_chan_between_nodes_with_value(node_a, node_b, 100000, 10001)
  87 }
  88
  89 fn create_chan_between_nodes_with_value(node_a: &Node, node_b: &Node, channel_value: u64, push_msat: u64) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
  90         let (funding_locked, channel_id, tx) = create_chan_between_nodes_with_value_a(node_a, node_b, channel_value, push_msat);
  91         let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(node_a, node_b, &funding_locked);
  92         (announcement, as_update, bs_update, channel_id, tx)
  93 }
  94
  95 macro_rules! get_revoke_commit_msgs {
  96         ($node: expr, $node_id: expr) => {
  97                 {
  98                         let events = $node.node.get_and_clear_pending_msg_events();
  99                         assert_eq!(events.len(), 2);
 100                         (match events[0] {
 101                                 MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
 102                                         assert_eq!(*node_id, $node_id);
 103                                         (*msg).clone()
 104                                 },
 105                                 _ => panic!("Unexpected event"),
 106                         }, match events[1] {
 107                                 MessageSendEvent::UpdateHTLCs { ref node_id, ref updates } => {
 108                                         assert_eq!(*node_id, $node_id);
 109                                         assert!(updates.update_add_htlcs.is_empty());
 110                                         assert!(updates.update_fulfill_htlcs.is_empty());
 111                                         assert!(updates.update_fail_htlcs.is_empty());
 112                                         assert!(updates.update_fail_malformed_htlcs.is_empty());
 113                                         assert!(updates.update_fee.is_none());
 114                                         updates.commitment_signed.clone()
 115                                 },
 116                                 _ => panic!("Unexpected event"),
 117                         })
 118                 }
 119         }
 120 }
 121
 122 macro_rules! get_event_msg {
 123         ($node: expr, $event_type: path, $node_id: expr) => {
 124                 {
 125                         let events = $node.node.get_and_clear_pending_msg_events();
 126                         assert_eq!(events.len(), 1);
 127                         match events[0] {
 128                                 $event_type { ref node_id, ref msg } => {
 129                                         assert_eq!(*node_id, $node_id);
 130                                         (*msg).clone()
 131                                 },
 132                                 _ => panic!("Unexpected event"),
 133                         }
 134                 }
 135         }
 136 }
 137
 138 macro_rules! get_htlc_update_msgs {
 139         ($node: expr, $node_id: expr) => {
 140                 {
 141                         let events = $node.node.get_and_clear_pending_msg_events();
 142                         assert_eq!(events.len(), 1);
 143                         match events[0] {
 144                                 MessageSendEvent::UpdateHTLCs { ref node_id, ref updates } => {
 145                                         assert_eq!(*node_id, $node_id);
 146                                         (*updates).clone()
 147                                 },
 148                                 _ => panic!("Unexpected event"),
 149                         }
 150                 }
 151         }
 152 }
 153
 154 macro_rules! get_feerate {
 155         ($node: expr, $channel_id: expr) => {
 156                 {
 157                         let chan_lock = $node.node.channel_state.lock().unwrap();
 158                         let chan = chan_lock.by_id.get(&$channel_id).unwrap();
 159                         chan.get_feerate()
 160                 }
 161         }
 162 }
 163
 164
 165 fn create_chan_between_nodes_with_value_init(node_a: &Node, node_b: &Node, channel_value: u64, push_msat: u64) -> Transaction {
 166         node_a.node.create_channel(node_b.node.get_our_node_id(), channel_value, push_msat, 42).unwrap();
 167         node_b.node.handle_open_channel(&node_a.node.get_our_node_id(), &get_event_msg!(node_a, MessageSendEvent::SendOpenChannel, node_b.node.get_our_node_id())).unwrap();
 168         node_a.node.handle_accept_channel(&node_b.node.get_our_node_id(), &get_event_msg!(node_b, MessageSendEvent::SendAcceptChannel, node_a.node.get_our_node_id())).unwrap();
 169
 170         let chan_id = *node_a.network_chan_count.borrow();
 171         let tx;
 172         let funding_output;
 173
 174         let events_2 = node_a.node.get_and_clear_pending_events();
 175         assert_eq!(events_2.len(), 1);
 176         match events_2[0] {
 177                 Event::FundingGenerationReady { ref temporary_channel_id, ref channel_value_satoshis, ref output_script, user_channel_id } => {
 178                         assert_eq!(*channel_value_satoshis, channel_value);
 179                         assert_eq!(user_channel_id, 42);
 180
 181                         tx = Transaction { version: chan_id as u32, lock_time: 0, input: Vec::new(), output: vec![TxOut {
 182                                 value: *channel_value_satoshis, script_pubkey: output_script.clone(),
 183                         }]};
 184                         funding_output = OutPoint::new(tx.txid(), 0);
 185
 186                         node_a.node.funding_transaction_generated(&temporary_channel_id, funding_output);
 187                         let mut added_monitors = node_a.chan_monitor.added_monitors.lock().unwrap();
 188                         assert_eq!(added_monitors.len(), 1);
 189                         assert_eq!(added_monitors[0].0, funding_output);
 190                         added_monitors.clear();
 191                 },
 192                 _ => panic!("Unexpected event"),
 193         }
 194
 195         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())).unwrap();
 196         {
 197                 let mut added_monitors = node_b.chan_monitor.added_monitors.lock().unwrap();
 198                 assert_eq!(added_monitors.len(), 1);
 199                 assert_eq!(added_monitors[0].0, funding_output);
 200                 added_monitors.clear();
 201         }
 202
 203         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())).unwrap();
 204         {
 205                 let mut added_monitors = node_a.chan_monitor.added_monitors.lock().unwrap();
 206                 assert_eq!(added_monitors.len(), 1);
 207                 assert_eq!(added_monitors[0].0, funding_output);
 208                 added_monitors.clear();
 209         }
 210
 211         let events_4 = node_a.node.get_and_clear_pending_events();
 212         assert_eq!(events_4.len(), 1);
 213         match events_4[0] {
 214                 Event::FundingBroadcastSafe { ref funding_txo, user_channel_id } => {
 215                         assert_eq!(user_channel_id, 42);
 216                         assert_eq!(*funding_txo, funding_output);
 217                 },
 218                 _ => panic!("Unexpected event"),
 219         };
 220
 221         tx
 222 }
 223
 224 fn create_chan_between_nodes_with_value_confirm(node_a: &Node, node_b: &Node, tx: &Transaction) -> ((msgs::FundingLocked, msgs::AnnouncementSignatures), [u8; 32]) {
 225         confirm_transaction(&node_b.chain_monitor, &tx, tx.version);
 226         node_a.node.handle_funding_locked(&node_b.node.get_our_node_id(), &get_event_msg!(node_b, MessageSendEvent::SendFundingLocked, node_a.node.get_our_node_id())).unwrap();
 227
 228         let channel_id;
 229
 230         confirm_transaction(&node_a.chain_monitor, &tx, tx.version);
 231         let events_6 = node_a.node.get_and_clear_pending_msg_events();
 232         assert_eq!(events_6.len(), 2);
 233         ((match events_6[0] {
 234                 MessageSendEvent::SendFundingLocked { ref node_id, ref msg } => {
 235                         channel_id = msg.channel_id.clone();
 236                         assert_eq!(*node_id, node_b.node.get_our_node_id());
 237                         msg.clone()
 238                 },
 239                 _ => panic!("Unexpected event"),
 240         }, match events_6[1] {
 241                 MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } => {
 242                         assert_eq!(*node_id, node_b.node.get_our_node_id());
 243                         msg.clone()
 244                 },
 245                 _ => panic!("Unexpected event"),
 246         }), channel_id)
 247 }
 248
 249 fn create_chan_between_nodes_with_value_a(node_a: &Node, node_b: &Node, channel_value: u64, push_msat: u64) -> ((msgs::FundingLocked, msgs::AnnouncementSignatures), [u8; 32], Transaction) {
 250         let tx = create_chan_between_nodes_with_value_init(node_a, node_b, channel_value, push_msat);
 251         let (msgs, chan_id) = create_chan_between_nodes_with_value_confirm(node_a, node_b, &tx);
 252         (msgs, chan_id, tx)
 253 }
 254
 255 fn create_chan_between_nodes_with_value_b(node_a: &Node, node_b: &Node, as_funding_msgs: &(msgs::FundingLocked, msgs::AnnouncementSignatures)) -> (msgs::ChannelAnnouncement, msgs::ChannelUpdate, msgs::ChannelUpdate) {
 256         node_b.node.handle_funding_locked(&node_a.node.get_our_node_id(), &as_funding_msgs.0).unwrap();
 257         let bs_announcement_sigs = get_event_msg!(node_b, MessageSendEvent::SendAnnouncementSignatures, node_a.node.get_our_node_id());
 258         node_b.node.handle_announcement_signatures(&node_a.node.get_our_node_id(), &as_funding_msgs.1).unwrap();
 259
 260         let events_7 = node_b.node.get_and_clear_pending_msg_events();
 261         assert_eq!(events_7.len(), 1);
 262         let (announcement, bs_update) = match events_7[0] {
 263                 MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } => {
 264                         (msg, update_msg)
 265                 },
 266                 _ => panic!("Unexpected event"),
 267         };
 268
 269         node_a.node.handle_announcement_signatures(&node_b.node.get_our_node_id(), &bs_announcement_sigs).unwrap();
 270         let events_8 = node_a.node.get_and_clear_pending_msg_events();
 271         assert_eq!(events_8.len(), 1);
 272         let as_update = match events_8[0] {
 273                 MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } => {
 274                         assert!(*announcement == *msg);
 275                         assert_eq!(update_msg.contents.short_channel_id, announcement.contents.short_channel_id);
 276                         assert_eq!(update_msg.contents.short_channel_id, bs_update.contents.short_channel_id);
 277                         update_msg
 278                 },
 279                 _ => panic!("Unexpected event"),
 280         };
 281
 282         *node_a.network_chan_count.borrow_mut() += 1;
 283
 284         ((*announcement).clone(), (*as_update).clone(), (*bs_update).clone())
 285 }
 286
 287 fn create_announced_chan_between_nodes(nodes: &Vec<Node>, a: usize, b: usize) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
 288         create_announced_chan_between_nodes_with_value(nodes, a, b, 100000, 10001)
 289 }
 290
 291 fn create_announced_chan_between_nodes_with_value(nodes: &Vec<Node>, a: usize, b: usize, channel_value: u64, push_msat: u64) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction) {
 292         let chan_announcement = create_chan_between_nodes_with_value(&nodes[a], &nodes[b], channel_value, push_msat);
 293         for node in nodes {
 294                 assert!(node.router.handle_channel_announcement(&chan_announcement.0).unwrap());
 295                 node.router.handle_channel_update(&chan_announcement.1).unwrap();
 296                 node.router.handle_channel_update(&chan_announcement.2).unwrap();
 297         }
 298         (chan_announcement.1, chan_announcement.2, chan_announcement.3, chan_announcement.4)
 299 }
 300
 301 macro_rules! check_spends {
 302         ($tx: expr, $spends_tx: expr) => {
 303                 {
 304                         let mut funding_tx_map = HashMap::new();
 305                         let spends_tx = $spends_tx;
 306                         funding_tx_map.insert(spends_tx.txid(), spends_tx);
 307                         $tx.verify(&funding_tx_map).unwrap();
 308                 }
 309         }
 310 }
 311
 312 macro_rules! get_closing_signed_broadcast {
 313         ($node: expr, $dest_pubkey: expr) => {
 314                 {
 315                         let events = $node.get_and_clear_pending_msg_events();
 316                         assert!(events.len() == 1 || events.len() == 2);
 317                         (match events[events.len() - 1] {
 318                                 MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
 319                                         assert_eq!(msg.contents.flags & 2, 2);
 320                                         msg.clone()
 321                                 },
 322                                 _ => panic!("Unexpected event"),
 323                         }, if events.len() == 2 {
 324                                 match events[0] {
 325                                         MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => {
 326                                                 assert_eq!(*node_id, $dest_pubkey);
 327                                                 Some(msg.clone())
 328                                         },
 329                                         _ => panic!("Unexpected event"),
 330                                 }
 331                         } else { None })
 332                 }
 333         }
 334 }
 335
 336 fn close_channel(outbound_node: &Node, inbound_node: &Node, channel_id: &[u8; 32], funding_tx: Transaction, close_inbound_first: bool) -> (msgs::ChannelUpdate, msgs::ChannelUpdate, Transaction) {
 337         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) };
 338         let (node_b, broadcaster_b) = if close_inbound_first { (&outbound_node.node, &outbound_node.tx_broadcaster) } else { (&inbound_node.node, &inbound_node.tx_broadcaster) };
 339         let (tx_a, tx_b);
 340
 341         node_a.close_channel(channel_id).unwrap();
 342         node_b.handle_shutdown(&node_a.get_our_node_id(), &get_event_msg!(struct_a, MessageSendEvent::SendShutdown, node_b.get_our_node_id())).unwrap();
 343
 344         let events_1 = node_b.get_and_clear_pending_msg_events();
 345         assert!(events_1.len() >= 1);
 346         let shutdown_b = match events_1[0] {
 347                 MessageSendEvent::SendShutdown { ref node_id, ref msg } => {
 348                         assert_eq!(node_id, &node_a.get_our_node_id());
 349                         msg.clone()
 350                 },
 351                 _ => panic!("Unexpected event"),
 352         };
 353
 354         let closing_signed_b = if !close_inbound_first {
 355                 assert_eq!(events_1.len(), 1);
 356                 None
 357         } else {
 358                 Some(match events_1[1] {
 359                         MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => {
 360                                 assert_eq!(node_id, &node_a.get_our_node_id());
 361                                 msg.clone()
 362                         },
 363                         _ => panic!("Unexpected event"),
 364                 })
 365         };
 366
 367         node_a.handle_shutdown(&node_b.get_our_node_id(), &shutdown_b).unwrap();
 368         let (as_update, bs_update) = if close_inbound_first {
 369                 assert!(node_a.get_and_clear_pending_msg_events().is_empty());
 370                 node_a.handle_closing_signed(&node_b.get_our_node_id(), &closing_signed_b.unwrap()).unwrap();
 371                 assert_eq!(broadcaster_a.txn_broadcasted.lock().unwrap().len(), 1);
 372                 tx_a = broadcaster_a.txn_broadcasted.lock().unwrap().remove(0);
 373                 let (as_update, closing_signed_a) = get_closing_signed_broadcast!(node_a, node_b.get_our_node_id());
 374
 375                 node_b.handle_closing_signed(&node_a.get_our_node_id(), &closing_signed_a.unwrap()).unwrap();
 376                 let (bs_update, none_b) = get_closing_signed_broadcast!(node_b, node_a.get_our_node_id());
 377                 assert!(none_b.is_none());
 378                 assert_eq!(broadcaster_b.txn_broadcasted.lock().unwrap().len(), 1);
 379                 tx_b = broadcaster_b.txn_broadcasted.lock().unwrap().remove(0);
 380                 (as_update, bs_update)
 381         } else {
 382                 let closing_signed_a = get_event_msg!(struct_a, MessageSendEvent::SendClosingSigned, node_b.get_our_node_id());
 383
 384                 node_b.handle_closing_signed(&node_a.get_our_node_id(), &closing_signed_a).unwrap();
 385                 assert_eq!(broadcaster_b.txn_broadcasted.lock().unwrap().len(), 1);
 386                 tx_b = broadcaster_b.txn_broadcasted.lock().unwrap().remove(0);
 387                 let (bs_update, closing_signed_b) = get_closing_signed_broadcast!(node_b, node_a.get_our_node_id());
 388
 389                 node_a.handle_closing_signed(&node_b.get_our_node_id(), &closing_signed_b.unwrap()).unwrap();
 390                 let (as_update, none_a) = get_closing_signed_broadcast!(node_a, node_b.get_our_node_id());
 391                 assert!(none_a.is_none());
 392                 assert_eq!(broadcaster_a.txn_broadcasted.lock().unwrap().len(), 1);
 393                 tx_a = broadcaster_a.txn_broadcasted.lock().unwrap().remove(0);
 394                 (as_update, bs_update)
 395         };
 396         assert_eq!(tx_a, tx_b);
 397         check_spends!(tx_a, funding_tx);
 398
 399         (as_update, bs_update, tx_a)
 400 }
 401
 402 struct SendEvent {
 403         node_id: PublicKey,
 404         msgs: Vec<msgs::UpdateAddHTLC>,
 405         commitment_msg: msgs::CommitmentSigned,
 406 }
 407 impl SendEvent {
 408         fn from_commitment_update(node_id: PublicKey, updates: msgs::CommitmentUpdate) -> SendEvent {
 409                 assert!(updates.update_fulfill_htlcs.is_empty());
 410                 assert!(updates.update_fail_htlcs.is_empty());
 411                 assert!(updates.update_fail_malformed_htlcs.is_empty());
 412                 assert!(updates.update_fee.is_none());
 413                 SendEvent { node_id: node_id, msgs: updates.update_add_htlcs, commitment_msg: updates.commitment_signed }
 414         }
 415
 416         fn from_event(event: MessageSendEvent) -> SendEvent {
 417                 match event {
 418                         MessageSendEvent::UpdateHTLCs { node_id, updates } => SendEvent::from_commitment_update(node_id, updates),
 419                         _ => panic!("Unexpected event type!"),
 420                 }
 421         }
 422
 423         fn from_node(node: &Node) -> SendEvent {
 424                 let mut events = node.node.get_and_clear_pending_msg_events();
 425                 assert_eq!(events.len(), 1);
 426                 SendEvent::from_event(events.pop().unwrap())
 427         }
 428 }
 429
 430 macro_rules! check_added_monitors {
 431         ($node: expr, $count: expr) => {
 432                 {
 433                         let mut added_monitors = $node.chan_monitor.added_monitors.lock().unwrap();
 434                         assert_eq!(added_monitors.len(), $count);
 435                         added_monitors.clear();
 436                 }
 437         }
 438 }
 439
 440 macro_rules! commitment_signed_dance {
 441         ($node_a: expr, $node_b: expr, $commitment_signed: expr, $fail_backwards: expr, true /* skip last step */) => {
 442                 {
 443                         check_added_monitors!($node_a, 0);
 444                         assert!($node_a.node.get_and_clear_pending_msg_events().is_empty());
 445                         $node_a.node.handle_commitment_signed(&$node_b.node.get_our_node_id(), &$commitment_signed).unwrap();
 446                         check_added_monitors!($node_a, 1);
 447                         commitment_signed_dance!($node_a, $node_b, (), $fail_backwards, true, false);
 448                 }
 449         };
 450         ($node_a: expr, $node_b: expr, (), $fail_backwards: expr, true /* skip last step */, true /* return extra message */, true /* return last RAA */) => {
 451                 {
 452                         let (as_revoke_and_ack, as_commitment_signed) = get_revoke_commit_msgs!($node_a, $node_b.node.get_our_node_id());
 453                         check_added_monitors!($node_b, 0);
 454                         assert!($node_b.node.get_and_clear_pending_msg_events().is_empty());
 455                         $node_b.node.handle_revoke_and_ack(&$node_a.node.get_our_node_id(), &as_revoke_and_ack).unwrap();
 456                         assert!($node_b.node.get_and_clear_pending_msg_events().is_empty());
 457                         check_added_monitors!($node_b, 1);
 458                         $node_b.node.handle_commitment_signed(&$node_a.node.get_our_node_id(), &as_commitment_signed).unwrap();
 459                         let (bs_revoke_and_ack, extra_msg_option) = {
 460                                 let events = $node_b.node.get_and_clear_pending_msg_events();
 461                                 assert!(events.len() <= 2);
 462                                 (match events[0] {
 463                                         MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
 464                                                 assert_eq!(*node_id, $node_a.node.get_our_node_id());
 465                                                 (*msg).clone()
 466                                         },
 467                                         _ => panic!("Unexpected event"),
 468                                 }, events.get(1).map(|e| e.clone()))
 469                         };
 470                         check_added_monitors!($node_b, 1);
 471                         if $fail_backwards {
 472                                 assert!($node_a.node.get_and_clear_pending_events().is_empty());
 473                                 assert!($node_a.node.get_and_clear_pending_msg_events().is_empty());
 474                         }
 475                         (extra_msg_option, bs_revoke_and_ack)
 476                 }
 477         };
 478         ($node_a: expr, $node_b: expr, $commitment_signed: expr, $fail_backwards: expr, true /* skip last step */, false /* return extra message */, true /* return last RAA */) => {
 479                 {
 480                         check_added_monitors!($node_a, 0);
 481                         assert!($node_a.node.get_and_clear_pending_msg_events().is_empty());
 482                         $node_a.node.handle_commitment_signed(&$node_b.node.get_our_node_id(), &$commitment_signed).unwrap();
 483                         check_added_monitors!($node_a, 1);
 484                         let (extra_msg_option, bs_revoke_and_ack) = commitment_signed_dance!($node_a, $node_b, (), $fail_backwards, true, true, true);
 485                         assert!(extra_msg_option.is_none());
 486                         bs_revoke_and_ack
 487                 }
 488         };
 489         ($node_a: expr, $node_b: expr, (), $fail_backwards: expr, true /* skip last step */, true /* return extra message */) => {
 490                 {
 491                         let (extra_msg_option, bs_revoke_and_ack) = commitment_signed_dance!($node_a, $node_b, (), $fail_backwards, true, true, true);
 492                         $node_a.node.handle_revoke_and_ack(&$node_b.node.get_our_node_id(), &bs_revoke_and_ack).unwrap();
 493                         {
 494                                 let mut added_monitors = $node_a.chan_monitor.added_monitors.lock().unwrap();
 495                                 if $fail_backwards {
 496                                         assert_eq!(added_monitors.len(), 2);
 497                                         assert!(added_monitors[0].0 != added_monitors[1].0);
 498                                 } else {
 499                                         assert_eq!(added_monitors.len(), 1);
 500                                 }
 501                                 added_monitors.clear();
 502                         }
 503                         extra_msg_option
 504                 }
 505         };
 506         ($node_a: expr, $node_b: expr, (), $fail_backwards: expr, true /* skip last step */, false /* no extra message */) => {
 507                 {
 508                         assert!(commitment_signed_dance!($node_a, $node_b, (), $fail_backwards, true, true).is_none());
 509                 }
 510         };
 511         ($node_a: expr, $node_b: expr, $commitment_signed: expr, $fail_backwards: expr) => {
 512                 {
 513                         commitment_signed_dance!($node_a, $node_b, $commitment_signed, $fail_backwards, true);
 514                         if $fail_backwards {
 515                                 let channel_state = $node_a.node.channel_state.lock().unwrap();
 516                                 assert_eq!(channel_state.pending_msg_events.len(), 1);
 517                                 if let MessageSendEvent::UpdateHTLCs { ref node_id, .. } = channel_state.pending_msg_events[0] {
 518                                         assert_ne!(*node_id, $node_b.node.get_our_node_id());
 519                                 } else { panic!("Unexpected event"); }
 520                         } else {
 521                                 assert!($node_a.node.get_and_clear_pending_msg_events().is_empty());
 522                         }
 523                 }
 524         }
 525 }
 526
 527 macro_rules! get_payment_preimage_hash {
 528         ($node: expr) => {
 529                 {
 530                         let payment_preimage = PaymentPreimage([*$node.network_payment_count.borrow(); 32]);
 531                         *$node.network_payment_count.borrow_mut() += 1;
 532                         let payment_hash = PaymentHash(Sha256::hash(&payment_preimage.0[..]).into_inner());
 533                         (payment_preimage, payment_hash)
 534                 }
 535         }
 536 }
 537
 538 macro_rules! expect_pending_htlcs_forwardable {
 539         ($node: expr) => {{
 540                 let events = $node.node.get_and_clear_pending_events();
 541                 assert_eq!(events.len(), 1);
 542                 match events[0] {
 543                         Event::PendingHTLCsForwardable { .. } => { },
 544                         _ => panic!("Unexpected event"),
 545                 };
 546                 let node_ref: &Node = &$node;
 547                 node_ref.node.channel_state.lock().unwrap().next_forward = Instant::now();
 548                 $node.node.process_pending_htlc_forwards();
 549         }}
 550 }
 551
 552 fn send_along_route(origin_node: &Node, route: Route, expected_route: &[&Node], recv_value: u64) -> (PaymentPreimage, PaymentHash) {
 553         let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(origin_node);
 554
 555         let mut payment_event = {
 556                 origin_node.node.send_payment(route, our_payment_hash).unwrap();
 557                 check_added_monitors!(origin_node, 1);
 558
 559                 let mut events = origin_node.node.get_and_clear_pending_msg_events();
 560                 assert_eq!(events.len(), 1);
 561                 SendEvent::from_event(events.remove(0))
 562         };
 563         let mut prev_node = origin_node;
 564
 565         for (idx, &node) in expected_route.iter().enumerate() {
 566                 assert_eq!(node.node.get_our_node_id(), payment_event.node_id);
 567
 568                 node.node.handle_update_add_htlc(&prev_node.node.get_our_node_id(), &payment_event.msgs[0]).unwrap();
 569                 check_added_monitors!(node, 0);
 570                 commitment_signed_dance!(node, prev_node, payment_event.commitment_msg, false);
 571
 572                 expect_pending_htlcs_forwardable!(node);
 573
 574                 if idx == expected_route.len() - 1 {
 575                         let events_2 = node.node.get_and_clear_pending_events();
 576                         assert_eq!(events_2.len(), 1);
 577                         match events_2[0] {
 578                                 Event::PaymentReceived { ref payment_hash, amt } => {
 579                                         assert_eq!(our_payment_hash, *payment_hash);
 580                                         assert_eq!(amt, recv_value);
 581                                 },
 582                                 _ => panic!("Unexpected event"),
 583                         }
 584                 } else {
 585                         let mut events_2 = node.node.get_and_clear_pending_msg_events();
 586                         assert_eq!(events_2.len(), 1);
 587                         check_added_monitors!(node, 1);
 588                         payment_event = SendEvent::from_event(events_2.remove(0));
 589                         assert_eq!(payment_event.msgs.len(), 1);
 590                 }
 591
 592                 prev_node = node;
 593         }
 594
 595         (our_payment_preimage, our_payment_hash)
 596 }
 597
 598 fn claim_payment_along_route(origin_node: &Node, expected_route: &[&Node], skip_last: bool, our_payment_preimage: PaymentPreimage) {
 599         assert!(expected_route.last().unwrap().node.claim_funds(our_payment_preimage));
 600         check_added_monitors!(expected_route.last().unwrap(), 1);
 601
 602         let mut next_msgs: Option<(msgs::UpdateFulfillHTLC, msgs::CommitmentSigned)> = None;
 603         let mut expected_next_node = expected_route.last().unwrap().node.get_our_node_id();
 604         macro_rules! get_next_msgs {
 605                 ($node: expr) => {
 606                         {
 607                                 let events = $node.node.get_and_clear_pending_msg_events();
 608                                 assert_eq!(events.len(), 1);
 609                                 match events[0] {
 610                                         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 } } => {
 611                                                 assert!(update_add_htlcs.is_empty());
 612                                                 assert_eq!(update_fulfill_htlcs.len(), 1);
 613                                                 assert!(update_fail_htlcs.is_empty());
 614                                                 assert!(update_fail_malformed_htlcs.is_empty());
 615                                                 assert!(update_fee.is_none());
 616                                                 expected_next_node = node_id.clone();
 617                                                 Some((update_fulfill_htlcs[0].clone(), commitment_signed.clone()))
 618                                         },
 619                                         _ => panic!("Unexpected event"),
 620                                 }
 621                         }
 622                 }
 623         }
 624
 625         macro_rules! last_update_fulfill_dance {
 626                 ($node: expr, $prev_node: expr) => {
 627                         {
 628                                 $node.node.handle_update_fulfill_htlc(&$prev_node.node.get_our_node_id(), &next_msgs.as_ref().unwrap().0).unwrap();
 629                                 check_added_monitors!($node, 0);
 630                                 assert!($node.node.get_and_clear_pending_msg_events().is_empty());
 631                                 commitment_signed_dance!($node, $prev_node, next_msgs.as_ref().unwrap().1, false);
 632                         }
 633                 }
 634         }
 635         macro_rules! mid_update_fulfill_dance {
 636                 ($node: expr, $prev_node: expr, $new_msgs: expr) => {
 637                         {
 638                                 $node.node.handle_update_fulfill_htlc(&$prev_node.node.get_our_node_id(), &next_msgs.as_ref().unwrap().0).unwrap();
 639                                 check_added_monitors!($node, 1);
 640                                 let new_next_msgs = if $new_msgs {
 641                                         get_next_msgs!($node)
 642                                 } else {
 643                                         assert!($node.node.get_and_clear_pending_msg_events().is_empty());
 644                                         None
 645                                 };
 646                                 commitment_signed_dance!($node, $prev_node, next_msgs.as_ref().unwrap().1, false);
 647                                 next_msgs = new_next_msgs;
 648                         }
 649                 }
 650         }
 651
 652         let mut prev_node = expected_route.last().unwrap();
 653         for (idx, node) in expected_route.iter().rev().enumerate() {
 654                 assert_eq!(expected_next_node, node.node.get_our_node_id());
 655                 let update_next_msgs = !skip_last || idx != expected_route.len() - 1;
 656                 if next_msgs.is_some() {
 657                         mid_update_fulfill_dance!(node, prev_node, update_next_msgs);
 658                 } else if update_next_msgs {
 659                         next_msgs = get_next_msgs!(node);
 660                 } else {
 661                         assert!(node.node.get_and_clear_pending_msg_events().is_empty());
 662                 }
 663                 if !skip_last && idx == expected_route.len() - 1 {
 664                         assert_eq!(expected_next_node, origin_node.node.get_our_node_id());
 665                 }
 666
 667                 prev_node = node;
 668         }
 669
 670         if !skip_last {
 671                 last_update_fulfill_dance!(origin_node, expected_route.first().unwrap());
 672                 let events = origin_node.node.get_and_clear_pending_events();
 673                 assert_eq!(events.len(), 1);
 674                 match events[0] {
 675                         Event::PaymentSent { payment_preimage } => {
 676                                 assert_eq!(payment_preimage, our_payment_preimage);
 677                         },
 678                         _ => panic!("Unexpected event"),
 679                 }
 680         }
 681 }
 682
 683 fn claim_payment(origin_node: &Node, expected_route: &[&Node], our_payment_preimage: PaymentPreimage) {
 684         claim_payment_along_route(origin_node, expected_route, false, our_payment_preimage);
 685 }
 686
 687 const TEST_FINAL_CLTV: u32 = 32;
 688
 689 fn route_payment(origin_node: &Node, expected_route: &[&Node], recv_value: u64) -> (PaymentPreimage, PaymentHash) {
 690         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();
 691         assert_eq!(route.hops.len(), expected_route.len());
 692         for (node, hop) in expected_route.iter().zip(route.hops.iter()) {
 693                 assert_eq!(hop.pubkey, node.node.get_our_node_id());
 694         }
 695
 696         send_along_route(origin_node, route, expected_route, recv_value)
 697 }
 698
 699 fn route_over_limit(origin_node: &Node, expected_route: &[&Node], recv_value: u64) {
 700         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();
 701         assert_eq!(route.hops.len(), expected_route.len());
 702         for (node, hop) in expected_route.iter().zip(route.hops.iter()) {
 703                 assert_eq!(hop.pubkey, node.node.get_our_node_id());
 704         }
 705
 706         let (_, our_payment_hash) = get_payment_preimage_hash!(origin_node);
 707
 708         let err = origin_node.node.send_payment(route, our_payment_hash).err().unwrap();
 709         match err {
 710                 APIError::ChannelUnavailable{err} => assert_eq!(err, "Cannot send value that would put us over our max HTLC value in flight"),
 711                 _ => panic!("Unknown error variants"),
 712         };
 713 }
 714
 715 fn send_payment(origin: &Node, expected_route: &[&Node], recv_value: u64) {
 716         let our_payment_preimage = route_payment(&origin, expected_route, recv_value).0;
 717         claim_payment(&origin, expected_route, our_payment_preimage);
 718 }
 719
 720 fn fail_payment_along_route(origin_node: &Node, expected_route: &[&Node], skip_last: bool, our_payment_hash: PaymentHash) {
 721         assert!(expected_route.last().unwrap().node.fail_htlc_backwards(&our_payment_hash, 0));
 722         check_added_monitors!(expected_route.last().unwrap(), 1);
 723
 724         let mut next_msgs: Option<(msgs::UpdateFailHTLC, msgs::CommitmentSigned)> = None;
 725         macro_rules! update_fail_dance {
 726                 ($node: expr, $prev_node: expr, $last_node: expr) => {
 727                         {
 728                                 $node.node.handle_update_fail_htlc(&$prev_node.node.get_our_node_id(), &next_msgs.as_ref().unwrap().0).unwrap();
 729                                 commitment_signed_dance!($node, $prev_node, next_msgs.as_ref().unwrap().1, !$last_node);
 730                         }
 731                 }
 732         }
 733
 734         let mut expected_next_node = expected_route.last().unwrap().node.get_our_node_id();
 735         let mut prev_node = expected_route.last().unwrap();
 736         for (idx, node) in expected_route.iter().rev().enumerate() {
 737                 assert_eq!(expected_next_node, node.node.get_our_node_id());
 738                 if next_msgs.is_some() {
 739                         // We may be the "last node" for the purpose of the commitment dance if we're
 740                         // skipping the last node (implying it is disconnected) and we're the
 741                         // second-to-last node!
 742                         update_fail_dance!(node, prev_node, skip_last && idx == expected_route.len() - 1);
 743                 }
 744
 745                 let events = node.node.get_and_clear_pending_msg_events();
 746                 if !skip_last || idx != expected_route.len() - 1 {
 747                         assert_eq!(events.len(), 1);
 748                         match events[0] {
 749                                 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 } } => {
 750                                         assert!(update_add_htlcs.is_empty());
 751                                         assert!(update_fulfill_htlcs.is_empty());
 752                                         assert_eq!(update_fail_htlcs.len(), 1);
 753                                         assert!(update_fail_malformed_htlcs.is_empty());
 754                                         assert!(update_fee.is_none());
 755                                         expected_next_node = node_id.clone();
 756                                         next_msgs = Some((update_fail_htlcs[0].clone(), commitment_signed.clone()));
 757                                 },
 758                                 _ => panic!("Unexpected event"),
 759                         }
 760                 } else {
 761                         assert!(events.is_empty());
 762                 }
 763                 if !skip_last && idx == expected_route.len() - 1 {
 764                         assert_eq!(expected_next_node, origin_node.node.get_our_node_id());
 765                 }
 766
 767                 prev_node = node;
 768         }
 769
 770         if !skip_last {
 771                 update_fail_dance!(origin_node, expected_route.first().unwrap(), true);
 772
 773                 let events = origin_node.node.get_and_clear_pending_events();
 774                 assert_eq!(events.len(), 1);
 775                 match events[0] {
 776                         Event::PaymentFailed { payment_hash, rejected_by_dest, .. } => {
 777                                 assert_eq!(payment_hash, our_payment_hash);
 778                                 assert!(rejected_by_dest);
 779                         },
 780                         _ => panic!("Unexpected event"),
 781                 }
 782         }
 783 }
 784
 785 fn fail_payment(origin_node: &Node, expected_route: &[&Node], our_payment_hash: PaymentHash) {
 786         fail_payment_along_route(origin_node, expected_route, false, our_payment_hash);
 787 }
 788
 789 fn create_network(node_count: usize) -> Vec<Node> {
 790         let mut nodes = Vec::new();
 791         let mut rng = thread_rng();
 792         let secp_ctx = Secp256k1::new();
 793
 794         let chan_count = Rc::new(RefCell::new(0));
 795         let payment_count = Rc::new(RefCell::new(0));
 796
 797         for i in 0..node_count {
 798                 let logger: Arc<Logger> = Arc::new(test_utils::TestLogger::with_id(format!("node {}", i)));
 799                 let feeest = Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 });
 800                 let chain_monitor = Arc::new(chaininterface::ChainWatchInterfaceUtil::new(Network::Testnet, Arc::clone(&logger)));
 801                 let tx_broadcaster = Arc::new(test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new())});
 802                 let mut seed = [0; 32];
 803                 rng.fill_bytes(&mut seed);
 804                 let keys_manager = Arc::new(test_utils::TestKeysInterface::new(&seed, Network::Testnet, Arc::clone(&logger)));
 805                 let chan_monitor = Arc::new(test_utils::TestChannelMonitor::new(chain_monitor.clone(), tx_broadcaster.clone(), logger.clone()));
 806                 let mut config = UserConfig::new();
 807                 config.channel_options.announced_channel = true;
 808                 config.channel_limits.force_announced_channel_preference = false;
 809                 let node = ChannelManager::new(Network::Testnet, feeest.clone(), chan_monitor.clone(), chain_monitor.clone(), tx_broadcaster.clone(), Arc::clone(&logger), keys_manager.clone(), config).unwrap();
 810                 let router = Router::new(PublicKey::from_secret_key(&secp_ctx, &keys_manager.get_node_secret()), chain_monitor.clone(), Arc::clone(&logger));
 811                 nodes.push(Node { chain_monitor, tx_broadcaster, chan_monitor, node, router, keys_manager, node_seed: seed,
 812                         network_payment_count: payment_count.clone(),
 813                         network_chan_count: chan_count.clone(),
 814                 });
 815         }
 816
 817         nodes
 818 }
 819
 820 #[test]
 821 fn test_async_inbound_update_fee() {
 822         let mut nodes = create_network(2);
 823         let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
 824         let channel_id = chan.2;
 825
 826         // balancing
 827         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
 828
 829         // A                                        B
 830         // update_fee                            ->
 831         // send (1) commitment_signed            -.
 832         //                                       <- update_add_htlc/commitment_signed
 833         // send (2) RAA (awaiting remote revoke) -.
 834         // (1) commitment_signed is delivered    ->
 835         //                                       .- send (3) RAA (awaiting remote revoke)
 836         // (2) RAA is delivered                  ->
 837         //                                       .- send (4) commitment_signed
 838         //                                       <- (3) RAA is delivered
 839         // send (5) commitment_signed            -.
 840         //                                       <- (4) commitment_signed is delivered
 841         // send (6) RAA                          -.
 842         // (5) commitment_signed is delivered    ->
 843         //                                       <- RAA
 844         // (6) RAA is delivered                  ->
 845
 846         // First nodes[0] generates an update_fee
 847         nodes[0].node.update_fee(channel_id, get_feerate!(nodes[0], channel_id) + 20).unwrap();
 848         check_added_monitors!(nodes[0], 1);
 849
 850         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 851         assert_eq!(events_0.len(), 1);
 852         let (update_msg, commitment_signed) = match events_0[0] { // (1)
 853                 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fee, ref commitment_signed, .. }, .. } => {
 854                         (update_fee.as_ref(), commitment_signed)
 855                 },
 856                 _ => panic!("Unexpected event"),
 857         };
 858
 859         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap()).unwrap();
 860
 861         // ...but before it's delivered, nodes[1] starts to send a payment back to nodes[0]...
 862         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 863         nodes[1].node.send_payment(nodes[1].router.get_route(&nodes[0].node.get_our_node_id(), None, &Vec::new(), 40000, TEST_FINAL_CLTV).unwrap(), our_payment_hash).unwrap();
 864         check_added_monitors!(nodes[1], 1);
 865
 866         let payment_event = {
 867                 let mut events_1 = nodes[1].node.get_and_clear_pending_msg_events();
 868                 assert_eq!(events_1.len(), 1);
 869                 SendEvent::from_event(events_1.remove(0))
 870         };
 871         assert_eq!(payment_event.node_id, nodes[0].node.get_our_node_id());
 872         assert_eq!(payment_event.msgs.len(), 1);
 873
 874         // ...now when the messages get delivered everyone should be happy
 875         nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]).unwrap();
 876         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &payment_event.commitment_msg).unwrap(); // (2)
 877         let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 878         // nodes[0] is awaiting nodes[1] revoke_and_ack so get_event_msg's assert(len == 1) passes
 879         check_added_monitors!(nodes[0], 1);
 880
 881         // deliver(1), generate (3):
 882         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed).unwrap();
 883         let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
 884         // nodes[1] is awaiting nodes[0] revoke_and_ack so get_event_msg's assert(len == 1) passes
 885         check_added_monitors!(nodes[1], 1);
 886
 887         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_and_ack).unwrap(); // deliver (2)
 888         let bs_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 889         assert!(bs_update.update_add_htlcs.is_empty()); // (4)
 890         assert!(bs_update.update_fulfill_htlcs.is_empty()); // (4)
 891         assert!(bs_update.update_fail_htlcs.is_empty()); // (4)
 892         assert!(bs_update.update_fail_malformed_htlcs.is_empty()); // (4)
 893         assert!(bs_update.update_fee.is_none()); // (4)
 894         check_added_monitors!(nodes[1], 1);
 895
 896         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack).unwrap(); // deliver (3)
 897         let as_update = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 898         assert!(as_update.update_add_htlcs.is_empty()); // (5)
 899         assert!(as_update.update_fulfill_htlcs.is_empty()); // (5)
 900         assert!(as_update.update_fail_htlcs.is_empty()); // (5)
 901         assert!(as_update.update_fail_malformed_htlcs.is_empty()); // (5)
 902         assert!(as_update.update_fee.is_none()); // (5)
 903         check_added_monitors!(nodes[0], 1);
 904
 905         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_update.commitment_signed).unwrap(); // deliver (4)
 906         let as_second_revoke = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 907         // only (6) so get_event_msg's assert(len == 1) passes
 908         check_added_monitors!(nodes[0], 1);
 909
 910         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_update.commitment_signed).unwrap(); // deliver (5)
 911         let bs_second_revoke = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
 912         check_added_monitors!(nodes[1], 1);
 913
 914         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_second_revoke).unwrap();
 915         check_added_monitors!(nodes[0], 1);
 916
 917         let events_2 = nodes[0].node.get_and_clear_pending_events();
 918         assert_eq!(events_2.len(), 1);
 919         match events_2[0] {
 920                 Event::PendingHTLCsForwardable {..} => {}, // If we actually processed we'd receive the payment
 921                 _ => panic!("Unexpected event"),
 922         }
 923
 924         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_second_revoke).unwrap(); // deliver (6)
 925         check_added_monitors!(nodes[1], 1);
 926 }
 927
 928 #[test]
 929 fn test_update_fee_unordered_raa() {
 930         // Just the intro to the previous test followed by an out-of-order RAA (which caused a
 931         // crash in an earlier version of the update_fee patch)
 932         let mut nodes = create_network(2);
 933         let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
 934         let channel_id = chan.2;
 935
 936         // balancing
 937         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
 938
 939         // First nodes[0] generates an update_fee
 940         nodes[0].node.update_fee(channel_id, get_feerate!(nodes[0], channel_id) + 20).unwrap();
 941         check_added_monitors!(nodes[0], 1);
 942
 943         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 944         assert_eq!(events_0.len(), 1);
 945         let update_msg = match events_0[0] { // (1)
 946                 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fee, .. }, .. } => {
 947                         update_fee.as_ref()
 948                 },
 949                 _ => panic!("Unexpected event"),
 950         };
 951
 952         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap()).unwrap();
 953
 954         // ...but before it's delivered, nodes[1] starts to send a payment back to nodes[0]...
 955         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 956         nodes[1].node.send_payment(nodes[1].router.get_route(&nodes[0].node.get_our_node_id(), None, &Vec::new(), 40000, TEST_FINAL_CLTV).unwrap(), our_payment_hash).unwrap();
 957         check_added_monitors!(nodes[1], 1);
 958
 959         let payment_event = {
 960                 let mut events_1 = nodes[1].node.get_and_clear_pending_msg_events();
 961                 assert_eq!(events_1.len(), 1);
 962                 SendEvent::from_event(events_1.remove(0))
 963         };
 964         assert_eq!(payment_event.node_id, nodes[0].node.get_our_node_id());
 965         assert_eq!(payment_event.msgs.len(), 1);
 966
 967         // ...now when the messages get delivered everyone should be happy
 968         nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]).unwrap();
 969         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &payment_event.commitment_msg).unwrap(); // (2)
 970         let as_revoke_msg = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 971         // nodes[0] is awaiting nodes[1] revoke_and_ack so get_event_msg's assert(len == 1) passes
 972         check_added_monitors!(nodes[0], 1);
 973
 974         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_msg).unwrap(); // deliver (2)
 975         check_added_monitors!(nodes[1], 1);
 976
 977         // We can't continue, sadly, because our (1) now has a bogus signature
 978 }
 979
 980 #[test]
 981 fn test_multi_flight_update_fee() {
 982         let nodes = create_network(2);
 983         let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
 984         let channel_id = chan.2;
 985
 986         // A                                        B
 987         // update_fee/commitment_signed          ->
 988         //                                       .- send (1) RAA and (2) commitment_signed
 989         // update_fee (never committed)          ->
 990         // (3) update_fee                        ->
 991         // We have to manually generate the above update_fee, it is allowed by the protocol but we
 992         // don't track which updates correspond to which revoke_and_ack responses so we're in
 993         // AwaitingRAA mode and will not generate the update_fee yet.
 994         //                                       <- (1) RAA delivered
 995         // (3) is generated and send (4) CS      -.
 996         // Note that A cannot generate (4) prior to (1) being delivered as it otherwise doesn't
 997         // know the per_commitment_point to use for it.
 998         //                                       <- (2) commitment_signed delivered
 999         // revoke_and_ack                        ->
1000         //                                          B should send no response here
1001         // (4) commitment_signed delivered       ->
1002         //                                       <- RAA/commitment_signed delivered
1003         // revoke_and_ack                        ->
1004
1005         // First nodes[0] generates an update_fee
1006         let initial_feerate = get_feerate!(nodes[0], channel_id);
1007         nodes[0].node.update_fee(channel_id, initial_feerate + 20).unwrap();
1008         check_added_monitors!(nodes[0], 1);
1009
1010         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
1011         assert_eq!(events_0.len(), 1);
1012         let (update_msg_1, commitment_signed_1) = match events_0[0] { // (1)
1013                 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fee, ref commitment_signed, .. }, .. } => {
1014                         (update_fee.as_ref().unwrap(), commitment_signed)
1015                 },
1016                 _ => panic!("Unexpected event"),
1017         };
1018
1019         // Deliver first update_fee/commitment_signed pair, generating (1) and (2):
1020         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg_1).unwrap();
1021         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed_1).unwrap();
1022         let (bs_revoke_msg, bs_commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1023         check_added_monitors!(nodes[1], 1);
1024
1025         // nodes[0] is awaiting a revoke from nodes[1] before it will create a new commitment
1026         // transaction:
1027         nodes[0].node.update_fee(channel_id, initial_feerate + 40).unwrap();
1028         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
1029         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1030
1031         // Create the (3) update_fee message that nodes[0] will generate before it does...
1032         let mut update_msg_2 = msgs::UpdateFee {
1033                 channel_id: update_msg_1.channel_id.clone(),
1034                 feerate_per_kw: (initial_feerate + 30) as u32,
1035         };
1036
1037         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &update_msg_2).unwrap();
1038
1039         update_msg_2.feerate_per_kw = (initial_feerate + 40) as u32;
1040         // Deliver (3)
1041         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &update_msg_2).unwrap();
1042
1043         // Deliver (1), generating (3) and (4)
1044         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_msg).unwrap();
1045         let as_second_update = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
1046         check_added_monitors!(nodes[0], 1);
1047         assert!(as_second_update.update_add_htlcs.is_empty());
1048         assert!(as_second_update.update_fulfill_htlcs.is_empty());
1049         assert!(as_second_update.update_fail_htlcs.is_empty());
1050         assert!(as_second_update.update_fail_malformed_htlcs.is_empty());
1051         // Check that the update_fee newly generated matches what we delivered:
1052         assert_eq!(as_second_update.update_fee.as_ref().unwrap().channel_id, update_msg_2.channel_id);
1053         assert_eq!(as_second_update.update_fee.as_ref().unwrap().feerate_per_kw, update_msg_2.feerate_per_kw);
1054
1055         // Deliver (2) commitment_signed
1056         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_commitment_signed).unwrap();
1057         let as_revoke_msg = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1058         check_added_monitors!(nodes[0], 1);
1059         // No commitment_signed so get_event_msg's assert(len == 1) passes
1060
1061         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_msg).unwrap();
1062         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1063         check_added_monitors!(nodes[1], 1);
1064
1065         // Delever (4)
1066         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_second_update.commitment_signed).unwrap();
1067         let (bs_second_revoke, bs_second_commitment) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1068         check_added_monitors!(nodes[1], 1);
1069
1070         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_second_revoke).unwrap();
1071         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1072         check_added_monitors!(nodes[0], 1);
1073
1074         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_second_commitment).unwrap();
1075         let as_second_revoke = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1076         // No commitment_signed so get_event_msg's assert(len == 1) passes
1077         check_added_monitors!(nodes[0], 1);
1078
1079         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_second_revoke).unwrap();
1080         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1081         check_added_monitors!(nodes[1], 1);
1082 }
1083
1084 #[test]
1085 fn test_update_fee_vanilla() {
1086         let nodes = create_network(2);
1087         let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
1088         let channel_id = chan.2;
1089
1090         let feerate = get_feerate!(nodes[0], channel_id);
1091         nodes[0].node.update_fee(channel_id, feerate+25).unwrap();
1092         check_added_monitors!(nodes[0], 1);
1093
1094         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
1095         assert_eq!(events_0.len(), 1);
1096         let (update_msg, commitment_signed) = match events_0[0] {
1097                         MessageSendEvent::UpdateHTLCs { node_id:_, updates: msgs::CommitmentUpdate { update_add_htlcs:_, update_fulfill_htlcs:_, update_fail_htlcs:_, update_fail_malformed_htlcs:_, ref update_fee, ref commitment_signed } } => {
1098                         (update_fee.as_ref(), commitment_signed)
1099                 },
1100                 _ => panic!("Unexpected event"),
1101         };
1102         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap()).unwrap();
1103
1104         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed).unwrap();
1105         let (revoke_msg, commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1106         check_added_monitors!(nodes[1], 1);
1107
1108         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke_msg).unwrap();
1109         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1110         check_added_monitors!(nodes[0], 1);
1111
1112         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_signed).unwrap();
1113         let revoke_msg = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1114         // No commitment_signed so get_event_msg's assert(len == 1) passes
1115         check_added_monitors!(nodes[0], 1);
1116
1117         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &revoke_msg).unwrap();
1118         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1119         check_added_monitors!(nodes[1], 1);
1120 }
1121
1122 #[test]
1123 fn test_update_fee_that_funder_cannot_afford() {
1124         let nodes = create_network(2);
1125         let channel_value = 1888;
1126         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, channel_value, 700000);
1127         let channel_id = chan.2;
1128
1129         let feerate = 260;
1130         nodes[0].node.update_fee(channel_id, feerate).unwrap();
1131         check_added_monitors!(nodes[0], 1);
1132         let update_msg = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
1133
1134         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &update_msg.update_fee.unwrap()).unwrap();
1135
1136         commitment_signed_dance!(nodes[1], nodes[0], update_msg.commitment_signed, false);
1137
1138         //Confirm that the new fee based on the last local commitment txn is what we expected based on the feerate of 260 set above.
1139         //This value results in a fee that is exactly what the funder can afford (277 sat + 1000 sat channel reserve)
1140         {
1141                 let chan_lock = nodes[1].node.channel_state.lock().unwrap();
1142                 let chan = chan_lock.by_id.get(&channel_id).unwrap();
1143
1144                 //We made sure neither party's funds are below the dust limit so -2 non-HTLC txns from number of outputs
1145                 let num_htlcs = chan.last_local_commitment_txn[0].output.len() - 2;
1146                 let total_fee: u64 = feerate * (COMMITMENT_TX_BASE_WEIGHT + (num_htlcs as u64) * COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000;
1147                 let mut actual_fee = chan.last_local_commitment_txn[0].output.iter().fold(0, |acc, output| acc + output.value);
1148                 actual_fee = channel_value - actual_fee;
1149                 assert_eq!(total_fee, actual_fee);
1150         } //drop the mutex
1151
1152         //Add 2 to the previous fee rate to the final fee increases by 1 (with no HTLCs the fee is essentially
1153         //fee_rate*(724/1000) so the increment of 1*0.724 is rounded back down)
1154         nodes[0].node.update_fee(channel_id, feerate+2).unwrap();
1155         check_added_monitors!(nodes[0], 1);
1156
1157         let update2_msg = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
1158
1159         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &update2_msg.update_fee.unwrap()).unwrap();
1160
1161         //While producing the commitment_signed response after handling a received update_fee request the
1162         //check to see if the funder, who sent the update_fee request, can afford the new fee (funder_balance >= fee+channel_reserve)
1163         //Should produce and error.
1164         let err = nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &update2_msg.commitment_signed).unwrap_err();
1165
1166         assert!(match err.err {
1167                 "Funding remote cannot afford proposed new fee" => true,
1168                 _ => false,
1169         });
1170
1171         //clear the message we could not handle
1172         nodes[1].node.get_and_clear_pending_msg_events();
1173 }
1174
1175 #[test]
1176 fn test_update_fee_with_fundee_update_add_htlc() {
1177         let mut nodes = create_network(2);
1178         let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
1179         let channel_id = chan.2;
1180
1181         // balancing
1182         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
1183
1184         let feerate = get_feerate!(nodes[0], channel_id);
1185         nodes[0].node.update_fee(channel_id, feerate+20).unwrap();
1186         check_added_monitors!(nodes[0], 1);
1187
1188         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
1189         assert_eq!(events_0.len(), 1);
1190         let (update_msg, commitment_signed) = match events_0[0] {
1191                         MessageSendEvent::UpdateHTLCs { node_id:_, updates: msgs::CommitmentUpdate { update_add_htlcs:_, update_fulfill_htlcs:_, update_fail_htlcs:_, update_fail_malformed_htlcs:_, ref update_fee, ref commitment_signed } } => {
1192                         (update_fee.as_ref(), commitment_signed)
1193                 },
1194                 _ => panic!("Unexpected event"),
1195         };
1196         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap()).unwrap();
1197         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed).unwrap();
1198         let (revoke_msg, commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1199         check_added_monitors!(nodes[1], 1);
1200
1201         let route = nodes[1].router.get_route(&nodes[0].node.get_our_node_id(), None, &Vec::new(), 800000, TEST_FINAL_CLTV).unwrap();
1202
1203         let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[1]);
1204
1205         // nothing happens since node[1] is in AwaitingRemoteRevoke
1206         nodes[1].node.send_payment(route, our_payment_hash).unwrap();
1207         {
1208                 let mut added_monitors = nodes[0].chan_monitor.added_monitors.lock().unwrap();
1209                 assert_eq!(added_monitors.len(), 0);
1210                 added_monitors.clear();
1211         }
1212         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
1213         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1214         // node[1] has nothing to do
1215
1216         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke_msg).unwrap();
1217         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1218         check_added_monitors!(nodes[0], 1);
1219
1220         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_signed).unwrap();
1221         let revoke_msg = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1222         // No commitment_signed so get_event_msg's assert(len == 1) passes
1223         check_added_monitors!(nodes[0], 1);
1224         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &revoke_msg).unwrap();
1225         check_added_monitors!(nodes[1], 1);
1226         // AwaitingRemoteRevoke ends here
1227
1228         let commitment_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1229         assert_eq!(commitment_update.update_add_htlcs.len(), 1);
1230         assert_eq!(commitment_update.update_fulfill_htlcs.len(), 0);
1231         assert_eq!(commitment_update.update_fail_htlcs.len(), 0);
1232         assert_eq!(commitment_update.update_fail_malformed_htlcs.len(), 0);
1233         assert_eq!(commitment_update.update_fee.is_none(), true);
1234
1235         nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &commitment_update.update_add_htlcs[0]).unwrap();
1236         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_update.commitment_signed).unwrap();
1237         check_added_monitors!(nodes[0], 1);
1238         let (revoke, commitment_signed) = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
1239
1240         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &revoke).unwrap();
1241         check_added_monitors!(nodes[1], 1);
1242         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1243
1244         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &commitment_signed).unwrap();
1245         check_added_monitors!(nodes[1], 1);
1246         let revoke = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
1247         // No commitment_signed so get_event_msg's assert(len == 1) passes
1248
1249         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke).unwrap();
1250         check_added_monitors!(nodes[0], 1);
1251         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1252
1253         expect_pending_htlcs_forwardable!(nodes[0]);
1254
1255         let events = nodes[0].node.get_and_clear_pending_events();
1256         assert_eq!(events.len(), 1);
1257         match events[0] {
1258                 Event::PaymentReceived { .. } => { },
1259                 _ => panic!("Unexpected event"),
1260         };
1261
1262         claim_payment(&nodes[1], &vec!(&nodes[0])[..], our_payment_preimage);
1263
1264         send_payment(&nodes[1], &vec!(&nodes[0])[..], 800000);
1265         send_payment(&nodes[0], &vec!(&nodes[1])[..], 800000);
1266         close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true);
1267 }
1268
1269 #[test]
1270 fn test_update_fee() {
1271         let nodes = create_network(2);
1272         let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
1273         let channel_id = chan.2;
1274
1275         // A                                        B
1276         // (1) update_fee/commitment_signed      ->
1277         //                                       <- (2) revoke_and_ack
1278         //                                       .- send (3) commitment_signed
1279         // (4) update_fee/commitment_signed      ->
1280         //                                       .- send (5) revoke_and_ack (no CS as we're awaiting a revoke)
1281         //                                       <- (3) commitment_signed delivered
1282         // send (6) revoke_and_ack               -.
1283         //                                       <- (5) deliver revoke_and_ack
1284         // (6) deliver revoke_and_ack            ->
1285         //                                       .- send (7) commitment_signed in response to (4)
1286         //                                       <- (7) deliver commitment_signed
1287         // revoke_and_ack                        ->
1288
1289         // Create and deliver (1)...
1290         let feerate = get_feerate!(nodes[0], channel_id);
1291         nodes[0].node.update_fee(channel_id, feerate+20).unwrap();
1292         check_added_monitors!(nodes[0], 1);
1293
1294         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
1295         assert_eq!(events_0.len(), 1);
1296         let (update_msg, commitment_signed) = match events_0[0] {
1297                         MessageSendEvent::UpdateHTLCs { node_id:_, updates: msgs::CommitmentUpdate { update_add_htlcs:_, update_fulfill_htlcs:_, update_fail_htlcs:_, update_fail_malformed_htlcs:_, ref update_fee, ref commitment_signed } } => {
1298                         (update_fee.as_ref(), commitment_signed)
1299                 },
1300                 _ => panic!("Unexpected event"),
1301         };
1302         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap()).unwrap();
1303
1304         // Generate (2) and (3):
1305         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed).unwrap();
1306         let (revoke_msg, commitment_signed_0) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1307         check_added_monitors!(nodes[1], 1);
1308
1309         // Deliver (2):
1310         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke_msg).unwrap();
1311         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1312         check_added_monitors!(nodes[0], 1);
1313
1314         // Create and deliver (4)...
1315         nodes[0].node.update_fee(channel_id, feerate+30).unwrap();
1316         check_added_monitors!(nodes[0], 1);
1317         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
1318         assert_eq!(events_0.len(), 1);
1319         let (update_msg, commitment_signed) = match events_0[0] {
1320                         MessageSendEvent::UpdateHTLCs { node_id:_, updates: msgs::CommitmentUpdate { update_add_htlcs:_, update_fulfill_htlcs:_, update_fail_htlcs:_, update_fail_malformed_htlcs:_, ref update_fee, ref commitment_signed } } => {
1321                         (update_fee.as_ref(), commitment_signed)
1322                 },
1323                 _ => panic!("Unexpected event"),
1324         };
1325
1326         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap()).unwrap();
1327         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed).unwrap();
1328         check_added_monitors!(nodes[1], 1);
1329         // ... creating (5)
1330         let revoke_msg = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
1331         // No commitment_signed so get_event_msg's assert(len == 1) passes
1332
1333         // Handle (3), creating (6):
1334         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_signed_0).unwrap();
1335         check_added_monitors!(nodes[0], 1);
1336         let revoke_msg_0 = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1337         // No commitment_signed so get_event_msg's assert(len == 1) passes
1338
1339         // Deliver (5):
1340         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke_msg).unwrap();
1341         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1342         check_added_monitors!(nodes[0], 1);
1343
1344         // Deliver (6), creating (7):
1345         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &revoke_msg_0).unwrap();
1346         let commitment_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1347         assert!(commitment_update.update_add_htlcs.is_empty());
1348         assert!(commitment_update.update_fulfill_htlcs.is_empty());
1349         assert!(commitment_update.update_fail_htlcs.is_empty());
1350         assert!(commitment_update.update_fail_malformed_htlcs.is_empty());
1351         assert!(commitment_update.update_fee.is_none());
1352         check_added_monitors!(nodes[1], 1);
1353
1354         // Deliver (7)
1355         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_update.commitment_signed).unwrap();
1356         check_added_monitors!(nodes[0], 1);
1357         let revoke_msg = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1358         // No commitment_signed so get_event_msg's assert(len == 1) passes
1359
1360         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &revoke_msg).unwrap();
1361         check_added_monitors!(nodes[1], 1);
1362         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1363
1364         assert_eq!(get_feerate!(nodes[0], channel_id), feerate + 30);
1365         assert_eq!(get_feerate!(nodes[1], channel_id), feerate + 30);
1366         close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true);
1367 }
1368
1369 #[test]
1370 fn pre_funding_lock_shutdown_test() {
1371         // Test sending a shutdown prior to funding_locked after funding generation
1372         let nodes = create_network(2);
1373         let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 8000000, 0);
1374         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
1375         nodes[0].chain_monitor.block_connected_checked(&header, 1, &[&tx; 1], &[1; 1]);
1376         nodes[1].chain_monitor.block_connected_checked(&header, 1, &[&tx; 1], &[1; 1]);
1377
1378         nodes[0].node.close_channel(&OutPoint::new(tx.txid(), 0).to_channel_id()).unwrap();
1379         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1380         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown).unwrap();
1381         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1382         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown).unwrap();
1383
1384         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
1385         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed).unwrap();
1386         let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
1387         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap()).unwrap();
1388         let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
1389         assert!(node_0_none.is_none());
1390
1391         assert!(nodes[0].node.list_channels().is_empty());
1392         assert!(nodes[1].node.list_channels().is_empty());
1393 }
1394
1395 #[test]
1396 fn updates_shutdown_wait() {
1397         // Test sending a shutdown with outstanding updates pending
1398         let mut nodes = create_network(3);
1399         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
1400         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
1401         let route_1 = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV).unwrap();
1402         let route_2 = nodes[1].router.get_route(&nodes[0].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV).unwrap();
1403
1404         let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
1405
1406         nodes[0].node.close_channel(&chan_1.2).unwrap();
1407         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1408         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown).unwrap();
1409         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1410         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown).unwrap();
1411
1412         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1413         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1414
1415         let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
1416         if let Err(APIError::ChannelUnavailable {..}) = nodes[0].node.send_payment(route_1, payment_hash) {}
1417         else { panic!("New sends should fail!") };
1418         if let Err(APIError::ChannelUnavailable {..}) = nodes[1].node.send_payment(route_2, payment_hash) {}
1419         else { panic!("New sends should fail!") };
1420
1421         assert!(nodes[2].node.claim_funds(our_payment_preimage));
1422         check_added_monitors!(nodes[2], 1);
1423         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
1424         assert!(updates.update_add_htlcs.is_empty());
1425         assert!(updates.update_fail_htlcs.is_empty());
1426         assert!(updates.update_fail_malformed_htlcs.is_empty());
1427         assert!(updates.update_fee.is_none());
1428         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
1429         nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]).unwrap();
1430         check_added_monitors!(nodes[1], 1);
1431         let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1432         commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false);
1433
1434         assert!(updates_2.update_add_htlcs.is_empty());
1435         assert!(updates_2.update_fail_htlcs.is_empty());
1436         assert!(updates_2.update_fail_malformed_htlcs.is_empty());
1437         assert!(updates_2.update_fee.is_none());
1438         assert_eq!(updates_2.update_fulfill_htlcs.len(), 1);
1439         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]).unwrap();
1440         commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
1441
1442         let events = nodes[0].node.get_and_clear_pending_events();
1443         assert_eq!(events.len(), 1);
1444         match events[0] {
1445                 Event::PaymentSent { ref payment_preimage } => {
1446                         assert_eq!(our_payment_preimage, *payment_preimage);
1447                 },
1448                 _ => panic!("Unexpected event"),
1449         }
1450
1451         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
1452         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed).unwrap();
1453         let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
1454         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap()).unwrap();
1455         let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
1456         assert!(node_0_none.is_none());
1457
1458         assert!(nodes[0].node.list_channels().is_empty());
1459
1460         assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
1461         nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
1462         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
1463         assert!(nodes[1].node.list_channels().is_empty());
1464         assert!(nodes[2].node.list_channels().is_empty());
1465 }
1466
1467 #[test]
1468 fn htlc_fail_async_shutdown() {
1469         // Test HTLCs fail if shutdown starts even if messages are delivered out-of-order
1470         let mut nodes = create_network(3);
1471         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
1472         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
1473
1474         let route = nodes[0].router.get_route(&nodes[2].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV).unwrap();
1475         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
1476         nodes[0].node.send_payment(route, our_payment_hash).unwrap();
1477         check_added_monitors!(nodes[0], 1);
1478         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
1479         assert_eq!(updates.update_add_htlcs.len(), 1);
1480         assert!(updates.update_fulfill_htlcs.is_empty());
1481         assert!(updates.update_fail_htlcs.is_empty());
1482         assert!(updates.update_fail_malformed_htlcs.is_empty());
1483         assert!(updates.update_fee.is_none());
1484
1485         nodes[1].node.close_channel(&chan_1.2).unwrap();
1486         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1487         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown).unwrap();
1488         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1489
1490         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]).unwrap();
1491         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &updates.commitment_signed).unwrap();
1492         check_added_monitors!(nodes[1], 1);
1493         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown).unwrap();
1494         commitment_signed_dance!(nodes[1], nodes[0], (), false, true, false);
1495
1496         let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1497         assert!(updates_2.update_add_htlcs.is_empty());
1498         assert!(updates_2.update_fulfill_htlcs.is_empty());
1499         assert_eq!(updates_2.update_fail_htlcs.len(), 1);
1500         assert!(updates_2.update_fail_malformed_htlcs.is_empty());
1501         assert!(updates_2.update_fee.is_none());
1502
1503         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fail_htlcs[0]).unwrap();
1504         commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
1505
1506         let events = nodes[0].node.get_and_clear_pending_events();
1507         assert_eq!(events.len(), 1);
1508         match events[0] {
1509                 Event::PaymentFailed { ref payment_hash, ref rejected_by_dest, .. } => {
1510                         assert_eq!(our_payment_hash, *payment_hash);
1511                         assert!(!rejected_by_dest);
1512                 },
1513                 _ => panic!("Unexpected event"),
1514         }
1515
1516         let msg_events = nodes[0].node.get_and_clear_pending_msg_events();
1517         assert_eq!(msg_events.len(), 2);
1518         let node_0_closing_signed = match msg_events[0] {
1519                 MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => {
1520                         assert_eq!(*node_id, nodes[1].node.get_our_node_id());
1521                         (*msg).clone()
1522                 },
1523                 _ => panic!("Unexpected event"),
1524         };
1525         match msg_events[1] {
1526                 MessageSendEvent::PaymentFailureNetworkUpdate { update: msgs::HTLCFailChannelUpdate::ChannelUpdateMessage { ref msg }} => {
1527                         assert_eq!(msg.contents.short_channel_id, chan_1.0.contents.short_channel_id);
1528                 },
1529                 _ => panic!("Unexpected event"),
1530         }
1531
1532         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1533         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed).unwrap();
1534         let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
1535         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap()).unwrap();
1536         let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
1537         assert!(node_0_none.is_none());
1538
1539         assert!(nodes[0].node.list_channels().is_empty());
1540
1541         assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
1542         nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
1543         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
1544         assert!(nodes[1].node.list_channels().is_empty());
1545         assert!(nodes[2].node.list_channels().is_empty());
1546 }
1547
1548 fn do_test_shutdown_rebroadcast(recv_count: u8) {
1549         // Test that shutdown/closing_signed is re-sent on reconnect with a variable number of
1550         // messages delivered prior to disconnect
1551         let nodes = create_network(3);
1552         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
1553         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
1554
1555         let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
1556
1557         nodes[1].node.close_channel(&chan_1.2).unwrap();
1558         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1559         if recv_count > 0 {
1560                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown).unwrap();
1561                 let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1562                 if recv_count > 1 {
1563                         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown).unwrap();
1564                 }
1565         }
1566
1567         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
1568         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
1569
1570         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id());
1571         let node_0_reestablish = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReestablish, nodes[1].node.get_our_node_id());
1572         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id());
1573         let node_1_reestablish = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
1574
1575         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &node_0_reestablish).unwrap();
1576         let node_1_2nd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1577         assert!(node_1_shutdown == node_1_2nd_shutdown);
1578
1579         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &node_1_reestablish).unwrap();
1580         let node_0_2nd_shutdown = if recv_count > 0 {
1581                 let node_0_2nd_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1582                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown).unwrap();
1583                 node_0_2nd_shutdown
1584         } else {
1585                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1586                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown).unwrap();
1587                 get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id())
1588         };
1589         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_2nd_shutdown).unwrap();
1590
1591         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1592         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1593
1594         assert!(nodes[2].node.claim_funds(our_payment_preimage));
1595         check_added_monitors!(nodes[2], 1);
1596         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
1597         assert!(updates.update_add_htlcs.is_empty());
1598         assert!(updates.update_fail_htlcs.is_empty());
1599         assert!(updates.update_fail_malformed_htlcs.is_empty());
1600         assert!(updates.update_fee.is_none());
1601         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
1602         nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]).unwrap();
1603         check_added_monitors!(nodes[1], 1);
1604         let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1605         commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false);
1606
1607         assert!(updates_2.update_add_htlcs.is_empty());
1608         assert!(updates_2.update_fail_htlcs.is_empty());
1609         assert!(updates_2.update_fail_malformed_htlcs.is_empty());
1610         assert!(updates_2.update_fee.is_none());
1611         assert_eq!(updates_2.update_fulfill_htlcs.len(), 1);
1612         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]).unwrap();
1613         commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
1614
1615         let events = nodes[0].node.get_and_clear_pending_events();
1616         assert_eq!(events.len(), 1);
1617         match events[0] {
1618                 Event::PaymentSent { ref payment_preimage } => {
1619                         assert_eq!(our_payment_preimage, *payment_preimage);
1620                 },
1621                 _ => panic!("Unexpected event"),
1622         }
1623
1624         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
1625         if recv_count > 0 {
1626                 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed).unwrap();
1627                 let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
1628                 assert!(node_1_closing_signed.is_some());
1629         }
1630
1631         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
1632         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
1633
1634         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id());
1635         let node_0_2nd_reestablish = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReestablish, nodes[1].node.get_our_node_id());
1636         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id());
1637         if recv_count == 0 {
1638                 // If all closing_signeds weren't delivered we can just resume where we left off...
1639                 let node_1_2nd_reestablish = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
1640
1641                 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &node_1_2nd_reestablish).unwrap();
1642                 let node_0_3rd_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1643                 assert!(node_0_2nd_shutdown == node_0_3rd_shutdown);
1644
1645                 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &node_0_2nd_reestablish).unwrap();
1646                 let node_1_3rd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1647                 assert!(node_1_3rd_shutdown == node_1_2nd_shutdown);
1648
1649                 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_3rd_shutdown).unwrap();
1650                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1651
1652                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_3rd_shutdown).unwrap();
1653                 let node_0_2nd_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
1654                 assert!(node_0_closing_signed == node_0_2nd_closing_signed);
1655
1656                 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed).unwrap();
1657                 let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
1658                 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap()).unwrap();
1659                 let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
1660                 assert!(node_0_none.is_none());
1661         } else {
1662                 // If one node, however, received + responded with an identical closing_signed we end
1663                 // up erroring and node[0] will try to broadcast its own latest commitment transaction.
1664                 // There isn't really anything better we can do simply, but in the future we might
1665                 // explore storing a set of recently-closed channels that got disconnected during
1666                 // closing_signed and avoiding broadcasting local commitment txn for some timeout to
1667                 // give our counterparty enough time to (potentially) broadcast a cooperative closing
1668                 // transaction.
1669                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1670
1671                 if let Err(msgs::HandleError{action: Some(msgs::ErrorAction::SendErrorMessage{msg}), ..}) =
1672                                 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &node_0_2nd_reestablish) {
1673                         nodes[0].node.handle_error(&nodes[1].node.get_our_node_id(), &msg);
1674                         let msgs::ErrorMessage {ref channel_id, ..} = msg;
1675                         assert_eq!(*channel_id, chan_1.2);
1676                 } else { panic!("Needed SendErrorMessage close"); }
1677
1678                 // get_closing_signed_broadcast usually eats the BroadcastChannelUpdate for us and
1679                 // checks it, but in this case nodes[0] didn't ever get a chance to receive a
1680                 // closing_signed so we do it ourselves
1681                 let events = nodes[0].node.get_and_clear_pending_msg_events();
1682                 assert_eq!(events.len(), 1);
1683                 match events[0] {
1684                         MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
1685                                 assert_eq!(msg.contents.flags & 2, 2);
1686                         },
1687                         _ => panic!("Unexpected event"),
1688                 }
1689         }
1690
1691         assert!(nodes[0].node.list_channels().is_empty());
1692
1693         assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
1694         nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
1695         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
1696         assert!(nodes[1].node.list_channels().is_empty());
1697         assert!(nodes[2].node.list_channels().is_empty());
1698 }
1699
1700 #[test]
1701 fn test_shutdown_rebroadcast() {
1702         do_test_shutdown_rebroadcast(0);
1703         do_test_shutdown_rebroadcast(1);
1704         do_test_shutdown_rebroadcast(2);
1705 }
1706
1707 #[test]
1708 fn fake_network_test() {
1709         // Simple test which builds a network of ChannelManagers, connects them to each other, and
1710         // tests that payments get routed and transactions broadcast in semi-reasonable ways.
1711         let nodes = create_network(4);
1712
1713         // Create some initial channels
1714         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
1715         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
1716         let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3);
1717
1718         // Rebalance the network a bit by relaying one payment through all the channels...
1719         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000);
1720         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000);
1721         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000);
1722         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000);
1723
1724         // Send some more payments
1725         send_payment(&nodes[1], &vec!(&nodes[2], &nodes[3])[..], 1000000);
1726         send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1], &nodes[0])[..], 1000000);
1727         send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1])[..], 1000000);
1728
1729         // Test failure packets
1730         let payment_hash_1 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 1000000).1;
1731         fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], payment_hash_1);
1732
1733         // Add a new channel that skips 3
1734         let chan_4 = create_announced_chan_between_nodes(&nodes, 1, 3);
1735
1736         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 1000000);
1737         send_payment(&nodes[2], &vec!(&nodes[3])[..], 1000000);
1738         send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000);
1739         send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000);
1740         send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000);
1741         send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000);
1742         send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000);
1743
1744         // Do some rebalance loop payments, simultaneously
1745         let mut hops = Vec::with_capacity(3);
1746         hops.push(RouteHop {
1747                 pubkey: nodes[2].node.get_our_node_id(),
1748                 short_channel_id: chan_2.0.contents.short_channel_id,
1749                 fee_msat: 0,
1750                 cltv_expiry_delta: chan_3.0.contents.cltv_expiry_delta as u32
1751         });
1752         hops.push(RouteHop {
1753                 pubkey: nodes[3].node.get_our_node_id(),
1754                 short_channel_id: chan_3.0.contents.short_channel_id,
1755                 fee_msat: 0,
1756                 cltv_expiry_delta: chan_4.1.contents.cltv_expiry_delta as u32
1757         });
1758         hops.push(RouteHop {
1759                 pubkey: nodes[1].node.get_our_node_id(),
1760                 short_channel_id: chan_4.0.contents.short_channel_id,
1761                 fee_msat: 1000000,
1762                 cltv_expiry_delta: TEST_FINAL_CLTV,
1763         });
1764         hops[1].fee_msat = chan_4.1.contents.fee_base_msat as u64 + chan_4.1.contents.fee_proportional_millionths as u64 * hops[2].fee_msat as u64 / 1000000;
1765         hops[0].fee_msat = chan_3.0.contents.fee_base_msat as u64 + chan_3.0.contents.fee_proportional_millionths as u64 * hops[1].fee_msat as u64 / 1000000;
1766         let payment_preimage_1 = send_along_route(&nodes[1], Route { hops }, &vec!(&nodes[2], &nodes[3], &nodes[1])[..], 1000000).0;
1767
1768         let mut hops = Vec::with_capacity(3);
1769         hops.push(RouteHop {
1770                 pubkey: nodes[3].node.get_our_node_id(),
1771                 short_channel_id: chan_4.0.contents.short_channel_id,
1772                 fee_msat: 0,
1773                 cltv_expiry_delta: chan_3.1.contents.cltv_expiry_delta as u32
1774         });
1775         hops.push(RouteHop {
1776                 pubkey: nodes[2].node.get_our_node_id(),
1777                 short_channel_id: chan_3.0.contents.short_channel_id,
1778                 fee_msat: 0,
1779                 cltv_expiry_delta: chan_2.1.contents.cltv_expiry_delta as u32
1780         });
1781         hops.push(RouteHop {
1782                 pubkey: nodes[1].node.get_our_node_id(),
1783                 short_channel_id: chan_2.0.contents.short_channel_id,
1784                 fee_msat: 1000000,
1785                 cltv_expiry_delta: TEST_FINAL_CLTV,
1786         });
1787         hops[1].fee_msat = chan_2.1.contents.fee_base_msat as u64 + chan_2.1.contents.fee_proportional_millionths as u64 * hops[2].fee_msat as u64 / 1000000;
1788         hops[0].fee_msat = chan_3.1.contents.fee_base_msat as u64 + chan_3.1.contents.fee_proportional_millionths as u64 * hops[1].fee_msat as u64 / 1000000;
1789         let payment_hash_2 = send_along_route(&nodes[1], Route { hops }, &vec!(&nodes[3], &nodes[2], &nodes[1])[..], 1000000).1;
1790
1791         // Claim the rebalances...
1792         fail_payment(&nodes[1], &vec!(&nodes[3], &nodes[2], &nodes[1])[..], payment_hash_2);
1793         claim_payment(&nodes[1], &vec!(&nodes[2], &nodes[3], &nodes[1])[..], payment_preimage_1);
1794
1795         // Add a duplicate new channel from 2 to 4
1796         let chan_5 = create_announced_chan_between_nodes(&nodes, 1, 3);
1797
1798         // Send some payments across both channels
1799         let payment_preimage_3 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000).0;
1800         let payment_preimage_4 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000).0;
1801         let payment_preimage_5 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000).0;
1802
1803         route_over_limit(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000);
1804
1805         //TODO: Test that routes work again here as we've been notified that the channel is full
1806
1807         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_3);
1808         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_4);
1809         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_5);
1810
1811         // Close down the channels...
1812         close_channel(&nodes[0], &nodes[1], &chan_1.2, chan_1.3, true);
1813         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, false);
1814         close_channel(&nodes[2], &nodes[3], &chan_3.2, chan_3.3, true);
1815         close_channel(&nodes[1], &nodes[3], &chan_4.2, chan_4.3, false);
1816         close_channel(&nodes[1], &nodes[3], &chan_5.2, chan_5.3, false);
1817 }
1818
1819 #[test]
1820 fn duplicate_htlc_test() {
1821         // Test that we accept duplicate payment_hash HTLCs across the network and that
1822         // claiming/failing them are all separate and don't effect each other
1823         let mut nodes = create_network(6);
1824
1825         // Create some initial channels to route via 3 to 4/5 from 0/1/2
1826         create_announced_chan_between_nodes(&nodes, 0, 3);
1827         create_announced_chan_between_nodes(&nodes, 1, 3);
1828         create_announced_chan_between_nodes(&nodes, 2, 3);
1829         create_announced_chan_between_nodes(&nodes, 3, 4);
1830         create_announced_chan_between_nodes(&nodes, 3, 5);
1831
1832         let (payment_preimage, payment_hash) = route_payment(&nodes[0], &vec!(&nodes[3], &nodes[4])[..], 1000000);
1833
1834         *nodes[0].network_payment_count.borrow_mut() -= 1;
1835         assert_eq!(route_payment(&nodes[1], &vec!(&nodes[3])[..], 1000000).0, payment_preimage);
1836
1837         *nodes[0].network_payment_count.borrow_mut() -= 1;
1838         assert_eq!(route_payment(&nodes[2], &vec!(&nodes[3], &nodes[5])[..], 1000000).0, payment_preimage);
1839
1840         claim_payment(&nodes[0], &vec!(&nodes[3], &nodes[4])[..], payment_preimage);
1841         fail_payment(&nodes[2], &vec!(&nodes[3], &nodes[5])[..], payment_hash);
1842         claim_payment(&nodes[1], &vec!(&nodes[3])[..], payment_preimage);
1843 }
1844
1845 #[derive(PartialEq)]
1846 enum HTLCType { NONE, TIMEOUT, SUCCESS }
1847 /// Tests that the given node has broadcast transactions for the given Channel
1848 ///
1849 /// First checks that the latest local commitment tx has been broadcast, unless an explicit
1850 /// commitment_tx is provided, which may be used to test that a remote commitment tx was
1851 /// broadcast and the revoked outputs were claimed.
1852 ///
1853 /// Next tests that there is (or is not) a transaction that spends the commitment transaction
1854 /// that appears to be the type of HTLC transaction specified in has_htlc_tx.
1855 ///
1856 /// All broadcast transactions must be accounted for in one of the above three types of we'll
1857 /// also fail.
1858 fn test_txn_broadcast(node: &Node, chan: &(msgs::ChannelUpdate, msgs::ChannelUpdate, [u8; 32], Transaction), commitment_tx: Option<Transaction>, has_htlc_tx: HTLCType) -> Vec<Transaction> {
1859         let mut node_txn = node.tx_broadcaster.txn_broadcasted.lock().unwrap();
1860         assert!(node_txn.len() >= if commitment_tx.is_some() { 0 } else { 1 } + if has_htlc_tx == HTLCType::NONE { 0 } else { 1 });
1861
1862         let mut res = Vec::with_capacity(2);
1863         node_txn.retain(|tx| {
1864                 if tx.input.len() == 1 && tx.input[0].previous_output.txid == chan.3.txid() {
1865                         check_spends!(tx, chan.3.clone());
1866                         if commitment_tx.is_none() {
1867                                 res.push(tx.clone());
1868                         }
1869                         false
1870                 } else { true }
1871         });
1872         if let Some(explicit_tx) = commitment_tx {
1873                 res.push(explicit_tx.clone());
1874         }
1875
1876         assert_eq!(res.len(), 1);
1877
1878         if has_htlc_tx != HTLCType::NONE {
1879                 node_txn.retain(|tx| {
1880                         if tx.input.len() == 1 && tx.input[0].previous_output.txid == res[0].txid() {
1881                                 check_spends!(tx, res[0].clone());
1882                                 if has_htlc_tx == HTLCType::TIMEOUT {
1883                                         assert!(tx.lock_time != 0);
1884                                 } else {
1885                                         assert!(tx.lock_time == 0);
1886                                 }
1887                                 res.push(tx.clone());
1888                                 false
1889                         } else { true }
1890                 });
1891                 assert!(res.len() == 2 || res.len() == 3);
1892                 if res.len() == 3 {
1893                         assert_eq!(res[1], res[2]);
1894                 }
1895         }
1896
1897         assert!(node_txn.is_empty());
1898         res
1899 }
1900
1901 /// Tests that the given node has broadcast a claim transaction against the provided revoked
1902 /// HTLC transaction.
1903 fn test_revoked_htlc_claim_txn_broadcast(node: &Node, revoked_tx: Transaction) {
1904         let mut node_txn = node.tx_broadcaster.txn_broadcasted.lock().unwrap();
1905         assert_eq!(node_txn.len(), 1);
1906         node_txn.retain(|tx| {
1907                 if tx.input.len() == 1 && tx.input[0].previous_output.txid == revoked_tx.txid() {
1908                         check_spends!(tx, revoked_tx.clone());
1909                         false
1910                 } else { true }
1911         });
1912         assert!(node_txn.is_empty());
1913 }
1914
1915 fn check_preimage_claim(node: &Node, prev_txn: &Vec<Transaction>) -> Vec<Transaction> {
1916         let mut node_txn = node.tx_broadcaster.txn_broadcasted.lock().unwrap();
1917
1918         assert!(node_txn.len() >= 1);
1919         assert_eq!(node_txn[0].input.len(), 1);
1920         let mut found_prev = false;
1921
1922         for tx in prev_txn {
1923                 if node_txn[0].input[0].previous_output.txid == tx.txid() {
1924                         check_spends!(node_txn[0], tx.clone());
1925                         assert!(node_txn[0].input[0].witness[2].len() > 106); // must spend an htlc output
1926                         assert_eq!(tx.input.len(), 1); // must spend a commitment tx
1927
1928                         found_prev = true;
1929                         break;
1930                 }
1931         }
1932         assert!(found_prev);
1933
1934         let mut res = Vec::new();
1935         mem::swap(&mut *node_txn, &mut res);
1936         res
1937 }
1938
1939 fn get_announce_close_broadcast_events(nodes: &Vec<Node>, a: usize, b: usize) {
1940         let events_1 = nodes[a].node.get_and_clear_pending_msg_events();
1941         assert_eq!(events_1.len(), 1);
1942         let as_update = match events_1[0] {
1943                 MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
1944                         msg.clone()
1945                 },
1946                 _ => panic!("Unexpected event"),
1947         };
1948
1949         let events_2 = nodes[b].node.get_and_clear_pending_msg_events();
1950         assert_eq!(events_2.len(), 1);
1951         let bs_update = match events_2[0] {
1952                 MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
1953                         msg.clone()
1954                 },
1955                 _ => panic!("Unexpected event"),
1956         };
1957
1958         for node in nodes {
1959                 node.router.handle_channel_update(&as_update).unwrap();
1960                 node.router.handle_channel_update(&bs_update).unwrap();
1961         }
1962 }
1963
1964 fn do_channel_reserve_test(test_recv: bool) {
1965         use util::rng;
1966         use std::sync::atomic::Ordering;
1967         use ln::msgs::HandleError;
1968
1969         macro_rules! get_channel_value_stat {
1970                 ($node: expr, $channel_id: expr) => {{
1971                         let chan_lock = $node.node.channel_state.lock().unwrap();
1972                         let chan = chan_lock.by_id.get(&$channel_id).unwrap();
1973                         chan.get_value_stat()
1974                 }}
1975         }
1976
1977         let mut nodes = create_network(3);
1978         let chan_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1900, 1001);
1979         let chan_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1900, 1001);
1980
1981         let mut stat01 = get_channel_value_stat!(nodes[0], chan_1.2);
1982         let mut stat11 = get_channel_value_stat!(nodes[1], chan_1.2);
1983
1984         let mut stat12 = get_channel_value_stat!(nodes[1], chan_2.2);
1985         let mut stat22 = get_channel_value_stat!(nodes[2], chan_2.2);
1986
1987         macro_rules! get_route_and_payment_hash {
1988                 ($recv_value: expr) => {{
1989                         let route = nodes[0].router.get_route(&nodes.last().unwrap().node.get_our_node_id(), None, &Vec::new(), $recv_value, TEST_FINAL_CLTV).unwrap();
1990                         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[0]);
1991                         (route, payment_hash, payment_preimage)
1992                 }}
1993         };
1994
1995         macro_rules! expect_forward {
1996                 ($node: expr) => {{
1997                         let mut events = $node.node.get_and_clear_pending_msg_events();
1998                         assert_eq!(events.len(), 1);
1999                         check_added_monitors!($node, 1);
2000                         let payment_event = SendEvent::from_event(events.remove(0));
2001                         payment_event
2002                 }}
2003         }
2004
2005         macro_rules! expect_payment_received {
2006                 ($node: expr, $expected_payment_hash: expr, $expected_recv_value: expr) => {
2007                         let events = $node.node.get_and_clear_pending_events();
2008                         assert_eq!(events.len(), 1);
2009                         match events[0] {
2010                                 Event::PaymentReceived { ref payment_hash, amt } => {
2011                                         assert_eq!($expected_payment_hash, *payment_hash);
2012                                         assert_eq!($expected_recv_value, amt);
2013                                 },
2014                                 _ => panic!("Unexpected event"),
2015                         }
2016                 }
2017         };
2018
2019         let feemsat = 239; // somehow we know?
2020         let total_fee_msat = (nodes.len() - 2) as u64 * 239;
2021
2022         let recv_value_0 = stat01.their_max_htlc_value_in_flight_msat - total_fee_msat;
2023
2024         // attempt to send amt_msat > their_max_htlc_value_in_flight_msat
2025         {
2026                 let (route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value_0 + 1);
2027                 assert!(route.hops.iter().rev().skip(1).all(|h| h.fee_msat == feemsat));
2028                 let err = nodes[0].node.send_payment(route, our_payment_hash).err().unwrap();
2029                 match err {
2030                         APIError::ChannelUnavailable{err} => assert_eq!(err, "Cannot send value that would put us over our max HTLC value in flight"),
2031                         _ => panic!("Unknown error variants"),
2032                 }
2033         }
2034
2035         let mut htlc_id = 0;
2036         // channel reserve is bigger than their_max_htlc_value_in_flight_msat so loop to deplete
2037         // nodes[0]'s wealth
2038         loop {
2039                 let amt_msat = recv_value_0 + total_fee_msat;
2040                 if stat01.value_to_self_msat - amt_msat < stat01.channel_reserve_msat {
2041                         break;
2042                 }
2043                 send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_0);
2044                 htlc_id += 1;
2045
2046                 let (stat01_, stat11_, stat12_, stat22_) = (
2047                         get_channel_value_stat!(nodes[0], chan_1.2),
2048                         get_channel_value_stat!(nodes[1], chan_1.2),
2049                         get_channel_value_stat!(nodes[1], chan_2.2),
2050                         get_channel_value_stat!(nodes[2], chan_2.2),
2051                 );
2052
2053                 assert_eq!(stat01_.value_to_self_msat, stat01.value_to_self_msat - amt_msat);
2054                 assert_eq!(stat11_.value_to_self_msat, stat11.value_to_self_msat + amt_msat);
2055                 assert_eq!(stat12_.value_to_self_msat, stat12.value_to_self_msat - (amt_msat - feemsat));
2056                 assert_eq!(stat22_.value_to_self_msat, stat22.value_to_self_msat + (amt_msat - feemsat));
2057                 stat01 = stat01_; stat11 = stat11_; stat12 = stat12_; stat22 = stat22_;
2058         }
2059
2060         {
2061                 let recv_value = stat01.value_to_self_msat - stat01.channel_reserve_msat - total_fee_msat;
2062                 // attempt to get channel_reserve violation
2063                 let (route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value + 1);
2064                 let err = nodes[0].node.send_payment(route.clone(), our_payment_hash).err().unwrap();
2065                 match err {
2066                         APIError::ChannelUnavailable{err} => assert_eq!(err, "Cannot send value that would put us over our reserve value"),
2067                         _ => panic!("Unknown error variants"),
2068                 }
2069         }
2070
2071         // adding pending output
2072         let recv_value_1 = (stat01.value_to_self_msat - stat01.channel_reserve_msat - total_fee_msat)/2;
2073         let amt_msat_1 = recv_value_1 + total_fee_msat;
2074
2075         let (route_1, our_payment_hash_1, our_payment_preimage_1) = get_route_and_payment_hash!(recv_value_1);
2076         let payment_event_1 = {
2077                 nodes[0].node.send_payment(route_1, our_payment_hash_1).unwrap();
2078                 check_added_monitors!(nodes[0], 1);
2079
2080                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
2081                 assert_eq!(events.len(), 1);
2082                 SendEvent::from_event(events.remove(0))
2083         };
2084         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event_1.msgs[0]).unwrap();
2085
2086         // channel reserve test with htlc pending output > 0
2087         let recv_value_2 = stat01.value_to_self_msat - amt_msat_1 - stat01.channel_reserve_msat - total_fee_msat;
2088         {
2089                 let (route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value_2 + 1);
2090                 match nodes[0].node.send_payment(route, our_payment_hash).err().unwrap() {
2091                         APIError::ChannelUnavailable{err} => assert_eq!(err, "Cannot send value that would put us over our reserve value"),
2092                         _ => panic!("Unknown error variants"),
2093                 }
2094         }
2095
2096         {
2097                 // test channel_reserve test on nodes[1] side
2098                 let (route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value_2 + 1);
2099
2100                 // Need to manually create update_add_htlc message to go around the channel reserve check in send_htlc()
2101                 let secp_ctx = Secp256k1::new();
2102                 let session_priv = SecretKey::from_slice(&secp_ctx, &{
2103                         let mut session_key = [0; 32];
2104                         rng::fill_bytes(&mut session_key);
2105                         session_key
2106                 }).expect("RNG is bad!");
2107
2108                 let cur_height = nodes[0].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
2109                 let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route, &session_priv).unwrap();
2110                 let (onion_payloads, htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route, cur_height).unwrap();
2111                 let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, &our_payment_hash);
2112                 let msg = msgs::UpdateAddHTLC {
2113                         channel_id: chan_1.2,
2114                         htlc_id,
2115                         amount_msat: htlc_msat,
2116                         payment_hash: our_payment_hash,
2117                         cltv_expiry: htlc_cltv,
2118                         onion_routing_packet: onion_packet,
2119                 };
2120
2121                 if test_recv {
2122                         let err = nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &msg).err().unwrap();
2123                         match err {
2124                                 HandleError{err, .. } => assert_eq!(err, "Remote HTLC add would put them over their reserve value"),
2125                         }
2126                         // If we send a garbage message, the channel should get closed, making the rest of this test case fail.
2127                         assert_eq!(nodes[1].node.list_channels().len(), 1);
2128                         assert_eq!(nodes[1].node.list_channels().len(), 1);
2129                         let channel_close_broadcast = nodes[1].node.get_and_clear_pending_msg_events();
2130                         assert_eq!(channel_close_broadcast.len(), 1);
2131                         match channel_close_broadcast[0] {
2132                                 MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
2133                                         assert_eq!(msg.contents.flags & 2, 2);
2134                                 },
2135                                 _ => panic!("Unexpected event"),
2136                         }
2137                         return;
2138                 }
2139         }
2140
2141         // split the rest to test holding cell
2142         let recv_value_21 = recv_value_2/2;
2143         let recv_value_22 = recv_value_2 - recv_value_21 - total_fee_msat;
2144         {
2145                 let stat = get_channel_value_stat!(nodes[0], chan_1.2);
2146                 assert_eq!(stat.value_to_self_msat - (stat.pending_outbound_htlcs_amount_msat + recv_value_21 + recv_value_22 + total_fee_msat + total_fee_msat), stat.channel_reserve_msat);
2147         }
2148
2149         // now see if they go through on both sides
2150         let (route_21, our_payment_hash_21, our_payment_preimage_21) = get_route_and_payment_hash!(recv_value_21);
2151         // but this will stuck in the holding cell
2152         nodes[0].node.send_payment(route_21, our_payment_hash_21).unwrap();
2153         check_added_monitors!(nodes[0], 0);
2154         let events = nodes[0].node.get_and_clear_pending_events();
2155         assert_eq!(events.len(), 0);
2156
2157         // test with outbound holding cell amount > 0
2158         {
2159                 let (route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value_22+1);
2160                 match nodes[0].node.send_payment(route, our_payment_hash).err().unwrap() {
2161                         APIError::ChannelUnavailable{err} => assert_eq!(err, "Cannot send value that would put us over our reserve value"),
2162                         _ => panic!("Unknown error variants"),
2163                 }
2164         }
2165
2166         let (route_22, our_payment_hash_22, our_payment_preimage_22) = get_route_and_payment_hash!(recv_value_22);
2167         // this will also stuck in the holding cell
2168         nodes[0].node.send_payment(route_22, our_payment_hash_22).unwrap();
2169         check_added_monitors!(nodes[0], 0);
2170         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
2171         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
2172
2173         // flush the pending htlc
2174         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event_1.commitment_msg).unwrap();
2175         let (as_revoke_and_ack, as_commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
2176         check_added_monitors!(nodes[1], 1);
2177
2178         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_revoke_and_ack).unwrap();
2179         check_added_monitors!(nodes[0], 1);
2180         let commitment_update_2 = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
2181
2182         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &as_commitment_signed).unwrap();
2183         let bs_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
2184         // No commitment_signed so get_event_msg's assert(len == 1) passes
2185         check_added_monitors!(nodes[0], 1);
2186
2187         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &bs_revoke_and_ack).unwrap();
2188         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
2189         check_added_monitors!(nodes[1], 1);
2190
2191         expect_pending_htlcs_forwardable!(nodes[1]);
2192
2193         let ref payment_event_11 = expect_forward!(nodes[1]);
2194         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_11.msgs[0]).unwrap();
2195         commitment_signed_dance!(nodes[2], nodes[1], payment_event_11.commitment_msg, false);
2196
2197         expect_pending_htlcs_forwardable!(nodes[2]);
2198         expect_payment_received!(nodes[2], our_payment_hash_1, recv_value_1);
2199
2200         // flush the htlcs in the holding cell
2201         assert_eq!(commitment_update_2.update_add_htlcs.len(), 2);
2202         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &commitment_update_2.update_add_htlcs[0]).unwrap();
2203         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &commitment_update_2.update_add_htlcs[1]).unwrap();
2204         commitment_signed_dance!(nodes[1], nodes[0], &commitment_update_2.commitment_signed, false);
2205         expect_pending_htlcs_forwardable!(nodes[1]);
2206
2207         let ref payment_event_3 = expect_forward!(nodes[1]);
2208         assert_eq!(payment_event_3.msgs.len(), 2);
2209         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_3.msgs[0]).unwrap();
2210         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_3.msgs[1]).unwrap();
2211
2212         commitment_signed_dance!(nodes[2], nodes[1], &payment_event_3.commitment_msg, false);
2213         expect_pending_htlcs_forwardable!(nodes[2]);
2214
2215         let events = nodes[2].node.get_and_clear_pending_events();
2216         assert_eq!(events.len(), 2);
2217         match events[0] {
2218                 Event::PaymentReceived { ref payment_hash, amt } => {
2219                         assert_eq!(our_payment_hash_21, *payment_hash);
2220                         assert_eq!(recv_value_21, amt);
2221                 },
2222                 _ => panic!("Unexpected event"),
2223         }
2224         match events[1] {
2225                 Event::PaymentReceived { ref payment_hash, amt } => {
2226                         assert_eq!(our_payment_hash_22, *payment_hash);
2227                         assert_eq!(recv_value_22, amt);
2228                 },
2229                 _ => panic!("Unexpected event"),
2230         }
2231
2232         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_1);
2233         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_21);
2234         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_22);
2235
2236         let expected_value_to_self = stat01.value_to_self_msat - (recv_value_1 + total_fee_msat) - (recv_value_21 + total_fee_msat) - (recv_value_22 + total_fee_msat);
2237         let stat0 = get_channel_value_stat!(nodes[0], chan_1.2);
2238         assert_eq!(stat0.value_to_self_msat, expected_value_to_self);
2239         assert_eq!(stat0.value_to_self_msat, stat0.channel_reserve_msat);
2240
2241         let stat2 = get_channel_value_stat!(nodes[2], chan_2.2);
2242         assert_eq!(stat2.value_to_self_msat, stat22.value_to_self_msat + recv_value_1 + recv_value_21 + recv_value_22);
2243 }
2244
2245 #[test]
2246 fn channel_reserve_test() {
2247         do_channel_reserve_test(false);
2248         do_channel_reserve_test(true);
2249 }
2250
2251 #[test]
2252 fn channel_monitor_network_test() {
2253         // Simple test which builds a network of ChannelManagers, connects them to each other, and
2254         // tests that ChannelMonitor is able to recover from various states.
2255         let nodes = create_network(5);
2256
2257         // Create some initial channels
2258         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
2259         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
2260         let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3);
2261         let chan_4 = create_announced_chan_between_nodes(&nodes, 3, 4);
2262
2263         // Rebalance the network a bit by relaying one payment through all the channels...
2264         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000);
2265         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000);
2266         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000);
2267         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000);
2268
2269         // Simple case with no pending HTLCs:
2270         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), true);
2271         {
2272                 let mut node_txn = test_txn_broadcast(&nodes[1], &chan_1, None, HTLCType::NONE);
2273                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2274                 nodes[0].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![node_txn.drain(..).next().unwrap()] }, 1);
2275                 test_txn_broadcast(&nodes[0], &chan_1, None, HTLCType::NONE);
2276         }
2277         get_announce_close_broadcast_events(&nodes, 0, 1);
2278         assert_eq!(nodes[0].node.list_channels().len(), 0);
2279         assert_eq!(nodes[1].node.list_channels().len(), 1);
2280
2281         // One pending HTLC is discarded by the force-close:
2282         let payment_preimage_1 = route_payment(&nodes[1], &vec!(&nodes[2], &nodes[3])[..], 3000000).0;
2283
2284         // Simple case of one pending HTLC to HTLC-Timeout
2285         nodes[1].node.peer_disconnected(&nodes[2].node.get_our_node_id(), true);
2286         {
2287                 let mut node_txn = test_txn_broadcast(&nodes[1], &chan_2, None, HTLCType::TIMEOUT);
2288                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2289                 nodes[2].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![node_txn.drain(..).next().unwrap()] }, 1);
2290                 test_txn_broadcast(&nodes[2], &chan_2, None, HTLCType::NONE);
2291         }
2292         get_announce_close_broadcast_events(&nodes, 1, 2);
2293         assert_eq!(nodes[1].node.list_channels().len(), 0);
2294         assert_eq!(nodes[2].node.list_channels().len(), 1);
2295
2296         macro_rules! claim_funds {
2297                 ($node: expr, $prev_node: expr, $preimage: expr) => {
2298                         {
2299                                 assert!($node.node.claim_funds($preimage));
2300                                 check_added_monitors!($node, 1);
2301
2302                                 let events = $node.node.get_and_clear_pending_msg_events();
2303                                 assert_eq!(events.len(), 1);
2304                                 match events[0] {
2305                                         MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fail_htlcs, .. } } => {
2306                                                 assert!(update_add_htlcs.is_empty());
2307                                                 assert!(update_fail_htlcs.is_empty());
2308                                                 assert_eq!(*node_id, $prev_node.node.get_our_node_id());
2309                                         },
2310                                         _ => panic!("Unexpected event"),
2311                                 };
2312                         }
2313                 }
2314         }
2315
2316         // nodes[3] gets the preimage, but nodes[2] already disconnected, resulting in a nodes[2]
2317         // HTLC-Timeout and a nodes[3] claim against it (+ its own announces)
2318         nodes[2].node.peer_disconnected(&nodes[3].node.get_our_node_id(), true);
2319         {
2320                 let node_txn = test_txn_broadcast(&nodes[2], &chan_3, None, HTLCType::TIMEOUT);
2321
2322                 // Claim the payment on nodes[3], giving it knowledge of the preimage
2323                 claim_funds!(nodes[3], nodes[2], payment_preimage_1);
2324
2325                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2326                 nodes[3].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![node_txn[0].clone()] }, 1);
2327
2328                 check_preimage_claim(&nodes[3], &node_txn);
2329         }
2330         get_announce_close_broadcast_events(&nodes, 2, 3);
2331         assert_eq!(nodes[2].node.list_channels().len(), 0);
2332         assert_eq!(nodes[3].node.list_channels().len(), 1);
2333
2334         { // Cheat and reset nodes[4]'s height to 1
2335                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2336                 nodes[4].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![] }, 1);
2337         }
2338
2339         assert_eq!(nodes[3].node.latest_block_height.load(Ordering::Acquire), 1);
2340         assert_eq!(nodes[4].node.latest_block_height.load(Ordering::Acquire), 1);
2341         // One pending HTLC to time out:
2342         let payment_preimage_2 = route_payment(&nodes[3], &vec!(&nodes[4])[..], 3000000).0;
2343         // CLTV expires at TEST_FINAL_CLTV + 1 (current height) + 1 (added in send_payment for
2344         // buffer space).
2345
2346         {
2347                 let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2348                 nodes[3].chain_monitor.block_connected_checked(&header, 2, &Vec::new()[..], &[0; 0]);
2349                 for i in 3..TEST_FINAL_CLTV + 2 + HTLC_FAIL_TIMEOUT_BLOCKS + 1 {
2350                         header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2351                         nodes[3].chain_monitor.block_connected_checked(&header, i, &Vec::new()[..], &[0; 0]);
2352                 }
2353
2354                 let node_txn = test_txn_broadcast(&nodes[3], &chan_4, None, HTLCType::TIMEOUT);
2355
2356                 // Claim the payment on nodes[4], giving it knowledge of the preimage
2357                 claim_funds!(nodes[4], nodes[3], payment_preimage_2);
2358
2359                 header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2360                 nodes[4].chain_monitor.block_connected_checked(&header, 2, &Vec::new()[..], &[0; 0]);
2361                 for i in 3..TEST_FINAL_CLTV + 2 - CLTV_CLAIM_BUFFER + 1 {
2362                         header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2363                         nodes[4].chain_monitor.block_connected_checked(&header, i, &Vec::new()[..], &[0; 0]);
2364                 }
2365
2366                 test_txn_broadcast(&nodes[4], &chan_4, None, HTLCType::SUCCESS);
2367
2368                 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2369                 nodes[4].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![node_txn[0].clone()] }, TEST_FINAL_CLTV - 5);
2370
2371                 check_preimage_claim(&nodes[4], &node_txn);
2372         }
2373         get_announce_close_broadcast_events(&nodes, 3, 4);
2374         assert_eq!(nodes[3].node.list_channels().len(), 0);
2375         assert_eq!(nodes[4].node.list_channels().len(), 0);
2376 }
2377
2378 #[test]
2379 fn test_justice_tx() {
2380         // Test justice txn built on revoked HTLC-Success tx, against both sides
2381
2382         let nodes = create_network(2);
2383         // Create some new channels:
2384         let chan_5 = create_announced_chan_between_nodes(&nodes, 0, 1);
2385
2386         // A pending HTLC which will be revoked:
2387         let payment_preimage_3 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
2388         // Get the will-be-revoked local txn from nodes[0]
2389         let revoked_local_txn = nodes[0].node.channel_state.lock().unwrap().by_id.iter().next().unwrap().1.last_local_commitment_txn.clone();
2390         assert_eq!(revoked_local_txn.len(), 2); // First commitment tx, then HTLC tx
2391         assert_eq!(revoked_local_txn[0].input.len(), 1);
2392         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_5.3.txid());
2393         assert_eq!(revoked_local_txn[0].output.len(), 2); // Only HTLC and output back to 0 are present
2394         assert_eq!(revoked_local_txn[1].input.len(), 1);
2395         assert_eq!(revoked_local_txn[1].input[0].previous_output.txid, revoked_local_txn[0].txid());
2396         assert_eq!(revoked_local_txn[1].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT); // HTLC-Timeout
2397         // Revoke the old state
2398         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3);
2399
2400         {
2401                 let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2402                 nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2403                 {
2404                         let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2405                         assert_eq!(node_txn.len(), 3);
2406                         assert_eq!(node_txn.pop().unwrap(), node_txn[0]); // An outpoint registration will result in a 2nd block_connected
2407                         assert_eq!(node_txn[0].input.len(), 2); // We should claim the revoked output and the HTLC output
2408
2409                         check_spends!(node_txn[0], revoked_local_txn[0].clone());
2410                         node_txn.swap_remove(0);
2411                 }
2412                 test_txn_broadcast(&nodes[1], &chan_5, None, HTLCType::NONE);
2413
2414                 nodes[0].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2415                 let node_txn = test_txn_broadcast(&nodes[0], &chan_5, Some(revoked_local_txn[0].clone()), HTLCType::TIMEOUT);
2416                 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2417                 nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![node_txn[1].clone()] }, 1);
2418                 test_revoked_htlc_claim_txn_broadcast(&nodes[1], node_txn[1].clone());
2419         }
2420         get_announce_close_broadcast_events(&nodes, 0, 1);
2421
2422         assert_eq!(nodes[0].node.list_channels().len(), 0);
2423         assert_eq!(nodes[1].node.list_channels().len(), 0);
2424
2425         // We test justice_tx build by A on B's revoked HTLC-Success tx
2426         // Create some new channels:
2427         let chan_6 = create_announced_chan_between_nodes(&nodes, 0, 1);
2428
2429         // A pending HTLC which will be revoked:
2430         let payment_preimage_4 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
2431         // Get the will-be-revoked local txn from B
2432         let revoked_local_txn = nodes[1].node.channel_state.lock().unwrap().by_id.iter().next().unwrap().1.last_local_commitment_txn.clone();
2433         assert_eq!(revoked_local_txn.len(), 1); // Only commitment tx
2434         assert_eq!(revoked_local_txn[0].input.len(), 1);
2435         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_6.3.txid());
2436         assert_eq!(revoked_local_txn[0].output.len(), 2); // Only HTLC and output back to A are present
2437         // Revoke the old state
2438         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_4);
2439         {
2440                 let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2441                 nodes[0].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2442                 {
2443                         let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
2444                         assert_eq!(node_txn.len(), 3);
2445                         assert_eq!(node_txn.pop().unwrap(), node_txn[0]); // An outpoint registration will result in a 2nd block_connected
2446                         assert_eq!(node_txn[0].input.len(), 1); // We claim the received HTLC output
2447
2448                         check_spends!(node_txn[0], revoked_local_txn[0].clone());
2449                         node_txn.swap_remove(0);
2450                 }
2451                 test_txn_broadcast(&nodes[0], &chan_6, None, HTLCType::NONE);
2452
2453                 nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2454                 let node_txn = test_txn_broadcast(&nodes[1], &chan_6, Some(revoked_local_txn[0].clone()), HTLCType::SUCCESS);
2455                 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2456                 nodes[0].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![node_txn[1].clone()] }, 1);
2457                 test_revoked_htlc_claim_txn_broadcast(&nodes[0], node_txn[1].clone());
2458         }
2459         get_announce_close_broadcast_events(&nodes, 0, 1);
2460         assert_eq!(nodes[0].node.list_channels().len(), 0);
2461         assert_eq!(nodes[1].node.list_channels().len(), 0);
2462 }
2463
2464 #[test]
2465 fn revoked_output_claim() {
2466         // Simple test to ensure a node will claim a revoked output when a stale remote commitment
2467         // transaction is broadcast by its counterparty
2468         let nodes = create_network(2);
2469         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
2470         // node[0] is gonna to revoke an old state thus node[1] should be able to claim the revoked output
2471         let revoked_local_txn = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan_1.2).unwrap().last_local_commitment_txn.clone();
2472         assert_eq!(revoked_local_txn.len(), 1);
2473         // Only output is the full channel value back to nodes[0]:
2474         assert_eq!(revoked_local_txn[0].output.len(), 1);
2475         // Send a payment through, updating everyone's latest commitment txn
2476         send_payment(&nodes[0], &vec!(&nodes[1])[..], 5000000);
2477
2478         // Inform nodes[1] that nodes[0] broadcast a stale tx
2479         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2480         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2481         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2482         assert_eq!(node_txn.len(), 3); // nodes[1] will broadcast justice tx twice, and its own local state once
2483
2484         assert_eq!(node_txn[0], node_txn[2]);
2485
2486         check_spends!(node_txn[0], revoked_local_txn[0].clone());
2487         check_spends!(node_txn[1], chan_1.3.clone());
2488
2489         // Inform nodes[0] that a watchtower cheated on its behalf, so it will force-close the chan
2490         nodes[0].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2491         get_announce_close_broadcast_events(&nodes, 0, 1);
2492 }
2493
2494 #[test]
2495 fn claim_htlc_outputs_shared_tx() {
2496         // Node revoked old state, htlcs haven't time out yet, claim them in shared justice tx
2497         let nodes = create_network(2);
2498
2499         // Create some new channel:
2500         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
2501
2502         // Rebalance the network to generate htlc in the two directions
2503         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
2504         // node[0] is gonna to revoke an old state thus node[1] should be able to claim both offered/received HTLC outputs on top of commitment tx
2505         let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
2506         let (_payment_preimage_2, payment_hash_2) = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000);
2507
2508         // Get the will-be-revoked local txn from node[0]
2509         let revoked_local_txn = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan_1.2).unwrap().last_local_commitment_txn.clone();
2510         assert_eq!(revoked_local_txn.len(), 2); // commitment tx + 1 HTLC-Timeout tx
2511         assert_eq!(revoked_local_txn[0].input.len(), 1);
2512         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
2513         assert_eq!(revoked_local_txn[1].input.len(), 1);
2514         assert_eq!(revoked_local_txn[1].input[0].previous_output.txid, revoked_local_txn[0].txid());
2515         assert_eq!(revoked_local_txn[1].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT); // HTLC-Timeout
2516         check_spends!(revoked_local_txn[1], revoked_local_txn[0].clone());
2517
2518         //Revoke the old state
2519         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1);
2520
2521         {
2522                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2523                 nodes[0].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2524                 nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2525
2526                 let events = nodes[1].node.get_and_clear_pending_events();
2527                 assert_eq!(events.len(), 1);
2528                 match events[0] {
2529                         Event::PaymentFailed { payment_hash, .. } => {
2530                                 assert_eq!(payment_hash, payment_hash_2);
2531                         },
2532                         _ => panic!("Unexpected event"),
2533                 }
2534
2535                 let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2536                 assert_eq!(node_txn.len(), 4);
2537
2538                 assert_eq!(node_txn[0].input.len(), 3); // Claim the revoked output + both revoked HTLC outputs
2539                 check_spends!(node_txn[0], revoked_local_txn[0].clone());
2540
2541                 assert_eq!(node_txn[0], node_txn[3]); // justice tx is duplicated due to block re-scanning
2542
2543                 let mut witness_lens = BTreeSet::new();
2544                 witness_lens.insert(node_txn[0].input[0].witness.last().unwrap().len());
2545                 witness_lens.insert(node_txn[0].input[1].witness.last().unwrap().len());
2546                 witness_lens.insert(node_txn[0].input[2].witness.last().unwrap().len());
2547                 assert_eq!(witness_lens.len(), 3);
2548                 assert_eq!(*witness_lens.iter().skip(0).next().unwrap(), 77); // revoked to_local
2549                 assert_eq!(*witness_lens.iter().skip(1).next().unwrap(), OFFERED_HTLC_SCRIPT_WEIGHT); // revoked offered HTLC
2550                 assert_eq!(*witness_lens.iter().skip(2).next().unwrap(), ACCEPTED_HTLC_SCRIPT_WEIGHT); // revoked received HTLC
2551
2552                 // Next nodes[1] broadcasts its current local tx state:
2553                 assert_eq!(node_txn[1].input.len(), 1);
2554                 assert_eq!(node_txn[1].input[0].previous_output.txid, chan_1.3.txid()); //Spending funding tx unique txouput, tx broadcasted by ChannelManager
2555
2556                 assert_eq!(node_txn[2].input.len(), 1);
2557                 let witness_script = node_txn[2].clone().input[0].witness.pop().unwrap();
2558                 assert_eq!(witness_script.len(), OFFERED_HTLC_SCRIPT_WEIGHT); //Spending an offered htlc output
2559                 assert_eq!(node_txn[2].input[0].previous_output.txid, node_txn[1].txid());
2560                 assert_ne!(node_txn[2].input[0].previous_output.txid, node_txn[0].input[0].previous_output.txid);
2561                 assert_ne!(node_txn[2].input[0].previous_output.txid, node_txn[0].input[1].previous_output.txid);
2562         }
2563         get_announce_close_broadcast_events(&nodes, 0, 1);
2564         assert_eq!(nodes[0].node.list_channels().len(), 0);
2565         assert_eq!(nodes[1].node.list_channels().len(), 0);
2566 }
2567
2568 #[test]
2569 fn claim_htlc_outputs_single_tx() {
2570         // Node revoked old state, htlcs have timed out, claim each of them in separated justice tx
2571         let nodes = create_network(2);
2572
2573         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
2574
2575         // Rebalance the network to generate htlc in the two directions
2576         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
2577         // node[0] is gonna to revoke an old state thus node[1] should be able to claim both offered/received HTLC outputs on top of commitment tx, but this
2578         // time as two different claim transactions as we're gonna to timeout htlc with given a high current height
2579         let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
2580         let (_payment_preimage_2, payment_hash_2) = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000);
2581
2582         // Get the will-be-revoked local txn from node[0]
2583         let revoked_local_txn = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan_1.2).unwrap().last_local_commitment_txn.clone();
2584
2585         //Revoke the old state
2586         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1);
2587
2588         {
2589                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2590                 nodes[0].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 200);
2591                 nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 200);
2592
2593                 let events = nodes[1].node.get_and_clear_pending_events();
2594                 assert_eq!(events.len(), 1);
2595                 match events[0] {
2596                         Event::PaymentFailed { payment_hash, .. } => {
2597                                 assert_eq!(payment_hash, payment_hash_2);
2598                         },
2599                         _ => panic!("Unexpected event"),
2600                 }
2601
2602                 let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2603                 assert_eq!(node_txn.len(), 12); // ChannelManager : 2, ChannelMontitor: 8 (1 standard revoked output, 2 revocation htlc tx, 1 local commitment tx + 1 htlc timeout tx) * 2 (block-rescan)
2604
2605                 assert_eq!(node_txn[0], node_txn[7]);
2606                 assert_eq!(node_txn[1], node_txn[8]);
2607                 assert_eq!(node_txn[2], node_txn[9]);
2608                 assert_eq!(node_txn[3], node_txn[10]);
2609                 assert_eq!(node_txn[4], node_txn[11]);
2610                 assert_eq!(node_txn[3], node_txn[5]); //local commitment tx + htlc timeout tx broadcated by ChannelManger
2611                 assert_eq!(node_txn[4], node_txn[6]);
2612
2613                 assert_eq!(node_txn[0].input.len(), 1);
2614                 assert_eq!(node_txn[1].input.len(), 1);
2615                 assert_eq!(node_txn[2].input.len(), 1);
2616
2617                 let mut revoked_tx_map = HashMap::new();
2618                 revoked_tx_map.insert(revoked_local_txn[0].txid(), revoked_local_txn[0].clone());
2619                 node_txn[0].verify(&revoked_tx_map).unwrap();
2620                 node_txn[1].verify(&revoked_tx_map).unwrap();
2621                 node_txn[2].verify(&revoked_tx_map).unwrap();
2622
2623                 let mut witness_lens = BTreeSet::new();
2624                 witness_lens.insert(node_txn[0].input[0].witness.last().unwrap().len());
2625                 witness_lens.insert(node_txn[1].input[0].witness.last().unwrap().len());
2626                 witness_lens.insert(node_txn[2].input[0].witness.last().unwrap().len());
2627                 assert_eq!(witness_lens.len(), 3);
2628                 assert_eq!(*witness_lens.iter().skip(0).next().unwrap(), 77); // revoked to_local
2629                 assert_eq!(*witness_lens.iter().skip(1).next().unwrap(), OFFERED_HTLC_SCRIPT_WEIGHT); // revoked offered HTLC
2630                 assert_eq!(*witness_lens.iter().skip(2).next().unwrap(), ACCEPTED_HTLC_SCRIPT_WEIGHT); // revoked received HTLC
2631
2632                 assert_eq!(node_txn[3].input.len(), 1);
2633                 check_spends!(node_txn[3], chan_1.3.clone());
2634
2635                 assert_eq!(node_txn[4].input.len(), 1);
2636                 let witness_script = node_txn[4].input[0].witness.last().unwrap();
2637                 assert_eq!(witness_script.len(), OFFERED_HTLC_SCRIPT_WEIGHT); //Spending an offered htlc output
2638                 assert_eq!(node_txn[4].input[0].previous_output.txid, node_txn[3].txid());
2639                 assert_ne!(node_txn[4].input[0].previous_output.txid, node_txn[0].input[0].previous_output.txid);
2640                 assert_ne!(node_txn[4].input[0].previous_output.txid, node_txn[1].input[0].previous_output.txid);
2641         }
2642         get_announce_close_broadcast_events(&nodes, 0, 1);
2643         assert_eq!(nodes[0].node.list_channels().len(), 0);
2644         assert_eq!(nodes[1].node.list_channels().len(), 0);
2645 }
2646
2647 #[test]
2648 fn test_htlc_on_chain_success() {
2649         // Test that in case of an unilateral close onchain, we detect the state of output thanks to
2650         // ChainWatchInterface and pass the preimage backward accordingly. So here we test that ChannelManager is
2651         // broadcasting the right event to other nodes in payment path.
2652         // A --------------------> B ----------------------> C (preimage)
2653         // First, C should claim the HTLC output via HTLC-Success when its own latest local
2654         // commitment transaction was broadcast.
2655         // Then, B should learn the preimage from said transactions, attempting to claim backwards
2656         // towards B.
2657         // B should be able to claim via preimage if A then broadcasts its local tx.
2658         // Finally, when A sees B's latest local commitment transaction it should be able to claim
2659         // the HTLC output via the preimage it learned (which, once confirmed should generate a
2660         // PaymentSent event).
2661
2662         let nodes = create_network(3);
2663
2664         // Create some initial channels
2665         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
2666         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
2667
2668         // Rebalance the network a bit by relaying one payment through all the channels...
2669         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
2670         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
2671
2672         let (our_payment_preimage, _payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
2673         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
2674
2675         // Broadcast legit commitment tx from C on B's chain
2676         // Broadcast HTLC Success transation by C on received output from C's commitment tx on B's chain
2677         let commitment_tx = nodes[2].node.channel_state.lock().unwrap().by_id.get(&chan_2.2).unwrap().last_local_commitment_txn.clone();
2678         assert_eq!(commitment_tx.len(), 1);
2679         check_spends!(commitment_tx[0], chan_2.3.clone());
2680         nodes[2].node.claim_funds(our_payment_preimage);
2681         check_added_monitors!(nodes[2], 1);
2682         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
2683         assert!(updates.update_add_htlcs.is_empty());
2684         assert!(updates.update_fail_htlcs.is_empty());
2685         assert!(updates.update_fail_malformed_htlcs.is_empty());
2686         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
2687
2688         nodes[2].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
2689         let events = nodes[2].node.get_and_clear_pending_msg_events();
2690         assert_eq!(events.len(), 1);
2691         match events[0] {
2692                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
2693                 _ => panic!("Unexpected event"),
2694         }
2695         let node_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 1 (commitment tx), ChannelMonitor : 2 (2 * HTLC-Success tx)
2696         assert_eq!(node_txn.len(), 3);
2697         assert_eq!(node_txn[1], commitment_tx[0]);
2698         assert_eq!(node_txn[0], node_txn[2]);
2699         check_spends!(node_txn[0], commitment_tx[0].clone());
2700         assert_eq!(node_txn[0].input[0].witness.clone().last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
2701         assert!(node_txn[0].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2702         assert_eq!(node_txn[0].lock_time, 0);
2703
2704         // Verify that B's ChannelManager is able to extract preimage from HTLC Success tx and pass it backward
2705         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: node_txn}, 1);
2706         let events = nodes[1].node.get_and_clear_pending_msg_events();
2707         {
2708                 let mut added_monitors = nodes[1].chan_monitor.added_monitors.lock().unwrap();
2709                 assert_eq!(added_monitors.len(), 1);
2710                 assert_eq!(added_monitors[0].0.txid, chan_1.3.txid());
2711                 added_monitors.clear();
2712         }
2713         assert_eq!(events.len(), 2);
2714         match events[0] {
2715                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
2716                 _ => panic!("Unexpected event"),
2717         }
2718         match events[1] {
2719                 MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fail_htlcs, ref update_fulfill_htlcs, ref update_fail_malformed_htlcs, .. } } => {
2720                         assert!(update_add_htlcs.is_empty());
2721                         assert!(update_fail_htlcs.is_empty());
2722                         assert_eq!(update_fulfill_htlcs.len(), 1);
2723                         assert!(update_fail_malformed_htlcs.is_empty());
2724                         assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
2725                 },
2726                 _ => panic!("Unexpected event"),
2727         };
2728         {
2729                 // nodes[1] now broadcasts its own local state as a fallback, suggesting an alternate
2730                 // commitment transaction with a corresponding HTLC-Timeout transaction, as well as a
2731                 // timeout-claim of the output that nodes[2] just claimed via success.
2732                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); // ChannelManager : 2 (commitment tx, HTLC-Timeout tx), ChannelMonitor : 1 (timeout tx) * 2 (block-rescan)
2733                 assert_eq!(node_txn.len(), 4);
2734                 assert_eq!(node_txn[0], node_txn[3]);
2735                 check_spends!(node_txn[0], commitment_tx[0].clone());
2736                 assert_eq!(node_txn[0].input[0].witness.clone().last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
2737                 assert_ne!(node_txn[0].lock_time, 0);
2738                 assert!(node_txn[0].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
2739                 check_spends!(node_txn[1], chan_2.3.clone());
2740                 check_spends!(node_txn[2], node_txn[1].clone());
2741                 assert_eq!(node_txn[1].input[0].witness.clone().last().unwrap().len(), 71);
2742                 assert_eq!(node_txn[2].input[0].witness.clone().last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2743                 assert!(node_txn[2].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2744                 assert_ne!(node_txn[2].lock_time, 0);
2745                 node_txn.clear();
2746         }
2747
2748         // Broadcast legit commitment tx from A on B's chain
2749         // Broadcast preimage tx by B on offered output from A commitment tx  on A's chain
2750         let commitment_tx = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan_1.2).unwrap().last_local_commitment_txn.clone();
2751         check_spends!(commitment_tx[0], chan_1.3.clone());
2752         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
2753         let events = nodes[1].node.get_and_clear_pending_msg_events();
2754         assert_eq!(events.len(), 1);
2755         match events[0] {
2756                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
2757                 _ => panic!("Unexpected event"),
2758         }
2759         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 1 (commitment tx), ChannelMonitor : 1 (HTLC-Success) * 2 (block-rescan)
2760         assert_eq!(node_txn.len(), 3);
2761         assert_eq!(node_txn[0], node_txn[2]);
2762         check_spends!(node_txn[0], commitment_tx[0].clone());
2763         assert_eq!(node_txn[0].input[0].witness.clone().last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2764         assert_eq!(node_txn[0].lock_time, 0);
2765         assert!(node_txn[0].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
2766         check_spends!(node_txn[1], chan_1.3.clone());
2767         assert_eq!(node_txn[1].input[0].witness.clone().last().unwrap().len(), 71);
2768         // We don't bother to check that B can claim the HTLC output on its commitment tx here as
2769         // we already checked the same situation with A.
2770
2771         // Verify that A's ChannelManager is able to extract preimage from preimage tx and generate PaymentSent
2772         nodes[0].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![commitment_tx[0].clone(), node_txn[0].clone()] }, 1);
2773         let events = nodes[0].node.get_and_clear_pending_msg_events();
2774         assert_eq!(events.len(), 1);
2775         match events[0] {
2776                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
2777                 _ => panic!("Unexpected event"),
2778         }
2779         let events = nodes[0].node.get_and_clear_pending_events();
2780         assert_eq!(events.len(), 1);
2781         match events[0] {
2782                 Event::PaymentSent { payment_preimage } => {
2783                         assert_eq!(payment_preimage, our_payment_preimage);
2784                 },
2785                 _ => panic!("Unexpected event"),
2786         }
2787         let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 2 (commitment tx, HTLC-Timeout tx), ChannelMonitor : 1 (HTLC-Timeout tx) * 2 (block-rescan)
2788         assert_eq!(node_txn.len(), 4);
2789         assert_eq!(node_txn[0], node_txn[3]);
2790         check_spends!(node_txn[0], commitment_tx[0].clone());
2791         assert_eq!(node_txn[0].input[0].witness.clone().last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2792         assert_ne!(node_txn[0].lock_time, 0);
2793         assert!(node_txn[0].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2794         check_spends!(node_txn[1], chan_1.3.clone());
2795         check_spends!(node_txn[2], node_txn[1].clone());
2796         assert_eq!(node_txn[1].input[0].witness.clone().last().unwrap().len(), 71);
2797         assert_eq!(node_txn[2].input[0].witness.clone().last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2798         assert!(node_txn[2].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2799         assert_ne!(node_txn[2].lock_time, 0);
2800 }
2801
2802 #[test]
2803 fn test_htlc_on_chain_timeout() {
2804         // Test that in case of an unilateral close onchain, we detect the state of output thanks to
2805         // ChainWatchInterface and timeout the HTLC  bacward accordingly. So here we test that ChannelManager is
2806         // broadcasting the right event to other nodes in payment path.
2807         // A ------------------> B ----------------------> C (timeout)
2808         //    B's commitment tx                 C's commitment tx
2809         //            \                                  \
2810         //         B's HTLC timeout tx               B's timeout tx
2811
2812         let nodes = create_network(3);
2813
2814         // Create some intial channels
2815         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
2816         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
2817
2818         // Rebalance the network a bit by relaying one payment thorugh all the channels...
2819         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
2820         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
2821
2822         let (_payment_preimage, payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
2823         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
2824
2825         // Brodacast legit commitment tx from C on B's chain
2826         let commitment_tx = nodes[2].node.channel_state.lock().unwrap().by_id.get(&chan_2.2).unwrap().last_local_commitment_txn.clone();
2827         check_spends!(commitment_tx[0], chan_2.3.clone());
2828         nodes[2].node.fail_htlc_backwards(&payment_hash, 0);
2829         {
2830                 let mut added_monitors = nodes[2].chan_monitor.added_monitors.lock().unwrap();
2831                 assert_eq!(added_monitors.len(), 1);
2832                 added_monitors.clear();
2833         }
2834         let events = nodes[2].node.get_and_clear_pending_msg_events();
2835         assert_eq!(events.len(), 1);
2836         match events[0] {
2837                 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, .. } } => {
2838                         assert!(update_add_htlcs.is_empty());
2839                         assert!(!update_fail_htlcs.is_empty());
2840                         assert!(update_fulfill_htlcs.is_empty());
2841                         assert!(update_fail_malformed_htlcs.is_empty());
2842                         assert_eq!(nodes[1].node.get_our_node_id(), *node_id);
2843                 },
2844                 _ => panic!("Unexpected event"),
2845         };
2846         nodes[2].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
2847         let events = nodes[2].node.get_and_clear_pending_msg_events();
2848         assert_eq!(events.len(), 1);
2849         match events[0] {
2850                 MessageSendEvent::BroadcastChannelUpdate { msg: msgs::ChannelUpdate { .. } } => {},
2851                 _ => panic!("Unexpected event"),
2852         }
2853         let node_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 1 (commitment tx)
2854         assert_eq!(node_txn.len(), 1);
2855         check_spends!(node_txn[0], chan_2.3.clone());
2856         assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), 71);
2857
2858         // Broadcast timeout transaction by B on received output fron C's commitment tx on B's chain
2859         // Verify that B's ChannelManager is able to detect that HTLC is timeout by its own tx and react backward in consequence
2860         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 200);
2861         let timeout_tx;
2862         {
2863                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2864                 assert_eq!(node_txn.len(), 8); // ChannelManager : 2 (commitment tx, HTLC-Timeout tx), ChannelMonitor : 6 (HTLC-Timeout tx, commitment tx, timeout tx) * 2 (block-rescan)
2865                 assert_eq!(node_txn[0], node_txn[5]);
2866                 assert_eq!(node_txn[1], node_txn[6]);
2867                 assert_eq!(node_txn[2], node_txn[7]);
2868                 check_spends!(node_txn[0], commitment_tx[0].clone());
2869                 assert_eq!(node_txn[0].clone().input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
2870                 check_spends!(node_txn[1], chan_2.3.clone());
2871                 check_spends!(node_txn[2], node_txn[1].clone());
2872                 assert_eq!(node_txn[1].clone().input[0].witness.last().unwrap().len(), 71);
2873                 assert_eq!(node_txn[2].clone().input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2874                 check_spends!(node_txn[3], chan_2.3.clone());
2875                 check_spends!(node_txn[4], node_txn[3].clone());
2876                 assert_eq!(node_txn[3].input[0].witness.clone().last().unwrap().len(), 71);
2877                 assert_eq!(node_txn[4].input[0].witness.clone().last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2878                 timeout_tx = node_txn[0].clone();
2879                 node_txn.clear();
2880         }
2881
2882         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![timeout_tx]}, 1);
2883         let events = nodes[1].node.get_and_clear_pending_msg_events();
2884         check_added_monitors!(nodes[1], 1);
2885         assert_eq!(events.len(), 2);
2886         match events[0] {
2887                 MessageSendEvent::BroadcastChannelUpdate { msg: msgs::ChannelUpdate { .. } } => {},
2888                 _ => panic!("Unexpected event"),
2889         }
2890         match events[1] {
2891                 MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fail_htlcs, ref update_fulfill_htlcs, ref update_fail_malformed_htlcs, .. } } => {
2892                         assert!(update_add_htlcs.is_empty());
2893                         assert!(!update_fail_htlcs.is_empty());
2894                         assert!(update_fulfill_htlcs.is_empty());
2895                         assert!(update_fail_malformed_htlcs.is_empty());
2896                         assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
2897                 },
2898                 _ => panic!("Unexpected event"),
2899         };
2900         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // Well... here we detect our own htlc_timeout_tx so no tx to be generated
2901         assert_eq!(node_txn.len(), 0);
2902
2903         // Broadcast legit commitment tx from B on A's chain
2904         let commitment_tx = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan_1.2).unwrap().last_local_commitment_txn.clone();
2905         check_spends!(commitment_tx[0], chan_1.3.clone());
2906
2907         nodes[0].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 200);
2908         let events = nodes[0].node.get_and_clear_pending_msg_events();
2909         assert_eq!(events.len(), 1);
2910         match events[0] {
2911                 MessageSendEvent::BroadcastChannelUpdate { msg: msgs::ChannelUpdate { .. } } => {},
2912                 _ => panic!("Unexpected event"),
2913         }
2914         let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 2 (commitment tx, HTLC-Timeout tx), ChannelMonitor : 2 (timeout tx) * 2 block-rescan
2915         assert_eq!(node_txn.len(), 4);
2916         assert_eq!(node_txn[0], node_txn[3]);
2917         check_spends!(node_txn[0], commitment_tx[0].clone());
2918         assert_eq!(node_txn[0].clone().input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
2919         check_spends!(node_txn[1], chan_1.3.clone());
2920         check_spends!(node_txn[2], node_txn[1].clone());
2921         assert_eq!(node_txn[1].clone().input[0].witness.last().unwrap().len(), 71);
2922         assert_eq!(node_txn[2].clone().input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2923 }
2924
2925 #[test]
2926 fn test_simple_commitment_revoked_fail_backward() {
2927         // Test that in case of a revoked commitment tx, we detect the resolution of output by justice tx
2928         // and fail backward accordingly.
2929
2930         let nodes = create_network(3);
2931
2932         // Create some initial channels
2933         create_announced_chan_between_nodes(&nodes, 0, 1);
2934         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
2935
2936         let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
2937         // Get the will-be-revoked local txn from nodes[2]
2938         let revoked_local_txn = nodes[2].node.channel_state.lock().unwrap().by_id.get(&chan_2.2).unwrap().last_local_commitment_txn.clone();
2939         // Revoke the old state
2940         claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage);
2941
2942         route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
2943
2944         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
2945         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2946         let events = nodes[1].node.get_and_clear_pending_msg_events();
2947         check_added_monitors!(nodes[1], 1);
2948         assert_eq!(events.len(), 2);
2949         match events[0] {
2950                 MessageSendEvent::BroadcastChannelUpdate { msg: msgs::ChannelUpdate { .. } } => {},
2951                 _ => panic!("Unexpected event"),
2952         }
2953         match events[1] {
2954                 MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fail_htlcs, ref update_fulfill_htlcs, ref update_fail_malformed_htlcs, ref commitment_signed, .. } } => {
2955                         assert!(update_add_htlcs.is_empty());
2956                         assert_eq!(update_fail_htlcs.len(), 1);
2957                         assert!(update_fulfill_htlcs.is_empty());
2958                         assert!(update_fail_malformed_htlcs.is_empty());
2959                         assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
2960
2961                         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlcs[0]).unwrap();
2962                         commitment_signed_dance!(nodes[0], nodes[1], commitment_signed, false, true);
2963
2964                         let events = nodes[0].node.get_and_clear_pending_msg_events();
2965                         assert_eq!(events.len(), 1);
2966                         match events[0] {
2967                                 MessageSendEvent::PaymentFailureNetworkUpdate { .. } => {},
2968                                 _ => panic!("Unexpected event"),
2969                         }
2970                         let events = nodes[0].node.get_and_clear_pending_events();
2971                         assert_eq!(events.len(), 1);
2972                         match events[0] {
2973                                 Event::PaymentFailed { .. } => {},
2974                                 _ => panic!("Unexpected event"),
2975                         }
2976                 },
2977                 _ => panic!("Unexpected event"),
2978         }
2979 }
2980
2981 fn do_test_commitment_revoked_fail_backward_exhaustive(deliver_bs_raa: bool) {
2982         // Test that if our counterparty broadcasts a revoked commitment transaction we fail all
2983         // pending HTLCs on that channel backwards even if the HTLCs aren't present in our latest
2984         // commitment transaction anymore.
2985         // To do this, we have the peer which will broadcast a revoked commitment transaction send
2986         // a number of update_fail/commitment_signed updates without ever sending the RAA in
2987         // response to our commitment_signed. This is somewhat misbehavior-y, though not
2988         // technically disallowed and we should probably handle it reasonably.
2989         // Note that this is pretty exhaustive as an outbound HTLC which we haven't yet
2990         // failed/fulfilled backwards must be in at least one of the latest two remote commitment
2991         // transactions:
2992         // * Once we move it out of our holding cell/add it, we will immediately include it in a
2993         //   commitment_signed (implying it will be in the latest remote commitment transaction).
2994         // * Once they remove it, we will send a (the first) commitment_signed without the HTLC,
2995         //   and once they revoke the previous commitment transaction (allowing us to send a new
2996         //   commitment_signed) we will be free to fail/fulfill the HTLC backwards.
2997         let mut nodes = create_network(3);
2998
2999         // Create some initial channels
3000         create_announced_chan_between_nodes(&nodes, 0, 1);
3001         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
3002
3003         let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
3004         // Get the will-be-revoked local txn from nodes[2]
3005         let revoked_local_txn = nodes[2].node.channel_state.lock().unwrap().by_id.get(&chan_2.2).unwrap().last_local_commitment_txn.clone();
3006         // Revoke the old state
3007         claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage);
3008
3009         let (_, first_payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
3010         let (_, second_payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
3011         let (_, third_payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
3012
3013         assert!(nodes[2].node.fail_htlc_backwards(&first_payment_hash, 0));
3014         check_added_monitors!(nodes[2], 1);
3015         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
3016         assert!(updates.update_add_htlcs.is_empty());
3017         assert!(updates.update_fulfill_htlcs.is_empty());
3018         assert!(updates.update_fail_malformed_htlcs.is_empty());
3019         assert_eq!(updates.update_fail_htlcs.len(), 1);
3020         assert!(updates.update_fee.is_none());
3021         nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[0]).unwrap();
3022         let bs_raa = commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false, true, false, true);
3023         // Drop the last RAA from 3 -> 2
3024
3025         assert!(nodes[2].node.fail_htlc_backwards(&second_payment_hash, 0));
3026         check_added_monitors!(nodes[2], 1);
3027         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
3028         assert!(updates.update_add_htlcs.is_empty());
3029         assert!(updates.update_fulfill_htlcs.is_empty());
3030         assert!(updates.update_fail_malformed_htlcs.is_empty());
3031         assert_eq!(updates.update_fail_htlcs.len(), 1);
3032         assert!(updates.update_fee.is_none());
3033         nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[0]).unwrap();
3034         nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &updates.commitment_signed).unwrap();
3035         check_added_monitors!(nodes[1], 1);
3036         // Note that nodes[1] is in AwaitingRAA, so won't send a CS
3037         let as_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[2].node.get_our_node_id());
3038         nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_raa).unwrap();
3039         check_added_monitors!(nodes[2], 1);
3040
3041         assert!(nodes[2].node.fail_htlc_backwards(&third_payment_hash, 0));
3042         check_added_monitors!(nodes[2], 1);
3043         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
3044         assert!(updates.update_add_htlcs.is_empty());
3045         assert!(updates.update_fulfill_htlcs.is_empty());
3046         assert!(updates.update_fail_malformed_htlcs.is_empty());
3047         assert_eq!(updates.update_fail_htlcs.len(), 1);
3048         assert!(updates.update_fee.is_none());
3049         nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[0]).unwrap();
3050         // At this point first_payment_hash has dropped out of the latest two commitment
3051         // transactions that nodes[1] is tracking...
3052         nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &updates.commitment_signed).unwrap();
3053         check_added_monitors!(nodes[1], 1);
3054         // Note that nodes[1] is (still) in AwaitingRAA, so won't send a CS
3055         let as_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[2].node.get_our_node_id());
3056         nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_raa).unwrap();
3057         check_added_monitors!(nodes[2], 1);
3058
3059         // Add a fourth HTLC, this one will get sequestered away in nodes[1]'s holding cell waiting
3060         // on nodes[2]'s RAA.
3061         let route = nodes[1].router.get_route(&nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
3062         let (_, fourth_payment_hash) = get_payment_preimage_hash!(nodes[0]);
3063         nodes[1].node.send_payment(route, fourth_payment_hash).unwrap();
3064         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
3065         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
3066         check_added_monitors!(nodes[1], 0);
3067
3068         if deliver_bs_raa {
3069                 nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &bs_raa).unwrap();
3070                 // One monitor for the new revocation preimage, one as we generate a commitment for
3071                 // nodes[0] to fail first_payment_hash backwards.
3072                 check_added_monitors!(nodes[1], 2);
3073         }
3074
3075         let mut failed_htlcs = HashSet::new();
3076         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
3077
3078         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
3079         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
3080
3081         let events = nodes[1].node.get_and_clear_pending_events();
3082         assert_eq!(events.len(), 1);
3083         match events[0] {
3084                 Event::PaymentFailed { ref payment_hash, .. } => {
3085                         assert_eq!(*payment_hash, fourth_payment_hash);
3086                 },
3087                 _ => panic!("Unexpected event"),
3088         }
3089
3090         if !deliver_bs_raa {
3091                 // If we delivered the RAA already then we already failed first_payment_hash backwards.
3092                 check_added_monitors!(nodes[1], 1);
3093         }
3094
3095         let events = nodes[1].node.get_and_clear_pending_msg_events();
3096         assert_eq!(events.len(), if deliver_bs_raa { 3 } else { 2 });
3097         match events[if deliver_bs_raa { 2 } else { 0 }] {
3098                 MessageSendEvent::BroadcastChannelUpdate { msg: msgs::ChannelUpdate { .. } } => {},
3099                 _ => panic!("Unexpected event"),
3100         }
3101         if deliver_bs_raa {
3102                 match events[0] {
3103                         MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fail_htlcs, ref update_fulfill_htlcs, ref update_fail_malformed_htlcs, .. } } => {
3104                                 assert_eq!(nodes[2].node.get_our_node_id(), *node_id);
3105                                 assert_eq!(update_add_htlcs.len(), 1);
3106                                 assert!(update_fulfill_htlcs.is_empty());
3107                                 assert!(update_fail_htlcs.is_empty());
3108                                 assert!(update_fail_malformed_htlcs.is_empty());
3109                         },
3110                         _ => panic!("Unexpected event"),
3111                 }
3112         }
3113         // Due to the way backwards-failing occurs we do the updates in two steps.
3114         let updates = match events[1] {
3115                 MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fail_htlcs, ref update_fulfill_htlcs, ref update_fail_malformed_htlcs, ref commitment_signed, .. } } => {
3116                         assert!(update_add_htlcs.is_empty());
3117                         assert_eq!(update_fail_htlcs.len(), 1);
3118                         assert!(update_fulfill_htlcs.is_empty());
3119                         assert!(update_fail_malformed_htlcs.is_empty());
3120                         assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
3121
3122                         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlcs[0]).unwrap();
3123                         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), commitment_signed).unwrap();
3124                         check_added_monitors!(nodes[0], 1);
3125                         let (as_revoke_and_ack, as_commitment_signed) = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
3126                         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_and_ack).unwrap();
3127                         check_added_monitors!(nodes[1], 1);
3128                         let bs_second_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
3129                         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_commitment_signed).unwrap();
3130                         check_added_monitors!(nodes[1], 1);
3131                         let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
3132                         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack).unwrap();
3133                         check_added_monitors!(nodes[0], 1);
3134
3135                         if !deliver_bs_raa {
3136                                 // If we delievered B's RAA we got an unknown preimage error, not something
3137                                 // that we should update our routing table for.
3138                                 let events = nodes[0].node.get_and_clear_pending_msg_events();
3139                                 assert_eq!(events.len(), 1);
3140                                 match events[0] {
3141                                         MessageSendEvent::PaymentFailureNetworkUpdate { .. } => {},
3142                                         _ => panic!("Unexpected event"),
3143                                 }
3144                         }
3145                         let events = nodes[0].node.get_and_clear_pending_events();
3146                         assert_eq!(events.len(), 1);
3147                         match events[0] {
3148                                 Event::PaymentFailed { ref payment_hash, .. } => {
3149                                         assert!(failed_htlcs.insert(payment_hash.0));
3150                                 },
3151                                 _ => panic!("Unexpected event"),
3152                         }
3153
3154                         bs_second_update
3155                 },
3156                 _ => panic!("Unexpected event"),
3157         };
3158
3159         assert!(updates.update_add_htlcs.is_empty());
3160         assert_eq!(updates.update_fail_htlcs.len(), 2);
3161         assert!(updates.update_fulfill_htlcs.is_empty());
3162         assert!(updates.update_fail_malformed_htlcs.is_empty());
3163         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]).unwrap();
3164         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[1]).unwrap();
3165         commitment_signed_dance!(nodes[0], nodes[1], updates.commitment_signed, false, true);
3166
3167         let events = nodes[0].node.get_and_clear_pending_msg_events();
3168         assert_eq!(events.len(), 2);
3169         for event in events {
3170                 match event {
3171                         MessageSendEvent::PaymentFailureNetworkUpdate { .. } => {},
3172                         _ => panic!("Unexpected event"),
3173                 }
3174         }
3175
3176         let events = nodes[0].node.get_and_clear_pending_events();
3177         assert_eq!(events.len(), 2);
3178         match events[0] {
3179                 Event::PaymentFailed { ref payment_hash, .. } => {
3180                         assert!(failed_htlcs.insert(payment_hash.0));
3181                 },
3182                 _ => panic!("Unexpected event"),
3183         }
3184         match events[1] {
3185                 Event::PaymentFailed { ref payment_hash, .. } => {
3186                         assert!(failed_htlcs.insert(payment_hash.0));
3187                 },
3188                 _ => panic!("Unexpected event"),
3189         }
3190
3191         assert!(failed_htlcs.contains(&first_payment_hash.0));
3192         assert!(failed_htlcs.contains(&second_payment_hash.0));
3193         assert!(failed_htlcs.contains(&third_payment_hash.0));
3194 }
3195
3196 #[test]
3197 fn test_commitment_revoked_fail_backward_exhaustive() {
3198         do_test_commitment_revoked_fail_backward_exhaustive(false);
3199         do_test_commitment_revoked_fail_backward_exhaustive(true);
3200 }
3201
3202 #[test]
3203 fn test_htlc_ignore_latest_remote_commitment() {
3204         // Test that HTLC transactions spending the latest remote commitment transaction are simply
3205         // ignored if we cannot claim them. This originally tickled an invalid unwrap().
3206         let nodes = create_network(2);
3207         create_announced_chan_between_nodes(&nodes, 0, 1);
3208
3209         route_payment(&nodes[0], &[&nodes[1]], 10000000);
3210         nodes[0].node.force_close_channel(&nodes[0].node.list_channels()[0].channel_id);
3211         {
3212                 let events = nodes[0].node.get_and_clear_pending_msg_events();
3213                 assert_eq!(events.len(), 1);
3214                 match events[0] {
3215                         MessageSendEvent::BroadcastChannelUpdate { msg: msgs::ChannelUpdate { contents: msgs::UnsignedChannelUpdate { flags, .. }, .. } } => {
3216                                 assert_eq!(flags & 0b10, 0b10);
3217                         },
3218                         _ => panic!("Unexpected event"),
3219                 }
3220         }
3221
3222         let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
3223         assert_eq!(node_txn.len(), 2);
3224
3225         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
3226         nodes[1].chain_monitor.block_connected_checked(&header, 1, &[&node_txn[0], &node_txn[1]], &[1; 2]);
3227
3228         {
3229                 let events = nodes[1].node.get_and_clear_pending_msg_events();
3230                 assert_eq!(events.len(), 1);
3231                 match events[0] {
3232                         MessageSendEvent::BroadcastChannelUpdate { msg: msgs::ChannelUpdate { contents: msgs::UnsignedChannelUpdate { flags, .. }, .. } } => {
3233                                 assert_eq!(flags & 0b10, 0b10);
3234                         },
3235                         _ => panic!("Unexpected event"),
3236                 }
3237         }
3238
3239         // Duplicate the block_connected call since this may happen due to other listeners
3240         // registering new transactions
3241         nodes[1].chain_monitor.block_connected_checked(&header, 1, &[&node_txn[0], &node_txn[1]], &[1; 2]);
3242 }
3243
3244 #[test]
3245 fn test_force_close_fail_back() {
3246         // Check which HTLCs are failed-backwards on channel force-closure
3247         let mut nodes = create_network(3);
3248         create_announced_chan_between_nodes(&nodes, 0, 1);
3249         create_announced_chan_between_nodes(&nodes, 1, 2);
3250
3251         let route = nodes[0].router.get_route(&nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, 42).unwrap();
3252
3253         let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
3254
3255         let mut payment_event = {
3256                 nodes[0].node.send_payment(route, our_payment_hash).unwrap();
3257                 check_added_monitors!(nodes[0], 1);
3258
3259                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
3260                 assert_eq!(events.len(), 1);
3261                 SendEvent::from_event(events.remove(0))
3262         };
3263
3264         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]).unwrap();
3265         commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
3266
3267         expect_pending_htlcs_forwardable!(nodes[1]);
3268
3269         let mut events_2 = nodes[1].node.get_and_clear_pending_msg_events();
3270         assert_eq!(events_2.len(), 1);
3271         payment_event = SendEvent::from_event(events_2.remove(0));
3272         assert_eq!(payment_event.msgs.len(), 1);
3273
3274         check_added_monitors!(nodes[1], 1);
3275         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]).unwrap();
3276         nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &payment_event.commitment_msg).unwrap();
3277         check_added_monitors!(nodes[2], 1);
3278         let (_, _) = get_revoke_commit_msgs!(nodes[2], nodes[1].node.get_our_node_id());
3279
3280         // nodes[2] now has the latest commitment transaction, but hasn't revoked its previous
3281         // state or updated nodes[1]' state. Now force-close and broadcast that commitment/HTLC
3282         // transaction and ensure nodes[1] doesn't fail-backwards (this was originally a bug!).
3283
3284         nodes[2].node.force_close_channel(&payment_event.commitment_msg.channel_id);
3285         let events_3 = nodes[2].node.get_and_clear_pending_msg_events();
3286         assert_eq!(events_3.len(), 1);
3287         match events_3[0] {
3288                 MessageSendEvent::BroadcastChannelUpdate { msg: msgs::ChannelUpdate { contents: msgs::UnsignedChannelUpdate { flags, .. }, .. } } => {
3289                         assert_eq!(flags & 0b10, 0b10);
3290                 },
3291                 _ => panic!("Unexpected event"),
3292         }
3293
3294         let tx = {
3295                 let mut node_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap();
3296                 // Note that we don't bother broadcasting the HTLC-Success transaction here as we don't
3297                 // have a use for it unless nodes[2] learns the preimage somehow, the funds will go
3298                 // back to nodes[1] upon timeout otherwise.
3299                 assert_eq!(node_txn.len(), 1);
3300                 node_txn.remove(0)
3301         };
3302
3303         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
3304         nodes[1].chain_monitor.block_connected_checked(&header, 1, &[&tx], &[1]);
3305
3306         let events_4 = nodes[1].node.get_and_clear_pending_msg_events();
3307         // Note no UpdateHTLCs event here from nodes[1] to nodes[0]!
3308         assert_eq!(events_4.len(), 1);
3309         match events_4[0] {
3310                 MessageSendEvent::BroadcastChannelUpdate { msg: msgs::ChannelUpdate { contents: msgs::UnsignedChannelUpdate { flags, .. }, .. } } => {
3311                         assert_eq!(flags & 0b10, 0b10);
3312                 },
3313                 _ => panic!("Unexpected event"),
3314         }
3315
3316         // Now check that if we add the preimage to ChannelMonitor it broadcasts our HTLC-Success..
3317         {
3318                 let mut monitors = nodes[2].chan_monitor.simple_monitor.monitors.lock().unwrap();
3319                 monitors.get_mut(&OutPoint::new(Sha256dHash::from(&payment_event.commitment_msg.channel_id[..]), 0)).unwrap()
3320                         .provide_payment_preimage(&our_payment_hash, &our_payment_preimage);
3321         }
3322         nodes[2].chain_monitor.block_connected_checked(&header, 1, &[&tx], &[1]);
3323         let node_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap();
3324         assert_eq!(node_txn.len(), 1);
3325         assert_eq!(node_txn[0].input.len(), 1);
3326         assert_eq!(node_txn[0].input[0].previous_output.txid, tx.txid());
3327         assert_eq!(node_txn[0].lock_time, 0); // Must be an HTLC-Success
3328         assert_eq!(node_txn[0].input[0].witness.len(), 5); // Must be an HTLC-Success
3329
3330         check_spends!(node_txn[0], tx);
3331 }
3332
3333 #[test]
3334 fn test_unconf_chan() {
3335         // After creating a chan between nodes, we disconnect all blocks previously seen to force a channel close on nodes[0] side
3336         let nodes = create_network(2);
3337         create_announced_chan_between_nodes(&nodes, 0, 1);
3338
3339         let channel_state = nodes[0].node.channel_state.lock().unwrap();
3340         assert_eq!(channel_state.by_id.len(), 1);
3341         assert_eq!(channel_state.short_to_id.len(), 1);
3342         mem::drop(channel_state);
3343
3344         let mut headers = Vec::new();
3345         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
3346         headers.push(header.clone());
3347         for _i in 2..100 {
3348                 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
3349                 headers.push(header.clone());
3350         }
3351         while !headers.is_empty() {
3352                 nodes[0].node.block_disconnected(&headers.pop().unwrap());
3353         }
3354         {
3355                 let events = nodes[0].node.get_and_clear_pending_msg_events();
3356                 assert_eq!(events.len(), 1);
3357                 match events[0] {
3358                         MessageSendEvent::BroadcastChannelUpdate { msg: msgs::ChannelUpdate { contents: msgs::UnsignedChannelUpdate { flags, .. }, .. } } => {
3359                                 assert_eq!(flags & 0b10, 0b10);
3360                         },
3361                         _ => panic!("Unexpected event"),
3362                 }
3363         }
3364         let channel_state = nodes[0].node.channel_state.lock().unwrap();
3365         assert_eq!(channel_state.by_id.len(), 0);
3366         assert_eq!(channel_state.short_to_id.len(), 0);
3367 }
3368
3369 macro_rules! get_chan_reestablish_msgs {
3370         ($src_node: expr, $dst_node: expr) => {
3371                 {
3372                         let mut res = Vec::with_capacity(1);
3373                         for msg in $src_node.node.get_and_clear_pending_msg_events() {
3374                                 if let MessageSendEvent::SendChannelReestablish { ref node_id, ref msg } = msg {
3375                                         assert_eq!(*node_id, $dst_node.node.get_our_node_id());
3376                                         res.push(msg.clone());
3377                                 } else {
3378                                         panic!("Unexpected event")
3379                                 }
3380                         }
3381                         res
3382                 }
3383         }
3384 }
3385
3386 macro_rules! handle_chan_reestablish_msgs {
3387         ($src_node: expr, $dst_node: expr) => {
3388                 {
3389                         let msg_events = $src_node.node.get_and_clear_pending_msg_events();
3390                         let mut idx = 0;
3391                         let funding_locked = if let Some(&MessageSendEvent::SendFundingLocked { ref node_id, ref msg }) = msg_events.get(0) {
3392                                 idx += 1;
3393                                 assert_eq!(*node_id, $dst_node.node.get_our_node_id());
3394                                 Some(msg.clone())
3395                         } else {
3396                                 None
3397                         };
3398
3399                         let mut revoke_and_ack = None;
3400                         let mut commitment_update = None;
3401                         let order = if let Some(ev) = msg_events.get(idx) {
3402                                 idx += 1;
3403                                 match ev {
3404                                         &MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
3405                                                 assert_eq!(*node_id, $dst_node.node.get_our_node_id());
3406                                                 revoke_and_ack = Some(msg.clone());
3407                                                 RAACommitmentOrder::RevokeAndACKFirst
3408                                         },
3409                                         &MessageSendEvent::UpdateHTLCs { ref node_id, ref updates } => {
3410                                                 assert_eq!(*node_id, $dst_node.node.get_our_node_id());
3411                                                 commitment_update = Some(updates.clone());
3412                                                 RAACommitmentOrder::CommitmentFirst
3413                                         },
3414                                         _ => panic!("Unexpected event"),
3415                                 }
3416                         } else {
3417                                 RAACommitmentOrder::CommitmentFirst
3418                         };
3419
3420                         if let Some(ev) = msg_events.get(idx) {
3421                                 match ev {
3422                                         &MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
3423                                                 assert_eq!(*node_id, $dst_node.node.get_our_node_id());
3424                                                 assert!(revoke_and_ack.is_none());
3425                                                 revoke_and_ack = Some(msg.clone());
3426                                         },
3427                                         &MessageSendEvent::UpdateHTLCs { ref node_id, ref updates } => {
3428                                                 assert_eq!(*node_id, $dst_node.node.get_our_node_id());
3429                                                 assert!(commitment_update.is_none());
3430                                                 commitment_update = Some(updates.clone());
3431                                         },
3432                                         _ => panic!("Unexpected event"),
3433                                 }
3434                         }
3435
3436                         (funding_locked, revoke_and_ack, commitment_update, order)
3437                 }
3438         }
3439 }
3440
3441 /// pending_htlc_adds includes both the holding cell and in-flight update_add_htlcs, whereas
3442 /// for claims/fails they are separated out.
3443 fn reconnect_nodes(node_a: &Node, node_b: &Node, 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)) {
3444         node_a.node.peer_connected(&node_b.node.get_our_node_id());
3445         let reestablish_1 = get_chan_reestablish_msgs!(node_a, node_b);
3446         node_b.node.peer_connected(&node_a.node.get_our_node_id());
3447         let reestablish_2 = get_chan_reestablish_msgs!(node_b, node_a);
3448
3449         if send_funding_locked.0 {
3450                 // If a expects a funding_locked, it better not think it has received a revoke_and_ack
3451                 // from b
3452                 for reestablish in reestablish_1.iter() {
3453                         assert_eq!(reestablish.next_remote_commitment_number, 0);
3454                 }
3455         }
3456         if send_funding_locked.1 {
3457                 // If b expects a funding_locked, it better not think it has received a revoke_and_ack
3458                 // from a
3459                 for reestablish in reestablish_2.iter() {
3460                         assert_eq!(reestablish.next_remote_commitment_number, 0);
3461                 }
3462         }
3463         if send_funding_locked.0 || send_funding_locked.1 {
3464                 // If we expect any funding_locked's, both sides better have set
3465                 // next_local_commitment_number to 1
3466                 for reestablish in reestablish_1.iter() {
3467                         assert_eq!(reestablish.next_local_commitment_number, 1);
3468                 }
3469                 for reestablish in reestablish_2.iter() {
3470                         assert_eq!(reestablish.next_local_commitment_number, 1);
3471                 }
3472         }
3473
3474         let mut resp_1 = Vec::new();
3475         for msg in reestablish_1 {
3476                 node_b.node.handle_channel_reestablish(&node_a.node.get_our_node_id(), &msg).unwrap();
3477                 resp_1.push(handle_chan_reestablish_msgs!(node_b, node_a));
3478         }
3479         if pending_cell_htlc_claims.0 != 0 || pending_cell_htlc_fails.0 != 0 {
3480                 check_added_monitors!(node_b, 1);
3481         } else {
3482                 check_added_monitors!(node_b, 0);
3483         }
3484
3485         let mut resp_2 = Vec::new();
3486         for msg in reestablish_2 {
3487                 node_a.node.handle_channel_reestablish(&node_b.node.get_our_node_id(), &msg).unwrap();
3488                 resp_2.push(handle_chan_reestablish_msgs!(node_a, node_b));
3489         }
3490         if pending_cell_htlc_claims.1 != 0 || pending_cell_htlc_fails.1 != 0 {
3491                 check_added_monitors!(node_a, 1);
3492         } else {
3493                 check_added_monitors!(node_a, 0);
3494         }
3495
3496         // We dont yet support both needing updates, as that would require a different commitment dance:
3497         assert!((pending_htlc_adds.0 == 0 && pending_htlc_claims.0 == 0 && pending_cell_htlc_claims.0 == 0 && pending_cell_htlc_fails.0 == 0) ||
3498                         (pending_htlc_adds.1 == 0 && pending_htlc_claims.1 == 0 && pending_cell_htlc_claims.1 == 0 && pending_cell_htlc_fails.1 == 0));
3499
3500         for chan_msgs in resp_1.drain(..) {
3501                 if send_funding_locked.0 {
3502                         node_a.node.handle_funding_locked(&node_b.node.get_our_node_id(), &chan_msgs.0.unwrap()).unwrap();
3503                         let announcement_event = node_a.node.get_and_clear_pending_msg_events();
3504                         if !announcement_event.is_empty() {
3505                                 assert_eq!(announcement_event.len(), 1);
3506                                 if let MessageSendEvent::SendAnnouncementSignatures { .. } = announcement_event[0] {
3507                                         //TODO: Test announcement_sigs re-sending
3508                                 } else { panic!("Unexpected event!"); }
3509                         }
3510                 } else {
3511                         assert!(chan_msgs.0.is_none());
3512                 }
3513                 if pending_raa.0 {
3514                         assert!(chan_msgs.3 == RAACommitmentOrder::RevokeAndACKFirst);
3515                         node_a.node.handle_revoke_and_ack(&node_b.node.get_our_node_id(), &chan_msgs.1.unwrap()).unwrap();
3516                         assert!(node_a.node.get_and_clear_pending_msg_events().is_empty());
3517                         check_added_monitors!(node_a, 1);
3518                 } else {
3519                         assert!(chan_msgs.1.is_none());
3520                 }
3521                 if pending_htlc_adds.0 != 0 || pending_htlc_claims.0 != 0 || pending_cell_htlc_claims.0 != 0 || pending_cell_htlc_fails.0 != 0 {
3522                         let commitment_update = chan_msgs.2.unwrap();
3523                         if pending_htlc_adds.0 != -1 { // We use -1 to denote a response commitment_signed
3524                                 assert_eq!(commitment_update.update_add_htlcs.len(), pending_htlc_adds.0 as usize);
3525                         } else {
3526                                 assert!(commitment_update.update_add_htlcs.is_empty());
3527                         }
3528                         assert_eq!(commitment_update.update_fulfill_htlcs.len(), pending_htlc_claims.0 + pending_cell_htlc_claims.0);
3529                         assert_eq!(commitment_update.update_fail_htlcs.len(), pending_cell_htlc_fails.0);
3530                         assert!(commitment_update.update_fail_malformed_htlcs.is_empty());
3531                         for update_add in commitment_update.update_add_htlcs {
3532                                 node_a.node.handle_update_add_htlc(&node_b.node.get_our_node_id(), &update_add).unwrap();
3533                         }
3534                         for update_fulfill in commitment_update.update_fulfill_htlcs {
3535                                 node_a.node.handle_update_fulfill_htlc(&node_b.node.get_our_node_id(), &update_fulfill).unwrap();
3536                         }
3537                         for update_fail in commitment_update.update_fail_htlcs {
3538                                 node_a.node.handle_update_fail_htlc(&node_b.node.get_our_node_id(), &update_fail).unwrap();
3539                         }
3540
3541                         if pending_htlc_adds.0 != -1 { // We use -1 to denote a response commitment_signed
3542                                 commitment_signed_dance!(node_a, node_b, commitment_update.commitment_signed, false);
3543                         } else {
3544                                 node_a.node.handle_commitment_signed(&node_b.node.get_our_node_id(), &commitment_update.commitment_signed).unwrap();
3545                                 check_added_monitors!(node_a, 1);
3546                                 let as_revoke_and_ack = get_event_msg!(node_a, MessageSendEvent::SendRevokeAndACK, node_b.node.get_our_node_id());
3547                                 // No commitment_signed so get_event_msg's assert(len == 1) passes
3548                                 node_b.node.handle_revoke_and_ack(&node_a.node.get_our_node_id(), &as_revoke_and_ack).unwrap();
3549                                 assert!(node_b.node.get_and_clear_pending_msg_events().is_empty());
3550                                 check_added_monitors!(node_b, 1);
3551                         }
3552                 } else {
3553                         assert!(chan_msgs.2.is_none());
3554                 }
3555         }
3556
3557         for chan_msgs in resp_2.drain(..) {
3558                 if send_funding_locked.1 {
3559                         node_b.node.handle_funding_locked(&node_a.node.get_our_node_id(), &chan_msgs.0.unwrap()).unwrap();
3560                         let announcement_event = node_b.node.get_and_clear_pending_msg_events();
3561                         if !announcement_event.is_empty() {
3562                                 assert_eq!(announcement_event.len(), 1);
3563                                 if let MessageSendEvent::SendAnnouncementSignatures { .. } = announcement_event[0] {
3564                                         //TODO: Test announcement_sigs re-sending
3565                                 } else { panic!("Unexpected event!"); }
3566                         }
3567                 } else {
3568                         assert!(chan_msgs.0.is_none());
3569                 }
3570                 if pending_raa.1 {
3571                         assert!(chan_msgs.3 == RAACommitmentOrder::RevokeAndACKFirst);
3572                         node_b.node.handle_revoke_and_ack(&node_a.node.get_our_node_id(), &chan_msgs.1.unwrap()).unwrap();
3573                         assert!(node_b.node.get_and_clear_pending_msg_events().is_empty());
3574                         check_added_monitors!(node_b, 1);
3575                 } else {
3576                         assert!(chan_msgs.1.is_none());
3577                 }
3578                 if pending_htlc_adds.1 != 0 || pending_htlc_claims.1 != 0 || pending_cell_htlc_claims.1 != 0 || pending_cell_htlc_fails.1 != 0 {
3579                         let commitment_update = chan_msgs.2.unwrap();
3580                         if pending_htlc_adds.1 != -1 { // We use -1 to denote a response commitment_signed
3581                                 assert_eq!(commitment_update.update_add_htlcs.len(), pending_htlc_adds.1 as usize);
3582                         }
3583                         assert_eq!(commitment_update.update_fulfill_htlcs.len(), pending_htlc_claims.0 + pending_cell_htlc_claims.0);
3584                         assert_eq!(commitment_update.update_fail_htlcs.len(), pending_cell_htlc_fails.0);
3585                         assert!(commitment_update.update_fail_malformed_htlcs.is_empty());
3586                         for update_add in commitment_update.update_add_htlcs {
3587                                 node_b.node.handle_update_add_htlc(&node_a.node.get_our_node_id(), &update_add).unwrap();
3588                         }
3589                         for update_fulfill in commitment_update.update_fulfill_htlcs {
3590                                 node_b.node.handle_update_fulfill_htlc(&node_a.node.get_our_node_id(), &update_fulfill).unwrap();
3591                         }
3592                         for update_fail in commitment_update.update_fail_htlcs {
3593                                 node_b.node.handle_update_fail_htlc(&node_a.node.get_our_node_id(), &update_fail).unwrap();
3594                         }
3595
3596                         if pending_htlc_adds.1 != -1 { // We use -1 to denote a response commitment_signed
3597                                 commitment_signed_dance!(node_b, node_a, commitment_update.commitment_signed, false);
3598                         } else {
3599                                 node_b.node.handle_commitment_signed(&node_a.node.get_our_node_id(), &commitment_update.commitment_signed).unwrap();
3600                                 check_added_monitors!(node_b, 1);
3601                                 let bs_revoke_and_ack = get_event_msg!(node_b, MessageSendEvent::SendRevokeAndACK, node_a.node.get_our_node_id());
3602                                 // No commitment_signed so get_event_msg's assert(len == 1) passes
3603                                 node_a.node.handle_revoke_and_ack(&node_b.node.get_our_node_id(), &bs_revoke_and_ack).unwrap();
3604                                 assert!(node_a.node.get_and_clear_pending_msg_events().is_empty());
3605                                 check_added_monitors!(node_a, 1);
3606                         }
3607                 } else {
3608                         assert!(chan_msgs.2.is_none());
3609                 }
3610         }
3611 }
3612
3613 #[test]
3614 fn test_simple_peer_disconnect() {
3615         // Test that we can reconnect when there are no lost messages
3616         let nodes = create_network(3);
3617         create_announced_chan_between_nodes(&nodes, 0, 1);
3618         create_announced_chan_between_nodes(&nodes, 1, 2);
3619
3620         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3621         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3622         reconnect_nodes(&nodes[0], &nodes[1], (true, true), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3623
3624         let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).0;
3625         let payment_hash_2 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).1;
3626         fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_hash_2);
3627         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_1);
3628
3629         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3630         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3631         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3632
3633         let payment_preimage_3 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).0;
3634         let payment_preimage_4 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).0;
3635         let payment_hash_5 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).1;
3636         let payment_hash_6 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).1;
3637
3638         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3639         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3640
3641         claim_payment_along_route(&nodes[0], &vec!(&nodes[1], &nodes[2]), true, payment_preimage_3);
3642         fail_payment_along_route(&nodes[0], &[&nodes[1], &nodes[2]], true, payment_hash_5);
3643
3644         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (1, 0), (1, 0), (false, false));
3645         {
3646                 let events = nodes[0].node.get_and_clear_pending_events();
3647                 assert_eq!(events.len(), 2);
3648                 match events[0] {
3649                         Event::PaymentSent { payment_preimage } => {
3650                                 assert_eq!(payment_preimage, payment_preimage_3);
3651                         },
3652                         _ => panic!("Unexpected event"),
3653                 }
3654                 match events[1] {
3655                         Event::PaymentFailed { payment_hash, rejected_by_dest, .. } => {
3656                                 assert_eq!(payment_hash, payment_hash_5);
3657                                 assert!(rejected_by_dest);
3658                         },
3659                         _ => panic!("Unexpected event"),
3660                 }
3661         }
3662
3663         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_4);
3664         fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_hash_6);
3665 }
3666
3667 fn do_test_drop_messages_peer_disconnect(messages_delivered: u8) {
3668         // Test that we can reconnect when in-flight HTLC updates get dropped
3669         let mut nodes = create_network(2);
3670         if messages_delivered == 0 {
3671                 create_chan_between_nodes_with_value_a(&nodes[0], &nodes[1], 100000, 10001);
3672                 // nodes[1] doesn't receive the funding_locked message (it'll be re-sent on reconnect)
3673         } else {
3674                 create_announced_chan_between_nodes(&nodes, 0, 1);
3675         }
3676
3677         let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), Some(&nodes[0].node.list_usable_channels()), &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
3678         let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
3679
3680         let payment_event = {
3681                 nodes[0].node.send_payment(route.clone(), payment_hash_1).unwrap();
3682                 check_added_monitors!(nodes[0], 1);
3683
3684                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
3685                 assert_eq!(events.len(), 1);
3686                 SendEvent::from_event(events.remove(0))
3687         };
3688         assert_eq!(nodes[1].node.get_our_node_id(), payment_event.node_id);
3689
3690         if messages_delivered < 2 {
3691                 // Drop the payment_event messages, and let them get re-generated in reconnect_nodes!
3692         } else {
3693                 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]).unwrap();
3694                 if messages_delivered >= 3 {
3695                         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event.commitment_msg).unwrap();
3696                         check_added_monitors!(nodes[1], 1);
3697                         let (bs_revoke_and_ack, bs_commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
3698
3699                         if messages_delivered >= 4 {
3700                                 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack).unwrap();
3701                                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
3702                                 check_added_monitors!(nodes[0], 1);
3703
3704                                 if messages_delivered >= 5 {
3705                                         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_commitment_signed).unwrap();
3706                                         let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
3707                                         // No commitment_signed so get_event_msg's assert(len == 1) passes
3708                                         check_added_monitors!(nodes[0], 1);
3709
3710                                         if messages_delivered >= 6 {
3711                                                 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_and_ack).unwrap();
3712                                                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
3713                                                 check_added_monitors!(nodes[1], 1);
3714                                         }
3715                                 }
3716                         }
3717                 }
3718         }
3719
3720         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3721         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3722         if messages_delivered < 3 {
3723                 // Even if the funding_locked messages get exchanged, as long as nothing further was
3724                 // received on either side, both sides will need to resend them.
3725                 reconnect_nodes(&nodes[0], &nodes[1], (true, true), (0, 1), (0, 0), (0, 0), (0, 0), (false, false));
3726         } else if messages_delivered == 3 {
3727                 // nodes[0] still wants its RAA + commitment_signed
3728                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (-1, 0), (0, 0), (0, 0), (0, 0), (true, false));
3729         } else if messages_delivered == 4 {
3730                 // nodes[0] still wants its commitment_signed
3731                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (-1, 0), (0, 0), (0, 0), (0, 0), (false, false));
3732         } else if messages_delivered == 5 {
3733                 // nodes[1] still wants its final RAA
3734                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, true));
3735         } else if messages_delivered == 6 {
3736                 // Everything was delivered...
3737                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3738         }
3739
3740         let events_1 = nodes[1].node.get_and_clear_pending_events();
3741         assert_eq!(events_1.len(), 1);
3742         match events_1[0] {
3743                 Event::PendingHTLCsForwardable { .. } => { },
3744                 _ => panic!("Unexpected event"),
3745         };
3746
3747         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3748         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3749         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3750
3751         nodes[1].node.channel_state.lock().unwrap().next_forward = Instant::now();
3752         nodes[1].node.process_pending_htlc_forwards();
3753
3754         let events_2 = nodes[1].node.get_and_clear_pending_events();
3755         assert_eq!(events_2.len(), 1);
3756         match events_2[0] {
3757                 Event::PaymentReceived { ref payment_hash, amt } => {
3758                         assert_eq!(payment_hash_1, *payment_hash);
3759                         assert_eq!(amt, 1000000);
3760                 },
3761                 _ => panic!("Unexpected event"),
3762         }
3763
3764         nodes[1].node.claim_funds(payment_preimage_1);
3765         check_added_monitors!(nodes[1], 1);
3766
3767         let events_3 = nodes[1].node.get_and_clear_pending_msg_events();
3768         assert_eq!(events_3.len(), 1);
3769         let (update_fulfill_htlc, commitment_signed) = match events_3[0] {
3770                 MessageSendEvent::UpdateHTLCs { ref node_id, ref updates } => {
3771                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
3772                         assert!(updates.update_add_htlcs.is_empty());
3773                         assert!(updates.update_fail_htlcs.is_empty());
3774                         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
3775                         assert!(updates.update_fail_malformed_htlcs.is_empty());
3776                         assert!(updates.update_fee.is_none());
3777                         (updates.update_fulfill_htlcs[0].clone(), updates.commitment_signed.clone())
3778                 },
3779                 _ => panic!("Unexpected event"),
3780         };
3781
3782         if messages_delivered >= 1 {
3783                 nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_htlc).unwrap();
3784
3785                 let events_4 = nodes[0].node.get_and_clear_pending_events();
3786                 assert_eq!(events_4.len(), 1);
3787                 match events_4[0] {
3788                         Event::PaymentSent { ref payment_preimage } => {
3789                                 assert_eq!(payment_preimage_1, *payment_preimage);
3790                         },
3791                         _ => panic!("Unexpected event"),
3792                 }
3793
3794                 if messages_delivered >= 2 {
3795                         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_signed).unwrap();
3796                         check_added_monitors!(nodes[0], 1);
3797                         let (as_revoke_and_ack, as_commitment_signed) = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
3798
3799                         if messages_delivered >= 3 {
3800                                 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_and_ack).unwrap();
3801                                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
3802                                 check_added_monitors!(nodes[1], 1);
3803
3804                                 if messages_delivered >= 4 {
3805                                         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_commitment_signed).unwrap();
3806                                         let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
3807                                         // No commitment_signed so get_event_msg's assert(len == 1) passes
3808                                         check_added_monitors!(nodes[1], 1);
3809
3810                                         if messages_delivered >= 5 {
3811                                                 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack).unwrap();
3812                                                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
3813                                                 check_added_monitors!(nodes[0], 1);
3814                                         }
3815                                 }
3816                         }
3817                 }
3818         }
3819
3820         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3821         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3822         if messages_delivered < 2 {
3823                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (1, 0), (0, 0), (0, 0), (false, false));
3824                 //TODO: Deduplicate PaymentSent events, then enable this if:
3825                 //if messages_delivered < 1 {
3826                         let events_4 = nodes[0].node.get_and_clear_pending_events();
3827                         assert_eq!(events_4.len(), 1);
3828                         match events_4[0] {
3829                                 Event::PaymentSent { ref payment_preimage } => {
3830                                         assert_eq!(payment_preimage_1, *payment_preimage);
3831                                 },
3832                                 _ => panic!("Unexpected event"),
3833                         }
3834                 //}
3835         } else if messages_delivered == 2 {
3836                 // nodes[0] still wants its RAA + commitment_signed
3837                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, -1), (0, 0), (0, 0), (0, 0), (false, true));
3838         } else if messages_delivered == 3 {
3839                 // nodes[0] still wants its commitment_signed
3840                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, -1), (0, 0), (0, 0), (0, 0), (false, false));
3841         } else if messages_delivered == 4 {
3842                 // nodes[1] still wants its final RAA
3843                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (true, false));
3844         } else if messages_delivered == 5 {
3845                 // Everything was delivered...
3846                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3847         }
3848
3849         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3850         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3851         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3852
3853         // Channel should still work fine...
3854         let payment_preimage_2 = send_along_route(&nodes[0], route, &[&nodes[1]], 1000000).0;
3855         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
3856 }
3857
3858 #[test]
3859 fn test_drop_messages_peer_disconnect_a() {
3860         do_test_drop_messages_peer_disconnect(0);
3861         do_test_drop_messages_peer_disconnect(1);
3862         do_test_drop_messages_peer_disconnect(2);
3863         do_test_drop_messages_peer_disconnect(3);
3864 }
3865
3866 #[test]
3867 fn test_drop_messages_peer_disconnect_b() {
3868         do_test_drop_messages_peer_disconnect(4);
3869         do_test_drop_messages_peer_disconnect(5);
3870         do_test_drop_messages_peer_disconnect(6);
3871 }
3872
3873 #[test]
3874 fn test_funding_peer_disconnect() {
3875         // Test that we can lock in our funding tx while disconnected
3876         let nodes = create_network(2);
3877         let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001);
3878
3879         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3880         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3881
3882         confirm_transaction(&nodes[0].chain_monitor, &tx, tx.version);
3883         let events_1 = nodes[0].node.get_and_clear_pending_msg_events();
3884         assert_eq!(events_1.len(), 1);
3885         match events_1[0] {
3886                 MessageSendEvent::SendFundingLocked { ref node_id, msg: _ } => {
3887                         assert_eq!(*node_id, nodes[1].node.get_our_node_id());
3888                 },
3889                 _ => panic!("Unexpected event"),
3890         }
3891
3892         reconnect_nodes(&nodes[0], &nodes[1], (false, true), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3893
3894         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3895         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3896
3897         confirm_transaction(&nodes[1].chain_monitor, &tx, tx.version);
3898         let events_2 = nodes[1].node.get_and_clear_pending_msg_events();
3899         assert_eq!(events_2.len(), 2);
3900         match events_2[0] {
3901                 MessageSendEvent::SendFundingLocked { ref node_id, msg: _ } => {
3902                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
3903                 },
3904                 _ => panic!("Unexpected event"),
3905         }
3906         match events_2[1] {
3907                 MessageSendEvent::SendAnnouncementSignatures { ref node_id, msg: _ } => {
3908                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
3909                 },
3910                 _ => panic!("Unexpected event"),
3911         }
3912
3913         reconnect_nodes(&nodes[0], &nodes[1], (true, true), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3914
3915         // TODO: We shouldn't need to manually pass list_usable_chanels here once we support
3916         // rebroadcasting announcement_signatures upon reconnect.
3917
3918         let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), Some(&nodes[0].node.list_usable_channels()), &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
3919         let (payment_preimage, _) = send_along_route(&nodes[0], route, &[&nodes[1]], 1000000);
3920         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
3921 }
3922
3923 #[test]
3924 fn test_drop_messages_peer_disconnect_dual_htlc() {
3925         // Test that we can handle reconnecting when both sides of a channel have pending
3926         // commitment_updates when we disconnect.
3927         let mut nodes = create_network(2);
3928         create_announced_chan_between_nodes(&nodes, 0, 1);
3929
3930         let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
3931
3932         // Now try to send a second payment which will fail to send
3933         let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
3934         let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
3935
3936         nodes[0].node.send_payment(route.clone(), payment_hash_2).unwrap();
3937         check_added_monitors!(nodes[0], 1);
3938
3939         let events_1 = nodes[0].node.get_and_clear_pending_msg_events();
3940         assert_eq!(events_1.len(), 1);
3941         match events_1[0] {
3942                 MessageSendEvent::UpdateHTLCs { .. } => {},
3943                 _ => panic!("Unexpected event"),
3944         }
3945
3946         assert!(nodes[1].node.claim_funds(payment_preimage_1));
3947         check_added_monitors!(nodes[1], 1);
3948
3949         let events_2 = nodes[1].node.get_and_clear_pending_msg_events();
3950         assert_eq!(events_2.len(), 1);
3951         match events_2[0] {
3952                 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 } } => {
3953                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
3954                         assert!(update_add_htlcs.is_empty());
3955                         assert_eq!(update_fulfill_htlcs.len(), 1);
3956                         assert!(update_fail_htlcs.is_empty());
3957                         assert!(update_fail_malformed_htlcs.is_empty());
3958                         assert!(update_fee.is_none());
3959
3960                         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_htlcs[0]).unwrap();
3961                         let events_3 = nodes[0].node.get_and_clear_pending_events();
3962                         assert_eq!(events_3.len(), 1);
3963                         match events_3[0] {
3964                                 Event::PaymentSent { ref payment_preimage } => {
3965                                         assert_eq!(*payment_preimage, payment_preimage_1);
3966                                 },
3967                                 _ => panic!("Unexpected event"),
3968                         }
3969
3970                         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), commitment_signed).unwrap();
3971                         let _ = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
3972                         // No commitment_signed so get_event_msg's assert(len == 1) passes
3973                         check_added_monitors!(nodes[0], 1);
3974                 },
3975                 _ => panic!("Unexpected event"),
3976         }
3977
3978         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3979         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3980
3981         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id());
3982         let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
3983         assert_eq!(reestablish_1.len(), 1);
3984         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id());
3985         let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
3986         assert_eq!(reestablish_2.len(), 1);
3987
3988         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]).unwrap();
3989         let as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
3990         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]).unwrap();
3991         let bs_resp = handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
3992
3993         assert!(as_resp.0.is_none());
3994         assert!(bs_resp.0.is_none());
3995
3996         assert!(bs_resp.1.is_none());
3997         assert!(bs_resp.2.is_none());
3998
3999         assert!(as_resp.3 == RAACommitmentOrder::CommitmentFirst);
4000
4001         assert_eq!(as_resp.2.as_ref().unwrap().update_add_htlcs.len(), 1);
4002         assert!(as_resp.2.as_ref().unwrap().update_fulfill_htlcs.is_empty());
4003         assert!(as_resp.2.as_ref().unwrap().update_fail_htlcs.is_empty());
4004         assert!(as_resp.2.as_ref().unwrap().update_fail_malformed_htlcs.is_empty());
4005         assert!(as_resp.2.as_ref().unwrap().update_fee.is_none());
4006         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &as_resp.2.as_ref().unwrap().update_add_htlcs[0]).unwrap();
4007         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_resp.2.as_ref().unwrap().commitment_signed).unwrap();
4008         let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
4009         // No commitment_signed so get_event_msg's assert(len == 1) passes
4010         check_added_monitors!(nodes[1], 1);
4011
4012         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), as_resp.1.as_ref().unwrap()).unwrap();
4013         let bs_second_commitment_signed = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
4014         assert!(bs_second_commitment_signed.update_add_htlcs.is_empty());
4015         assert!(bs_second_commitment_signed.update_fulfill_htlcs.is_empty());
4016         assert!(bs_second_commitment_signed.update_fail_htlcs.is_empty());
4017         assert!(bs_second_commitment_signed.update_fail_malformed_htlcs.is_empty());
4018         assert!(bs_second_commitment_signed.update_fee.is_none());
4019         check_added_monitors!(nodes[1], 1);
4020
4021         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack).unwrap();
4022         let as_commitment_signed = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
4023         assert!(as_commitment_signed.update_add_htlcs.is_empty());
4024         assert!(as_commitment_signed.update_fulfill_htlcs.is_empty());
4025         assert!(as_commitment_signed.update_fail_htlcs.is_empty());
4026         assert!(as_commitment_signed.update_fail_malformed_htlcs.is_empty());
4027         assert!(as_commitment_signed.update_fee.is_none());
4028         check_added_monitors!(nodes[0], 1);
4029
4030         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_second_commitment_signed.commitment_signed).unwrap();
4031         let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
4032         // No commitment_signed so get_event_msg's assert(len == 1) passes
4033         check_added_monitors!(nodes[0], 1);
4034
4035         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_commitment_signed.commitment_signed).unwrap();
4036         let bs_second_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
4037         // No commitment_signed so get_event_msg's assert(len == 1) passes
4038         check_added_monitors!(nodes[1], 1);
4039
4040         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_and_ack).unwrap();
4041         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4042         check_added_monitors!(nodes[1], 1);
4043
4044         expect_pending_htlcs_forwardable!(nodes[1]);
4045
4046         let events_5 = nodes[1].node.get_and_clear_pending_events();
4047         assert_eq!(events_5.len(), 1);
4048         match events_5[0] {
4049                 Event::PaymentReceived { ref payment_hash, amt: _ } => {
4050                         assert_eq!(payment_hash_2, *payment_hash);
4051                 },
4052                 _ => panic!("Unexpected event"),
4053         }
4054
4055         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_second_revoke_and_ack).unwrap();
4056         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
4057         check_added_monitors!(nodes[0], 1);
4058
4059         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
4060 }
4061
4062 #[test]
4063 fn test_simple_monitor_permanent_update_fail() {
4064         // Test that we handle a simple permanent monitor update failure
4065         let mut nodes = create_network(2);
4066         create_announced_chan_between_nodes(&nodes, 0, 1);
4067
4068         let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
4069         let (_, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
4070
4071         *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::PermanentFailure);
4072         if let Err(APIError::ChannelUnavailable {..}) = nodes[0].node.send_payment(route, payment_hash_1) {} else { panic!(); }
4073         check_added_monitors!(nodes[0], 1);
4074
4075         let events_1 = nodes[0].node.get_and_clear_pending_msg_events();
4076         assert_eq!(events_1.len(), 2);
4077         match events_1[0] {
4078                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
4079                 _ => panic!("Unexpected event"),
4080         };
4081         match events_1[1] {
4082                 MessageSendEvent::HandleError { node_id, .. } => assert_eq!(node_id, nodes[1].node.get_our_node_id()),
4083                 _ => panic!("Unexpected event"),
4084         };
4085
4086         // TODO: Once we hit the chain with the failure transaction we should check that we get a
4087         // PaymentFailed event
4088
4089         assert_eq!(nodes[0].node.list_channels().len(), 0);
4090 }
4091
4092 fn do_test_simple_monitor_temporary_update_fail(disconnect: bool) {
4093         // Test that we can recover from a simple temporary monitor update failure optionally with
4094         // a disconnect in between
4095         let mut nodes = create_network(2);
4096         create_announced_chan_between_nodes(&nodes, 0, 1);
4097
4098         let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
4099         let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
4100
4101         *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
4102         if let Err(APIError::MonitorUpdateFailed) = nodes[0].node.send_payment(route.clone(), payment_hash_1) {} else { panic!(); }
4103         check_added_monitors!(nodes[0], 1);
4104
4105         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
4106         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
4107         assert_eq!(nodes[0].node.list_channels().len(), 1);
4108
4109         if disconnect {
4110                 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
4111                 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4112                 reconnect_nodes(&nodes[0], &nodes[1], (true, true), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
4113         }
4114
4115         *nodes[0].chan_monitor.update_ret.lock().unwrap() = Ok(());
4116         nodes[0].node.test_restore_channel_monitor();
4117         check_added_monitors!(nodes[0], 1);
4118
4119         let mut events_2 = nodes[0].node.get_and_clear_pending_msg_events();
4120         assert_eq!(events_2.len(), 1);
4121         let payment_event = SendEvent::from_event(events_2.pop().unwrap());
4122         assert_eq!(payment_event.node_id, nodes[1].node.get_our_node_id());
4123         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]).unwrap();
4124         commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
4125
4126         expect_pending_htlcs_forwardable!(nodes[1]);
4127
4128         let events_3 = nodes[1].node.get_and_clear_pending_events();
4129         assert_eq!(events_3.len(), 1);
4130         match events_3[0] {
4131                 Event::PaymentReceived { ref payment_hash, amt } => {
4132                         assert_eq!(payment_hash_1, *payment_hash);
4133                         assert_eq!(amt, 1000000);
4134                 },
4135                 _ => panic!("Unexpected event"),
4136         }
4137
4138         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1);
4139
4140         // Now set it to failed again...
4141         let (_, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
4142         *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
4143         if let Err(APIError::MonitorUpdateFailed) = nodes[0].node.send_payment(route, payment_hash_2) {} else { panic!(); }
4144         check_added_monitors!(nodes[0], 1);
4145
4146         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
4147         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
4148         assert_eq!(nodes[0].node.list_channels().len(), 1);
4149
4150         if disconnect {
4151                 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
4152                 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4153                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
4154         }
4155
4156         // ...and make sure we can force-close a TemporaryFailure channel with a PermanentFailure
4157         *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::PermanentFailure);
4158         nodes[0].node.test_restore_channel_monitor();
4159         check_added_monitors!(nodes[0], 1);
4160
4161         let events_5 = nodes[0].node.get_and_clear_pending_msg_events();
4162         assert_eq!(events_5.len(), 1);
4163         match events_5[0] {
4164                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
4165                 _ => panic!("Unexpected event"),
4166         }
4167
4168         // TODO: Once we hit the chain with the failure transaction we should check that we get a
4169         // PaymentFailed event
4170
4171         assert_eq!(nodes[0].node.list_channels().len(), 0);
4172 }
4173
4174 #[test]
4175 fn test_simple_monitor_temporary_update_fail() {
4176         do_test_simple_monitor_temporary_update_fail(false);
4177         do_test_simple_monitor_temporary_update_fail(true);
4178 }
4179
4180 fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
4181         let disconnect_flags = 8 | 16;
4182
4183         // Test that we can recover from a temporary monitor update failure with some in-flight
4184         // HTLCs going on at the same time potentially with some disconnection thrown in.
4185         // * First we route a payment, then get a temporary monitor update failure when trying to
4186         //   route a second payment. We then claim the first payment.
4187         // * If disconnect_count is set, we will disconnect at this point (which is likely as
4188         //   TemporaryFailure likely indicates net disconnect which resulted in failing to update
4189         //   the ChannelMonitor on a watchtower).
4190         // * If !(disconnect_count & 16) we deliver a update_fulfill_htlc/CS for the first payment
4191         //   immediately, otherwise we wait sconnect and deliver them via the reconnect
4192         //   channel_reestablish processing (ie disconnect_count & 16 makes no sense if
4193         //   disconnect_count & !disconnect_flags is 0).
4194         // * We then update the channel monitor, reconnecting if disconnect_count is set and walk
4195         //   through message sending, potentially disconnect/reconnecting multiple times based on
4196         //   disconnect_count, to get the update_fulfill_htlc through.
4197         // * We then walk through more message exchanges to get the original update_add_htlc
4198         //   through, swapping message ordering based on disconnect_count & 8 and optionally
4199         //   disconnect/reconnecting based on disconnect_count.
4200         let mut nodes = create_network(2);
4201         create_announced_chan_between_nodes(&nodes, 0, 1);
4202
4203         let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
4204
4205         // Now try to send a second payment which will fail to send
4206         let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
4207         let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
4208
4209         *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
4210         if let Err(APIError::MonitorUpdateFailed) = nodes[0].node.send_payment(route.clone(), payment_hash_2) {} else { panic!(); }
4211         check_added_monitors!(nodes[0], 1);
4212
4213         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
4214         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
4215         assert_eq!(nodes[0].node.list_channels().len(), 1);
4216
4217         // Claim the previous payment, which will result in a update_fulfill_htlc/CS from nodes[1]
4218         // but nodes[0] won't respond since it is frozen.
4219         assert!(nodes[1].node.claim_funds(payment_preimage_1));
4220         check_added_monitors!(nodes[1], 1);
4221         let events_2 = nodes[1].node.get_and_clear_pending_msg_events();
4222         assert_eq!(events_2.len(), 1);
4223         let (bs_initial_fulfill, bs_initial_commitment_signed) = match events_2[0] {
4224                 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 } } => {
4225                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
4226                         assert!(update_add_htlcs.is_empty());
4227                         assert_eq!(update_fulfill_htlcs.len(), 1);
4228                         assert!(update_fail_htlcs.is_empty());
4229                         assert!(update_fail_malformed_htlcs.is_empty());
4230                         assert!(update_fee.is_none());
4231
4232                         if (disconnect_count & 16) == 0 {
4233                                 nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_htlcs[0]).unwrap();
4234                                 let events_3 = nodes[0].node.get_and_clear_pending_events();
4235                                 assert_eq!(events_3.len(), 1);
4236                                 match events_3[0] {
4237                                         Event::PaymentSent { ref payment_preimage } => {
4238                                                 assert_eq!(*payment_preimage, payment_preimage_1);
4239                                         },
4240                                         _ => panic!("Unexpected event"),
4241                                 }
4242
4243                                 if let Err(msgs::HandleError{err, action: Some(msgs::ErrorAction::IgnoreError) }) = nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), commitment_signed) {
4244                                         assert_eq!(err, "Previous monitor update failure prevented generation of RAA");
4245                                 } else { panic!(); }
4246                         }
4247
4248                         (update_fulfill_htlcs[0].clone(), commitment_signed.clone())
4249                 },
4250                 _ => panic!("Unexpected event"),
4251         };
4252
4253         if disconnect_count & !disconnect_flags > 0 {
4254                 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
4255                 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4256         }
4257
4258         // Now fix monitor updating...
4259         *nodes[0].chan_monitor.update_ret.lock().unwrap() = Ok(());
4260         nodes[0].node.test_restore_channel_monitor();
4261         check_added_monitors!(nodes[0], 1);
4262
4263         macro_rules! disconnect_reconnect_peers { () => { {
4264                 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
4265                 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4266
4267                 nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id());
4268                 let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
4269                 assert_eq!(reestablish_1.len(), 1);
4270                 nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id());
4271                 let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
4272                 assert_eq!(reestablish_2.len(), 1);
4273
4274                 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]).unwrap();
4275                 let as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
4276                 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]).unwrap();
4277                 let bs_resp = handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
4278
4279                 assert!(as_resp.0.is_none());
4280                 assert!(bs_resp.0.is_none());
4281
4282                 (reestablish_1, reestablish_2, as_resp, bs_resp)
4283         } } }
4284
4285         let (payment_event, initial_revoke_and_ack) = if disconnect_count & !disconnect_flags > 0 {
4286                 assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
4287                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
4288
4289                 nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id());
4290                 let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
4291                 assert_eq!(reestablish_1.len(), 1);
4292                 nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id());
4293                 let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
4294                 assert_eq!(reestablish_2.len(), 1);
4295
4296                 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]).unwrap();
4297                 check_added_monitors!(nodes[0], 0);
4298                 let mut as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
4299                 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]).unwrap();
4300                 check_added_monitors!(nodes[1], 0);
4301                 let mut bs_resp = handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
4302
4303                 assert!(as_resp.0.is_none());
4304                 assert!(bs_resp.0.is_none());
4305
4306                 assert!(bs_resp.1.is_none());
4307                 if (disconnect_count & 16) == 0 {
4308                         assert!(bs_resp.2.is_none());
4309
4310                         assert!(as_resp.1.is_some());
4311                         assert!(as_resp.2.is_some());
4312                         assert!(as_resp.3 == RAACommitmentOrder::CommitmentFirst);
4313                 } else {
4314                         assert!(bs_resp.2.as_ref().unwrap().update_add_htlcs.is_empty());
4315                         assert!(bs_resp.2.as_ref().unwrap().update_fail_htlcs.is_empty());
4316                         assert!(bs_resp.2.as_ref().unwrap().update_fail_malformed_htlcs.is_empty());
4317                         assert!(bs_resp.2.as_ref().unwrap().update_fee.is_none());
4318                         assert!(bs_resp.2.as_ref().unwrap().update_fulfill_htlcs == vec![bs_initial_fulfill]);
4319                         assert!(bs_resp.2.as_ref().unwrap().commitment_signed == bs_initial_commitment_signed);
4320
4321                         assert!(as_resp.1.is_none());
4322
4323                         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &bs_resp.2.as_ref().unwrap().update_fulfill_htlcs[0]).unwrap();
4324                         let events_3 = nodes[0].node.get_and_clear_pending_events();
4325                         assert_eq!(events_3.len(), 1);
4326                         match events_3[0] {
4327                                 Event::PaymentSent { ref payment_preimage } => {
4328                                         assert_eq!(*payment_preimage, payment_preimage_1);
4329                                 },
4330                                 _ => panic!("Unexpected event"),
4331                         }
4332
4333                         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_resp.2.as_ref().unwrap().commitment_signed).unwrap();
4334                         let as_resp_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
4335                         // No commitment_signed so get_event_msg's assert(len == 1) passes
4336                         check_added_monitors!(nodes[0], 1);
4337
4338                         as_resp.1 = Some(as_resp_raa);
4339                         bs_resp.2 = None;
4340                 }
4341
4342                 if disconnect_count & !disconnect_flags > 1 {
4343                         let (second_reestablish_1, second_reestablish_2, second_as_resp, second_bs_resp) = disconnect_reconnect_peers!();
4344
4345                         if (disconnect_count & 16) == 0 {
4346                                 assert!(reestablish_1 == second_reestablish_1);
4347                                 assert!(reestablish_2 == second_reestablish_2);
4348                         }
4349                         assert!(as_resp == second_as_resp);
4350                         assert!(bs_resp == second_bs_resp);
4351                 }
4352
4353                 (SendEvent::from_commitment_update(nodes[1].node.get_our_node_id(), as_resp.2.unwrap()), as_resp.1.unwrap())
4354         } else {
4355                 let mut events_4 = nodes[0].node.get_and_clear_pending_msg_events();
4356                 assert_eq!(events_4.len(), 2);
4357                 (SendEvent::from_event(events_4.remove(0)), match events_4[0] {
4358                         MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
4359                                 assert_eq!(*node_id, nodes[1].node.get_our_node_id());
4360                                 msg.clone()
4361                         },
4362                         _ => panic!("Unexpected event"),
4363                 })
4364         };
4365
4366         assert_eq!(payment_event.node_id, nodes[1].node.get_our_node_id());
4367
4368         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]).unwrap();
4369         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event.commitment_msg).unwrap();
4370         let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
4371         // nodes[1] is awaiting an RAA from nodes[0] still so get_event_msg's assert(len == 1) passes
4372         check_added_monitors!(nodes[1], 1);
4373
4374         if disconnect_count & !disconnect_flags > 2 {
4375                 let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!();
4376
4377                 assert!(as_resp.1.unwrap() == initial_revoke_and_ack);
4378                 assert!(bs_resp.1.unwrap() == bs_revoke_and_ack);
4379
4380                 assert!(as_resp.2.is_none());
4381                 assert!(bs_resp.2.is_none());
4382         }
4383
4384         let as_commitment_update;
4385         let bs_second_commitment_update;
4386
4387         macro_rules! handle_bs_raa { () => {
4388                 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack).unwrap();
4389                 as_commitment_update = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
4390                 assert!(as_commitment_update.update_add_htlcs.is_empty());
4391                 assert!(as_commitment_update.update_fulfill_htlcs.is_empty());
4392                 assert!(as_commitment_update.update_fail_htlcs.is_empty());
4393                 assert!(as_commitment_update.update_fail_malformed_htlcs.is_empty());
4394                 assert!(as_commitment_update.update_fee.is_none());
4395                 check_added_monitors!(nodes[0], 1);
4396         } }
4397
4398         macro_rules! handle_initial_raa { () => {
4399                 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &initial_revoke_and_ack).unwrap();
4400                 bs_second_commitment_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
4401                 assert!(bs_second_commitment_update.update_add_htlcs.is_empty());
4402                 assert!(bs_second_commitment_update.update_fulfill_htlcs.is_empty());
4403                 assert!(bs_second_commitment_update.update_fail_htlcs.is_empty());
4404                 assert!(bs_second_commitment_update.update_fail_malformed_htlcs.is_empty());
4405                 assert!(bs_second_commitment_update.update_fee.is_none());
4406                 check_added_monitors!(nodes[1], 1);
4407         } }
4408
4409         if (disconnect_count & 8) == 0 {
4410                 handle_bs_raa!();
4411
4412                 if disconnect_count & !disconnect_flags > 3 {
4413                         let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!();
4414
4415                         assert!(as_resp.1.unwrap() == initial_revoke_and_ack);
4416                         assert!(bs_resp.1.is_none());
4417
4418                         assert!(as_resp.2.unwrap() == as_commitment_update);
4419                         assert!(bs_resp.2.is_none());
4420
4421                         assert!(as_resp.3 == RAACommitmentOrder::RevokeAndACKFirst);
4422                 }
4423
4424                 handle_initial_raa!();
4425
4426                 if disconnect_count & !disconnect_flags > 4 {
4427                         let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!();
4428
4429                         assert!(as_resp.1.is_none());
4430                         assert!(bs_resp.1.is_none());
4431
4432                         assert!(as_resp.2.unwrap() == as_commitment_update);
4433                         assert!(bs_resp.2.unwrap() == bs_second_commitment_update);
4434                 }
4435         } else {
4436                 handle_initial_raa!();
4437
4438                 if disconnect_count & !disconnect_flags > 3 {
4439                         let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!();
4440
4441                         assert!(as_resp.1.is_none());
4442                         assert!(bs_resp.1.unwrap() == bs_revoke_and_ack);
4443
4444                         assert!(as_resp.2.is_none());
4445                         assert!(bs_resp.2.unwrap() == bs_second_commitment_update);
4446
4447                         assert!(bs_resp.3 == RAACommitmentOrder::RevokeAndACKFirst);
4448                 }
4449
4450                 handle_bs_raa!();
4451
4452                 if disconnect_count & !disconnect_flags > 4 {
4453                         let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!();
4454
4455                         assert!(as_resp.1.is_none());
4456                         assert!(bs_resp.1.is_none());
4457
4458                         assert!(as_resp.2.unwrap() == as_commitment_update);
4459                         assert!(bs_resp.2.unwrap() == bs_second_commitment_update);
4460                 }
4461         }
4462
4463         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_second_commitment_update.commitment_signed).unwrap();
4464         let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
4465         // No commitment_signed so get_event_msg's assert(len == 1) passes
4466         check_added_monitors!(nodes[0], 1);
4467
4468         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_commitment_update.commitment_signed).unwrap();
4469         let bs_second_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
4470         // No commitment_signed so get_event_msg's assert(len == 1) passes
4471         check_added_monitors!(nodes[1], 1);
4472
4473         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_and_ack).unwrap();
4474         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4475         check_added_monitors!(nodes[1], 1);
4476
4477         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_second_revoke_and_ack).unwrap();
4478         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
4479         check_added_monitors!(nodes[0], 1);
4480
4481         expect_pending_htlcs_forwardable!(nodes[1]);
4482
4483         let events_5 = nodes[1].node.get_and_clear_pending_events();
4484         assert_eq!(events_5.len(), 1);
4485         match events_5[0] {
4486                 Event::PaymentReceived { ref payment_hash, amt } => {
4487                         assert_eq!(payment_hash_2, *payment_hash);
4488                         assert_eq!(amt, 1000000);
4489                 },
4490                 _ => panic!("Unexpected event"),
4491         }
4492
4493         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2);
4494 }
4495
4496 #[test]
4497 fn test_monitor_temporary_update_fail_a() {
4498         do_test_monitor_temporary_update_fail(0);
4499         do_test_monitor_temporary_update_fail(1);
4500         do_test_monitor_temporary_update_fail(2);
4501         do_test_monitor_temporary_update_fail(3);
4502         do_test_monitor_temporary_update_fail(4);
4503         do_test_monitor_temporary_update_fail(5);
4504 }
4505
4506 #[test]
4507 fn test_monitor_temporary_update_fail_b() {
4508         do_test_monitor_temporary_update_fail(2 | 8);
4509         do_test_monitor_temporary_update_fail(3 | 8);
4510         do_test_monitor_temporary_update_fail(4 | 8);
4511         do_test_monitor_temporary_update_fail(5 | 8);
4512 }
4513
4514 #[test]
4515 fn test_monitor_temporary_update_fail_c() {
4516         do_test_monitor_temporary_update_fail(1 | 16);
4517         do_test_monitor_temporary_update_fail(2 | 16);
4518         do_test_monitor_temporary_update_fail(3 | 16);
4519         do_test_monitor_temporary_update_fail(2 | 8 | 16);
4520         do_test_monitor_temporary_update_fail(3 | 8 | 16);
4521 }
4522
4523 #[test]
4524 fn test_monitor_update_fail_cs() {
4525         // Tests handling of a monitor update failure when processing an incoming commitment_signed
4526         let mut nodes = create_network(2);
4527         create_announced_chan_between_nodes(&nodes, 0, 1);
4528
4529         let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
4530         let (payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
4531         nodes[0].node.send_payment(route, our_payment_hash).unwrap();
4532         check_added_monitors!(nodes[0], 1);
4533
4534         let send_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
4535         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_event.msgs[0]).unwrap();
4536
4537         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
4538         if let msgs::HandleError { err, action: Some(msgs::ErrorAction::IgnoreError) } = nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &send_event.commitment_msg).unwrap_err() {
4539                 assert_eq!(err, "Failed to update ChannelMonitor");
4540         } else { panic!(); }
4541         check_added_monitors!(nodes[1], 1);
4542         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4543
4544         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
4545         nodes[1].node.test_restore_channel_monitor();
4546         check_added_monitors!(nodes[1], 1);
4547         let responses = nodes[1].node.get_and_clear_pending_msg_events();
4548         assert_eq!(responses.len(), 2);
4549
4550         match responses[0] {
4551                 MessageSendEvent::SendRevokeAndACK { ref msg, ref node_id } => {
4552                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
4553                         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &msg).unwrap();
4554                         check_added_monitors!(nodes[0], 1);
4555                 },
4556                 _ => panic!("Unexpected event"),
4557         }
4558         match responses[1] {
4559                 MessageSendEvent::UpdateHTLCs { ref updates, ref node_id } => {
4560                         assert!(updates.update_add_htlcs.is_empty());
4561                         assert!(updates.update_fulfill_htlcs.is_empty());
4562                         assert!(updates.update_fail_htlcs.is_empty());
4563                         assert!(updates.update_fail_malformed_htlcs.is_empty());
4564                         assert!(updates.update_fee.is_none());
4565                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
4566
4567                         *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
4568                         if let msgs::HandleError { err, action: Some(msgs::ErrorAction::IgnoreError) } = nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &updates.commitment_signed).unwrap_err() {
4569                                 assert_eq!(err, "Failed to update ChannelMonitor");
4570                         } else { panic!(); }
4571                         check_added_monitors!(nodes[0], 1);
4572                         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
4573                 },
4574                 _ => panic!("Unexpected event"),
4575         }
4576
4577         *nodes[0].chan_monitor.update_ret.lock().unwrap() = Ok(());
4578         nodes[0].node.test_restore_channel_monitor();
4579         check_added_monitors!(nodes[0], 1);
4580
4581         let final_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
4582         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &final_raa).unwrap();
4583         check_added_monitors!(nodes[1], 1);
4584
4585         expect_pending_htlcs_forwardable!(nodes[1]);
4586
4587         let events = nodes[1].node.get_and_clear_pending_events();
4588         assert_eq!(events.len(), 1);
4589         match events[0] {
4590                 Event::PaymentReceived { payment_hash, amt } => {
4591                         assert_eq!(payment_hash, our_payment_hash);
4592                         assert_eq!(amt, 1000000);
4593                 },
4594                 _ => panic!("Unexpected event"),
4595         };
4596
4597         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
4598 }
4599
4600 fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) {
4601         // Tests handling of a monitor update failure when processing an incoming RAA
4602         let mut nodes = create_network(3);
4603         create_announced_chan_between_nodes(&nodes, 0, 1);
4604         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
4605
4606         // Rebalance a bit so that we can send backwards from 2 to 1.
4607         send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000);
4608
4609         // Route a first payment that we'll fail backwards
4610         let (_, payment_hash_1) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000);
4611
4612         // Fail the payment backwards, failing the monitor update on nodes[1]'s receipt of the RAA
4613         assert!(nodes[2].node.fail_htlc_backwards(&payment_hash_1, 0));
4614         check_added_monitors!(nodes[2], 1);
4615
4616         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
4617         assert!(updates.update_add_htlcs.is_empty());
4618         assert!(updates.update_fulfill_htlcs.is_empty());
4619         assert_eq!(updates.update_fail_htlcs.len(), 1);
4620         assert!(updates.update_fail_malformed_htlcs.is_empty());
4621         assert!(updates.update_fee.is_none());
4622         nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[0]).unwrap();
4623
4624         let bs_revoke_and_ack = commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false, true, false, true);
4625         check_added_monitors!(nodes[0], 0);
4626
4627         // While the second channel is AwaitingRAA, forward a second payment to get it into the
4628         // holding cell.
4629         let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
4630         let route = nodes[0].router.get_route(&nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
4631         nodes[0].node.send_payment(route, payment_hash_2).unwrap();
4632         check_added_monitors!(nodes[0], 1);
4633
4634         let mut send_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
4635         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_event.msgs[0]).unwrap();
4636         commitment_signed_dance!(nodes[1], nodes[0], send_event.commitment_msg, false);
4637
4638         expect_pending_htlcs_forwardable!(nodes[1]);
4639         check_added_monitors!(nodes[1], 0);
4640         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4641
4642         // Now fail monitor updating.
4643         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
4644         if let msgs::HandleError { err, action: Some(msgs::ErrorAction::IgnoreError) } = nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &bs_revoke_and_ack).unwrap_err() {
4645                 assert_eq!(err, "Failed to update ChannelMonitor");
4646         } else { panic!(); }
4647         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
4648         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4649         check_added_monitors!(nodes[1], 1);
4650
4651         // Attempt to forward a third payment but fail due to the second channel being unavailable
4652         // for forwarding.
4653
4654         let (_, payment_hash_3) = get_payment_preimage_hash!(nodes[0]);
4655         let route = nodes[0].router.get_route(&nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
4656         nodes[0].node.send_payment(route, payment_hash_3).unwrap();
4657         check_added_monitors!(nodes[0], 1);
4658
4659         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(()); // We succeed in updating the monitor for the first channel
4660         send_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
4661         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_event.msgs[0]).unwrap();
4662         commitment_signed_dance!(nodes[1], nodes[0], send_event.commitment_msg, false, true);
4663         check_added_monitors!(nodes[1], 0);
4664
4665         let mut events_2 = nodes[1].node.get_and_clear_pending_msg_events();
4666         assert_eq!(events_2.len(), 1);
4667         match events_2.remove(0) {
4668                 MessageSendEvent::UpdateHTLCs { node_id, updates } => {
4669                         assert_eq!(node_id, nodes[0].node.get_our_node_id());
4670                         assert!(updates.update_fulfill_htlcs.is_empty());
4671                         assert_eq!(updates.update_fail_htlcs.len(), 1);
4672                         assert!(updates.update_fail_malformed_htlcs.is_empty());
4673                         assert!(updates.update_add_htlcs.is_empty());
4674                         assert!(updates.update_fee.is_none());
4675
4676                         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]).unwrap();
4677                         commitment_signed_dance!(nodes[0], nodes[1], updates.commitment_signed, false, true);
4678
4679                         let msg_events = nodes[0].node.get_and_clear_pending_msg_events();
4680                         assert_eq!(msg_events.len(), 1);
4681                         match msg_events[0] {
4682                                 MessageSendEvent::PaymentFailureNetworkUpdate { update: msgs::HTLCFailChannelUpdate::ChannelUpdateMessage { ref msg }} => {
4683                                         assert_eq!(msg.contents.short_channel_id, chan_2.0.contents.short_channel_id);
4684                                         assert_eq!(msg.contents.flags & 2, 2); // temp disabled
4685                                 },
4686                                 _ => panic!("Unexpected event"),
4687                         }
4688
4689                         let events = nodes[0].node.get_and_clear_pending_events();
4690                         assert_eq!(events.len(), 1);
4691                         if let Event::PaymentFailed { payment_hash, rejected_by_dest, .. } = events[0] {
4692                                 assert_eq!(payment_hash, payment_hash_3);
4693                                 assert!(!rejected_by_dest);
4694                         } else { panic!("Unexpected event!"); }
4695                 },
4696                 _ => panic!("Unexpected event type!"),
4697         };
4698
4699         let (payment_preimage_4, payment_hash_4) = if test_ignore_second_cs {
4700                 // Try to route another payment backwards from 2 to make sure 1 holds off on responding
4701                 let (payment_preimage_4, payment_hash_4) = get_payment_preimage_hash!(nodes[0]);
4702                 let route = nodes[2].router.get_route(&nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
4703                 nodes[2].node.send_payment(route, payment_hash_4).unwrap();
4704                 check_added_monitors!(nodes[2], 1);
4705
4706                 send_event = SendEvent::from_event(nodes[2].node.get_and_clear_pending_msg_events().remove(0));
4707                 nodes[1].node.handle_update_add_htlc(&nodes[2].node.get_our_node_id(), &send_event.msgs[0]).unwrap();
4708                 if let Err(msgs::HandleError{err, action: Some(msgs::ErrorAction::IgnoreError) }) = nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &send_event.commitment_msg) {
4709                         assert_eq!(err, "Previous monitor update failure prevented generation of RAA");
4710                 } else { panic!(); }
4711                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4712                 assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
4713                 (Some(payment_preimage_4), Some(payment_hash_4))
4714         } else { (None, None) };
4715
4716         // Restore monitor updating, ensuring we immediately get a fail-back update and a
4717         // update_add update.
4718         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
4719         nodes[1].node.test_restore_channel_monitor();
4720         check_added_monitors!(nodes[1], 2);
4721
4722         let mut events_3 = nodes[1].node.get_and_clear_pending_msg_events();
4723         if test_ignore_second_cs {
4724                 assert_eq!(events_3.len(), 3);
4725         } else {
4726                 assert_eq!(events_3.len(), 2);
4727         }
4728
4729         // Note that the ordering of the events for different nodes is non-prescriptive, though the
4730         // ordering of the two events that both go to nodes[2] have to stay in the same order.
4731         let messages_a = match events_3.pop().unwrap() {
4732                 MessageSendEvent::UpdateHTLCs { node_id, mut updates } => {
4733                         assert_eq!(node_id, nodes[0].node.get_our_node_id());
4734                         assert!(updates.update_fulfill_htlcs.is_empty());
4735                         assert_eq!(updates.update_fail_htlcs.len(), 1);
4736                         assert!(updates.update_fail_malformed_htlcs.is_empty());
4737                         assert!(updates.update_add_htlcs.is_empty());
4738                         assert!(updates.update_fee.is_none());
4739                         (updates.update_fail_htlcs.remove(0), updates.commitment_signed)
4740                 },
4741                 _ => panic!("Unexpected event type!"),
4742         };
4743         let raa = if test_ignore_second_cs {
4744                 match events_3.remove(1) {
4745                         MessageSendEvent::SendRevokeAndACK { node_id, msg } => {
4746                                 assert_eq!(node_id, nodes[2].node.get_our_node_id());
4747                                 Some(msg.clone())
4748                         },
4749                         _ => panic!("Unexpected event"),
4750                 }
4751         } else { None };
4752         let send_event_b = SendEvent::from_event(events_3.remove(0));
4753         assert_eq!(send_event_b.node_id, nodes[2].node.get_our_node_id());
4754
4755         // Now deliver the new messages...
4756
4757         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &messages_a.0).unwrap();
4758         commitment_signed_dance!(nodes[0], nodes[1], messages_a.1, false);
4759         let events_4 = nodes[0].node.get_and_clear_pending_events();
4760         assert_eq!(events_4.len(), 1);
4761         if let Event::PaymentFailed { payment_hash, rejected_by_dest, .. } = events_4[0] {
4762                 assert_eq!(payment_hash, payment_hash_1);
4763                 assert!(rejected_by_dest);
4764         } else { panic!("Unexpected event!"); }
4765
4766         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &send_event_b.msgs[0]).unwrap();
4767         if test_ignore_second_cs {
4768                 nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &send_event_b.commitment_msg).unwrap();
4769                 check_added_monitors!(nodes[2], 1);
4770                 let bs_revoke_and_ack = get_event_msg!(nodes[2], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
4771                 nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &raa.unwrap()).unwrap();
4772                 check_added_monitors!(nodes[2], 1);
4773                 let bs_cs = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
4774                 assert!(bs_cs.update_add_htlcs.is_empty());
4775                 assert!(bs_cs.update_fail_htlcs.is_empty());
4776                 assert!(bs_cs.update_fail_malformed_htlcs.is_empty());
4777                 assert!(bs_cs.update_fulfill_htlcs.is_empty());
4778                 assert!(bs_cs.update_fee.is_none());
4779
4780                 nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &bs_revoke_and_ack).unwrap();
4781                 check_added_monitors!(nodes[1], 1);
4782                 let as_cs = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
4783                 assert!(as_cs.update_add_htlcs.is_empty());
4784                 assert!(as_cs.update_fail_htlcs.is_empty());
4785                 assert!(as_cs.update_fail_malformed_htlcs.is_empty());
4786                 assert!(as_cs.update_fulfill_htlcs.is_empty());
4787                 assert!(as_cs.update_fee.is_none());
4788
4789                 nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &bs_cs.commitment_signed).unwrap();
4790                 check_added_monitors!(nodes[1], 1);
4791                 let as_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[2].node.get_our_node_id());
4792
4793                 nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &as_cs.commitment_signed).unwrap();
4794                 check_added_monitors!(nodes[2], 1);
4795                 let bs_second_raa = get_event_msg!(nodes[2], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
4796
4797                 nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_raa).unwrap();
4798                 check_added_monitors!(nodes[2], 1);
4799                 assert!(nodes[2].node.get_and_clear_pending_msg_events().is_empty());
4800
4801                 nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &bs_second_raa).unwrap();
4802                 check_added_monitors!(nodes[1], 1);
4803                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4804         } else {
4805                 commitment_signed_dance!(nodes[2], nodes[1], send_event_b.commitment_msg, false);
4806         }
4807
4808         expect_pending_htlcs_forwardable!(nodes[2]);
4809
4810         let events_6 = nodes[2].node.get_and_clear_pending_events();
4811         assert_eq!(events_6.len(), 1);
4812         match events_6[0] {
4813                 Event::PaymentReceived { payment_hash, .. } => { assert_eq!(payment_hash, payment_hash_2); },
4814                 _ => panic!("Unexpected event"),
4815         };
4816
4817         if test_ignore_second_cs {
4818                 expect_pending_htlcs_forwardable!(nodes[1]);
4819                 check_added_monitors!(nodes[1], 1);
4820
4821                 send_event = SendEvent::from_node(&nodes[1]);
4822                 assert_eq!(send_event.node_id, nodes[0].node.get_our_node_id());
4823                 assert_eq!(send_event.msgs.len(), 1);
4824                 nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &send_event.msgs[0]).unwrap();
4825                 commitment_signed_dance!(nodes[0], nodes[1], send_event.commitment_msg, false);
4826
4827                 expect_pending_htlcs_forwardable!(nodes[0]);
4828
4829                 let events_9 = nodes[0].node.get_and_clear_pending_events();
4830                 assert_eq!(events_9.len(), 1);
4831                 match events_9[0] {
4832                         Event::PaymentReceived { payment_hash, .. } => assert_eq!(payment_hash, payment_hash_4.unwrap()),
4833                         _ => panic!("Unexpected event"),
4834                 };
4835                 claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_4.unwrap());
4836         }
4837
4838         claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage_2);
4839 }
4840
4841 #[test]
4842 fn test_monitor_update_fail_raa() {
4843         do_test_monitor_update_fail_raa(false);
4844         do_test_monitor_update_fail_raa(true);
4845 }
4846
4847 #[test]
4848 fn test_monitor_update_fail_reestablish() {
4849         // Simple test for message retransmission after monitor update failure on
4850         // channel_reestablish generating a monitor update (which comes from freeing holding cell
4851         // HTLCs).
4852         let mut nodes = create_network(3);
4853         create_announced_chan_between_nodes(&nodes, 0, 1);
4854         create_announced_chan_between_nodes(&nodes, 1, 2);
4855
4856         let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000);
4857
4858         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4859         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
4860
4861         assert!(nodes[2].node.claim_funds(our_payment_preimage));
4862         check_added_monitors!(nodes[2], 1);
4863         let mut updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
4864         assert!(updates.update_add_htlcs.is_empty());
4865         assert!(updates.update_fail_htlcs.is_empty());
4866         assert!(updates.update_fail_malformed_htlcs.is_empty());
4867         assert!(updates.update_fee.is_none());
4868         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
4869         nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]).unwrap();
4870         check_added_monitors!(nodes[1], 1);
4871         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4872         commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false);
4873
4874         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
4875         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id());
4876         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id());
4877
4878         let as_reestablish = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReestablish, nodes[1].node.get_our_node_id());
4879         let bs_reestablish = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
4880
4881         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &bs_reestablish).unwrap();
4882
4883         if let msgs::HandleError { err, action: Some(msgs::ErrorAction::IgnoreError) } = nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &as_reestablish).unwrap_err() {
4884                 assert_eq!(err, "Failed to update ChannelMonitor");
4885         } else { panic!(); }
4886         check_added_monitors!(nodes[1], 1);
4887
4888         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4889         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
4890
4891         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id());
4892         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id());
4893
4894         assert!(as_reestablish == get_event_msg!(nodes[0], MessageSendEvent::SendChannelReestablish, nodes[1].node.get_our_node_id()));
4895         assert!(bs_reestablish == get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id()));
4896
4897         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &bs_reestablish).unwrap();
4898
4899         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &as_reestablish).unwrap();
4900         check_added_monitors!(nodes[1], 0);
4901         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4902
4903         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
4904         nodes[1].node.test_restore_channel_monitor();
4905         check_added_monitors!(nodes[1], 1);
4906
4907         updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
4908         assert!(updates.update_add_htlcs.is_empty());
4909         assert!(updates.update_fail_htlcs.is_empty());
4910         assert!(updates.update_fail_malformed_htlcs.is_empty());
4911         assert!(updates.update_fee.is_none());
4912         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
4913         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]).unwrap();
4914         commitment_signed_dance!(nodes[0], nodes[1], updates.commitment_signed, false);
4915
4916         let events = nodes[0].node.get_and_clear_pending_events();
4917         assert_eq!(events.len(), 1);
4918         match events[0] {
4919                 Event::PaymentSent { payment_preimage, .. } => assert_eq!(payment_preimage, our_payment_preimage),
4920                 _ => panic!("Unexpected event"),
4921         }
4922 }
4923
4924 #[test]
4925 fn test_invalid_channel_announcement() {
4926         //Test BOLT 7 channel_announcement msg requirement for final node, gather data to build customed channel_announcement msgs
4927         let secp_ctx = Secp256k1::new();
4928         let nodes = create_network(2);
4929
4930         let chan_announcement = create_chan_between_nodes(&nodes[0], &nodes[1]);
4931
4932         let a_channel_lock = nodes[0].node.channel_state.lock().unwrap();
4933         let b_channel_lock = nodes[1].node.channel_state.lock().unwrap();
4934         let as_chan = a_channel_lock.by_id.get(&chan_announcement.3).unwrap();
4935         let bs_chan = b_channel_lock.by_id.get(&chan_announcement.3).unwrap();
4936
4937         let _ = nodes[0].router.handle_htlc_fail_channel_update(&msgs::HTLCFailChannelUpdate::ChannelClosed { short_channel_id : as_chan.get_short_channel_id().unwrap(), is_permanent: false } );
4938
4939         let as_bitcoin_key = PublicKey::from_secret_key(&secp_ctx, &as_chan.get_local_keys().funding_key);
4940         let bs_bitcoin_key = PublicKey::from_secret_key(&secp_ctx, &bs_chan.get_local_keys().funding_key);
4941
4942         let as_network_key = nodes[0].node.get_our_node_id();
4943         let bs_network_key = nodes[1].node.get_our_node_id();
4944
4945         let were_node_one = as_bitcoin_key.serialize()[..] < bs_bitcoin_key.serialize()[..];
4946
4947         let mut chan_announcement;
4948
4949         macro_rules! dummy_unsigned_msg {
4950                 () => {
4951                         msgs::UnsignedChannelAnnouncement {
4952                                 features: msgs::GlobalFeatures::new(),
4953                                 chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
4954                                 short_channel_id: as_chan.get_short_channel_id().unwrap(),
4955                                 node_id_1: if were_node_one { as_network_key } else { bs_network_key },
4956                                 node_id_2: if were_node_one { bs_network_key } else { as_network_key },
4957                                 bitcoin_key_1: if were_node_one { as_bitcoin_key } else { bs_bitcoin_key },
4958                                 bitcoin_key_2: if were_node_one { bs_bitcoin_key } else { as_bitcoin_key },
4959                                 excess_data: Vec::new(),
4960                         };
4961                 }
4962         }
4963
4964         macro_rules! sign_msg {
4965                 ($unsigned_msg: expr) => {
4966                         let msghash = Message::from_slice(&Sha256dHash::from_data(&$unsigned_msg.encode()[..])[..]).unwrap();
4967                         let as_bitcoin_sig = secp_ctx.sign(&msghash, &as_chan.get_local_keys().funding_key);
4968                         let bs_bitcoin_sig = secp_ctx.sign(&msghash, &bs_chan.get_local_keys().funding_key);
4969                         let as_node_sig = secp_ctx.sign(&msghash, &nodes[0].keys_manager.get_node_secret());
4970                         let bs_node_sig = secp_ctx.sign(&msghash, &nodes[1].keys_manager.get_node_secret());
4971                         chan_announcement = msgs::ChannelAnnouncement {
4972                                 node_signature_1 : if were_node_one { as_node_sig } else { bs_node_sig},
4973                                 node_signature_2 : if were_node_one { bs_node_sig } else { as_node_sig},
4974                                 bitcoin_signature_1: if were_node_one { as_bitcoin_sig } else { bs_bitcoin_sig },
4975                                 bitcoin_signature_2 : if were_node_one { bs_bitcoin_sig } else { as_bitcoin_sig },
4976                                 contents: $unsigned_msg
4977                         }
4978                 }
4979         }
4980
4981         let unsigned_msg = dummy_unsigned_msg!();
4982         sign_msg!(unsigned_msg);
4983         assert_eq!(nodes[0].router.handle_channel_announcement(&chan_announcement).unwrap(), true);
4984         let _ = nodes[0].router.handle_htlc_fail_channel_update(&msgs::HTLCFailChannelUpdate::ChannelClosed { short_channel_id : as_chan.get_short_channel_id().unwrap(), is_permanent: false } );
4985
4986         // Configured with Network::Testnet
4987         let mut unsigned_msg = dummy_unsigned_msg!();
4988         unsigned_msg.chain_hash = genesis_block(Network::Bitcoin).header.bitcoin_hash();
4989         sign_msg!(unsigned_msg);
4990         assert!(nodes[0].router.handle_channel_announcement(&chan_announcement).is_err());
4991
4992         let mut unsigned_msg = dummy_unsigned_msg!();
4993         unsigned_msg.chain_hash = Sha256dHash::from_data(&[1,2,3,4,5,6,7,8,9]);
4994         sign_msg!(unsigned_msg);
4995         assert!(nodes[0].router.handle_channel_announcement(&chan_announcement).is_err());
4996 }
4997
4998 struct VecWriter(Vec<u8>);
4999 impl Writer for VecWriter {
5000         fn write_all(&mut self, buf: &[u8]) -> Result<(), ::std::io::Error> {
5001                 self.0.extend_from_slice(buf);
5002                 Ok(())
5003         }
5004         fn size_hint(&mut self, size: usize) {
5005                 self.0.reserve_exact(size);
5006         }
5007 }
5008
5009 #[test]
5010 fn test_no_txn_manager_serialize_deserialize() {
5011         let mut nodes = create_network(2);
5012
5013         let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001);
5014
5015         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
5016
5017         let nodes_0_serialized = nodes[0].node.encode();
5018         let mut chan_0_monitor_serialized = VecWriter(Vec::new());
5019         nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter().next().unwrap().1.write_for_disk(&mut chan_0_monitor_serialized).unwrap();
5020
5021         nodes[0].chan_monitor = Arc::new(test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), Arc::new(test_utils::TestLogger::new())));
5022         let mut chan_0_monitor_read = &chan_0_monitor_serialized.0[..];
5023         let (_, chan_0_monitor) = <(Sha256dHash, ChannelMonitor)>::read(&mut chan_0_monitor_read, Arc::new(test_utils::TestLogger::new())).unwrap();
5024         assert!(chan_0_monitor_read.is_empty());
5025
5026         let mut nodes_0_read = &nodes_0_serialized[..];
5027         let config = UserConfig::new();
5028         let keys_manager = Arc::new(keysinterface::KeysManager::new(&nodes[0].node_seed, Network::Testnet, Arc::new(test_utils::TestLogger::new())));
5029         let (_, nodes_0_deserialized) = {
5030                 let mut channel_monitors = HashMap::new();
5031                 channel_monitors.insert(chan_0_monitor.get_funding_txo().unwrap(), &chan_0_monitor);
5032                 <(Sha256dHash, ChannelManager)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
5033                         default_config: config,
5034                         keys_manager,
5035                         fee_estimator: Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 }),
5036                         monitor: nodes[0].chan_monitor.clone(),
5037                         chain_monitor: nodes[0].chain_monitor.clone(),
5038                         tx_broadcaster: nodes[0].tx_broadcaster.clone(),
5039                         logger: Arc::new(test_utils::TestLogger::new()),
5040                         channel_monitors: &channel_monitors,
5041                 }).unwrap()
5042         };
5043         assert!(nodes_0_read.is_empty());
5044
5045         assert!(nodes[0].chan_monitor.add_update_monitor(chan_0_monitor.get_funding_txo().unwrap(), chan_0_monitor).is_ok());
5046         nodes[0].node = Arc::new(nodes_0_deserialized);
5047         let nodes_0_as_listener: Arc<ChainListener> = nodes[0].node.clone();
5048         nodes[0].chain_monitor.register_listener(Arc::downgrade(&nodes_0_as_listener));
5049         assert_eq!(nodes[0].node.list_channels().len(), 1);
5050         check_added_monitors!(nodes[0], 1);
5051
5052         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id());
5053         let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
5054         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id());
5055         let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
5056
5057         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]).unwrap();
5058         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
5059         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]).unwrap();
5060         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
5061
5062         let (funding_locked, _) = create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
5063         let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked);
5064         for node in nodes.iter() {
5065                 assert!(node.router.handle_channel_announcement(&announcement).unwrap());
5066                 node.router.handle_channel_update(&as_update).unwrap();
5067                 node.router.handle_channel_update(&bs_update).unwrap();
5068         }
5069
5070         send_payment(&nodes[0], &[&nodes[1]], 1000000);
5071 }
5072
5073 #[test]
5074 fn test_simple_manager_serialize_deserialize() {
5075         let mut nodes = create_network(2);
5076         create_announced_chan_between_nodes(&nodes, 0, 1);
5077
5078         let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
5079         let (_, our_payment_hash) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
5080
5081         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
5082
5083         let nodes_0_serialized = nodes[0].node.encode();
5084         let mut chan_0_monitor_serialized = VecWriter(Vec::new());
5085         nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter().next().unwrap().1.write_for_disk(&mut chan_0_monitor_serialized).unwrap();
5086
5087         nodes[0].chan_monitor = Arc::new(test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), Arc::new(test_utils::TestLogger::new())));
5088         let mut chan_0_monitor_read = &chan_0_monitor_serialized.0[..];
5089         let (_, chan_0_monitor) = <(Sha256dHash, ChannelMonitor)>::read(&mut chan_0_monitor_read, Arc::new(test_utils::TestLogger::new())).unwrap();
5090         assert!(chan_0_monitor_read.is_empty());
5091
5092         let mut nodes_0_read = &nodes_0_serialized[..];
5093         let keys_manager = Arc::new(keysinterface::KeysManager::new(&nodes[0].node_seed, Network::Testnet, Arc::new(test_utils::TestLogger::new())));
5094         let (_, nodes_0_deserialized) = {
5095                 let mut channel_monitors = HashMap::new();
5096                 channel_monitors.insert(chan_0_monitor.get_funding_txo().unwrap(), &chan_0_monitor);
5097                 <(Sha256dHash, ChannelManager)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
5098                         default_config: UserConfig::new(),
5099                         keys_manager,
5100                         fee_estimator: Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 }),
5101                         monitor: nodes[0].chan_monitor.clone(),
5102                         chain_monitor: nodes[0].chain_monitor.clone(),
5103                         tx_broadcaster: nodes[0].tx_broadcaster.clone(),
5104                         logger: Arc::new(test_utils::TestLogger::new()),
5105                         channel_monitors: &channel_monitors,
5106                 }).unwrap()
5107         };
5108         assert!(nodes_0_read.is_empty());
5109
5110         assert!(nodes[0].chan_monitor.add_update_monitor(chan_0_monitor.get_funding_txo().unwrap(), chan_0_monitor).is_ok());
5111         nodes[0].node = Arc::new(nodes_0_deserialized);
5112         check_added_monitors!(nodes[0], 1);
5113
5114         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
5115
5116         fail_payment(&nodes[0], &[&nodes[1]], our_payment_hash);
5117         claim_payment(&nodes[0], &[&nodes[1]], our_payment_preimage);
5118 }
5119
5120 #[test]
5121 fn test_manager_serialize_deserialize_inconsistent_monitor() {
5122         // Test deserializing a ChannelManager with a out-of-date ChannelMonitor
5123         let mut nodes = create_network(4);
5124         create_announced_chan_between_nodes(&nodes, 0, 1);
5125         create_announced_chan_between_nodes(&nodes, 2, 0);
5126         let (_, _, channel_id, funding_tx) = create_announced_chan_between_nodes(&nodes, 0, 3);
5127
5128         let (our_payment_preimage, _) = route_payment(&nodes[2], &[&nodes[0], &nodes[1]], 1000000);
5129
5130         // Serialize the ChannelManager here, but the monitor we keep up-to-date
5131         let nodes_0_serialized = nodes[0].node.encode();
5132
5133         route_payment(&nodes[0], &[&nodes[3]], 1000000);
5134         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
5135         nodes[2].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
5136         nodes[3].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
5137
5138         // Now the ChannelMonitor (which is now out-of-sync with ChannelManager for channel w/
5139         // nodes[3])
5140         let mut node_0_monitors_serialized = Vec::new();
5141         for monitor in nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter() {
5142                 let mut writer = VecWriter(Vec::new());
5143                 monitor.1.write_for_disk(&mut writer).unwrap();
5144                 node_0_monitors_serialized.push(writer.0);
5145         }
5146
5147         nodes[0].chan_monitor = Arc::new(test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), Arc::new(test_utils::TestLogger::new())));
5148         let mut node_0_monitors = Vec::new();
5149         for serialized in node_0_monitors_serialized.iter() {
5150                 let mut read = &serialized[..];
5151                 let (_, monitor) = <(Sha256dHash, ChannelMonitor)>::read(&mut read, Arc::new(test_utils::TestLogger::new())).unwrap();
5152                 assert!(read.is_empty());
5153                 node_0_monitors.push(monitor);
5154         }
5155
5156         let mut nodes_0_read = &nodes_0_serialized[..];
5157         let keys_manager = Arc::new(keysinterface::KeysManager::new(&nodes[0].node_seed, Network::Testnet, Arc::new(test_utils::TestLogger::new())));
5158         let (_, nodes_0_deserialized) = <(Sha256dHash, ChannelManager)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
5159                 default_config: UserConfig::new(),
5160                 keys_manager,
5161                 fee_estimator: Arc::new(test_utils::TestFeeEstimator { sat_per_kw: 253 }),
5162                 monitor: nodes[0].chan_monitor.clone(),
5163                 chain_monitor: nodes[0].chain_monitor.clone(),
5164                 tx_broadcaster: nodes[0].tx_broadcaster.clone(),
5165                 logger: Arc::new(test_utils::TestLogger::new()),
5166                 channel_monitors: &node_0_monitors.iter().map(|monitor| { (monitor.get_funding_txo().unwrap(), monitor) }).collect(),
5167         }).unwrap();
5168         assert!(nodes_0_read.is_empty());
5169
5170         { // Channel close should result in a commitment tx and an HTLC tx
5171                 let txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
5172                 assert_eq!(txn.len(), 2);
5173                 assert_eq!(txn[0].input[0].previous_output.txid, funding_tx.txid());
5174                 assert_eq!(txn[1].input[0].previous_output.txid, txn[0].txid());
5175         }
5176
5177         for monitor in node_0_monitors.drain(..) {
5178                 assert!(nodes[0].chan_monitor.add_update_monitor(monitor.get_funding_txo().unwrap(), monitor).is_ok());
5179                 check_added_monitors!(nodes[0], 1);
5180         }
5181         nodes[0].node = Arc::new(nodes_0_deserialized);
5182
5183         // nodes[1] and nodes[2] have no lost state with nodes[0]...
5184         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
5185         reconnect_nodes(&nodes[0], &nodes[2], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
5186         //... and we can even still claim the payment!
5187         claim_payment(&nodes[2], &[&nodes[0], &nodes[1]], our_payment_preimage);
5188
5189         nodes[3].node.peer_connected(&nodes[0].node.get_our_node_id());
5190         let reestablish = get_event_msg!(nodes[3], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
5191         nodes[0].node.peer_connected(&nodes[3].node.get_our_node_id());
5192         if let Err(msgs::HandleError { action: Some(msgs::ErrorAction::SendErrorMessage { msg }), .. }) = nodes[0].node.handle_channel_reestablish(&nodes[3].node.get_our_node_id(), &reestablish) {
5193                 assert_eq!(msg.channel_id, channel_id);
5194         } else { panic!("Unexpected result"); }
5195 }
5196
5197 macro_rules! check_spendable_outputs {
5198         ($node: expr, $der_idx: expr) => {
5199                 {
5200                         let events = $node.chan_monitor.simple_monitor.get_and_clear_pending_events();
5201                         let mut txn = Vec::new();
5202                         for event in events {
5203                                 match event {
5204                                         Event::SpendableOutputs { ref outputs } => {
5205                                                 for outp in outputs {
5206                                                         match *outp {
5207                                                                 SpendableOutputDescriptor::DynamicOutputP2WPKH { ref outpoint, ref key, ref output } => {
5208                                                                         let input = TxIn {
5209                                                                                 previous_output: outpoint.clone(),
5210                                                                                 script_sig: Script::new(),
5211                                                                                 sequence: 0,
5212                                                                                 witness: Vec::new(),
5213                                                                         };
5214                                                                         let outp = TxOut {
5215                                                                                 script_pubkey: Builder::new().push_opcode(opcodes::All::OP_RETURN).into_script(),
5216                                                                                 value: output.value,
5217                                                                         };
5218                                                                         let mut spend_tx = Transaction {
5219                                                                                 version: 2,
5220                                                                                 lock_time: 0,
5221                                                                                 input: vec![input],
5222                                                                                 output: vec![outp],
5223                                                                         };
5224                                                                         let secp_ctx = Secp256k1::new();
5225                                                                         let remotepubkey = PublicKey::from_secret_key(&secp_ctx, &key);
5226                                                                         let witness_script = Address::p2pkh(&remotepubkey, Network::Testnet).script_pubkey();
5227                                                                         let sighash = Message::from_slice(&bip143::SighashComponents::new(&spend_tx).sighash_all(&spend_tx.input[0], &witness_script, output.value)[..]).unwrap();
5228                                                                         let remotesig = secp_ctx.sign(&sighash, key);
5229                                                                         spend_tx.input[0].witness.push(remotesig.serialize_der(&secp_ctx).to_vec());
5230                                                                         spend_tx.input[0].witness[0].push(SigHashType::All as u8);
5231                                                                         spend_tx.input[0].witness.push(remotepubkey.serialize().to_vec());
5232                                                                         txn.push(spend_tx);
5233                                                                 },
5234                                                                 SpendableOutputDescriptor::DynamicOutputP2WSH { ref outpoint, ref key, ref witness_script, ref to_self_delay, ref output } => {
5235                                                                         let input = TxIn {
5236                                                                                 previous_output: outpoint.clone(),
5237                                                                                 script_sig: Script::new(),
5238                                                                                 sequence: *to_self_delay as u32,
5239                                                                                 witness: Vec::new(),
5240                                                                         };
5241                                                                         let outp = TxOut {
5242                                                                                 script_pubkey: Builder::new().push_opcode(opcodes::All::OP_RETURN).into_script(),
5243                                                                                 value: output.value,
5244                                                                         };
5245                                                                         let mut spend_tx = Transaction {
5246                                                                                 version: 2,
5247                                                                                 lock_time: 0,
5248                                                                                 input: vec![input],
5249                                                                                 output: vec![outp],
5250                                                                         };
5251                                                                         let secp_ctx = Secp256k1::new();
5252                                                                         let sighash = Message::from_slice(&bip143::SighashComponents::new(&spend_tx).sighash_all(&spend_tx.input[0], witness_script, output.value)[..]).unwrap();
5253                                                                         let local_delaysig = secp_ctx.sign(&sighash, key);
5254                                                                         spend_tx.input[0].witness.push(local_delaysig.serialize_der(&secp_ctx).to_vec());
5255                                                                         spend_tx.input[0].witness[0].push(SigHashType::All as u8);
5256                                                                         spend_tx.input[0].witness.push(vec!(0));
5257                                                                         spend_tx.input[0].witness.push(witness_script.clone().into_bytes());
5258                                                                         txn.push(spend_tx);
5259                                                                 },
5260                                                                 SpendableOutputDescriptor::StaticOutput { ref outpoint, ref output } => {
5261                                                                         let secp_ctx = Secp256k1::new();
5262                                                                         let input = TxIn {
5263                                                                                 previous_output: outpoint.clone(),
5264                                                                                 script_sig: Script::new(),
5265                                                                                 sequence: 0,
5266                                                                                 witness: Vec::new(),
5267                                                                         };
5268                                                                         let outp = TxOut {
5269                                                                                 script_pubkey: Builder::new().push_opcode(opcodes::All::OP_RETURN).into_script(),
5270                                                                                 value: output.value,
5271                                                                         };
5272                                                                         let mut spend_tx = Transaction {
5273                                                                                 version: 2,
5274                                                                                 lock_time: 0,
5275                                                                                 input: vec![input],
5276                                                                                 output: vec![outp.clone()],
5277                                                                         };
5278                                                                         let secret = {
5279                                                                                 match ExtendedPrivKey::new_master(&secp_ctx, Network::Testnet, &$node.node_seed) {
5280                                                                                         Ok(master_key) => {
5281                                                                                                 match master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx($der_idx)) {
5282                                                                                                         Ok(key) => key,
5283                                                                                                         Err(_) => panic!("Your RNG is busted"),
5284                                                                                                 }
5285                                                                                         }
5286                                                                                         Err(_) => panic!("Your rng is busted"),
5287                                                                                 }
5288                                                                         };
5289                                                                         let pubkey = ExtendedPubKey::from_private(&secp_ctx, &secret).public_key;
5290                                                                         let witness_script = Address::p2pkh(&pubkey, Network::Testnet).script_pubkey();
5291                                                                         let sighash = Message::from_slice(&bip143::SighashComponents::new(&spend_tx).sighash_all(&spend_tx.input[0], &witness_script, output.value)[..]).unwrap();
5292                                                                         let sig = secp_ctx.sign(&sighash, &secret.secret_key);
5293                                                                         spend_tx.input[0].witness.push(sig.serialize_der(&secp_ctx).to_vec());
5294                                                                         spend_tx.input[0].witness[0].push(SigHashType::All as u8);
5295                                                                         spend_tx.input[0].witness.push(pubkey.serialize().to_vec());
5296                                                                         txn.push(spend_tx);
5297                                                                 },
5298                                                         }
5299                                                 }
5300                                         },
5301                                         _ => panic!("Unexpected event"),
5302                                 };
5303                         }
5304                         txn
5305                 }
5306         }
5307 }
5308
5309 #[test]
5310 fn test_claim_sizeable_push_msat() {
5311         // Incidentally test SpendableOutput event generation due to detection of to_local output on commitment tx
5312         let nodes = create_network(2);
5313
5314         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 99000000);
5315         nodes[1].node.force_close_channel(&chan.2);
5316         let events = nodes[1].node.get_and_clear_pending_msg_events();
5317         match events[0] {
5318                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5319                 _ => panic!("Unexpected event"),
5320         }
5321         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5322         assert_eq!(node_txn.len(), 1);
5323         check_spends!(node_txn[0], chan.3.clone());
5324         assert_eq!(node_txn[0].output.len(), 2); // We can't force trimming of to_remote output as channel_reserve_satoshis block us to do so at channel opening
5325
5326         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5327         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![node_txn[0].clone()] }, 0);
5328         let spend_txn = check_spendable_outputs!(nodes[1], 1);
5329         assert_eq!(spend_txn.len(), 1);
5330         check_spends!(spend_txn[0], node_txn[0].clone());
5331 }
5332
5333 #[test]
5334 fn test_claim_on_remote_sizeable_push_msat() {
5335         // Same test as previous, just test on remote commitment tx, as per_commitment_point registration changes following you're funder/fundee and
5336         // to_remote output is encumbered by a P2WPKH
5337
5338         let nodes = create_network(2);
5339
5340         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 99000000);
5341         nodes[0].node.force_close_channel(&chan.2);
5342         let events = nodes[0].node.get_and_clear_pending_msg_events();
5343         match events[0] {
5344                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5345                 _ => panic!("Unexpected event"),
5346         }
5347         let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
5348         assert_eq!(node_txn.len(), 1);
5349         check_spends!(node_txn[0], chan.3.clone());
5350         assert_eq!(node_txn[0].output.len(), 2); // We can't force trimming of to_remote output as channel_reserve_satoshis block us to do so at channel opening
5351
5352         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5353         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![node_txn[0].clone()] }, 0);
5354         let events = nodes[1].node.get_and_clear_pending_msg_events();
5355         match events[0] {
5356                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5357                 _ => panic!("Unexpected event"),
5358         }
5359         let spend_txn = check_spendable_outputs!(nodes[1], 1);
5360         assert_eq!(spend_txn.len(), 2);
5361         assert_eq!(spend_txn[0], spend_txn[1]);
5362         check_spends!(spend_txn[0], node_txn[0].clone());
5363 }
5364
5365 #[test]
5366 fn test_claim_on_remote_revoked_sizeable_push_msat() {
5367         // Same test as previous, just test on remote revoked commitment tx, as per_commitment_point registration changes following you're funder/fundee and
5368         // to_remote output is encumbered by a P2WPKH
5369
5370         let nodes = create_network(2);
5371
5372         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 59000000);
5373         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
5374         let revoked_local_txn = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().last_local_commitment_txn.clone();
5375         assert_eq!(revoked_local_txn[0].input.len(), 1);
5376         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid());
5377
5378         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
5379         let  header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5380         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
5381         let events = nodes[1].node.get_and_clear_pending_msg_events();
5382         match events[0] {
5383                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5384                 _ => panic!("Unexpected event"),
5385         }
5386         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5387         let spend_txn = check_spendable_outputs!(nodes[1], 1);
5388         assert_eq!(spend_txn.len(), 4);
5389         assert_eq!(spend_txn[0], spend_txn[2]); // to_remote output on revoked remote commitment_tx
5390         check_spends!(spend_txn[0], revoked_local_txn[0].clone());
5391         assert_eq!(spend_txn[1], spend_txn[3]); // to_local output on local commitment tx
5392         check_spends!(spend_txn[1], node_txn[0].clone());
5393 }
5394
5395 #[test]
5396 fn test_static_spendable_outputs_preimage_tx() {
5397         let nodes = create_network(2);
5398
5399         // Create some initial channels
5400         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
5401
5402         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
5403
5404         let commitment_tx = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan_1.2).unwrap().last_local_commitment_txn.clone();
5405         assert_eq!(commitment_tx[0].input.len(), 1);
5406         assert_eq!(commitment_tx[0].input[0].previous_output.txid, chan_1.3.txid());
5407
5408         // Settle A's commitment tx on B's chain
5409         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5410         assert!(nodes[1].node.claim_funds(payment_preimage));
5411         check_added_monitors!(nodes[1], 1);
5412         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![commitment_tx[0].clone()] }, 1);
5413         let events = nodes[1].node.get_and_clear_pending_msg_events();
5414         match events[0] {
5415                 MessageSendEvent::UpdateHTLCs { .. } => {},
5416                 _ => panic!("Unexpected event"),
5417         }
5418         match events[1] {
5419                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5420                 _ => panic!("Unexepected event"),
5421         }
5422
5423         // Check B's monitor was able to send back output descriptor event for preimage tx on A's commitment tx
5424         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); // ChannelManager : 1 (local commitment tx), ChannelMonitor: 2 (1 preimage tx) * 2 (block-rescan)
5425         check_spends!(node_txn[0], commitment_tx[0].clone());
5426         assert_eq!(node_txn[0], node_txn[2]);
5427         assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
5428         check_spends!(node_txn[1], chan_1.3.clone());
5429
5430         let spend_txn = check_spendable_outputs!(nodes[1], 1); // , 0, 0, 1, 1);
5431         assert_eq!(spend_txn.len(), 2);
5432         assert_eq!(spend_txn[0], spend_txn[1]);
5433         check_spends!(spend_txn[0], node_txn[0].clone());
5434 }
5435
5436 #[test]
5437 fn test_static_spendable_outputs_justice_tx_revoked_commitment_tx() {
5438         let nodes = create_network(2);
5439
5440         // Create some initial channels
5441         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
5442
5443         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
5444         let revoked_local_txn = nodes[0].node.channel_state.lock().unwrap().by_id.iter().next().unwrap().1.last_local_commitment_txn.clone();
5445         assert_eq!(revoked_local_txn[0].input.len(), 1);
5446         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
5447
5448         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
5449
5450         let  header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5451         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
5452         let events = nodes[1].node.get_and_clear_pending_msg_events();
5453         match events[0] {
5454                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5455                 _ => panic!("Unexpected event"),
5456         }
5457         let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5458         assert_eq!(node_txn.len(), 3);
5459         assert_eq!(node_txn.pop().unwrap(), node_txn[0]);
5460         assert_eq!(node_txn[0].input.len(), 2);
5461         check_spends!(node_txn[0], revoked_local_txn[0].clone());
5462
5463         let spend_txn = check_spendable_outputs!(nodes[1], 1);
5464         assert_eq!(spend_txn.len(), 2);
5465         assert_eq!(spend_txn[0], spend_txn[1]);
5466         check_spends!(spend_txn[0], node_txn[0].clone());
5467 }
5468
5469 #[test]
5470 fn test_static_spendable_outputs_justice_tx_revoked_htlc_timeout_tx() {
5471         let nodes = create_network(2);
5472
5473         // Create some initial channels
5474         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
5475
5476         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
5477         let revoked_local_txn = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan_1.2).unwrap().last_local_commitment_txn.clone();
5478         assert_eq!(revoked_local_txn[0].input.len(), 1);
5479         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
5480
5481         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
5482
5483         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5484         // A will generate HTLC-Timeout from revoked commitment tx
5485         nodes[0].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
5486         let events = nodes[0].node.get_and_clear_pending_msg_events();
5487         match events[0] {
5488                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5489                 _ => panic!("Unexpected event"),
5490         }
5491         let revoked_htlc_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
5492         assert_eq!(revoked_htlc_txn.len(), 3);
5493         assert_eq!(revoked_htlc_txn[0], revoked_htlc_txn[2]);
5494         assert_eq!(revoked_htlc_txn[0].input.len(), 1);
5495         assert_eq!(revoked_htlc_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
5496         check_spends!(revoked_htlc_txn[0], revoked_local_txn[0].clone());
5497         check_spends!(revoked_htlc_txn[1], chan_1.3.clone());
5498
5499         // B will generate justice tx from A's revoked commitment/HTLC tx
5500         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone(), revoked_htlc_txn[0].clone()] }, 1);
5501         let events = nodes[1].node.get_and_clear_pending_msg_events();
5502         match events[0] {
5503                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5504                 _ => panic!("Unexpected event"),
5505         }
5506
5507         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5508         assert_eq!(node_txn.len(), 4);
5509         assert_eq!(node_txn[3].input.len(), 1);
5510         check_spends!(node_txn[3], revoked_htlc_txn[0].clone());
5511
5512         // Check B's ChannelMonitor was able to generate the right spendable output descriptor
5513         let spend_txn = check_spendable_outputs!(nodes[1], 1);
5514         assert_eq!(spend_txn.len(), 3);
5515         assert_eq!(spend_txn[0], spend_txn[1]);
5516         check_spends!(spend_txn[0], node_txn[0].clone());
5517         check_spends!(spend_txn[2], node_txn[3].clone());
5518 }
5519
5520 #[test]
5521 fn test_static_spendable_outputs_justice_tx_revoked_htlc_success_tx() {
5522         let nodes = create_network(2);
5523
5524         // Create some initial channels
5525         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
5526
5527         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
5528         let revoked_local_txn = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan_1.2).unwrap().last_local_commitment_txn.clone();
5529         assert_eq!(revoked_local_txn[0].input.len(), 1);
5530         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
5531
5532         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage);
5533
5534         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5535         // B will generate HTLC-Success from revoked commitment tx
5536         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
5537         let events = nodes[1].node.get_and_clear_pending_msg_events();
5538         match events[0] {
5539                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5540                 _ => panic!("Unexpected event"),
5541         }
5542         let revoked_htlc_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5543
5544         assert_eq!(revoked_htlc_txn.len(), 3);
5545         assert_eq!(revoked_htlc_txn[0], revoked_htlc_txn[2]);
5546         assert_eq!(revoked_htlc_txn[0].input.len(), 1);
5547         assert_eq!(revoked_htlc_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5548         check_spends!(revoked_htlc_txn[0], revoked_local_txn[0].clone());
5549
5550         // A will generate justice tx from B's revoked commitment/HTLC tx
5551         nodes[0].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![revoked_local_txn[0].clone(), revoked_htlc_txn[0].clone()] }, 1);
5552         let events = nodes[0].node.get_and_clear_pending_msg_events();
5553         match events[0] {
5554                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5555                 _ => panic!("Unexpected event"),
5556         }
5557
5558         let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
5559         assert_eq!(node_txn.len(), 4);
5560         assert_eq!(node_txn[3].input.len(), 1);
5561         check_spends!(node_txn[3], revoked_htlc_txn[0].clone());
5562
5563         // Check A's ChannelMonitor was able to generate the right spendable output descriptor
5564         let spend_txn = check_spendable_outputs!(nodes[0], 1);
5565         assert_eq!(spend_txn.len(), 5);
5566         assert_eq!(spend_txn[0], spend_txn[2]);
5567         assert_eq!(spend_txn[1], spend_txn[3]);
5568         check_spends!(spend_txn[0], revoked_local_txn[0].clone()); // spending to_remote output from revoked local tx
5569         check_spends!(spend_txn[1], node_txn[2].clone()); // spending justice tx output from revoked local tx htlc received output
5570         check_spends!(spend_txn[4], node_txn[3].clone()); // spending justice tx output on htlc success tx
5571 }
5572
5573 #[test]
5574 fn test_onchain_to_onchain_claim() {
5575         // Test that in case of channel closure, we detect the state of output thanks to
5576         // ChainWatchInterface and claim HTLC on downstream peer's remote commitment tx.
5577         // First, have C claim an HTLC against its own latest commitment transaction.
5578         // Then, broadcast these to B, which should update the monitor downstream on the A<->B
5579         // channel.
5580         // Finally, check that B will claim the HTLC output if A's latest commitment transaction
5581         // gets broadcast.
5582
5583         let nodes = create_network(3);
5584
5585         // Create some initial channels
5586         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
5587         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
5588
5589         // Rebalance the network a bit by relaying one payment through all the channels ...
5590         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
5591         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000);
5592
5593         let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
5594         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
5595         let commitment_tx = nodes[2].node.channel_state.lock().unwrap().by_id.get(&chan_2.2).unwrap().last_local_commitment_txn.clone();
5596         check_spends!(commitment_tx[0], chan_2.3.clone());
5597         nodes[2].node.claim_funds(payment_preimage);
5598         check_added_monitors!(nodes[2], 1);
5599         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
5600         assert!(updates.update_add_htlcs.is_empty());
5601         assert!(updates.update_fail_htlcs.is_empty());
5602         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
5603         assert!(updates.update_fail_malformed_htlcs.is_empty());
5604
5605         nodes[2].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
5606         let events = nodes[2].node.get_and_clear_pending_msg_events();
5607         assert_eq!(events.len(), 1);
5608         match events[0] {
5609                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5610                 _ => panic!("Unexpected event"),
5611         }
5612
5613         let c_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 2 (commitment tx, HTLC-Success tx), ChannelMonitor : 1 (HTLC-Success tx)
5614         assert_eq!(c_txn.len(), 3);
5615         assert_eq!(c_txn[0], c_txn[2]);
5616         assert_eq!(commitment_tx[0], c_txn[1]);
5617         check_spends!(c_txn[1], chan_2.3.clone());
5618         check_spends!(c_txn[2], c_txn[1].clone());
5619         assert_eq!(c_txn[1].input[0].witness.clone().last().unwrap().len(), 71);
5620         assert_eq!(c_txn[2].input[0].witness.clone().last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5621         assert!(c_txn[0].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
5622         assert_eq!(c_txn[0].lock_time, 0); // Success tx
5623
5624         // So we broadcast C's commitment tx and HTLC-Success on B's chain, we should successfully be able to extract preimage and update downstream monitor
5625         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![c_txn[1].clone(), c_txn[2].clone()]}, 1);
5626         {
5627                 let mut b_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5628                 assert_eq!(b_txn.len(), 4);
5629                 assert_eq!(b_txn[0], b_txn[3]);
5630                 check_spends!(b_txn[1], chan_2.3); // B local commitment tx, issued by ChannelManager
5631                 check_spends!(b_txn[2], b_txn[1].clone()); // HTLC-Timeout on B local commitment tx, issued by ChannelManager
5632                 assert_eq!(b_txn[2].input[0].witness.clone().last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
5633                 assert!(b_txn[2].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
5634                 assert_ne!(b_txn[2].lock_time, 0); // Timeout tx
5635                 check_spends!(b_txn[0], c_txn[1].clone()); // timeout tx on C remote commitment tx, issued by ChannelMonitor, * 2 due to block rescan
5636                 assert_eq!(b_txn[0].input[0].witness.clone().last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5637                 assert!(b_txn[0].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
5638                 assert_ne!(b_txn[2].lock_time, 0); // Timeout tx
5639                 b_txn.clear();
5640         }
5641         let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
5642         check_added_monitors!(nodes[1], 1);
5643         match msg_events[0] {
5644                 MessageSendEvent::BroadcastChannelUpdate {  .. } => {},
5645                 _ => panic!("Unexpected event"),
5646         }
5647         match msg_events[1] {
5648                 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, .. } } => {
5649                         assert!(update_add_htlcs.is_empty());
5650                         assert!(update_fail_htlcs.is_empty());
5651                         assert_eq!(update_fulfill_htlcs.len(), 1);
5652                         assert!(update_fail_malformed_htlcs.is_empty());
5653                         assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
5654                 },
5655                 _ => panic!("Unexpected event"),
5656         };
5657         // Broadcast A's commitment tx on B's chain to see if we are able to claim inbound HTLC with our HTLC-Success tx
5658         let commitment_tx = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan_1.2).unwrap().last_local_commitment_txn.clone();
5659         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
5660         let b_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5661         assert_eq!(b_txn.len(), 3);
5662         check_spends!(b_txn[1], chan_1.3); // Local commitment tx, issued by ChannelManager
5663         assert_eq!(b_txn[0], b_txn[2]); // HTLC-Success tx, issued by ChannelMonitor, * 2 due to block rescan
5664         check_spends!(b_txn[0], commitment_tx[0].clone());
5665         assert_eq!(b_txn[0].input[0].witness.clone().last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
5666         assert!(b_txn[0].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
5667         assert_eq!(b_txn[2].lock_time, 0); // Success tx
5668         let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
5669         match msg_events[0] {
5670                 MessageSendEvent::BroadcastChannelUpdate {  .. } => {},
5671                 _ => panic!("Unexpected event"),
5672         }
5673 }
5674
5675 #[test]
5676 fn test_duplicate_payment_hash_one_failure_one_success() {
5677         // Topology : A --> B --> C
5678         // We route 2 payments with same hash between B and C, one will be timeout, the other successfully claim
5679         let mut nodes = create_network(3);
5680
5681         create_announced_chan_between_nodes(&nodes, 0, 1);
5682         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
5683
5684         let (our_payment_preimage, duplicate_payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 900000);
5685         *nodes[0].network_payment_count.borrow_mut() -= 1;
5686         assert_eq!(route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 900000).1, duplicate_payment_hash);
5687
5688         let commitment_txn = nodes[2].node.channel_state.lock().unwrap().by_id.get(&chan_2.2).unwrap().last_local_commitment_txn.clone();
5689         assert_eq!(commitment_txn[0].input.len(), 1);
5690         check_spends!(commitment_txn[0], chan_2.3.clone());
5691
5692         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5693         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![commitment_txn[0].clone()] }, 1);
5694         let htlc_timeout_tx;
5695         { // Extract one of the two HTLC-Timeout transaction
5696                 let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5697                 assert_eq!(node_txn.len(), 7);
5698                 assert_eq!(node_txn[0], node_txn[5]);
5699                 assert_eq!(node_txn[1], node_txn[6]);
5700                 check_spends!(node_txn[0], commitment_txn[0].clone());
5701                 assert_eq!(node_txn[0].input.len(), 1);
5702                 check_spends!(node_txn[1], commitment_txn[0].clone());
5703                 assert_eq!(node_txn[1].input.len(), 1);
5704                 assert_ne!(node_txn[0].input[0], node_txn[1].input[0]);
5705                 check_spends!(node_txn[2], chan_2.3.clone());
5706                 check_spends!(node_txn[3], node_txn[2].clone());
5707                 check_spends!(node_txn[4], node_txn[2].clone());
5708                 htlc_timeout_tx = node_txn[1].clone();
5709         }
5710
5711         let events = nodes[1].node.get_and_clear_pending_msg_events();
5712         match events[0] {
5713                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5714                 _ => panic!("Unexepected event"),
5715         }
5716
5717         nodes[2].node.claim_funds(our_payment_preimage);
5718         nodes[2].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![commitment_txn[0].clone()] }, 1);
5719         check_added_monitors!(nodes[2], 2);
5720         let events = nodes[2].node.get_and_clear_pending_msg_events();
5721         match events[0] {
5722                 MessageSendEvent::UpdateHTLCs { .. } => {},
5723                 _ => panic!("Unexpected event"),
5724         }
5725         match events[1] {
5726                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5727                 _ => panic!("Unexepected event"),
5728         }
5729         let htlc_success_txn: Vec<_> = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
5730         assert_eq!(htlc_success_txn.len(), 5);
5731         check_spends!(htlc_success_txn[2], chan_2.3.clone());
5732         assert_eq!(htlc_success_txn[0], htlc_success_txn[3]);
5733         assert_eq!(htlc_success_txn[0].input.len(), 1);
5734         assert_eq!(htlc_success_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5735         assert_eq!(htlc_success_txn[1], htlc_success_txn[4]);
5736         assert_eq!(htlc_success_txn[1].input.len(), 1);
5737         assert_eq!(htlc_success_txn[1].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5738         assert_ne!(htlc_success_txn[0].input[0], htlc_success_txn[1].input[0]);
5739         check_spends!(htlc_success_txn[0], commitment_txn[0].clone());
5740         check_spends!(htlc_success_txn[1], commitment_txn[0].clone());
5741
5742         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![htlc_timeout_tx] }, 200);
5743         let htlc_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5744         assert!(htlc_updates.update_add_htlcs.is_empty());
5745         assert_eq!(htlc_updates.update_fail_htlcs.len(), 1);
5746         assert_eq!(htlc_updates.update_fail_htlcs[0].htlc_id, 1);
5747         assert!(htlc_updates.update_fulfill_htlcs.is_empty());
5748         assert!(htlc_updates.update_fail_malformed_htlcs.is_empty());
5749         check_added_monitors!(nodes[1], 1);
5750
5751         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &htlc_updates.update_fail_htlcs[0]).unwrap();
5752         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
5753         {
5754                 commitment_signed_dance!(nodes[0], nodes[1], &htlc_updates.commitment_signed, false, true);
5755                 let events = nodes[0].node.get_and_clear_pending_msg_events();
5756                 assert_eq!(events.len(), 1);
5757                 match events[0] {
5758                         MessageSendEvent::PaymentFailureNetworkUpdate { update: msgs::HTLCFailChannelUpdate::ChannelClosed { .. }  } => {
5759                         },
5760                         _ => { panic!("Unexpected event"); }
5761                 }
5762         }
5763         let events = nodes[0].node.get_and_clear_pending_events();
5764         match events[0] {
5765                 Event::PaymentFailed { ref payment_hash, .. } => {
5766                         assert_eq!(*payment_hash, duplicate_payment_hash);
5767                 }
5768                 _ => panic!("Unexpected event"),
5769         }
5770
5771         // Solve 2nd HTLC by broadcasting on B's chain HTLC-Success Tx from C
5772         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![htlc_success_txn[0].clone()] }, 200);
5773         let updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5774         assert!(updates.update_add_htlcs.is_empty());
5775         assert!(updates.update_fail_htlcs.is_empty());
5776         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
5777         assert_eq!(updates.update_fulfill_htlcs[0].htlc_id, 0);
5778         assert!(updates.update_fail_malformed_htlcs.is_empty());
5779         check_added_monitors!(nodes[1], 1);
5780
5781         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]).unwrap();
5782         commitment_signed_dance!(nodes[0], nodes[1], &updates.commitment_signed, false);
5783
5784         let events = nodes[0].node.get_and_clear_pending_events();
5785         match events[0] {
5786                 Event::PaymentSent { ref payment_preimage } => {
5787                         assert_eq!(*payment_preimage, our_payment_preimage);
5788                 }
5789                 _ => panic!("Unexpected event"),
5790         }
5791 }
5792
5793 #[test]
5794 fn test_dynamic_spendable_outputs_local_htlc_success_tx() {
5795         let nodes = create_network(2);
5796
5797         // Create some initial channels
5798         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
5799
5800         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9000000).0;
5801         let local_txn = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan_1.2).unwrap().last_local_commitment_txn.clone();
5802         assert_eq!(local_txn[0].input.len(), 1);
5803         check_spends!(local_txn[0], chan_1.3.clone());
5804
5805         // Give B knowledge of preimage to be able to generate a local HTLC-Success Tx
5806         nodes[1].node.claim_funds(payment_preimage);
5807         check_added_monitors!(nodes[1], 1);
5808         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5809         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![local_txn[0].clone()] }, 1);
5810         let events = nodes[1].node.get_and_clear_pending_msg_events();
5811         match events[0] {
5812                 MessageSendEvent::UpdateHTLCs { .. } => {},
5813                 _ => panic!("Unexpected event"),
5814         }
5815         match events[1] {
5816                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5817                 _ => panic!("Unexepected event"),
5818         }
5819         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5820         assert_eq!(node_txn[0].input.len(), 1);
5821         assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5822         check_spends!(node_txn[0], local_txn[0].clone());
5823
5824         // Verify that B is able to spend its own HTLC-Success tx thanks to spendable output event given back by its ChannelMonitor
5825         let spend_txn = check_spendable_outputs!(nodes[1], 1);
5826         assert_eq!(spend_txn.len(), 2);
5827         check_spends!(spend_txn[0], node_txn[0].clone());
5828         check_spends!(spend_txn[1], node_txn[2].clone());
5829 }
5830
5831 #[test]
5832 fn test_dynamic_spendable_outputs_local_htlc_timeout_tx() {
5833         let nodes = create_network(2);
5834
5835         // Create some initial channels
5836         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
5837
5838         route_payment(&nodes[0], &vec!(&nodes[1])[..], 9000000).0;
5839         let local_txn = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan_1.2).unwrap().last_local_commitment_txn.clone();
5840         assert_eq!(local_txn[0].input.len(), 1);
5841         check_spends!(local_txn[0], chan_1.3.clone());
5842
5843         // Timeout HTLC on A's chain and so it can generate a HTLC-Timeout tx
5844         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5845         nodes[0].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![local_txn[0].clone()] }, 200);
5846         let events = nodes[0].node.get_and_clear_pending_msg_events();
5847         match events[0] {
5848                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5849                 _ => panic!("Unexepected event"),
5850         }
5851         let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
5852         assert_eq!(node_txn[0].input.len(), 1);
5853         assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
5854         check_spends!(node_txn[0], local_txn[0].clone());
5855
5856         // Verify that A is able to spend its own HTLC-Timeout tx thanks to spendable output event given back by its ChannelMonitor
5857         let spend_txn = check_spendable_outputs!(nodes[0], 1);
5858         assert_eq!(spend_txn.len(), 8);
5859         assert_eq!(spend_txn[0], spend_txn[2]);
5860         assert_eq!(spend_txn[0], spend_txn[4]);
5861         assert_eq!(spend_txn[0], spend_txn[6]);
5862         assert_eq!(spend_txn[1], spend_txn[3]);
5863         assert_eq!(spend_txn[1], spend_txn[5]);
5864         assert_eq!(spend_txn[1], spend_txn[7]);
5865         check_spends!(spend_txn[0], local_txn[0].clone());
5866         check_spends!(spend_txn[1], node_txn[0].clone());
5867 }
5868
5869 #[test]
5870 fn test_static_output_closing_tx() {
5871         let nodes = create_network(2);
5872
5873         let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
5874
5875         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000);
5876         let closing_tx = close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true).2;
5877
5878         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5879         nodes[0].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![closing_tx.clone()] }, 1);
5880         let spend_txn = check_spendable_outputs!(nodes[0], 2);
5881         assert_eq!(spend_txn.len(), 1);
5882         check_spends!(spend_txn[0], closing_tx.clone());
5883
5884         nodes[1].chain_monitor.block_connected_with_filtering(&Block { header, txdata: vec![closing_tx.clone()] }, 1);
5885         let spend_txn = check_spendable_outputs!(nodes[1], 2);
5886         assert_eq!(spend_txn.len(), 1);
5887         check_spends!(spend_txn[0], closing_tx);
5888 }
5889
5890 fn run_onion_failure_test<F1,F2>(_name: &str, test_case: u8, nodes: &Vec<Node>, route: &Route, payment_hash: &PaymentHash, callback_msg: F1, callback_node: F2, expected_retryable: bool, expected_error_code: Option<u16>, expected_channel_update: Option<HTLCFailChannelUpdate>)
5891         where F1: for <'a> FnMut(&'a mut msgs::UpdateAddHTLC),
5892                                 F2: FnMut(),
5893 {
5894         run_onion_failure_test_with_fail_intercept(_name, test_case, nodes, route, payment_hash, callback_msg, |_|{}, callback_node, expected_retryable, expected_error_code, expected_channel_update);
5895 }
5896
5897 // test_case
5898 // 0: node1 fail backward
5899 // 1: final node fail backward
5900 // 2: payment completed but the user reject the payment
5901 // 3: final node fail backward (but tamper onion payloads from node0)
5902 // 100: trigger error in the intermediate node and tamper returnning fail_htlc
5903 // 200: trigger error in the final node and tamper returnning fail_htlc
5904 fn run_onion_failure_test_with_fail_intercept<F1,F2,F3>(_name: &str, test_case: u8, nodes: &Vec<Node>, route: &Route, payment_hash: &PaymentHash, mut callback_msg: F1, mut callback_fail: F2, mut callback_node: F3, expected_retryable: bool, expected_error_code: Option<u16>, expected_channel_update: Option<HTLCFailChannelUpdate>)
5905         where F1: for <'a> FnMut(&'a mut msgs::UpdateAddHTLC),
5906                                 F2: for <'a> FnMut(&'a mut msgs::UpdateFailHTLC),
5907                                 F3: FnMut(),
5908 {
5909         use ln::msgs::HTLCFailChannelUpdate;
5910
5911         // reset block height
5912         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5913         for ix in 0..nodes.len() {
5914                 nodes[ix].chain_monitor.block_connected_checked(&header, 1, &Vec::new()[..], &[0; 0]);
5915         }
5916
5917         macro_rules! expect_event {
5918                 ($node: expr, $event_type: path) => {{
5919                         let events = $node.node.get_and_clear_pending_events();
5920                         assert_eq!(events.len(), 1);
5921                         match events[0] {
5922                                 $event_type { .. } => {},
5923                                 _ => panic!("Unexpected event"),
5924                         }
5925                 }}
5926         }
5927
5928         macro_rules! expect_htlc_forward {
5929                 ($node: expr) => {{
5930                         expect_event!($node, Event::PendingHTLCsForwardable);
5931                         $node.node.channel_state.lock().unwrap().next_forward = Instant::now();
5932                         $node.node.process_pending_htlc_forwards();
5933                 }}
5934         }
5935
5936         // 0 ~~> 2 send payment
5937         nodes[0].node.send_payment(route.clone(), payment_hash.clone()).unwrap();
5938         check_added_monitors!(nodes[0], 1);
5939         let update_0 = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
5940         // temper update_add (0 => 1)
5941         let mut update_add_0 = update_0.update_add_htlcs[0].clone();
5942         if test_case == 0 || test_case == 3 || test_case == 100 {
5943                 callback_msg(&mut update_add_0);
5944                 callback_node();
5945         }
5946         // 0 => 1 update_add & CS
5947         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &update_add_0).unwrap();
5948         commitment_signed_dance!(nodes[1], nodes[0], &update_0.commitment_signed, false, true);
5949
5950         let update_1_0 = match test_case {
5951                 0|100 => { // intermediate node failure; fail backward to 0
5952                         let update_1_0 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5953                         assert!(update_1_0.update_fail_htlcs.len()+update_1_0.update_fail_malformed_htlcs.len()==1 && (update_1_0.update_fail_htlcs.len()==1 || update_1_0.update_fail_malformed_htlcs.len()==1));
5954                         update_1_0
5955                 },
5956                 1|2|3|200 => { // final node failure; forwarding to 2
5957                         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
5958                         // forwarding on 1
5959                         if test_case != 200 {
5960                                 callback_node();
5961                         }
5962                         expect_htlc_forward!(&nodes[1]);
5963
5964                         let update_1 = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
5965                         check_added_monitors!(&nodes[1], 1);
5966                         assert_eq!(update_1.update_add_htlcs.len(), 1);
5967                         // tamper update_add (1 => 2)
5968                         let mut update_add_1 = update_1.update_add_htlcs[0].clone();
5969                         if test_case != 3 && test_case != 200 {
5970                                 callback_msg(&mut update_add_1);
5971                         }
5972
5973                         // 1 => 2
5974                         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &update_add_1).unwrap();
5975                         commitment_signed_dance!(nodes[2], nodes[1], update_1.commitment_signed, false, true);
5976
5977                         if test_case == 2 || test_case == 200 {
5978                                 expect_htlc_forward!(&nodes[2]);
5979                                 expect_event!(&nodes[2], Event::PaymentReceived);
5980                                 callback_node();
5981                         }
5982
5983                         let update_2_1 = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
5984                         if test_case == 2 || test_case == 200 {
5985                                 check_added_monitors!(&nodes[2], 1);
5986                         }
5987                         assert!(update_2_1.update_fail_htlcs.len() == 1);
5988
5989                         let mut fail_msg = update_2_1.update_fail_htlcs[0].clone();
5990                         if test_case == 200 {
5991                                 callback_fail(&mut fail_msg);
5992                         }
5993
5994                         // 2 => 1
5995                         nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &fail_msg).unwrap();
5996                         commitment_signed_dance!(nodes[1], nodes[2], update_2_1.commitment_signed, true, true);
5997
5998                         // backward fail on 1
5999                         let update_1_0 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
6000                         assert!(update_1_0.update_fail_htlcs.len() == 1);
6001                         update_1_0
6002                 },
6003                 _ => unreachable!(),
6004         };
6005
6006         // 1 => 0 commitment_signed_dance
6007         if update_1_0.update_fail_htlcs.len() > 0 {
6008                 let mut fail_msg = update_1_0.update_fail_htlcs[0].clone();
6009                 if test_case == 100 {
6010                         callback_fail(&mut fail_msg);
6011                 }
6012                 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &fail_msg).unwrap();
6013         } else {
6014                 nodes[0].node.handle_update_fail_malformed_htlc(&nodes[1].node.get_our_node_id(), &update_1_0.update_fail_malformed_htlcs[0]).unwrap();
6015         };
6016
6017         commitment_signed_dance!(nodes[0], nodes[1], update_1_0.commitment_signed, false, true);
6018
6019         let events = nodes[0].node.get_and_clear_pending_events();
6020         assert_eq!(events.len(), 1);
6021         if let &Event::PaymentFailed { payment_hash:_, ref rejected_by_dest, ref error_code } = &events[0] {
6022                 assert_eq!(*rejected_by_dest, !expected_retryable);
6023                 assert_eq!(*error_code, expected_error_code);
6024         } else {
6025                 panic!("Uexpected event");
6026         }
6027
6028         let events = nodes[0].node.get_and_clear_pending_msg_events();
6029         if expected_channel_update.is_some() {
6030                 assert_eq!(events.len(), 1);
6031                 match events[0] {
6032                         MessageSendEvent::PaymentFailureNetworkUpdate { ref update } => {
6033                                 match update {
6034                                         &HTLCFailChannelUpdate::ChannelUpdateMessage { .. } => {
6035                                                 if let HTLCFailChannelUpdate::ChannelUpdateMessage { .. } = expected_channel_update.unwrap() {} else {
6036                                                         panic!("channel_update not found!");
6037                                                 }
6038                                         },
6039                                         &HTLCFailChannelUpdate::ChannelClosed { ref short_channel_id, ref is_permanent } => {
6040                                                 if let HTLCFailChannelUpdate::ChannelClosed { short_channel_id: ref expected_short_channel_id, is_permanent: ref expected_is_permanent } = expected_channel_update.unwrap() {
6041                                                         assert!(*short_channel_id == *expected_short_channel_id);
6042                                                         assert!(*is_permanent == *expected_is_permanent);
6043                                                 } else {
6044                                                         panic!("Unexpected message event");
6045                                                 }
6046                                         },
6047                                         &HTLCFailChannelUpdate::NodeFailure { ref node_id, ref is_permanent } => {
6048                                                 if let HTLCFailChannelUpdate::NodeFailure { node_id: ref expected_node_id, is_permanent: ref expected_is_permanent } = expected_channel_update.unwrap() {
6049                                                         assert!(*node_id == *expected_node_id);
6050                                                         assert!(*is_permanent == *expected_is_permanent);
6051                                                 } else {
6052                                                         panic!("Unexpected message event");
6053                                                 }
6054                                         },
6055                                 }
6056                         },
6057                         _ => panic!("Unexpected message event"),
6058                 }
6059         } else {
6060                 assert_eq!(events.len(), 0);
6061         }
6062 }
6063
6064 impl msgs::ChannelUpdate {
6065         fn dummy() -> msgs::ChannelUpdate {
6066                 use secp256k1::ffi::Signature as FFISignature;
6067                 use secp256k1::Signature;
6068                 msgs::ChannelUpdate {
6069                         signature: Signature::from(FFISignature::new()),
6070                         contents: msgs::UnsignedChannelUpdate {
6071                                 chain_hash: Sha256dHash::from_data(&vec![0u8][..]),
6072                                 short_channel_id: 0,
6073                                 timestamp: 0,
6074                                 flags: 0,
6075                                 cltv_expiry_delta: 0,
6076                                 htlc_minimum_msat: 0,
6077                                 fee_base_msat: 0,
6078                                 fee_proportional_millionths: 0,
6079                                 excess_data: vec![],
6080                         }
6081                 }
6082         }
6083 }
6084
6085 #[test]
6086 fn test_onion_failure() {
6087         use ln::msgs::ChannelUpdate;
6088         use ln::channelmanager::CLTV_FAR_FAR_AWAY;
6089         use secp256k1;
6090
6091         const BADONION: u16 = 0x8000;
6092         const PERM: u16 = 0x4000;
6093         const NODE: u16 = 0x2000;
6094         const UPDATE: u16 = 0x1000;
6095
6096         let mut nodes = create_network(3);
6097         for node in nodes.iter() {
6098                 *node.keys_manager.override_session_priv.lock().unwrap() = Some(SecretKey::from_slice(&Secp256k1::without_caps(), &[3; 32]).unwrap());
6099         }
6100         let channels = [create_announced_chan_between_nodes(&nodes, 0, 1), create_announced_chan_between_nodes(&nodes, 1, 2)];
6101         let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
6102         let route = nodes[0].router.get_route(&nodes[2].node.get_our_node_id(), None, &Vec::new(), 40000, TEST_FINAL_CLTV).unwrap();
6103         // positve case
6104         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 40000);
6105
6106         // intermediate node failure
6107         run_onion_failure_test("invalid_realm", 0, &nodes, &route, &payment_hash, |msg| {
6108                 let session_priv = SecretKey::from_slice(&::secp256k1::Secp256k1::without_caps(), &[3; 32]).unwrap();
6109                 let cur_height = nodes[0].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
6110                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route, &session_priv).unwrap();
6111                 let (mut onion_payloads, _htlc_msat, _htlc_cltv) = onion_utils::build_onion_payloads(&route, cur_height).unwrap();
6112                 onion_payloads[0].realm = 3;
6113                 msg.onion_routing_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, &payment_hash);
6114         }, ||{}, true, Some(PERM|1), Some(msgs::HTLCFailChannelUpdate::ChannelClosed{short_channel_id: channels[1].0.contents.short_channel_id, is_permanent: true}));//XXX incremented channels idx here
6115
6116         // final node failure
6117         run_onion_failure_test("invalid_realm", 3, &nodes, &route, &payment_hash, |msg| {
6118                 let session_priv = SecretKey::from_slice(&::secp256k1::Secp256k1::without_caps(), &[3; 32]).unwrap();
6119                 let cur_height = nodes[0].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
6120                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route, &session_priv).unwrap();
6121                 let (mut onion_payloads, _htlc_msat, _htlc_cltv) = onion_utils::build_onion_payloads(&route, cur_height).unwrap();
6122                 onion_payloads[1].realm = 3;
6123                 msg.onion_routing_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, &payment_hash);
6124         }, ||{}, false, Some(PERM|1), Some(msgs::HTLCFailChannelUpdate::ChannelClosed{short_channel_id: channels[1].0.contents.short_channel_id, is_permanent: true}));
6125
6126         // the following three with run_onion_failure_test_with_fail_intercept() test only the origin node
6127         // receiving simulated fail messages
6128         // intermediate node failure
6129         run_onion_failure_test_with_fail_intercept("temporary_node_failure", 100, &nodes, &route, &payment_hash, |msg| {
6130                 // trigger error
6131                 msg.amount_msat -= 1;
6132         }, |msg| {
6133                 // and tamper returing error message
6134                 let session_priv = SecretKey::from_slice(&::secp256k1::Secp256k1::without_caps(), &[3; 32]).unwrap();
6135                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route, &session_priv).unwrap();
6136                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], NODE|2, &[0;0]);
6137         }, ||{}, true, Some(NODE|2), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.hops[0].pubkey, is_permanent: false}));
6138
6139         // final node failure
6140         run_onion_failure_test_with_fail_intercept("temporary_node_failure", 200, &nodes, &route, &payment_hash, |_msg| {}, |msg| {
6141                 // and tamper returing error message
6142                 let session_priv = SecretKey::from_slice(&::secp256k1::Secp256k1::without_caps(), &[3; 32]).unwrap();
6143                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route, &session_priv).unwrap();
6144                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[1].shared_secret[..], NODE|2, &[0;0]);
6145         }, ||{
6146                 nodes[2].node.fail_htlc_backwards(&payment_hash, 0);
6147         }, true, Some(NODE|2), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.hops[1].pubkey, is_permanent: false}));
6148
6149         // intermediate node failure
6150         run_onion_failure_test_with_fail_intercept("permanent_node_failure", 100, &nodes, &route, &payment_hash, |msg| {
6151                 msg.amount_msat -= 1;
6152         }, |msg| {
6153                 let session_priv = SecretKey::from_slice(&::secp256k1::Secp256k1::without_caps(), &[3; 32]).unwrap();
6154                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route, &session_priv).unwrap();
6155                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], PERM|NODE|2, &[0;0]);
6156         }, ||{}, true, Some(PERM|NODE|2), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.hops[0].pubkey, is_permanent: true}));
6157
6158         // final node failure
6159         run_onion_failure_test_with_fail_intercept("permanent_node_failure", 200, &nodes, &route, &payment_hash, |_msg| {}, |msg| {
6160                 let session_priv = SecretKey::from_slice(&::secp256k1::Secp256k1::without_caps(), &[3; 32]).unwrap();
6161                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route, &session_priv).unwrap();
6162                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[1].shared_secret[..], PERM|NODE|2, &[0;0]);
6163         }, ||{
6164                 nodes[2].node.fail_htlc_backwards(&payment_hash, 0);
6165         }, false, Some(PERM|NODE|2), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.hops[1].pubkey, is_permanent: true}));
6166
6167         // intermediate node failure
6168         run_onion_failure_test_with_fail_intercept("required_node_feature_missing", 100, &nodes, &route, &payment_hash, |msg| {
6169                 msg.amount_msat -= 1;
6170         }, |msg| {
6171                 let session_priv = SecretKey::from_slice(&::secp256k1::Secp256k1::without_caps(), &[3; 32]).unwrap();
6172                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route, &session_priv).unwrap();
6173                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], PERM|NODE|3, &[0;0]);
6174         }, ||{
6175                 nodes[2].node.fail_htlc_backwards(&payment_hash, 0);
6176         }, true, Some(PERM|NODE|3), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.hops[0].pubkey, is_permanent: true}));
6177
6178         // final node failure
6179         run_onion_failure_test_with_fail_intercept("required_node_feature_missing", 200, &nodes, &route, &payment_hash, |_msg| {}, |msg| {
6180                 let session_priv = SecretKey::from_slice(&::secp256k1::Secp256k1::without_caps(), &[3; 32]).unwrap();
6181                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route, &session_priv).unwrap();
6182                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[1].shared_secret[..], PERM|NODE|3, &[0;0]);
6183         }, ||{
6184                 nodes[2].node.fail_htlc_backwards(&payment_hash, 0);
6185         }, false, Some(PERM|NODE|3), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.hops[1].pubkey, is_permanent: true}));
6186
6187         run_onion_failure_test("invalid_onion_version", 0, &nodes, &route, &payment_hash, |msg| { msg.onion_routing_packet.version = 1; }, ||{}, true,
6188                 Some(BADONION|PERM|4), None);
6189
6190         run_onion_failure_test("invalid_onion_hmac", 0, &nodes, &route, &payment_hash, |msg| { msg.onion_routing_packet.hmac = [3; 32]; }, ||{}, true,
6191                 Some(BADONION|PERM|5), None);
6192
6193         run_onion_failure_test("invalid_onion_key", 0, &nodes, &route, &payment_hash, |msg| { msg.onion_routing_packet.public_key = Err(secp256k1::Error::InvalidPublicKey);}, ||{}, true,
6194                 Some(BADONION|PERM|6), None);
6195
6196         run_onion_failure_test_with_fail_intercept("temporary_channel_failure", 100, &nodes, &route, &payment_hash, |msg| {
6197                 msg.amount_msat -= 1;
6198         }, |msg| {
6199                 let session_priv = SecretKey::from_slice(&::secp256k1::Secp256k1::without_caps(), &[3; 32]).unwrap();
6200                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route, &session_priv).unwrap();
6201                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], UPDATE|7, &ChannelUpdate::dummy().encode_with_len()[..]);
6202         }, ||{}, true, Some(UPDATE|7), Some(msgs::HTLCFailChannelUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy()}));
6203
6204         run_onion_failure_test_with_fail_intercept("permanent_channel_failure", 100, &nodes, &route, &payment_hash, |msg| {
6205                 msg.amount_msat -= 1;
6206         }, |msg| {
6207                 let session_priv = SecretKey::from_slice(&::secp256k1::Secp256k1::without_caps(), &[3; 32]).unwrap();
6208                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route, &session_priv).unwrap();
6209                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], PERM|8, &[0;0]);
6210                 // short_channel_id from the processing node
6211         }, ||{}, true, Some(PERM|8), Some(msgs::HTLCFailChannelUpdate::ChannelClosed{short_channel_id: channels[1].0.contents.short_channel_id, is_permanent: true}));
6212
6213         run_onion_failure_test_with_fail_intercept("required_channel_feature_missing", 100, &nodes, &route, &payment_hash, |msg| {
6214                 msg.amount_msat -= 1;
6215         }, |msg| {
6216                 let session_priv = SecretKey::from_slice(&::secp256k1::Secp256k1::without_caps(), &[3; 32]).unwrap();
6217                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route, &session_priv).unwrap();
6218                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], PERM|9, &[0;0]);
6219                 // short_channel_id from the processing node
6220         }, ||{}, true, Some(PERM|9), Some(msgs::HTLCFailChannelUpdate::ChannelClosed{short_channel_id: channels[1].0.contents.short_channel_id, is_permanent: true}));
6221
6222         let mut bogus_route = route.clone();
6223         bogus_route.hops[1].short_channel_id -= 1;
6224         run_onion_failure_test("unknown_next_peer", 0, &nodes, &bogus_route, &payment_hash, |_| {}, ||{}, true, Some(PERM|10),
6225           Some(msgs::HTLCFailChannelUpdate::ChannelClosed{short_channel_id: bogus_route.hops[1].short_channel_id, is_permanent:true}));
6226
6227         let amt_to_forward = nodes[1].node.channel_state.lock().unwrap().by_id.get(&channels[1].2).unwrap().get_their_htlc_minimum_msat() - 1;
6228         let mut bogus_route = route.clone();
6229         let route_len = bogus_route.hops.len();
6230         bogus_route.hops[route_len-1].fee_msat = amt_to_forward;
6231         run_onion_failure_test("amount_below_minimum", 0, &nodes, &bogus_route, &payment_hash, |_| {}, ||{}, true, Some(UPDATE|11), Some(msgs::HTLCFailChannelUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy()}));
6232
6233         //TODO: with new config API, we will be able to generate both valid and
6234         //invalid channel_update cases.
6235         run_onion_failure_test("fee_insufficient", 0, &nodes, &route, &payment_hash, |msg| {
6236                 msg.amount_msat -= 1;
6237         }, || {}, true, Some(UPDATE|12), Some(msgs::HTLCFailChannelUpdate::ChannelClosed { short_channel_id: channels[0].0.contents.short_channel_id, is_permanent: true}));
6238
6239         run_onion_failure_test("incorrect_cltv_expiry", 0, &nodes, &route, &payment_hash, |msg| {
6240                 // need to violate: cltv_expiry - cltv_expiry_delta >= outgoing_cltv_value
6241                 msg.cltv_expiry -= 1;
6242         }, || {}, true, Some(UPDATE|13), Some(msgs::HTLCFailChannelUpdate::ChannelClosed { short_channel_id: channels[0].0.contents.short_channel_id, is_permanent: true}));
6243
6244         run_onion_failure_test("expiry_too_soon", 0, &nodes, &route, &payment_hash, |msg| {
6245                 let height = msg.cltv_expiry - CLTV_CLAIM_BUFFER - HTLC_FAIL_TIMEOUT_BLOCKS + 1;
6246                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
6247                 nodes[1].chain_monitor.block_connected_checked(&header, height, &Vec::new()[..], &[0; 0]);
6248         }, ||{}, true, Some(UPDATE|14), Some(msgs::HTLCFailChannelUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy()}));
6249
6250         run_onion_failure_test("unknown_payment_hash", 2, &nodes, &route, &payment_hash, |_| {}, || {
6251                 nodes[2].node.fail_htlc_backwards(&payment_hash, 0);
6252         }, false, Some(PERM|15), None);
6253
6254         run_onion_failure_test("final_expiry_too_soon", 1, &nodes, &route, &payment_hash, |msg| {
6255                 let height = msg.cltv_expiry - CLTV_CLAIM_BUFFER - HTLC_FAIL_TIMEOUT_BLOCKS + 1;
6256                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
6257                 nodes[2].chain_monitor.block_connected_checked(&header, height, &Vec::new()[..], &[0; 0]);
6258         }, || {}, true, Some(17), None);
6259
6260         run_onion_failure_test("final_incorrect_cltv_expiry", 1, &nodes, &route, &payment_hash, |_| {}, || {
6261                 for (_, pending_forwards) in nodes[1].node.channel_state.lock().unwrap().borrow_parts().forward_htlcs.iter_mut() {
6262                         for f in pending_forwards.iter_mut() {
6263                                 f.forward_info.outgoing_cltv_value += 1;
6264                         }
6265                 }
6266         }, true, Some(18), None);
6267
6268         run_onion_failure_test("final_incorrect_htlc_amount", 1, &nodes, &route, &payment_hash, |_| {}, || {
6269                 // violate amt_to_forward > msg.amount_msat
6270                 for (_, pending_forwards) in nodes[1].node.channel_state.lock().unwrap().borrow_parts().forward_htlcs.iter_mut() {
6271                         for f in pending_forwards.iter_mut() {
6272                                 f.forward_info.amt_to_forward -= 1;
6273                         }
6274                 }
6275         }, true, Some(19), None);
6276
6277         run_onion_failure_test("channel_disabled", 0, &nodes, &route, &payment_hash, |_| {}, || {
6278                 // disconnect event to the channel between nodes[1] ~ nodes[2]
6279                 nodes[1].node.peer_disconnected(&nodes[2].node.get_our_node_id(), false);
6280                 nodes[2].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
6281         }, true, Some(UPDATE|20), Some(msgs::HTLCFailChannelUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy()}));
6282         reconnect_nodes(&nodes[1], &nodes[2], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
6283
6284         run_onion_failure_test("expiry_too_far", 0, &nodes, &route, &payment_hash, |msg| {
6285                 let session_priv = SecretKey::from_slice(&::secp256k1::Secp256k1::without_caps(), &[3; 32]).unwrap();
6286                 let mut route = route.clone();
6287                 let height = 1;
6288                 route.hops[1].cltv_expiry_delta += CLTV_FAR_FAR_AWAY + route.hops[0].cltv_expiry_delta + 1;
6289                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route, &session_priv).unwrap();
6290                 let (onion_payloads, _, htlc_cltv) = onion_utils::build_onion_payloads(&route, height).unwrap();
6291                 let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, &payment_hash);
6292                 msg.cltv_expiry = htlc_cltv;
6293                 msg.onion_routing_packet = onion_packet;
6294         }, ||{}, true, Some(21), None);
6295 }