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

   1 //! Functional tests which test the correct handling of ChannelMonitorUpdateErr returns from
   2 //! monitor updates.
   3 //! There are a bunch of these as their handling is relatively error-prone so they are split out
   4 //! here. See also the chanmon_fail_consistency fuzz test.
   5
   6 use ln::channelmanager::{RAACommitmentOrder, PaymentPreimage, PaymentHash};
   7 use ln::channelmonitor::ChannelMonitorUpdateErr;
   8 use ln::msgs;
   9 use ln::msgs::{ChannelMessageHandler, LocalFeatures, RoutingMessageHandler};
  10 use util::events::{Event, EventsProvider, MessageSendEvent, MessageSendEventsProvider};
  11 use util::errors::APIError;
  12
  13 use bitcoin_hashes::sha256::Hash as Sha256;
  14 use bitcoin_hashes::Hash;
  15
  16 use ln::functional_test_utils::*;
  17
  18 #[test]
  19 fn test_simple_monitor_permanent_update_fail() {
  20         // Test that we handle a simple permanent monitor update failure
  21         let mut nodes = create_network(2, &[None, None]);
  22         create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
  23
  24         let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
  25         let (_, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
  26
  27         *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::PermanentFailure);
  28         if let Err(APIError::ChannelUnavailable {..}) = nodes[0].node.send_payment(route, payment_hash_1) {} else { panic!(); }
  29         check_added_monitors!(nodes[0], 1);
  30
  31         let events_1 = nodes[0].node.get_and_clear_pending_msg_events();
  32         assert_eq!(events_1.len(), 2);
  33         match events_1[0] {
  34                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
  35                 _ => panic!("Unexpected event"),
  36         };
  37         match events_1[1] {
  38                 MessageSendEvent::HandleError { node_id, .. } => assert_eq!(node_id, nodes[1].node.get_our_node_id()),
  39                 _ => panic!("Unexpected event"),
  40         };
  41
  42         // TODO: Once we hit the chain with the failure transaction we should check that we get a
  43         // PaymentFailed event
  44
  45         assert_eq!(nodes[0].node.list_channels().len(), 0);
  46 }
  47
  48 fn do_test_simple_monitor_temporary_update_fail(disconnect: bool) {
  49         // Test that we can recover from a simple temporary monitor update failure optionally with
  50         // a disconnect in between
  51         let mut nodes = create_network(2, &[None, None]);
  52         create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
  53
  54         let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
  55         let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
  56
  57         *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
  58         if let Err(APIError::MonitorUpdateFailed) = nodes[0].node.send_payment(route.clone(), payment_hash_1) {} else { panic!(); }
  59         check_added_monitors!(nodes[0], 1);
  60
  61         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
  62         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
  63         assert_eq!(nodes[0].node.list_channels().len(), 1);
  64
  65         if disconnect {
  66                 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
  67                 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
  68                 reconnect_nodes(&nodes[0], &nodes[1], (true, true), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
  69         }
  70
  71         *nodes[0].chan_monitor.update_ret.lock().unwrap() = Ok(());
  72         nodes[0].node.test_restore_channel_monitor();
  73         check_added_monitors!(nodes[0], 1);
  74
  75         let mut events_2 = nodes[0].node.get_and_clear_pending_msg_events();
  76         assert_eq!(events_2.len(), 1);
  77         let payment_event = SendEvent::from_event(events_2.pop().unwrap());
  78         assert_eq!(payment_event.node_id, nodes[1].node.get_our_node_id());
  79         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]).unwrap();
  80         commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
  81
  82         expect_pending_htlcs_forwardable!(nodes[1]);
  83
  84         let events_3 = nodes[1].node.get_and_clear_pending_events();
  85         assert_eq!(events_3.len(), 1);
  86         match events_3[0] {
  87                 Event::PaymentReceived { ref payment_hash, amt } => {
  88                         assert_eq!(payment_hash_1, *payment_hash);
  89                         assert_eq!(amt, 1000000);
  90                 },
  91                 _ => panic!("Unexpected event"),
  92         }
  93
  94         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
  95
  96         // Now set it to failed again...
  97         let (_, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
  98         *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
  99         if let Err(APIError::MonitorUpdateFailed) = nodes[0].node.send_payment(route, payment_hash_2) {} else { panic!(); }
 100         check_added_monitors!(nodes[0], 1);
 101
 102         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
 103         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 104         assert_eq!(nodes[0].node.list_channels().len(), 1);
 105
 106         if disconnect {
 107                 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
 108                 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
 109                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
 110         }
 111
 112         // ...and make sure we can force-close a TemporaryFailure channel with a PermanentFailure
 113         *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::PermanentFailure);
 114         nodes[0].node.test_restore_channel_monitor();
 115         check_added_monitors!(nodes[0], 1);
 116         check_closed_broadcast!(nodes[0]);
 117
 118         // TODO: Once we hit the chain with the failure transaction we should check that we get a
 119         // PaymentFailed event
 120
 121         assert_eq!(nodes[0].node.list_channels().len(), 0);
 122 }
 123
 124 #[test]
 125 fn test_simple_monitor_temporary_update_fail() {
 126         do_test_simple_monitor_temporary_update_fail(false);
 127         do_test_simple_monitor_temporary_update_fail(true);
 128 }
 129
 130 fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
 131         let disconnect_flags = 8 | 16;
 132
 133         // Test that we can recover from a temporary monitor update failure with some in-flight
 134         // HTLCs going on at the same time potentially with some disconnection thrown in.
 135         // * First we route a payment, then get a temporary monitor update failure when trying to
 136         //   route a second payment. We then claim the first payment.
 137         // * If disconnect_count is set, we will disconnect at this point (which is likely as
 138         //   TemporaryFailure likely indicates net disconnect which resulted in failing to update
 139         //   the ChannelMonitor on a watchtower).
 140         // * If !(disconnect_count & 16) we deliver a update_fulfill_htlc/CS for the first payment
 141         //   immediately, otherwise we wait disconnect and deliver them via the reconnect
 142         //   channel_reestablish processing (ie disconnect_count & 16 makes no sense if
 143         //   disconnect_count & !disconnect_flags is 0).
 144         // * We then update the channel monitor, reconnecting if disconnect_count is set and walk
 145         //   through message sending, potentially disconnect/reconnecting multiple times based on
 146         //   disconnect_count, to get the update_fulfill_htlc through.
 147         // * We then walk through more message exchanges to get the original update_add_htlc
 148         //   through, swapping message ordering based on disconnect_count & 8 and optionally
 149         //   disconnect/reconnecting based on disconnect_count.
 150         let mut nodes = create_network(2, &[None, None]);
 151         create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
 152
 153         let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
 154
 155         // Now try to send a second payment which will fail to send
 156         let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
 157         let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
 158
 159         *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
 160         if let Err(APIError::MonitorUpdateFailed) = nodes[0].node.send_payment(route.clone(), payment_hash_2) {} else { panic!(); }
 161         check_added_monitors!(nodes[0], 1);
 162
 163         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
 164         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 165         assert_eq!(nodes[0].node.list_channels().len(), 1);
 166
 167         // Claim the previous payment, which will result in a update_fulfill_htlc/CS from nodes[1]
 168         // but nodes[0] won't respond since it is frozen.
 169         assert!(nodes[1].node.claim_funds(payment_preimage_1, 1_000_000));
 170         check_added_monitors!(nodes[1], 1);
 171         let events_2 = nodes[1].node.get_and_clear_pending_msg_events();
 172         assert_eq!(events_2.len(), 1);
 173         let (bs_initial_fulfill, bs_initial_commitment_signed) = match events_2[0] {
 174                 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 } } => {
 175                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
 176                         assert!(update_add_htlcs.is_empty());
 177                         assert_eq!(update_fulfill_htlcs.len(), 1);
 178                         assert!(update_fail_htlcs.is_empty());
 179                         assert!(update_fail_malformed_htlcs.is_empty());
 180                         assert!(update_fee.is_none());
 181
 182                         if (disconnect_count & 16) == 0 {
 183                                 nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_htlcs[0]).unwrap();
 184                                 let events_3 = nodes[0].node.get_and_clear_pending_events();
 185                                 assert_eq!(events_3.len(), 1);
 186                                 match events_3[0] {
 187                                         Event::PaymentSent { ref payment_preimage } => {
 188                                                 assert_eq!(*payment_preimage, payment_preimage_1);
 189                                         },
 190                                         _ => panic!("Unexpected event"),
 191                                 }
 192
 193                                 if let Err(msgs::LightningError{err, action: msgs::ErrorAction::IgnoreError }) = nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), commitment_signed) {
 194                                         assert_eq!(err, "Previous monitor update failure prevented generation of RAA");
 195                                 } else { panic!(); }
 196                         }
 197
 198                         (update_fulfill_htlcs[0].clone(), commitment_signed.clone())
 199                 },
 200                 _ => panic!("Unexpected event"),
 201         };
 202
 203         if disconnect_count & !disconnect_flags > 0 {
 204                 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
 205                 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
 206         }
 207
 208         // Now fix monitor updating...
 209         *nodes[0].chan_monitor.update_ret.lock().unwrap() = Ok(());
 210         nodes[0].node.test_restore_channel_monitor();
 211         check_added_monitors!(nodes[0], 1);
 212
 213         macro_rules! disconnect_reconnect_peers { () => { {
 214                 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
 215                 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
 216
 217                 nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id());
 218                 let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
 219                 assert_eq!(reestablish_1.len(), 1);
 220                 nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id());
 221                 let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
 222                 assert_eq!(reestablish_2.len(), 1);
 223
 224                 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]).unwrap();
 225                 let as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
 226                 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]).unwrap();
 227                 let bs_resp = handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
 228
 229                 assert!(as_resp.0.is_none());
 230                 assert!(bs_resp.0.is_none());
 231
 232                 (reestablish_1, reestablish_2, as_resp, bs_resp)
 233         } } }
 234
 235         let (payment_event, initial_revoke_and_ack) = if disconnect_count & !disconnect_flags > 0 {
 236                 assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
 237                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 238
 239                 nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id());
 240                 let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
 241                 assert_eq!(reestablish_1.len(), 1);
 242                 nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id());
 243                 let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
 244                 assert_eq!(reestablish_2.len(), 1);
 245
 246                 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]).unwrap();
 247                 check_added_monitors!(nodes[0], 0);
 248                 let mut as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
 249                 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]).unwrap();
 250                 check_added_monitors!(nodes[1], 0);
 251                 let mut bs_resp = handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
 252
 253                 assert!(as_resp.0.is_none());
 254                 assert!(bs_resp.0.is_none());
 255
 256                 assert!(bs_resp.1.is_none());
 257                 if (disconnect_count & 16) == 0 {
 258                         assert!(bs_resp.2.is_none());
 259
 260                         assert!(as_resp.1.is_some());
 261                         assert!(as_resp.2.is_some());
 262                         assert!(as_resp.3 == RAACommitmentOrder::CommitmentFirst);
 263                 } else {
 264                         assert!(bs_resp.2.as_ref().unwrap().update_add_htlcs.is_empty());
 265                         assert!(bs_resp.2.as_ref().unwrap().update_fail_htlcs.is_empty());
 266                         assert!(bs_resp.2.as_ref().unwrap().update_fail_malformed_htlcs.is_empty());
 267                         assert!(bs_resp.2.as_ref().unwrap().update_fee.is_none());
 268                         assert!(bs_resp.2.as_ref().unwrap().update_fulfill_htlcs == vec![bs_initial_fulfill]);
 269                         assert!(bs_resp.2.as_ref().unwrap().commitment_signed == bs_initial_commitment_signed);
 270
 271                         assert!(as_resp.1.is_none());
 272
 273                         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();
 274                         let events_3 = nodes[0].node.get_and_clear_pending_events();
 275                         assert_eq!(events_3.len(), 1);
 276                         match events_3[0] {
 277                                 Event::PaymentSent { ref payment_preimage } => {
 278                                         assert_eq!(*payment_preimage, payment_preimage_1);
 279                                 },
 280                                 _ => panic!("Unexpected event"),
 281                         }
 282
 283                         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_resp.2.as_ref().unwrap().commitment_signed).unwrap();
 284                         let as_resp_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 285                         // No commitment_signed so get_event_msg's assert(len == 1) passes
 286                         check_added_monitors!(nodes[0], 1);
 287
 288                         as_resp.1 = Some(as_resp_raa);
 289                         bs_resp.2 = None;
 290                 }
 291
 292                 if disconnect_count & !disconnect_flags > 1 {
 293                         let (second_reestablish_1, second_reestablish_2, second_as_resp, second_bs_resp) = disconnect_reconnect_peers!();
 294
 295                         if (disconnect_count & 16) == 0 {
 296                                 assert!(reestablish_1 == second_reestablish_1);
 297                                 assert!(reestablish_2 == second_reestablish_2);
 298                         }
 299                         assert!(as_resp == second_as_resp);
 300                         assert!(bs_resp == second_bs_resp);
 301                 }
 302
 303                 (SendEvent::from_commitment_update(nodes[1].node.get_our_node_id(), as_resp.2.unwrap()), as_resp.1.unwrap())
 304         } else {
 305                 let mut events_4 = nodes[0].node.get_and_clear_pending_msg_events();
 306                 assert_eq!(events_4.len(), 2);
 307                 (SendEvent::from_event(events_4.remove(0)), match events_4[0] {
 308                         MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
 309                                 assert_eq!(*node_id, nodes[1].node.get_our_node_id());
 310                                 msg.clone()
 311                         },
 312                         _ => panic!("Unexpected event"),
 313                 })
 314         };
 315
 316         assert_eq!(payment_event.node_id, nodes[1].node.get_our_node_id());
 317
 318         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]).unwrap();
 319         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event.commitment_msg).unwrap();
 320         let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
 321         // nodes[1] is awaiting an RAA from nodes[0] still so get_event_msg's assert(len == 1) passes
 322         check_added_monitors!(nodes[1], 1);
 323
 324         if disconnect_count & !disconnect_flags > 2 {
 325                 let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!();
 326
 327                 assert!(as_resp.1.unwrap() == initial_revoke_and_ack);
 328                 assert!(bs_resp.1.unwrap() == bs_revoke_and_ack);
 329
 330                 assert!(as_resp.2.is_none());
 331                 assert!(bs_resp.2.is_none());
 332         }
 333
 334         let as_commitment_update;
 335         let bs_second_commitment_update;
 336
 337         macro_rules! handle_bs_raa { () => {
 338                 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack).unwrap();
 339                 as_commitment_update = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 340                 assert!(as_commitment_update.update_add_htlcs.is_empty());
 341                 assert!(as_commitment_update.update_fulfill_htlcs.is_empty());
 342                 assert!(as_commitment_update.update_fail_htlcs.is_empty());
 343                 assert!(as_commitment_update.update_fail_malformed_htlcs.is_empty());
 344                 assert!(as_commitment_update.update_fee.is_none());
 345                 check_added_monitors!(nodes[0], 1);
 346         } }
 347
 348         macro_rules! handle_initial_raa { () => {
 349                 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &initial_revoke_and_ack).unwrap();
 350                 bs_second_commitment_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 351                 assert!(bs_second_commitment_update.update_add_htlcs.is_empty());
 352                 assert!(bs_second_commitment_update.update_fulfill_htlcs.is_empty());
 353                 assert!(bs_second_commitment_update.update_fail_htlcs.is_empty());
 354                 assert!(bs_second_commitment_update.update_fail_malformed_htlcs.is_empty());
 355                 assert!(bs_second_commitment_update.update_fee.is_none());
 356                 check_added_monitors!(nodes[1], 1);
 357         } }
 358
 359         if (disconnect_count & 8) == 0 {
 360                 handle_bs_raa!();
 361
 362                 if disconnect_count & !disconnect_flags > 3 {
 363                         let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!();
 364
 365                         assert!(as_resp.1.unwrap() == initial_revoke_and_ack);
 366                         assert!(bs_resp.1.is_none());
 367
 368                         assert!(as_resp.2.unwrap() == as_commitment_update);
 369                         assert!(bs_resp.2.is_none());
 370
 371                         assert!(as_resp.3 == RAACommitmentOrder::RevokeAndACKFirst);
 372                 }
 373
 374                 handle_initial_raa!();
 375
 376                 if disconnect_count & !disconnect_flags > 4 {
 377                         let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!();
 378
 379                         assert!(as_resp.1.is_none());
 380                         assert!(bs_resp.1.is_none());
 381
 382                         assert!(as_resp.2.unwrap() == as_commitment_update);
 383                         assert!(bs_resp.2.unwrap() == bs_second_commitment_update);
 384                 }
 385         } else {
 386                 handle_initial_raa!();
 387
 388                 if disconnect_count & !disconnect_flags > 3 {
 389                         let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!();
 390
 391                         assert!(as_resp.1.is_none());
 392                         assert!(bs_resp.1.unwrap() == bs_revoke_and_ack);
 393
 394                         assert!(as_resp.2.is_none());
 395                         assert!(bs_resp.2.unwrap() == bs_second_commitment_update);
 396
 397                         assert!(bs_resp.3 == RAACommitmentOrder::RevokeAndACKFirst);
 398                 }
 399
 400                 handle_bs_raa!();
 401
 402                 if disconnect_count & !disconnect_flags > 4 {
 403                         let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!();
 404
 405                         assert!(as_resp.1.is_none());
 406                         assert!(bs_resp.1.is_none());
 407
 408                         assert!(as_resp.2.unwrap() == as_commitment_update);
 409                         assert!(bs_resp.2.unwrap() == bs_second_commitment_update);
 410                 }
 411         }
 412
 413         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_second_commitment_update.commitment_signed).unwrap();
 414         let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 415         // No commitment_signed so get_event_msg's assert(len == 1) passes
 416         check_added_monitors!(nodes[0], 1);
 417
 418         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_commitment_update.commitment_signed).unwrap();
 419         let bs_second_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
 420         // No commitment_signed so get_event_msg's assert(len == 1) passes
 421         check_added_monitors!(nodes[1], 1);
 422
 423         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_and_ack).unwrap();
 424         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 425         check_added_monitors!(nodes[1], 1);
 426
 427         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_second_revoke_and_ack).unwrap();
 428         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 429         check_added_monitors!(nodes[0], 1);
 430
 431         expect_pending_htlcs_forwardable!(nodes[1]);
 432
 433         let events_5 = nodes[1].node.get_and_clear_pending_events();
 434         assert_eq!(events_5.len(), 1);
 435         match events_5[0] {
 436                 Event::PaymentReceived { ref payment_hash, amt } => {
 437                         assert_eq!(payment_hash_2, *payment_hash);
 438                         assert_eq!(amt, 1000000);
 439                 },
 440                 _ => panic!("Unexpected event"),
 441         }
 442
 443         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
 444 }
 445
 446 #[test]
 447 fn test_monitor_temporary_update_fail_a() {
 448         do_test_monitor_temporary_update_fail(0);
 449         do_test_monitor_temporary_update_fail(1);
 450         do_test_monitor_temporary_update_fail(2);
 451         do_test_monitor_temporary_update_fail(3);
 452         do_test_monitor_temporary_update_fail(4);
 453         do_test_monitor_temporary_update_fail(5);
 454 }
 455
 456 #[test]
 457 fn test_monitor_temporary_update_fail_b() {
 458         do_test_monitor_temporary_update_fail(2 | 8);
 459         do_test_monitor_temporary_update_fail(3 | 8);
 460         do_test_monitor_temporary_update_fail(4 | 8);
 461         do_test_monitor_temporary_update_fail(5 | 8);
 462 }
 463
 464 #[test]
 465 fn test_monitor_temporary_update_fail_c() {
 466         do_test_monitor_temporary_update_fail(1 | 16);
 467         do_test_monitor_temporary_update_fail(2 | 16);
 468         do_test_monitor_temporary_update_fail(3 | 16);
 469         do_test_monitor_temporary_update_fail(2 | 8 | 16);
 470         do_test_monitor_temporary_update_fail(3 | 8 | 16);
 471 }
 472
 473 #[test]
 474 fn test_monitor_update_fail_cs() {
 475         // Tests handling of a monitor update failure when processing an incoming commitment_signed
 476         let mut nodes = create_network(2, &[None, None]);
 477         create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
 478
 479         let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
 480         let (payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 481         nodes[0].node.send_payment(route, our_payment_hash).unwrap();
 482         check_added_monitors!(nodes[0], 1);
 483
 484         let send_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
 485         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_event.msgs[0]).unwrap();
 486
 487         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
 488         if let msgs::LightningError { err, action: msgs::ErrorAction::IgnoreError } = nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &send_event.commitment_msg).unwrap_err() {
 489                 assert_eq!(err, "Failed to update ChannelMonitor");
 490         } else { panic!(); }
 491         check_added_monitors!(nodes[1], 1);
 492         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 493
 494         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
 495         nodes[1].node.test_restore_channel_monitor();
 496         check_added_monitors!(nodes[1], 1);
 497         let responses = nodes[1].node.get_and_clear_pending_msg_events();
 498         assert_eq!(responses.len(), 2);
 499
 500         match responses[0] {
 501                 MessageSendEvent::SendRevokeAndACK { ref msg, ref node_id } => {
 502                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
 503                         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &msg).unwrap();
 504                         check_added_monitors!(nodes[0], 1);
 505                 },
 506                 _ => panic!("Unexpected event"),
 507         }
 508         match responses[1] {
 509                 MessageSendEvent::UpdateHTLCs { ref updates, ref node_id } => {
 510                         assert!(updates.update_add_htlcs.is_empty());
 511                         assert!(updates.update_fulfill_htlcs.is_empty());
 512                         assert!(updates.update_fail_htlcs.is_empty());
 513                         assert!(updates.update_fail_malformed_htlcs.is_empty());
 514                         assert!(updates.update_fee.is_none());
 515                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
 516
 517                         *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
 518                         if let msgs::LightningError { err, action: msgs::ErrorAction::IgnoreError } = nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &updates.commitment_signed).unwrap_err() {
 519                                 assert_eq!(err, "Failed to update ChannelMonitor");
 520                         } else { panic!(); }
 521                         check_added_monitors!(nodes[0], 1);
 522                         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 523                 },
 524                 _ => panic!("Unexpected event"),
 525         }
 526
 527         *nodes[0].chan_monitor.update_ret.lock().unwrap() = Ok(());
 528         nodes[0].node.test_restore_channel_monitor();
 529         check_added_monitors!(nodes[0], 1);
 530
 531         let final_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 532         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &final_raa).unwrap();
 533         check_added_monitors!(nodes[1], 1);
 534
 535         expect_pending_htlcs_forwardable!(nodes[1]);
 536
 537         let events = nodes[1].node.get_and_clear_pending_events();
 538         assert_eq!(events.len(), 1);
 539         match events[0] {
 540                 Event::PaymentReceived { payment_hash, amt } => {
 541                         assert_eq!(payment_hash, our_payment_hash);
 542                         assert_eq!(amt, 1000000);
 543                 },
 544                 _ => panic!("Unexpected event"),
 545         };
 546
 547         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage, 1_000_000);
 548 }
 549
 550 #[test]
 551 fn test_monitor_update_fail_no_rebroadcast() {
 552         // Tests handling of a monitor update failure when no message rebroadcasting on
 553         // test_restore_channel_monitor() is required. Backported from
 554         // chanmon_fail_consistency fuzz tests.
 555         let mut nodes = create_network(2, &[None, None]);
 556         create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
 557
 558         let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
 559         let (payment_preimage_1, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 560         nodes[0].node.send_payment(route, our_payment_hash).unwrap();
 561         check_added_monitors!(nodes[0], 1);
 562
 563         let send_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
 564         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_event.msgs[0]).unwrap();
 565         let bs_raa = commitment_signed_dance!(nodes[1], nodes[0], send_event.commitment_msg, false, true, false, true);
 566
 567         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
 568         if let msgs::LightningError { err, action: msgs::ErrorAction::IgnoreError } = nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &bs_raa).unwrap_err() {
 569                 assert_eq!(err, "Failed to update ChannelMonitor");
 570         } else { panic!(); }
 571         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 572         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
 573         check_added_monitors!(nodes[1], 1);
 574
 575         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
 576         nodes[1].node.test_restore_channel_monitor();
 577         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 578         check_added_monitors!(nodes[1], 1);
 579         expect_pending_htlcs_forwardable!(nodes[1]);
 580
 581         let events = nodes[1].node.get_and_clear_pending_events();
 582         assert_eq!(events.len(), 1);
 583         match events[0] {
 584                 Event::PaymentReceived { payment_hash, .. } => {
 585                         assert_eq!(payment_hash, our_payment_hash);
 586                 },
 587                 _ => panic!("Unexpected event"),
 588         }
 589
 590         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
 591 }
 592
 593 #[test]
 594 fn test_monitor_update_raa_while_paused() {
 595         // Tests handling of an RAA while monitor updating has already been marked failed.
 596         // Backported from chanmon_fail_consistency fuzz tests as this used to be broken.
 597         let mut nodes = create_network(2, &[None, None]);
 598         create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
 599
 600         send_payment(&nodes[0], &[&nodes[1]], 5000000, 5_000_000);
 601
 602         let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
 603         let (payment_preimage_1, our_payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
 604         nodes[0].node.send_payment(route, our_payment_hash_1).unwrap();
 605         check_added_monitors!(nodes[0], 1);
 606         let send_event_1 = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
 607
 608         let route = nodes[1].router.get_route(&nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
 609         let (payment_preimage_2, our_payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
 610         nodes[1].node.send_payment(route, our_payment_hash_2).unwrap();
 611         check_added_monitors!(nodes[1], 1);
 612         let send_event_2 = SendEvent::from_event(nodes[1].node.get_and_clear_pending_msg_events().remove(0));
 613
 614         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_event_1.msgs[0]).unwrap();
 615         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &send_event_1.commitment_msg).unwrap();
 616         check_added_monitors!(nodes[1], 1);
 617         let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
 618
 619         *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
 620         nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &send_event_2.msgs[0]).unwrap();
 621         if let msgs::LightningError { err, action: msgs::ErrorAction::IgnoreError } = nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &send_event_2.commitment_msg).unwrap_err() {
 622                 assert_eq!(err, "Failed to update ChannelMonitor");
 623         } else { panic!(); }
 624         check_added_monitors!(nodes[0], 1);
 625
 626         if let msgs::LightningError { err, action: msgs::ErrorAction::IgnoreError } = nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_raa).unwrap_err() {
 627                 assert_eq!(err, "Previous monitor update failure prevented responses to RAA");
 628         } else { panic!(); }
 629         check_added_monitors!(nodes[0], 1);
 630
 631         *nodes[0].chan_monitor.update_ret.lock().unwrap() = Ok(());
 632         nodes[0].node.test_restore_channel_monitor();
 633         check_added_monitors!(nodes[0], 1);
 634
 635         let as_update_raa = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 636         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_update_raa.0).unwrap();
 637         check_added_monitors!(nodes[1], 1);
 638         let bs_cs = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 639
 640         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_update_raa.1).unwrap();
 641         check_added_monitors!(nodes[1], 1);
 642         let bs_second_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
 643
 644         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_cs.commitment_signed).unwrap();
 645         check_added_monitors!(nodes[0], 1);
 646         let as_second_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 647
 648         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_second_raa).unwrap();
 649         check_added_monitors!(nodes[0], 1);
 650         expect_pending_htlcs_forwardable!(nodes[0]);
 651         expect_payment_received!(nodes[0], our_payment_hash_2, 1000000);
 652
 653         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_second_raa).unwrap();
 654         check_added_monitors!(nodes[1], 1);
 655         expect_pending_htlcs_forwardable!(nodes[1]);
 656         expect_payment_received!(nodes[1], our_payment_hash_1, 1000000);
 657
 658         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
 659         claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_2, 1_000_000);
 660 }
 661
 662 fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) {
 663         // Tests handling of a monitor update failure when processing an incoming RAA
 664         let mut nodes = create_network(3, &[None, None, None]);
 665         create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
 666         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, LocalFeatures::new(), LocalFeatures::new());
 667
 668         // Rebalance a bit so that we can send backwards from 2 to 1.
 669         send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000, 5_000_000);
 670
 671         // Route a first payment that we'll fail backwards
 672         let (_, payment_hash_1) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000);
 673
 674         // Fail the payment backwards, failing the monitor update on nodes[1]'s receipt of the RAA
 675         assert!(nodes[2].node.fail_htlc_backwards(&payment_hash_1));
 676         expect_pending_htlcs_forwardable!(nodes[2]);
 677         check_added_monitors!(nodes[2], 1);
 678
 679         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
 680         assert!(updates.update_add_htlcs.is_empty());
 681         assert!(updates.update_fulfill_htlcs.is_empty());
 682         assert_eq!(updates.update_fail_htlcs.len(), 1);
 683         assert!(updates.update_fail_malformed_htlcs.is_empty());
 684         assert!(updates.update_fee.is_none());
 685         nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[0]).unwrap();
 686
 687         let bs_revoke_and_ack = commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false, true, false, true);
 688         check_added_monitors!(nodes[0], 0);
 689
 690         // While the second channel is AwaitingRAA, forward a second payment to get it into the
 691         // holding cell.
 692         let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
 693         let route = nodes[0].router.get_route(&nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
 694         nodes[0].node.send_payment(route, payment_hash_2).unwrap();
 695         check_added_monitors!(nodes[0], 1);
 696
 697         let mut send_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
 698         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_event.msgs[0]).unwrap();
 699         commitment_signed_dance!(nodes[1], nodes[0], send_event.commitment_msg, false);
 700
 701         expect_pending_htlcs_forwardable!(nodes[1]);
 702         check_added_monitors!(nodes[1], 0);
 703         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 704
 705         // Now fail monitor updating.
 706         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
 707         if let msgs::LightningError { err, action: msgs::ErrorAction::IgnoreError } = nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &bs_revoke_and_ack).unwrap_err() {
 708                 assert_eq!(err, "Failed to update ChannelMonitor");
 709         } else { panic!(); }
 710         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
 711         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 712         check_added_monitors!(nodes[1], 1);
 713
 714         // Attempt to forward a third payment but fail due to the second channel being unavailable
 715         // for forwarding.
 716
 717         let (_, payment_hash_3) = get_payment_preimage_hash!(nodes[0]);
 718         let route = nodes[0].router.get_route(&nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
 719         nodes[0].node.send_payment(route, payment_hash_3).unwrap();
 720         check_added_monitors!(nodes[0], 1);
 721
 722         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(()); // We succeed in updating the monitor for the first channel
 723         send_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
 724         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_event.msgs[0]).unwrap();
 725         commitment_signed_dance!(nodes[1], nodes[0], send_event.commitment_msg, false, true);
 726         check_added_monitors!(nodes[1], 0);
 727
 728         let mut events_2 = nodes[1].node.get_and_clear_pending_msg_events();
 729         assert_eq!(events_2.len(), 1);
 730         match events_2.remove(0) {
 731                 MessageSendEvent::UpdateHTLCs { node_id, updates } => {
 732                         assert_eq!(node_id, nodes[0].node.get_our_node_id());
 733                         assert!(updates.update_fulfill_htlcs.is_empty());
 734                         assert_eq!(updates.update_fail_htlcs.len(), 1);
 735                         assert!(updates.update_fail_malformed_htlcs.is_empty());
 736                         assert!(updates.update_add_htlcs.is_empty());
 737                         assert!(updates.update_fee.is_none());
 738
 739                         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]).unwrap();
 740                         commitment_signed_dance!(nodes[0], nodes[1], updates.commitment_signed, false, true);
 741
 742                         let msg_events = nodes[0].node.get_and_clear_pending_msg_events();
 743                         assert_eq!(msg_events.len(), 1);
 744                         match msg_events[0] {
 745                                 MessageSendEvent::PaymentFailureNetworkUpdate { update: msgs::HTLCFailChannelUpdate::ChannelUpdateMessage { ref msg }} => {
 746                                         assert_eq!(msg.contents.short_channel_id, chan_2.0.contents.short_channel_id);
 747                                         assert_eq!(msg.contents.flags & 2, 2); // temp disabled
 748                                 },
 749                                 _ => panic!("Unexpected event"),
 750                         }
 751
 752                         let events = nodes[0].node.get_and_clear_pending_events();
 753                         assert_eq!(events.len(), 1);
 754                         if let Event::PaymentFailed { payment_hash, rejected_by_dest, .. } = events[0] {
 755                                 assert_eq!(payment_hash, payment_hash_3);
 756                                 assert!(!rejected_by_dest);
 757                         } else { panic!("Unexpected event!"); }
 758                 },
 759                 _ => panic!("Unexpected event type!"),
 760         };
 761
 762         let (payment_preimage_4, payment_hash_4) = if test_ignore_second_cs {
 763                 // Try to route another payment backwards from 2 to make sure 1 holds off on responding
 764                 let (payment_preimage_4, payment_hash_4) = get_payment_preimage_hash!(nodes[0]);
 765                 let route = nodes[2].router.get_route(&nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
 766                 nodes[2].node.send_payment(route, payment_hash_4).unwrap();
 767                 check_added_monitors!(nodes[2], 1);
 768
 769                 send_event = SendEvent::from_event(nodes[2].node.get_and_clear_pending_msg_events().remove(0));
 770                 nodes[1].node.handle_update_add_htlc(&nodes[2].node.get_our_node_id(), &send_event.msgs[0]).unwrap();
 771                 if let Err(msgs::LightningError{err, action: msgs::ErrorAction::IgnoreError }) = nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &send_event.commitment_msg) {
 772                         assert_eq!(err, "Previous monitor update failure prevented generation of RAA");
 773                 } else { panic!(); }
 774                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 775                 assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
 776                 (Some(payment_preimage_4), Some(payment_hash_4))
 777         } else { (None, None) };
 778
 779         // Restore monitor updating, ensuring we immediately get a fail-back update and a
 780         // update_add update.
 781         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
 782         nodes[1].node.test_restore_channel_monitor();
 783         check_added_monitors!(nodes[1], 1);
 784         expect_pending_htlcs_forwardable!(nodes[1]);
 785         check_added_monitors!(nodes[1], 1);
 786
 787         let mut events_3 = nodes[1].node.get_and_clear_pending_msg_events();
 788         if test_ignore_second_cs {
 789                 assert_eq!(events_3.len(), 3);
 790         } else {
 791                 assert_eq!(events_3.len(), 2);
 792         }
 793
 794         // Note that the ordering of the events for different nodes is non-prescriptive, though the
 795         // ordering of the two events that both go to nodes[2] have to stay in the same order.
 796         let messages_a = match events_3.pop().unwrap() {
 797                 MessageSendEvent::UpdateHTLCs { node_id, mut updates } => {
 798                         assert_eq!(node_id, nodes[0].node.get_our_node_id());
 799                         assert!(updates.update_fulfill_htlcs.is_empty());
 800                         assert_eq!(updates.update_fail_htlcs.len(), 1);
 801                         assert!(updates.update_fail_malformed_htlcs.is_empty());
 802                         assert!(updates.update_add_htlcs.is_empty());
 803                         assert!(updates.update_fee.is_none());
 804                         (updates.update_fail_htlcs.remove(0), updates.commitment_signed)
 805                 },
 806                 _ => panic!("Unexpected event type!"),
 807         };
 808         let raa = if test_ignore_second_cs {
 809                 match events_3.remove(1) {
 810                         MessageSendEvent::SendRevokeAndACK { node_id, msg } => {
 811                                 assert_eq!(node_id, nodes[2].node.get_our_node_id());
 812                                 Some(msg.clone())
 813                         },
 814                         _ => panic!("Unexpected event"),
 815                 }
 816         } else { None };
 817         let send_event_b = SendEvent::from_event(events_3.remove(0));
 818         assert_eq!(send_event_b.node_id, nodes[2].node.get_our_node_id());
 819
 820         // Now deliver the new messages...
 821
 822         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &messages_a.0).unwrap();
 823         commitment_signed_dance!(nodes[0], nodes[1], messages_a.1, false);
 824         let events_4 = nodes[0].node.get_and_clear_pending_events();
 825         assert_eq!(events_4.len(), 1);
 826         if let Event::PaymentFailed { payment_hash, rejected_by_dest, .. } = events_4[0] {
 827                 assert_eq!(payment_hash, payment_hash_1);
 828                 assert!(rejected_by_dest);
 829         } else { panic!("Unexpected event!"); }
 830
 831         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &send_event_b.msgs[0]).unwrap();
 832         if test_ignore_second_cs {
 833                 nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &send_event_b.commitment_msg).unwrap();
 834                 check_added_monitors!(nodes[2], 1);
 835                 let bs_revoke_and_ack = get_event_msg!(nodes[2], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 836                 nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &raa.unwrap()).unwrap();
 837                 check_added_monitors!(nodes[2], 1);
 838                 let bs_cs = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
 839                 assert!(bs_cs.update_add_htlcs.is_empty());
 840                 assert!(bs_cs.update_fail_htlcs.is_empty());
 841                 assert!(bs_cs.update_fail_malformed_htlcs.is_empty());
 842                 assert!(bs_cs.update_fulfill_htlcs.is_empty());
 843                 assert!(bs_cs.update_fee.is_none());
 844
 845                 nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &bs_revoke_and_ack).unwrap();
 846                 check_added_monitors!(nodes[1], 1);
 847                 let as_cs = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
 848                 assert!(as_cs.update_add_htlcs.is_empty());
 849                 assert!(as_cs.update_fail_htlcs.is_empty());
 850                 assert!(as_cs.update_fail_malformed_htlcs.is_empty());
 851                 assert!(as_cs.update_fulfill_htlcs.is_empty());
 852                 assert!(as_cs.update_fee.is_none());
 853
 854                 nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &bs_cs.commitment_signed).unwrap();
 855                 check_added_monitors!(nodes[1], 1);
 856                 let as_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[2].node.get_our_node_id());
 857
 858                 nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &as_cs.commitment_signed).unwrap();
 859                 check_added_monitors!(nodes[2], 1);
 860                 let bs_second_raa = get_event_msg!(nodes[2], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 861
 862                 nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_raa).unwrap();
 863                 check_added_monitors!(nodes[2], 1);
 864                 assert!(nodes[2].node.get_and_clear_pending_msg_events().is_empty());
 865
 866                 nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &bs_second_raa).unwrap();
 867                 check_added_monitors!(nodes[1], 1);
 868                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 869         } else {
 870                 commitment_signed_dance!(nodes[2], nodes[1], send_event_b.commitment_msg, false);
 871         }
 872
 873         expect_pending_htlcs_forwardable!(nodes[2]);
 874
 875         let events_6 = nodes[2].node.get_and_clear_pending_events();
 876         assert_eq!(events_6.len(), 1);
 877         match events_6[0] {
 878                 Event::PaymentReceived { payment_hash, .. } => { assert_eq!(payment_hash, payment_hash_2); },
 879                 _ => panic!("Unexpected event"),
 880         };
 881
 882         if test_ignore_second_cs {
 883                 expect_pending_htlcs_forwardable!(nodes[1]);
 884                 check_added_monitors!(nodes[1], 1);
 885
 886                 send_event = SendEvent::from_node(&nodes[1]);
 887                 assert_eq!(send_event.node_id, nodes[0].node.get_our_node_id());
 888                 assert_eq!(send_event.msgs.len(), 1);
 889                 nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &send_event.msgs[0]).unwrap();
 890                 commitment_signed_dance!(nodes[0], nodes[1], send_event.commitment_msg, false);
 891
 892                 expect_pending_htlcs_forwardable!(nodes[0]);
 893
 894                 let events_9 = nodes[0].node.get_and_clear_pending_events();
 895                 assert_eq!(events_9.len(), 1);
 896                 match events_9[0] {
 897                         Event::PaymentReceived { payment_hash, .. } => assert_eq!(payment_hash, payment_hash_4.unwrap()),
 898                         _ => panic!("Unexpected event"),
 899                 };
 900                 claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_4.unwrap(), 1_000_000);
 901         }
 902
 903         claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage_2, 1_000_000);
 904 }
 905
 906 #[test]
 907 fn test_monitor_update_fail_raa() {
 908         do_test_monitor_update_fail_raa(false);
 909         do_test_monitor_update_fail_raa(true);
 910 }
 911
 912 #[test]
 913 fn test_monitor_update_fail_reestablish() {
 914         // Simple test for message retransmission after monitor update failure on
 915         // channel_reestablish generating a monitor update (which comes from freeing holding cell
 916         // HTLCs).
 917         let mut nodes = create_network(3, &[None, None, None]);
 918         create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
 919         create_announced_chan_between_nodes(&nodes, 1, 2, LocalFeatures::new(), LocalFeatures::new());
 920
 921         let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000);
 922
 923         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
 924         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
 925
 926         assert!(nodes[2].node.claim_funds(our_payment_preimage, 1_000_000));
 927         check_added_monitors!(nodes[2], 1);
 928         let mut updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
 929         assert!(updates.update_add_htlcs.is_empty());
 930         assert!(updates.update_fail_htlcs.is_empty());
 931         assert!(updates.update_fail_malformed_htlcs.is_empty());
 932         assert!(updates.update_fee.is_none());
 933         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
 934         nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]).unwrap();
 935         check_added_monitors!(nodes[1], 1);
 936         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 937         commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false);
 938
 939         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
 940         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id());
 941         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id());
 942
 943         let as_reestablish = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReestablish, nodes[1].node.get_our_node_id());
 944         let bs_reestablish = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
 945
 946         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &bs_reestablish).unwrap();
 947
 948         if let msgs::LightningError { err, action: msgs::ErrorAction::IgnoreError } = nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &as_reestablish).unwrap_err() {
 949                 assert_eq!(err, "Failed to update ChannelMonitor");
 950         } else { panic!(); }
 951         check_added_monitors!(nodes[1], 1);
 952
 953         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
 954         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
 955
 956         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id());
 957         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id());
 958
 959         assert!(as_reestablish == get_event_msg!(nodes[0], MessageSendEvent::SendChannelReestablish, nodes[1].node.get_our_node_id()));
 960         assert!(bs_reestablish == get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id()));
 961
 962         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &bs_reestablish).unwrap();
 963
 964         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &as_reestablish).unwrap();
 965         check_added_monitors!(nodes[1], 0);
 966         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 967
 968         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
 969         nodes[1].node.test_restore_channel_monitor();
 970         check_added_monitors!(nodes[1], 1);
 971
 972         updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 973         assert!(updates.update_add_htlcs.is_empty());
 974         assert!(updates.update_fail_htlcs.is_empty());
 975         assert!(updates.update_fail_malformed_htlcs.is_empty());
 976         assert!(updates.update_fee.is_none());
 977         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
 978         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]).unwrap();
 979         commitment_signed_dance!(nodes[0], nodes[1], updates.commitment_signed, false);
 980
 981         let events = nodes[0].node.get_and_clear_pending_events();
 982         assert_eq!(events.len(), 1);
 983         match events[0] {
 984                 Event::PaymentSent { payment_preimage, .. } => assert_eq!(payment_preimage, our_payment_preimage),
 985                 _ => panic!("Unexpected event"),
 986         }
 987 }
 988
 989 #[test]
 990 fn raa_no_response_awaiting_raa_state() {
 991         // This is a rather convoluted test which ensures that if handling of an RAA does not happen
 992         // due to a previous monitor update failure, we still set AwaitingRemoteRevoke on the channel
 993         // in question (assuming it intends to respond with a CS after monitor updating is restored).
 994         // Backported from chanmon_fail_consistency fuzz tests as this used to be broken.
 995         let mut nodes = create_network(2, &[None, None]);
 996         create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
 997
 998         let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
 999         let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
1000         let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
1001         let (payment_preimage_3, payment_hash_3) = get_payment_preimage_hash!(nodes[0]);
1002
1003         // Queue up two payments - one will be delivered right away, one immediately goes into the
1004         // holding cell as nodes[0] is AwaitingRAA. Ultimately this allows us to deliver an RAA
1005         // immediately after a CS. By setting failing the monitor update failure from the CS (which
1006         // requires only an RAA response due to AwaitingRAA) we can deliver the RAA and require the CS
1007         // generation during RAA while in monitor-update-failed state.
1008         nodes[0].node.send_payment(route.clone(), payment_hash_1).unwrap();
1009         check_added_monitors!(nodes[0], 1);
1010         nodes[0].node.send_payment(route.clone(), payment_hash_2).unwrap();
1011         check_added_monitors!(nodes[0], 0);
1012
1013         let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1014         assert_eq!(events.len(), 1);
1015         let payment_event = SendEvent::from_event(events.pop().unwrap());
1016         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]).unwrap();
1017         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event.commitment_msg).unwrap();
1018         check_added_monitors!(nodes[1], 1);
1019
1020         let bs_responses = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1021         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_responses.0).unwrap();
1022         check_added_monitors!(nodes[0], 1);
1023         let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1024         assert_eq!(events.len(), 1);
1025         let payment_event = SendEvent::from_event(events.pop().unwrap());
1026
1027         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_responses.1).unwrap();
1028         check_added_monitors!(nodes[0], 1);
1029         let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1030
1031         // Now we have a CS queued up which adds a new HTLC (which will need a RAA/CS response from
1032         // nodes[1]) followed by an RAA. Fail the monitor updating prior to the CS, deliver the RAA,
1033         // then restore channel monitor updates.
1034         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1035         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]).unwrap();
1036         if let msgs::LightningError { err, action: msgs::ErrorAction::IgnoreError } = nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event.commitment_msg).unwrap_err() {
1037                 assert_eq!(err, "Failed to update ChannelMonitor");
1038         } else { panic!(); }
1039         check_added_monitors!(nodes[1], 1);
1040
1041         if let msgs::LightningError { err, action: msgs::ErrorAction::IgnoreError } = nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa).unwrap_err() {
1042                 assert_eq!(err, "Previous monitor update failure prevented responses to RAA");
1043         } else { panic!(); }
1044         check_added_monitors!(nodes[1], 1);
1045
1046         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
1047         nodes[1].node.test_restore_channel_monitor();
1048         // nodes[1] should be AwaitingRAA here!
1049         check_added_monitors!(nodes[1], 1);
1050         let bs_responses = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1051         expect_pending_htlcs_forwardable!(nodes[1]);
1052         expect_payment_received!(nodes[1], payment_hash_1, 1000000);
1053
1054         // We send a third payment here, which is somewhat of a redundant test, but the
1055         // chanmon_fail_consistency test required it to actually find the bug (by seeing out-of-sync
1056         // commitment transaction states) whereas here we can explicitly check for it.
1057         nodes[0].node.send_payment(route.clone(), payment_hash_3).unwrap();
1058         check_added_monitors!(nodes[0], 0);
1059         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1060
1061         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_responses.0).unwrap();
1062         check_added_monitors!(nodes[0], 1);
1063         let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1064         assert_eq!(events.len(), 1);
1065         let payment_event = SendEvent::from_event(events.pop().unwrap());
1066
1067         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_responses.1).unwrap();
1068         check_added_monitors!(nodes[0], 1);
1069         let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1070
1071         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]).unwrap();
1072         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event.commitment_msg).unwrap();
1073         check_added_monitors!(nodes[1], 1);
1074         let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
1075
1076         // Finally deliver the RAA to nodes[1] which results in a CS response to the last update
1077         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa).unwrap();
1078         check_added_monitors!(nodes[1], 1);
1079         expect_pending_htlcs_forwardable!(nodes[1]);
1080         expect_payment_received!(nodes[1], payment_hash_2, 1000000);
1081         let bs_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1082
1083         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_raa).unwrap();
1084         check_added_monitors!(nodes[0], 1);
1085
1086         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_update.commitment_signed).unwrap();
1087         check_added_monitors!(nodes[0], 1);
1088         let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1089
1090         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa).unwrap();
1091         check_added_monitors!(nodes[1], 1);
1092         expect_pending_htlcs_forwardable!(nodes[1]);
1093         expect_payment_received!(nodes[1], payment_hash_3, 1000000);
1094
1095         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
1096         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
1097         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3, 1_000_000);
1098 }
1099
1100 #[test]
1101 fn claim_while_disconnected_monitor_update_fail() {
1102         // Test for claiming a payment while disconnected and then having the resulting
1103         // channel-update-generated monitor update fail. This kind of thing isn't a particularly
1104         // contrived case for nodes with network instability.
1105         // Backported from chanmon_fail_consistency fuzz tests as an unmerged version of the handling
1106         // code introduced a regression in this test (specifically, this caught a removal of the
1107         // channel_reestablish handling ensuring the order was sensical given the messages used).
1108         let mut nodes = create_network(2, &[None, None]);
1109         create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
1110
1111         // Forward a payment for B to claim
1112         let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
1113
1114         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
1115         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
1116
1117         assert!(nodes[1].node.claim_funds(payment_preimage_1, 1_000_000));
1118         check_added_monitors!(nodes[1], 1);
1119
1120         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id());
1121         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id());
1122
1123         let as_reconnect = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReestablish, nodes[1].node.get_our_node_id());
1124         let bs_reconnect = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
1125
1126         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &bs_reconnect).unwrap();
1127         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1128
1129         // Now deliver a's reestablish, freeing the claim from the holding cell, but fail the monitor
1130         // update.
1131         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1132
1133         if let msgs::LightningError { err, action: msgs::ErrorAction::IgnoreError } = nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &as_reconnect).unwrap_err() {
1134                 assert_eq!(err, "Failed to update ChannelMonitor");
1135         } else { panic!(); }
1136         check_added_monitors!(nodes[1], 1);
1137         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1138
1139         // Send a second payment from A to B, resulting in a commitment update that gets swallowed with
1140         // the monitor still failed
1141         let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1142         let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
1143         nodes[0].node.send_payment(route, payment_hash_2).unwrap();
1144         check_added_monitors!(nodes[0], 1);
1145
1146         let as_updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
1147         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &as_updates.update_add_htlcs[0]).unwrap();
1148         if let msgs::LightningError { err, action: msgs::ErrorAction::IgnoreError } = nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_updates.commitment_signed).unwrap_err() {
1149                 assert_eq!(err, "Previous monitor update failure prevented generation of RAA");
1150         } else { panic!(); }
1151         // Note that nodes[1] not updating monitor here is OK - it wont take action on the new HTLC
1152         // until we've test_restore_channel_monitor'd and updated for the new commitment transaction.
1153
1154         // Now un-fail the monitor, which will result in B sending its original commitment update,
1155         // receiving the commitment update from A, and the resulting commitment dances.
1156         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
1157         nodes[1].node.test_restore_channel_monitor();
1158         check_added_monitors!(nodes[1], 1);
1159
1160         let bs_msgs = nodes[1].node.get_and_clear_pending_msg_events();
1161         assert_eq!(bs_msgs.len(), 2);
1162
1163         match bs_msgs[0] {
1164                 MessageSendEvent::UpdateHTLCs { ref node_id, ref updates } => {
1165                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
1166                         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]).unwrap();
1167                         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &updates.commitment_signed).unwrap();
1168                         check_added_monitors!(nodes[0], 1);
1169
1170                         let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1171                         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa).unwrap();
1172                         check_added_monitors!(nodes[1], 1);
1173                 },
1174                 _ => panic!("Unexpected event"),
1175         }
1176
1177         match bs_msgs[1] {
1178                 MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
1179                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
1180                         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), msg).unwrap();
1181                         check_added_monitors!(nodes[0], 1);
1182                 },
1183                 _ => panic!("Unexpected event"),
1184         }
1185
1186         let as_commitment = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
1187
1188         let bs_commitment = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1189         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_commitment.commitment_signed).unwrap();
1190         check_added_monitors!(nodes[0], 1);
1191         let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1192
1193         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_commitment.commitment_signed).unwrap();
1194         check_added_monitors!(nodes[1], 1);
1195         let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
1196         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa).unwrap();
1197         check_added_monitors!(nodes[1], 1);
1198
1199         expect_pending_htlcs_forwardable!(nodes[1]);
1200         expect_payment_received!(nodes[1], payment_hash_2, 1000000);
1201
1202         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_raa).unwrap();
1203         check_added_monitors!(nodes[0], 1);
1204
1205         let events = nodes[0].node.get_and_clear_pending_events();
1206         assert_eq!(events.len(), 1);
1207         match events[0] {
1208                 Event::PaymentSent { ref payment_preimage } => {
1209                         assert_eq!(*payment_preimage, payment_preimage_1);
1210                 },
1211                 _ => panic!("Unexpected event"),
1212         }
1213
1214         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
1215 }
1216
1217 #[test]
1218 fn monitor_failed_no_reestablish_response() {
1219         // Test for receiving a channel_reestablish after a monitor update failure resulted in no
1220         // response to a commitment_signed.
1221         // Backported from chanmon_fail_consistency fuzz tests as it caught a long-standing
1222         // debug_assert!() failure in channel_reestablish handling.
1223         let mut nodes = create_network(2, &[None, None]);
1224         create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
1225
1226         // Route the payment and deliver the initial commitment_signed (with a monitor update failure
1227         // on receipt).
1228         let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1229         let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
1230         nodes[0].node.send_payment(route, payment_hash_1).unwrap();
1231         check_added_monitors!(nodes[0], 1);
1232
1233         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1234         let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1235         assert_eq!(events.len(), 1);
1236         let payment_event = SendEvent::from_event(events.pop().unwrap());
1237         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]).unwrap();
1238         if let msgs::LightningError { err, action: msgs::ErrorAction::IgnoreError } = nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event.commitment_msg).unwrap_err() {
1239                 assert_eq!(err, "Failed to update ChannelMonitor");
1240         } else { panic!(); }
1241         check_added_monitors!(nodes[1], 1);
1242
1243         // Now disconnect and immediately reconnect, delivering the channel_reestablish while nodes[1]
1244         // is still failing to update monitors.
1245         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
1246         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
1247
1248         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id());
1249         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id());
1250
1251         let as_reconnect = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReestablish, nodes[1].node.get_our_node_id());
1252         let bs_reconnect = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
1253
1254         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &as_reconnect).unwrap();
1255         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &bs_reconnect).unwrap();
1256
1257         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
1258         nodes[1].node.test_restore_channel_monitor();
1259         check_added_monitors!(nodes[1], 1);
1260         let bs_responses = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1261
1262         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_responses.0).unwrap();
1263         check_added_monitors!(nodes[0], 1);
1264         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_responses.1).unwrap();
1265         check_added_monitors!(nodes[0], 1);
1266
1267         let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1268         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa).unwrap();
1269         check_added_monitors!(nodes[1], 1);
1270
1271         expect_pending_htlcs_forwardable!(nodes[1]);
1272         expect_payment_received!(nodes[1], payment_hash_1, 1000000);
1273
1274         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
1275 }
1276
1277 #[test]
1278 fn first_message_on_recv_ordering() {
1279         // Test that if the initial generator of a monitor-update-frozen state doesn't generate
1280         // messages, we're willing to flip the order of response messages if neccessary in resposne to
1281         // a commitment_signed which needs to send an RAA first.
1282         // At a high level, our goal is to fail monitor updating in response to an RAA which needs no
1283         // response and then handle a CS while in the failed state, requiring an RAA followed by a CS
1284         // response. To do this, we start routing two payments, with the final RAA for the first being
1285         // delivered while B is in AwaitingRAA, hence when we deliver the CS for the second B will
1286         // have no pending response but will want to send a RAA/CS (with the updates for the second
1287         // payment applied).
1288         // Backported from chanmon_fail_consistency fuzz tests as it caught a bug here.
1289         let mut nodes = create_network(2, &[None, None]);
1290         create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
1291
1292         // Route the first payment outbound, holding the last RAA for B until we are set up so that we
1293         // can deliver it and fail the monitor update.
1294         let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1295         let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
1296         nodes[0].node.send_payment(route, payment_hash_1).unwrap();
1297         check_added_monitors!(nodes[0], 1);
1298
1299         let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1300         assert_eq!(events.len(), 1);
1301         let payment_event = SendEvent::from_event(events.pop().unwrap());
1302         assert_eq!(payment_event.node_id, nodes[1].node.get_our_node_id());
1303         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]).unwrap();
1304         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event.commitment_msg).unwrap();
1305         check_added_monitors!(nodes[1], 1);
1306         let bs_responses = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1307
1308         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_responses.0).unwrap();
1309         check_added_monitors!(nodes[0], 1);
1310         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_responses.1).unwrap();
1311         check_added_monitors!(nodes[0], 1);
1312
1313         let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1314
1315         // Route the second payment, generating an update_add_htlc/commitment_signed
1316         let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1317         let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
1318         nodes[0].node.send_payment(route, payment_hash_2).unwrap();
1319         check_added_monitors!(nodes[0], 1);
1320         let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1321         assert_eq!(events.len(), 1);
1322         let payment_event = SendEvent::from_event(events.pop().unwrap());
1323         assert_eq!(payment_event.node_id, nodes[1].node.get_our_node_id());
1324
1325         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1326
1327         // Deliver the final RAA for the first payment, which does not require a response. RAAs
1328         // generally require a commitment_signed, so the fact that we're expecting an opposite response
1329         // to the next message also tests resetting the delivery order.
1330         if let msgs::LightningError { err, action: msgs::ErrorAction::IgnoreError } = nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa).unwrap_err() {
1331                 assert_eq!(err, "Failed to update ChannelMonitor");
1332         } else { panic!(); }
1333         check_added_monitors!(nodes[1], 1);
1334
1335         // Now deliver the update_add_htlc/commitment_signed for the second payment, which does need an
1336         // RAA/CS response, which should be generated when we call test_restore_channel_monitor (with
1337         // the appropriate HTLC acceptance).
1338         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]).unwrap();
1339         if let msgs::LightningError { err, action: msgs::ErrorAction::IgnoreError } = nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event.commitment_msg).unwrap_err() {
1340                 assert_eq!(err, "Previous monitor update failure prevented generation of RAA");
1341         } else { panic!(); }
1342
1343         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
1344         nodes[1].node.test_restore_channel_monitor();
1345         check_added_monitors!(nodes[1], 1);
1346
1347         expect_pending_htlcs_forwardable!(nodes[1]);
1348         expect_payment_received!(nodes[1], payment_hash_1, 1000000);
1349
1350         let bs_responses = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1351         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_responses.0).unwrap();
1352         check_added_monitors!(nodes[0], 1);
1353         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_responses.1).unwrap();
1354         check_added_monitors!(nodes[0], 1);
1355
1356         let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1357         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa).unwrap();
1358         check_added_monitors!(nodes[1], 1);
1359
1360         expect_pending_htlcs_forwardable!(nodes[1]);
1361         expect_payment_received!(nodes[1], payment_hash_2, 1000000);
1362
1363         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
1364         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
1365 }
1366
1367 #[test]
1368 fn test_monitor_update_fail_claim() {
1369         // Basic test for monitor update failures when processing claim_funds calls.
1370         // We set up a simple 3-node network, sending a payment from A to B and failing B's monitor
1371         // update to claim the payment. We then send a payment C->B->A, making the forward of this
1372         // payment from B to A fail due to the paused channel. Finally, we restore the channel monitor
1373         // updating and claim the payment on B.
1374         let mut nodes = create_network(3, &[None, None, None]);
1375         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
1376         create_announced_chan_between_nodes(&nodes, 1, 2, LocalFeatures::new(), LocalFeatures::new());
1377
1378         // Rebalance a bit so that we can send backwards from 3 to 2.
1379         send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000, 5_000_000);
1380
1381         let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
1382
1383         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1384         assert!(nodes[1].node.claim_funds(payment_preimage_1, 1_000_000));
1385         check_added_monitors!(nodes[1], 1);
1386
1387         let route = nodes[2].router.get_route(&nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1388         let (_, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
1389         nodes[2].node.send_payment(route, payment_hash_2).unwrap();
1390         check_added_monitors!(nodes[2], 1);
1391
1392         // Successfully update the monitor on the 1<->2 channel, but the 0<->1 channel should still be
1393         // paused, so forward shouldn't succeed until we call test_restore_channel_monitor().
1394         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
1395
1396         let mut events = nodes[2].node.get_and_clear_pending_msg_events();
1397         assert_eq!(events.len(), 1);
1398         let payment_event = SendEvent::from_event(events.pop().unwrap());
1399         nodes[1].node.handle_update_add_htlc(&nodes[2].node.get_our_node_id(), &payment_event.msgs[0]).unwrap();
1400         commitment_signed_dance!(nodes[1], nodes[2], payment_event.commitment_msg, false, true);
1401
1402         let bs_fail_update = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
1403         nodes[2].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &bs_fail_update.update_fail_htlcs[0]).unwrap();
1404         commitment_signed_dance!(nodes[2], nodes[1], bs_fail_update.commitment_signed, false, true);
1405
1406         let msg_events = nodes[2].node.get_and_clear_pending_msg_events();
1407         assert_eq!(msg_events.len(), 1);
1408         match msg_events[0] {
1409                 MessageSendEvent::PaymentFailureNetworkUpdate { update: msgs::HTLCFailChannelUpdate::ChannelUpdateMessage { ref msg }} => {
1410                         assert_eq!(msg.contents.short_channel_id, chan_1.0.contents.short_channel_id);
1411                         assert_eq!(msg.contents.flags & 2, 2); // temp disabled
1412                 },
1413                 _ => panic!("Unexpected event"),
1414         }
1415
1416         let events = nodes[2].node.get_and_clear_pending_events();
1417         assert_eq!(events.len(), 1);
1418         if let Event::PaymentFailed { payment_hash, rejected_by_dest, .. } = events[0] {
1419                 assert_eq!(payment_hash, payment_hash_2);
1420                 assert!(!rejected_by_dest);
1421         } else { panic!("Unexpected event!"); }
1422
1423         // Now restore monitor updating on the 0<->1 channel and claim the funds on B.
1424         nodes[1].node.test_restore_channel_monitor();
1425         check_added_monitors!(nodes[1], 1);
1426
1427         let bs_fulfill_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1428         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &bs_fulfill_update.update_fulfill_htlcs[0]).unwrap();
1429         commitment_signed_dance!(nodes[0], nodes[1], bs_fulfill_update.commitment_signed, false);
1430
1431         let events = nodes[0].node.get_and_clear_pending_events();
1432         assert_eq!(events.len(), 1);
1433         if let Event::PaymentSent { payment_preimage, .. } = events[0] {
1434                 assert_eq!(payment_preimage, payment_preimage_1);
1435         } else { panic!("Unexpected event!"); }
1436 }
1437
1438 #[test]
1439 fn test_monitor_update_on_pending_forwards() {
1440         // Basic test for monitor update failures when processing pending HTLC fail/add forwards.
1441         // We do this with a simple 3-node network, sending a payment from A to C and one from C to A.
1442         // The payment from A to C will be failed by C and pending a back-fail to A, while the payment
1443         // from C to A will be pending a forward to A.
1444         let mut nodes = create_network(3, &[None, None, None]);
1445         create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
1446         create_announced_chan_between_nodes(&nodes, 1, 2, LocalFeatures::new(), LocalFeatures::new());
1447
1448         // Rebalance a bit so that we can send backwards from 3 to 1.
1449         send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000, 5_000_000);
1450
1451         let (_, payment_hash_1) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000);
1452         assert!(nodes[2].node.fail_htlc_backwards(&payment_hash_1));
1453         expect_pending_htlcs_forwardable!(nodes[2]);
1454         check_added_monitors!(nodes[2], 1);
1455
1456         let cs_fail_update = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
1457         nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &cs_fail_update.update_fail_htlcs[0]).unwrap();
1458         commitment_signed_dance!(nodes[1], nodes[2], cs_fail_update.commitment_signed, true, true);
1459         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1460
1461         let route = nodes[2].router.get_route(&nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1462         let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
1463         nodes[2].node.send_payment(route, payment_hash_2).unwrap();
1464         check_added_monitors!(nodes[2], 1);
1465
1466         let mut events = nodes[2].node.get_and_clear_pending_msg_events();
1467         assert_eq!(events.len(), 1);
1468         let payment_event = SendEvent::from_event(events.pop().unwrap());
1469         nodes[1].node.handle_update_add_htlc(&nodes[2].node.get_our_node_id(), &payment_event.msgs[0]).unwrap();
1470         commitment_signed_dance!(nodes[1], nodes[2], payment_event.commitment_msg, false);
1471
1472         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1473         expect_pending_htlcs_forwardable!(nodes[1]);
1474         check_added_monitors!(nodes[1], 1);
1475         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1476
1477         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
1478         nodes[1].node.test_restore_channel_monitor();
1479         check_added_monitors!(nodes[1], 1);
1480
1481         let bs_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1482         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &bs_updates.update_fail_htlcs[0]).unwrap();
1483         nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &bs_updates.update_add_htlcs[0]).unwrap();
1484         commitment_signed_dance!(nodes[0], nodes[1], bs_updates.commitment_signed, false, true);
1485
1486         let events = nodes[0].node.get_and_clear_pending_events();
1487         assert_eq!(events.len(), 2);
1488         if let Event::PaymentFailed { payment_hash, rejected_by_dest, .. } = events[0] {
1489                 assert_eq!(payment_hash, payment_hash_1);
1490                 assert!(rejected_by_dest);
1491         } else { panic!("Unexpected event!"); }
1492         match events[1] {
1493                 Event::PendingHTLCsForwardable { .. } => { },
1494                 _ => panic!("Unexpected event"),
1495         };
1496         nodes[0].node.process_pending_htlc_forwards();
1497         expect_payment_received!(nodes[0], payment_hash_2, 1000000);
1498
1499         claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_2, 1_000_000);
1500 }
1501
1502 #[test]
1503 fn monitor_update_claim_fail_no_response() {
1504         // Test for claim_funds resulting in both a monitor update failure and no message response (due
1505         // to channel being AwaitingRAA).
1506         // Backported from chanmon_fail_consistency fuzz tests as an unmerged version of the handling
1507         // code was broken.
1508         let mut nodes = create_network(2, &[None, None]);
1509         create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
1510
1511         // Forward a payment for B to claim
1512         let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
1513
1514         // Now start forwarding a second payment, skipping the last RAA so B is in AwaitingRAA
1515         let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1516         let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
1517         nodes[0].node.send_payment(route, payment_hash_2).unwrap();
1518         check_added_monitors!(nodes[0], 1);
1519
1520         let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1521         assert_eq!(events.len(), 1);
1522         let payment_event = SendEvent::from_event(events.pop().unwrap());
1523         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]).unwrap();
1524         let as_raa = commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false, true, false, true);
1525
1526         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1527         assert!(nodes[1].node.claim_funds(payment_preimage_1, 1_000_000));
1528         check_added_monitors!(nodes[1], 1);
1529         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1530
1531         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
1532         nodes[1].node.test_restore_channel_monitor();
1533         check_added_monitors!(nodes[1], 1);
1534         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1535
1536         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa).unwrap();
1537         check_added_monitors!(nodes[1], 1);
1538         expect_pending_htlcs_forwardable!(nodes[1]);
1539         expect_payment_received!(nodes[1], payment_hash_2, 1000000);
1540
1541         let bs_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1542         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &bs_updates.update_fulfill_htlcs[0]).unwrap();
1543         commitment_signed_dance!(nodes[0], nodes[1], bs_updates.commitment_signed, false);
1544
1545         let events = nodes[0].node.get_and_clear_pending_events();
1546         assert_eq!(events.len(), 1);
1547         match events[0] {
1548                 Event::PaymentSent { ref payment_preimage } => {
1549                         assert_eq!(*payment_preimage, payment_preimage_1);
1550                 },
1551                 _ => panic!("Unexpected event"),
1552         }
1553
1554         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
1555 }
1556
1557 // Note that restore_between_fails with !fail_on_generate is useless
1558 // Also note that !fail_on_generate && !fail_on_signed is useless
1559 // Finally, note that !fail_on_signed is not possible with fail_on_generate && !restore_between_fails
1560 // confirm_a_first and restore_b_before_conf are wholly unrelated to earlier bools and
1561 // restore_b_before_conf has no meaning if !confirm_a_first
1562 fn do_during_funding_monitor_fail(fail_on_generate: bool, restore_between_fails: bool, fail_on_signed: bool, confirm_a_first: bool, restore_b_before_conf: bool) {
1563         // Test that if the monitor update generated by funding_transaction_generated fails we continue
1564         // the channel setup happily after the update is restored.
1565         let mut nodes = create_network(2, &[None, None]);
1566
1567         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 43).unwrap();
1568         nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), LocalFeatures::new(), &get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id())).unwrap();
1569         nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), LocalFeatures::new(), &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id())).unwrap();
1570
1571         let (temporary_channel_id, funding_tx, funding_output) = create_funding_transaction(&nodes[0], 100000, 43);
1572
1573         if fail_on_generate {
1574                 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1575         }
1576         nodes[0].node.funding_transaction_generated(&temporary_channel_id, funding_output);
1577         check_added_monitors!(nodes[0], 1);
1578
1579         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1580         nodes[1].node.handle_funding_created(&nodes[0].node.get_our_node_id(), &get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id())).unwrap();
1581         check_added_monitors!(nodes[1], 1);
1582
1583         if restore_between_fails {
1584                 assert!(fail_on_generate);
1585                 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Ok(());
1586                 nodes[0].node.test_restore_channel_monitor();
1587                 check_added_monitors!(nodes[0], 1);
1588                 assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
1589                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1590         }
1591
1592         if fail_on_signed {
1593                 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1594         } else {
1595                 assert!(restore_between_fails || !fail_on_generate); // We can't switch to good now (there's no monitor update)
1596                 assert!(fail_on_generate); // Somebody has to fail
1597         }
1598         let funding_signed_res = nodes[0].node.handle_funding_signed(&nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, nodes[0].node.get_our_node_id()));
1599         if fail_on_signed || !restore_between_fails {
1600                 if let msgs::LightningError { err, action: msgs::ErrorAction::IgnoreError } = funding_signed_res.unwrap_err() {
1601                         if fail_on_generate && !restore_between_fails {
1602                                 assert_eq!(err, "Previous monitor update failure prevented funding_signed from allowing funding broadcast");
1603                                 check_added_monitors!(nodes[0], 0);
1604                         } else {
1605                                 assert_eq!(err, "Failed to update ChannelMonitor");
1606                                 check_added_monitors!(nodes[0], 1);
1607                         }
1608                 } else { panic!(); }
1609
1610                 assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
1611                 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Ok(());
1612                 nodes[0].node.test_restore_channel_monitor();
1613         } else {
1614                 funding_signed_res.unwrap();
1615         }
1616
1617         check_added_monitors!(nodes[0], 1);
1618
1619         let events = nodes[0].node.get_and_clear_pending_events();
1620         assert_eq!(events.len(), 1);
1621         match events[0] {
1622                 Event::FundingBroadcastSafe { ref funding_txo, user_channel_id } => {
1623                         assert_eq!(user_channel_id, 43);
1624                         assert_eq!(*funding_txo, funding_output);
1625                 },
1626                 _ => panic!("Unexpected event"),
1627         };
1628
1629         if confirm_a_first {
1630                 confirm_transaction(&nodes[0].block_notifier, &nodes[0].chain_monitor, &funding_tx, funding_tx.version);
1631                 nodes[1].node.handle_funding_locked(&nodes[0].node.get_our_node_id(), &get_event_msg!(nodes[0], MessageSendEvent::SendFundingLocked, nodes[1].node.get_our_node_id())).unwrap();
1632         } else {
1633                 assert!(!restore_b_before_conf);
1634                 confirm_transaction(&nodes[1].block_notifier, &nodes[1].chain_monitor, &funding_tx, funding_tx.version);
1635                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1636         }
1637
1638         // Make sure nodes[1] isn't stupid enough to re-send the FundingLocked on reconnect
1639         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
1640         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
1641         reconnect_nodes(&nodes[0], &nodes[1], (false, confirm_a_first), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
1642         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1643         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1644
1645         if !restore_b_before_conf {
1646                 confirm_transaction(&nodes[1].block_notifier, &nodes[1].chain_monitor, &funding_tx, funding_tx.version);
1647                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1648                 assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
1649         }
1650
1651         *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
1652         nodes[1].node.test_restore_channel_monitor();
1653         check_added_monitors!(nodes[1], 1);
1654
1655         let (channel_id, (announcement, as_update, bs_update)) = if !confirm_a_first {
1656                 nodes[0].node.handle_funding_locked(&nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendFundingLocked, nodes[0].node.get_our_node_id())).unwrap();
1657
1658                 confirm_transaction(&nodes[0].block_notifier, &nodes[0].chain_monitor, &funding_tx, funding_tx.version);
1659                 let (funding_locked, channel_id) = create_chan_between_nodes_with_value_confirm_second(&nodes[1], &nodes[0]);
1660                 (channel_id, create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked))
1661         } else {
1662                 if restore_b_before_conf {
1663                         confirm_transaction(&nodes[1].block_notifier, &nodes[1].chain_monitor, &funding_tx, funding_tx.version);
1664                 }
1665                 let (funding_locked, channel_id) = create_chan_between_nodes_with_value_confirm_second(&nodes[0], &nodes[1]);
1666                 (channel_id, create_chan_between_nodes_with_value_b(&nodes[1], &nodes[0], &funding_locked))
1667         };
1668         for node in nodes.iter() {
1669                 assert!(node.router.handle_channel_announcement(&announcement).unwrap());
1670                 node.router.handle_channel_update(&as_update).unwrap();
1671                 node.router.handle_channel_update(&bs_update).unwrap();
1672         }
1673
1674         send_payment(&nodes[0], &[&nodes[1]], 8000000, 8_000_000);
1675         close_channel(&nodes[0], &nodes[1], &channel_id, funding_tx, true);
1676 }
1677
1678 #[test]
1679 fn during_funding_monitor_fail() {
1680         do_during_funding_monitor_fail(false, false, true, true, true);
1681         do_during_funding_monitor_fail(true, false, true, false, false);
1682         do_during_funding_monitor_fail(true, true, true, true, false);
1683         do_during_funding_monitor_fail(true, true, false, false, false);
1684 }