1 //! Functional tests which test the correct handling of ChannelMonitorUpdateErr returns from
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.
6 use ln::channelmanager::{RAACommitmentOrder, PaymentPreimage, PaymentHash};
7 use ln::channelmonitor::ChannelMonitorUpdateErr;
9 use ln::msgs::{ChannelMessageHandler, LocalFeatures, RoutingMessageHandler};
10 use util::events::{Event, EventsProvider, MessageSendEvent, MessageSendEventsProvider};
11 use util::errors::APIError;
13 use bitcoin_hashes::sha256::Hash as Sha256;
14 use bitcoin_hashes::Hash;
16 use ln::functional_test_utils::*;
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());
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]);
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);
31 let events_1 = nodes[0].node.get_and_clear_pending_msg_events();
32 assert_eq!(events_1.len(), 2);
34 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
35 _ => panic!("Unexpected event"),
38 MessageSendEvent::HandleError { node_id, .. } => assert_eq!(node_id, nodes[1].node.get_our_node_id()),
39 _ => panic!("Unexpected event"),
42 // TODO: Once we hit the chain with the failure transaction we should check that we get a
43 // PaymentFailed event
45 assert_eq!(nodes[0].node.list_channels().len(), 0);
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());
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]);
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);
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);
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));
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);
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);
82 expect_pending_htlcs_forwardable!(nodes[1]);
84 let events_3 = nodes[1].node.get_and_clear_pending_events();
85 assert_eq!(events_3.len(), 1);
87 Event::PaymentReceived { ref payment_hash, amt } => {
88 assert_eq!(payment_hash_1, *payment_hash);
89 assert_eq!(amt, 1000000);
91 _ => panic!("Unexpected event"),
94 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
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);
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);
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));
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]);
118 // TODO: Once we hit the chain with the failure transaction we should check that we get a
119 // PaymentFailed event
121 assert_eq!(nodes[0].node.list_channels().len(), 0);
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);
130 fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
131 let disconnect_flags = 8 | 16;
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());
153 let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
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]);
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);
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);
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());
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);
187 Event::PaymentSent { ref payment_preimage } => {
188 assert_eq!(*payment_preimage, payment_preimage_1);
190 _ => panic!("Unexpected event"),
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");
198 (update_fulfill_htlcs[0].clone(), commitment_signed.clone())
200 _ => panic!("Unexpected event"),
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);
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);
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);
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);
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]);
229 assert!(as_resp.0.is_none());
230 assert!(bs_resp.0.is_none());
232 (reestablish_1, reestablish_2, as_resp, bs_resp)
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());
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);
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]);
253 assert!(as_resp.0.is_none());
254 assert!(bs_resp.0.is_none());
256 assert!(bs_resp.1.is_none());
257 if (disconnect_count & 16) == 0 {
258 assert!(bs_resp.2.is_none());
260 assert!(as_resp.1.is_some());
261 assert!(as_resp.2.is_some());
262 assert!(as_resp.3 == RAACommitmentOrder::CommitmentFirst);
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);
271 assert!(as_resp.1.is_none());
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);
277 Event::PaymentSent { ref payment_preimage } => {
278 assert_eq!(*payment_preimage, payment_preimage_1);
280 _ => panic!("Unexpected event"),
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);
288 as_resp.1 = Some(as_resp_raa);
292 if disconnect_count & !disconnect_flags > 1 {
293 let (second_reestablish_1, second_reestablish_2, second_as_resp, second_bs_resp) = disconnect_reconnect_peers!();
295 if (disconnect_count & 16) == 0 {
296 assert!(reestablish_1 == second_reestablish_1);
297 assert!(reestablish_2 == second_reestablish_2);
299 assert!(as_resp == second_as_resp);
300 assert!(bs_resp == second_bs_resp);
303 (SendEvent::from_commitment_update(nodes[1].node.get_our_node_id(), as_resp.2.unwrap()), as_resp.1.unwrap())
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());
312 _ => panic!("Unexpected event"),
316 assert_eq!(payment_event.node_id, nodes[1].node.get_our_node_id());
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);
324 if disconnect_count & !disconnect_flags > 2 {
325 let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!();
327 assert!(as_resp.1.unwrap() == initial_revoke_and_ack);
328 assert!(bs_resp.1.unwrap() == bs_revoke_and_ack);
330 assert!(as_resp.2.is_none());
331 assert!(bs_resp.2.is_none());
334 let as_commitment_update;
335 let bs_second_commitment_update;
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);
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);
359 if (disconnect_count & 8) == 0 {
362 if disconnect_count & !disconnect_flags > 3 {
363 let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!();
365 assert!(as_resp.1.unwrap() == initial_revoke_and_ack);
366 assert!(bs_resp.1.is_none());
368 assert!(as_resp.2.unwrap() == as_commitment_update);
369 assert!(bs_resp.2.is_none());
371 assert!(as_resp.3 == RAACommitmentOrder::RevokeAndACKFirst);
374 handle_initial_raa!();
376 if disconnect_count & !disconnect_flags > 4 {
377 let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!();
379 assert!(as_resp.1.is_none());
380 assert!(bs_resp.1.is_none());
382 assert!(as_resp.2.unwrap() == as_commitment_update);
383 assert!(bs_resp.2.unwrap() == bs_second_commitment_update);
386 handle_initial_raa!();
388 if disconnect_count & !disconnect_flags > 3 {
389 let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!();
391 assert!(as_resp.1.is_none());
392 assert!(bs_resp.1.unwrap() == bs_revoke_and_ack);
394 assert!(as_resp.2.is_none());
395 assert!(bs_resp.2.unwrap() == bs_second_commitment_update);
397 assert!(bs_resp.3 == RAACommitmentOrder::RevokeAndACKFirst);
402 if disconnect_count & !disconnect_flags > 4 {
403 let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!();
405 assert!(as_resp.1.is_none());
406 assert!(bs_resp.1.is_none());
408 assert!(as_resp.2.unwrap() == as_commitment_update);
409 assert!(bs_resp.2.unwrap() == bs_second_commitment_update);
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);
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);
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);
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);
431 expect_pending_htlcs_forwardable!(nodes[1]);
433 let events_5 = nodes[1].node.get_and_clear_pending_events();
434 assert_eq!(events_5.len(), 1);
436 Event::PaymentReceived { ref payment_hash, amt } => {
437 assert_eq!(payment_hash_2, *payment_hash);
438 assert_eq!(amt, 1000000);
440 _ => panic!("Unexpected event"),
443 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
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);
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);
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);
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());
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);
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();
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");
491 check_added_monitors!(nodes[1], 1);
492 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
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);
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);
506 _ => panic!("Unexpected event"),
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());
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");
521 check_added_monitors!(nodes[0], 1);
522 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
524 _ => panic!("Unexpected event"),
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);
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);
535 expect_pending_htlcs_forwardable!(nodes[1]);
537 let events = nodes[1].node.get_and_clear_pending_events();
538 assert_eq!(events.len(), 1);
540 Event::PaymentReceived { payment_hash, amt } => {
541 assert_eq!(payment_hash, our_payment_hash);
542 assert_eq!(amt, 1000000);
544 _ => panic!("Unexpected event"),
547 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage, 1_000_000);
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());
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);
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);
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");
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);
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]);
581 let events = nodes[1].node.get_and_clear_pending_events();
582 assert_eq!(events.len(), 1);
584 Event::PaymentReceived { payment_hash, .. } => {
585 assert_eq!(payment_hash, our_payment_hash);
587 _ => panic!("Unexpected event"),
590 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
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());
600 send_payment(&nodes[0], &[&nodes[1]], 5000000, 5_000_000);
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));
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));
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());
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");
624 check_added_monitors!(nodes[0], 1);
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");
629 check_added_monitors!(nodes[0], 1);
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);
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());
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());
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());
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);
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);
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);
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());
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);
671 // Route a first payment that we'll fail backwards
672 let (_, payment_hash_1) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000);
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);
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();
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);
690 // While the second channel is AwaitingRAA, forward a second payment to get it into the
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);
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);
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());
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");
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);
714 // Attempt to forward a third payment but fail due to the second channel being unavailable
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);
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);
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());
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);
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
749 _ => panic!("Unexpected event"),
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!"); }
759 _ => panic!("Unexpected event type!"),
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);
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");
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) };
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);
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);
791 assert_eq!(events_3.len(), 2);
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)
806 _ => panic!("Unexpected event type!"),
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());
814 _ => panic!("Unexpected event"),
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());
820 // Now deliver the new messages...
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!"); }
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());
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());
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());
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());
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());
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());
870 commitment_signed_dance!(nodes[2], nodes[1], send_event_b.commitment_msg, false);
873 expect_pending_htlcs_forwardable!(nodes[2]);
875 let events_6 = nodes[2].node.get_and_clear_pending_events();
876 assert_eq!(events_6.len(), 1);
878 Event::PaymentReceived { payment_hash, .. } => { assert_eq!(payment_hash, payment_hash_2); },
879 _ => panic!("Unexpected event"),
882 if test_ignore_second_cs {
883 expect_pending_htlcs_forwardable!(nodes[1]);
884 check_added_monitors!(nodes[1], 1);
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);
892 expect_pending_htlcs_forwardable!(nodes[0]);
894 let events_9 = nodes[0].node.get_and_clear_pending_events();
895 assert_eq!(events_9.len(), 1);
897 Event::PaymentReceived { payment_hash, .. } => assert_eq!(payment_hash, payment_hash_4.unwrap()),
898 _ => panic!("Unexpected event"),
900 claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_4.unwrap(), 1_000_000);
903 claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage_2, 1_000_000);
907 fn test_monitor_update_fail_raa() {
908 do_test_monitor_update_fail_raa(false);
909 do_test_monitor_update_fail_raa(true);
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
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());
921 let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000);
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);
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);
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());
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());
946 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &bs_reestablish).unwrap();
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");
951 check_added_monitors!(nodes[1], 1);
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);
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());
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()));
962 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &bs_reestablish).unwrap();
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());
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);
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);
981 let events = nodes[0].node.get_and_clear_pending_events();
982 assert_eq!(events.len(), 1);
984 Event::PaymentSent { payment_preimage, .. } => assert_eq!(payment_preimage, our_payment_preimage),
985 _ => panic!("Unexpected event"),
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());
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]);
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);
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);
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());
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());
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);
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);
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);
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());
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());
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());
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());
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());
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);
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());
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);
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);
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());
1111 // Forward a payment for B to claim
1112 let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
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);
1117 assert!(nodes[1].node.claim_funds(payment_preimage_1, 1_000_000));
1118 check_added_monitors!(nodes[1], 1);
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());
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());
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());
1129 // Now deliver a's reestablish, freeing the claim from the holding cell, but fail the monitor
1131 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
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());
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);
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.
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);
1160 let bs_msgs = nodes[1].node.get_and_clear_pending_msg_events();
1161 assert_eq!(bs_msgs.len(), 2);
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);
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);
1174 _ => panic!("Unexpected event"),
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);
1183 _ => panic!("Unexpected event"),
1186 let as_commitment = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
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());
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);
1199 expect_pending_htlcs_forwardable!(nodes[1]);
1200 expect_payment_received!(nodes[1], payment_hash_2, 1000000);
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);
1205 let events = nodes[0].node.get_and_clear_pending_events();
1206 assert_eq!(events.len(), 1);
1208 Event::PaymentSent { ref payment_preimage } => {
1209 assert_eq!(*payment_preimage, payment_preimage_1);
1211 _ => panic!("Unexpected event"),
1214 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
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());
1226 // Route the payment and deliver the initial commitment_signed (with a monitor update failure
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);
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);
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);
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());
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());
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();
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());
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);
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);
1271 expect_pending_htlcs_forwardable!(nodes[1]);
1272 expect_payment_received!(nodes[1], payment_hash_1, 1000000);
1274 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
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());
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);
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());
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);
1313 let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
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());
1325 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
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);
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!(); }
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);
1347 expect_pending_htlcs_forwardable!(nodes[1]);
1348 expect_payment_received!(nodes[1], payment_hash_1, 1000000);
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);
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);
1360 expect_pending_htlcs_forwardable!(nodes[1]);
1361 expect_payment_received!(nodes[1], payment_hash_2, 1000000);
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);
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());
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);
1381 let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
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);
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);
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(());
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);
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);
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
1413 _ => panic!("Unexpected event"),
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!"); }
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);
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);
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!"); }
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());
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);
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);
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());
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);
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);
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());
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);
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);
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!"); }
1493 Event::PendingHTLCsForwardable { .. } => { },
1494 _ => panic!("Unexpected event"),
1496 nodes[0].node.process_pending_htlc_forwards();
1497 expect_payment_received!(nodes[0], payment_hash_2, 1000000);
1499 claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_2, 1_000_000);
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
1508 let mut nodes = create_network(2, &[None, None]);
1509 create_announced_chan_between_nodes(&nodes, 0, 1, LocalFeatures::new(), LocalFeatures::new());
1511 // Forward a payment for B to claim
1512 let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
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);
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);
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());
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());
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);
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);
1545 let events = nodes[0].node.get_and_clear_pending_events();
1546 assert_eq!(events.len(), 1);
1548 Event::PaymentSent { ref payment_preimage } => {
1549 assert_eq!(*payment_preimage, payment_preimage_1);
1551 _ => panic!("Unexpected event"),
1554 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
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]);
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();
1571 let (temporary_channel_id, funding_tx, funding_output) = create_funding_transaction(&nodes[0], 100000, 43);
1573 if fail_on_generate {
1574 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1576 nodes[0].node.funding_transaction_generated(&temporary_channel_id, funding_output);
1577 check_added_monitors!(nodes[0], 1);
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);
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());
1593 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
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
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);
1605 assert_eq!(err, "Failed to update ChannelMonitor");
1606 check_added_monitors!(nodes[0], 1);
1608 } else { panic!(); }
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();
1614 funding_signed_res.unwrap();
1617 check_added_monitors!(nodes[0], 1);
1619 let events = nodes[0].node.get_and_clear_pending_events();
1620 assert_eq!(events.len(), 1);
1622 Event::FundingBroadcastSafe { ref funding_txo, user_channel_id } => {
1623 assert_eq!(user_channel_id, 43);
1624 assert_eq!(*funding_txo, funding_output);
1626 _ => panic!("Unexpected event"),
1629 if confirm_a_first {
1630 confirm_transaction(&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();
1633 assert!(!restore_b_before_conf);
1634 confirm_transaction(&nodes[1].chain_monitor, &funding_tx, funding_tx.version);
1635 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
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());
1645 if !restore_b_before_conf {
1646 confirm_transaction(&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());
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);
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();
1658 confirm_transaction(&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))
1662 if restore_b_before_conf {
1663 confirm_transaction(&nodes[1].chain_monitor, &funding_tx, funding_tx.version);
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))
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();
1674 send_payment(&nodes[0], &[&nodes[1]], 8000000, 8_000_000);
1675 close_channel(&nodes[0], &nodes[1], &channel_id, funding_tx, true);
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);