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, PaymentSendFailure};
7 use ln::channelmonitor::ChannelMonitorUpdateErr;
8 use ln::features::InitFeatures;
10 use ln::msgs::{ChannelMessageHandler, ErrorAction, RoutingMessageHandler};
11 use util::events::{Event, EventsProvider, MessageSendEvent, MessageSendEventsProvider};
12 use util::errors::APIError;
14 use bitcoin_hashes::sha256::Hash as Sha256;
15 use bitcoin_hashes::Hash;
17 use ln::functional_test_utils::*;
20 fn test_simple_monitor_permanent_update_fail() {
21 // Test that we handle a simple permanent monitor update failure
22 let node_cfgs = create_node_cfgs(2);
23 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
24 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
25 create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
27 let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
28 let (_, payment_hash_1) = get_payment_preimage_hash!(&nodes[0]);
30 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::PermanentFailure);
31 unwrap_send_err!(nodes[0].node.send_payment(route, payment_hash_1, None), true, APIError::ChannelUnavailable {..}, {});
32 check_added_monitors!(nodes[0], 1);
34 let events_1 = nodes[0].node.get_and_clear_pending_msg_events();
35 assert_eq!(events_1.len(), 2);
37 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
38 _ => panic!("Unexpected event"),
41 MessageSendEvent::HandleError { node_id, .. } => assert_eq!(node_id, nodes[1].node.get_our_node_id()),
42 _ => panic!("Unexpected event"),
45 // TODO: Once we hit the chain with the failure transaction we should check that we get a
46 // PaymentFailed event
48 assert_eq!(nodes[0].node.list_channels().len(), 0);
51 fn do_test_simple_monitor_temporary_update_fail(disconnect: bool) {
52 // Test that we can recover from a simple temporary monitor update failure optionally with
53 // a disconnect in between
54 let node_cfgs = create_node_cfgs(2);
55 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
56 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
57 create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
59 let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
60 let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(&nodes[0]);
62 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
64 unwrap_send_err!(nodes[0].node.send_payment(route.clone(), payment_hash_1, None), false, APIError::MonitorUpdateFailed, {});
65 check_added_monitors!(nodes[0], 1);
67 assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
68 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
69 assert_eq!(nodes[0].node.list_channels().len(), 1);
72 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
73 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
74 reconnect_nodes(&nodes[0], &nodes[1], (true, true), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
77 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Ok(());
78 nodes[0].node.test_restore_channel_monitor();
79 check_added_monitors!(nodes[0], 1);
81 let mut events_2 = nodes[0].node.get_and_clear_pending_msg_events();
82 assert_eq!(events_2.len(), 1);
83 let payment_event = SendEvent::from_event(events_2.pop().unwrap());
84 assert_eq!(payment_event.node_id, nodes[1].node.get_our_node_id());
85 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
86 commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
88 expect_pending_htlcs_forwardable!(nodes[1]);
90 let events_3 = nodes[1].node.get_and_clear_pending_events();
91 assert_eq!(events_3.len(), 1);
93 Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
94 assert_eq!(payment_hash_1, *payment_hash);
95 assert_eq!(*payment_secret, None);
96 assert_eq!(amt, 1000000);
98 _ => panic!("Unexpected event"),
101 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
103 // Now set it to failed again...
104 let (_, payment_hash_2) = get_payment_preimage_hash!(&nodes[0]);
105 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
106 unwrap_send_err!(nodes[0].node.send_payment(route, payment_hash_2, None), false, APIError::MonitorUpdateFailed, {});
107 check_added_monitors!(nodes[0], 1);
109 assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
110 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
111 assert_eq!(nodes[0].node.list_channels().len(), 1);
114 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
115 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
116 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
119 // ...and make sure we can force-close a TemporaryFailure channel with a PermanentFailure
120 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::PermanentFailure);
121 nodes[0].node.test_restore_channel_monitor();
122 check_added_monitors!(nodes[0], 1);
123 check_closed_broadcast!(nodes[0], false);
125 // TODO: Once we hit the chain with the failure transaction we should check that we get a
126 // PaymentFailed event
128 assert_eq!(nodes[0].node.list_channels().len(), 0);
132 fn test_simple_monitor_temporary_update_fail() {
133 do_test_simple_monitor_temporary_update_fail(false);
134 do_test_simple_monitor_temporary_update_fail(true);
137 fn do_test_monitor_temporary_update_fail(disconnect_count: usize) {
138 let disconnect_flags = 8 | 16;
140 // Test that we can recover from a temporary monitor update failure with some in-flight
141 // HTLCs going on at the same time potentially with some disconnection thrown in.
142 // * First we route a payment, then get a temporary monitor update failure when trying to
143 // route a second payment. We then claim the first payment.
144 // * If disconnect_count is set, we will disconnect at this point (which is likely as
145 // TemporaryFailure likely indicates net disconnect which resulted in failing to update
146 // the ChannelMonitor on a watchtower).
147 // * If !(disconnect_count & 16) we deliver a update_fulfill_htlc/CS for the first payment
148 // immediately, otherwise we wait disconnect and deliver them via the reconnect
149 // channel_reestablish processing (ie disconnect_count & 16 makes no sense if
150 // disconnect_count & !disconnect_flags is 0).
151 // * We then update the channel monitor, reconnecting if disconnect_count is set and walk
152 // through message sending, potentially disconnect/reconnecting multiple times based on
153 // disconnect_count, to get the update_fulfill_htlc through.
154 // * We then walk through more message exchanges to get the original update_add_htlc
155 // through, swapping message ordering based on disconnect_count & 8 and optionally
156 // disconnect/reconnecting based on disconnect_count.
157 let node_cfgs = create_node_cfgs(2);
158 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
159 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
160 create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
162 let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
164 // Now try to send a second payment which will fail to send
165 let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
166 let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
168 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
169 unwrap_send_err!(nodes[0].node.send_payment(route.clone(), payment_hash_2, None), false, APIError::MonitorUpdateFailed, {});
170 check_added_monitors!(nodes[0], 1);
172 assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
173 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
174 assert_eq!(nodes[0].node.list_channels().len(), 1);
176 // Claim the previous payment, which will result in a update_fulfill_htlc/CS from nodes[1]
177 // but nodes[0] won't respond since it is frozen.
178 assert!(nodes[1].node.claim_funds(payment_preimage_1, &None, 1_000_000));
179 check_added_monitors!(nodes[1], 1);
180 let events_2 = nodes[1].node.get_and_clear_pending_msg_events();
181 assert_eq!(events_2.len(), 1);
182 let (bs_initial_fulfill, bs_initial_commitment_signed) = match events_2[0] {
183 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 } } => {
184 assert_eq!(*node_id, nodes[0].node.get_our_node_id());
185 assert!(update_add_htlcs.is_empty());
186 assert_eq!(update_fulfill_htlcs.len(), 1);
187 assert!(update_fail_htlcs.is_empty());
188 assert!(update_fail_malformed_htlcs.is_empty());
189 assert!(update_fee.is_none());
191 if (disconnect_count & 16) == 0 {
192 nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_htlcs[0]);
193 let events_3 = nodes[0].node.get_and_clear_pending_events();
194 assert_eq!(events_3.len(), 1);
196 Event::PaymentSent { ref payment_preimage } => {
197 assert_eq!(*payment_preimage, payment_preimage_1);
199 _ => panic!("Unexpected event"),
202 nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), commitment_signed);
203 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
204 nodes[0].logger.assert_log("lightning::ln::channelmanager".to_string(), "Previous monitor update failure prevented generation of RAA".to_string(), 1);
207 (update_fulfill_htlcs[0].clone(), commitment_signed.clone())
209 _ => panic!("Unexpected event"),
212 if disconnect_count & !disconnect_flags > 0 {
213 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
214 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
217 // Now fix monitor updating...
218 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Ok(());
219 nodes[0].node.test_restore_channel_monitor();
220 check_added_monitors!(nodes[0], 1);
222 macro_rules! disconnect_reconnect_peers { () => { {
223 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
224 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
226 nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
227 let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
228 assert_eq!(reestablish_1.len(), 1);
229 nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
230 let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
231 assert_eq!(reestablish_2.len(), 1);
233 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
234 let as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
235 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
236 let bs_resp = handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
238 assert!(as_resp.0.is_none());
239 assert!(bs_resp.0.is_none());
241 (reestablish_1, reestablish_2, as_resp, bs_resp)
244 let (payment_event, initial_revoke_and_ack) = if disconnect_count & !disconnect_flags > 0 {
245 assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
246 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
248 nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
249 let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
250 assert_eq!(reestablish_1.len(), 1);
251 nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
252 let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
253 assert_eq!(reestablish_2.len(), 1);
255 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
256 check_added_monitors!(nodes[0], 0);
257 let mut as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
258 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
259 check_added_monitors!(nodes[1], 0);
260 let mut bs_resp = handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
262 assert!(as_resp.0.is_none());
263 assert!(bs_resp.0.is_none());
265 assert!(bs_resp.1.is_none());
266 if (disconnect_count & 16) == 0 {
267 assert!(bs_resp.2.is_none());
269 assert!(as_resp.1.is_some());
270 assert!(as_resp.2.is_some());
271 assert!(as_resp.3 == RAACommitmentOrder::CommitmentFirst);
273 assert!(bs_resp.2.as_ref().unwrap().update_add_htlcs.is_empty());
274 assert!(bs_resp.2.as_ref().unwrap().update_fail_htlcs.is_empty());
275 assert!(bs_resp.2.as_ref().unwrap().update_fail_malformed_htlcs.is_empty());
276 assert!(bs_resp.2.as_ref().unwrap().update_fee.is_none());
277 assert!(bs_resp.2.as_ref().unwrap().update_fulfill_htlcs == vec![bs_initial_fulfill]);
278 assert!(bs_resp.2.as_ref().unwrap().commitment_signed == bs_initial_commitment_signed);
280 assert!(as_resp.1.is_none());
282 nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &bs_resp.2.as_ref().unwrap().update_fulfill_htlcs[0]);
283 let events_3 = nodes[0].node.get_and_clear_pending_events();
284 assert_eq!(events_3.len(), 1);
286 Event::PaymentSent { ref payment_preimage } => {
287 assert_eq!(*payment_preimage, payment_preimage_1);
289 _ => panic!("Unexpected event"),
292 nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_resp.2.as_ref().unwrap().commitment_signed);
293 let as_resp_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
294 // No commitment_signed so get_event_msg's assert(len == 1) passes
295 check_added_monitors!(nodes[0], 1);
297 as_resp.1 = Some(as_resp_raa);
301 if disconnect_count & !disconnect_flags > 1 {
302 let (second_reestablish_1, second_reestablish_2, second_as_resp, second_bs_resp) = disconnect_reconnect_peers!();
304 if (disconnect_count & 16) == 0 {
305 assert!(reestablish_1 == second_reestablish_1);
306 assert!(reestablish_2 == second_reestablish_2);
308 assert!(as_resp == second_as_resp);
309 assert!(bs_resp == second_bs_resp);
312 (SendEvent::from_commitment_update(nodes[1].node.get_our_node_id(), as_resp.2.unwrap()), as_resp.1.unwrap())
314 let mut events_4 = nodes[0].node.get_and_clear_pending_msg_events();
315 assert_eq!(events_4.len(), 2);
316 (SendEvent::from_event(events_4.remove(0)), match events_4[0] {
317 MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
318 assert_eq!(*node_id, nodes[1].node.get_our_node_id());
321 _ => panic!("Unexpected event"),
325 assert_eq!(payment_event.node_id, nodes[1].node.get_our_node_id());
327 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
328 nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event.commitment_msg);
329 let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
330 // nodes[1] is awaiting an RAA from nodes[0] still so get_event_msg's assert(len == 1) passes
331 check_added_monitors!(nodes[1], 1);
333 if disconnect_count & !disconnect_flags > 2 {
334 let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!();
336 assert!(as_resp.1.unwrap() == initial_revoke_and_ack);
337 assert!(bs_resp.1.unwrap() == bs_revoke_and_ack);
339 assert!(as_resp.2.is_none());
340 assert!(bs_resp.2.is_none());
343 let as_commitment_update;
344 let bs_second_commitment_update;
346 macro_rules! handle_bs_raa { () => {
347 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack);
348 as_commitment_update = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
349 assert!(as_commitment_update.update_add_htlcs.is_empty());
350 assert!(as_commitment_update.update_fulfill_htlcs.is_empty());
351 assert!(as_commitment_update.update_fail_htlcs.is_empty());
352 assert!(as_commitment_update.update_fail_malformed_htlcs.is_empty());
353 assert!(as_commitment_update.update_fee.is_none());
354 check_added_monitors!(nodes[0], 1);
357 macro_rules! handle_initial_raa { () => {
358 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &initial_revoke_and_ack);
359 bs_second_commitment_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
360 assert!(bs_second_commitment_update.update_add_htlcs.is_empty());
361 assert!(bs_second_commitment_update.update_fulfill_htlcs.is_empty());
362 assert!(bs_second_commitment_update.update_fail_htlcs.is_empty());
363 assert!(bs_second_commitment_update.update_fail_malformed_htlcs.is_empty());
364 assert!(bs_second_commitment_update.update_fee.is_none());
365 check_added_monitors!(nodes[1], 1);
368 if (disconnect_count & 8) == 0 {
371 if disconnect_count & !disconnect_flags > 3 {
372 let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!();
374 assert!(as_resp.1.unwrap() == initial_revoke_and_ack);
375 assert!(bs_resp.1.is_none());
377 assert!(as_resp.2.unwrap() == as_commitment_update);
378 assert!(bs_resp.2.is_none());
380 assert!(as_resp.3 == RAACommitmentOrder::RevokeAndACKFirst);
383 handle_initial_raa!();
385 if disconnect_count & !disconnect_flags > 4 {
386 let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!();
388 assert!(as_resp.1.is_none());
389 assert!(bs_resp.1.is_none());
391 assert!(as_resp.2.unwrap() == as_commitment_update);
392 assert!(bs_resp.2.unwrap() == bs_second_commitment_update);
395 handle_initial_raa!();
397 if disconnect_count & !disconnect_flags > 3 {
398 let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!();
400 assert!(as_resp.1.is_none());
401 assert!(bs_resp.1.unwrap() == bs_revoke_and_ack);
403 assert!(as_resp.2.is_none());
404 assert!(bs_resp.2.unwrap() == bs_second_commitment_update);
406 assert!(bs_resp.3 == RAACommitmentOrder::RevokeAndACKFirst);
411 if disconnect_count & !disconnect_flags > 4 {
412 let (_, _, as_resp, bs_resp) = disconnect_reconnect_peers!();
414 assert!(as_resp.1.is_none());
415 assert!(bs_resp.1.is_none());
417 assert!(as_resp.2.unwrap() == as_commitment_update);
418 assert!(bs_resp.2.unwrap() == bs_second_commitment_update);
422 nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_second_commitment_update.commitment_signed);
423 let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
424 // No commitment_signed so get_event_msg's assert(len == 1) passes
425 check_added_monitors!(nodes[0], 1);
427 nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_commitment_update.commitment_signed);
428 let bs_second_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
429 // No commitment_signed so get_event_msg's assert(len == 1) passes
430 check_added_monitors!(nodes[1], 1);
432 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_and_ack);
433 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
434 check_added_monitors!(nodes[1], 1);
436 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_second_revoke_and_ack);
437 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
438 check_added_monitors!(nodes[0], 1);
440 expect_pending_htlcs_forwardable!(nodes[1]);
442 let events_5 = nodes[1].node.get_and_clear_pending_events();
443 assert_eq!(events_5.len(), 1);
445 Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
446 assert_eq!(payment_hash_2, *payment_hash);
447 assert_eq!(*payment_secret, None);
448 assert_eq!(amt, 1000000);
450 _ => panic!("Unexpected event"),
453 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
457 fn test_monitor_temporary_update_fail_a() {
458 do_test_monitor_temporary_update_fail(0);
459 do_test_monitor_temporary_update_fail(1);
460 do_test_monitor_temporary_update_fail(2);
461 do_test_monitor_temporary_update_fail(3);
462 do_test_monitor_temporary_update_fail(4);
463 do_test_monitor_temporary_update_fail(5);
467 fn test_monitor_temporary_update_fail_b() {
468 do_test_monitor_temporary_update_fail(2 | 8);
469 do_test_monitor_temporary_update_fail(3 | 8);
470 do_test_monitor_temporary_update_fail(4 | 8);
471 do_test_monitor_temporary_update_fail(5 | 8);
475 fn test_monitor_temporary_update_fail_c() {
476 do_test_monitor_temporary_update_fail(1 | 16);
477 do_test_monitor_temporary_update_fail(2 | 16);
478 do_test_monitor_temporary_update_fail(3 | 16);
479 do_test_monitor_temporary_update_fail(2 | 8 | 16);
480 do_test_monitor_temporary_update_fail(3 | 8 | 16);
484 fn test_monitor_update_fail_cs() {
485 // Tests handling of a monitor update failure when processing an incoming commitment_signed
486 let node_cfgs = create_node_cfgs(2);
487 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
488 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
489 create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
491 let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
492 let (payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
493 nodes[0].node.send_payment(route, our_payment_hash, None).unwrap();
494 check_added_monitors!(nodes[0], 1);
496 let send_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
497 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_event.msgs[0]);
499 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
500 nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &send_event.commitment_msg);
501 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
502 nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Failed to update ChannelMonitor".to_string(), 1);
503 check_added_monitors!(nodes[1], 1);
504 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
506 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
507 nodes[1].node.test_restore_channel_monitor();
508 check_added_monitors!(nodes[1], 1);
509 let responses = nodes[1].node.get_and_clear_pending_msg_events();
510 assert_eq!(responses.len(), 2);
513 MessageSendEvent::SendRevokeAndACK { ref msg, ref node_id } => {
514 assert_eq!(*node_id, nodes[0].node.get_our_node_id());
515 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &msg);
516 check_added_monitors!(nodes[0], 1);
518 _ => panic!("Unexpected event"),
521 MessageSendEvent::UpdateHTLCs { ref updates, ref node_id } => {
522 assert!(updates.update_add_htlcs.is_empty());
523 assert!(updates.update_fulfill_htlcs.is_empty());
524 assert!(updates.update_fail_htlcs.is_empty());
525 assert!(updates.update_fail_malformed_htlcs.is_empty());
526 assert!(updates.update_fee.is_none());
527 assert_eq!(*node_id, nodes[0].node.get_our_node_id());
529 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
530 nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &updates.commitment_signed);
531 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
532 nodes[0].logger.assert_log("lightning::ln::channelmanager".to_string(), "Failed to update ChannelMonitor".to_string(), 1);
533 check_added_monitors!(nodes[0], 1);
534 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
536 _ => panic!("Unexpected event"),
539 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Ok(());
540 nodes[0].node.test_restore_channel_monitor();
541 check_added_monitors!(nodes[0], 1);
543 let final_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
544 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &final_raa);
545 check_added_monitors!(nodes[1], 1);
547 expect_pending_htlcs_forwardable!(nodes[1]);
549 let events = nodes[1].node.get_and_clear_pending_events();
550 assert_eq!(events.len(), 1);
552 Event::PaymentReceived { payment_hash, payment_secret, amt } => {
553 assert_eq!(payment_hash, our_payment_hash);
554 assert_eq!(payment_secret, None);
555 assert_eq!(amt, 1000000);
557 _ => panic!("Unexpected event"),
560 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage, 1_000_000);
564 fn test_monitor_update_fail_no_rebroadcast() {
565 // Tests handling of a monitor update failure when no message rebroadcasting on
566 // test_restore_channel_monitor() is required. Backported from
567 // chanmon_fail_consistency fuzz tests.
568 let node_cfgs = create_node_cfgs(2);
569 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
570 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
571 create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
573 let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
574 let (payment_preimage_1, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
575 nodes[0].node.send_payment(route, our_payment_hash, None).unwrap();
576 check_added_monitors!(nodes[0], 1);
578 let send_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
579 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_event.msgs[0]);
580 let bs_raa = commitment_signed_dance!(nodes[1], nodes[0], send_event.commitment_msg, false, true, false, true);
582 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
583 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &bs_raa);
584 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
585 nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Failed to update ChannelMonitor".to_string(), 1);
586 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
587 assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
588 check_added_monitors!(nodes[1], 1);
590 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
591 nodes[1].node.test_restore_channel_monitor();
592 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
593 check_added_monitors!(nodes[1], 1);
594 expect_pending_htlcs_forwardable!(nodes[1]);
596 let events = nodes[1].node.get_and_clear_pending_events();
597 assert_eq!(events.len(), 1);
599 Event::PaymentReceived { payment_hash, .. } => {
600 assert_eq!(payment_hash, our_payment_hash);
602 _ => panic!("Unexpected event"),
605 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
609 fn test_monitor_update_raa_while_paused() {
610 // Tests handling of an RAA while monitor updating has already been marked failed.
611 // Backported from chanmon_fail_consistency fuzz tests as this used to be broken.
612 let node_cfgs = create_node_cfgs(2);
613 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
614 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
615 create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
617 send_payment(&nodes[0], &[&nodes[1]], 5000000, 5_000_000);
619 let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
620 let (payment_preimage_1, our_payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
621 nodes[0].node.send_payment(route, our_payment_hash_1, None).unwrap();
622 check_added_monitors!(nodes[0], 1);
623 let send_event_1 = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
625 let route = nodes[1].router.get_route(&nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
626 let (payment_preimage_2, our_payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
627 nodes[1].node.send_payment(route, our_payment_hash_2, None).unwrap();
628 check_added_monitors!(nodes[1], 1);
629 let send_event_2 = SendEvent::from_event(nodes[1].node.get_and_clear_pending_msg_events().remove(0));
631 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_event_1.msgs[0]);
632 nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &send_event_1.commitment_msg);
633 check_added_monitors!(nodes[1], 1);
634 let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
636 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
637 nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &send_event_2.msgs[0]);
638 nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &send_event_2.commitment_msg);
639 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
640 nodes[0].logger.assert_log("lightning::ln::channelmanager".to_string(), "Failed to update ChannelMonitor".to_string(), 1);
641 check_added_monitors!(nodes[0], 1);
643 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_raa);
644 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
645 nodes[0].logger.assert_log("lightning::ln::channelmanager".to_string(), "Previous monitor update failure prevented responses to RAA".to_string(), 1);
646 check_added_monitors!(nodes[0], 1);
648 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Ok(());
649 nodes[0].node.test_restore_channel_monitor();
650 check_added_monitors!(nodes[0], 1);
652 let as_update_raa = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
653 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_update_raa.0);
654 check_added_monitors!(nodes[1], 1);
655 let bs_cs = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
657 nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_update_raa.1);
658 check_added_monitors!(nodes[1], 1);
659 let bs_second_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
661 nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_cs.commitment_signed);
662 check_added_monitors!(nodes[0], 1);
663 let as_second_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
665 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_second_raa);
666 check_added_monitors!(nodes[0], 1);
667 expect_pending_htlcs_forwardable!(nodes[0]);
668 expect_payment_received!(nodes[0], our_payment_hash_2, 1000000);
670 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_second_raa);
671 check_added_monitors!(nodes[1], 1);
672 expect_pending_htlcs_forwardable!(nodes[1]);
673 expect_payment_received!(nodes[1], our_payment_hash_1, 1000000);
675 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
676 claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_2, 1_000_000);
679 fn do_test_monitor_update_fail_raa(test_ignore_second_cs: bool) {
680 // Tests handling of a monitor update failure when processing an incoming RAA
681 let node_cfgs = create_node_cfgs(3);
682 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
683 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
684 create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
685 let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
687 // Rebalance a bit so that we can send backwards from 2 to 1.
688 send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000, 5_000_000);
690 // Route a first payment that we'll fail backwards
691 let (_, payment_hash_1) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000);
693 // Fail the payment backwards, failing the monitor update on nodes[1]'s receipt of the RAA
694 assert!(nodes[2].node.fail_htlc_backwards(&payment_hash_1, &None));
695 expect_pending_htlcs_forwardable!(nodes[2]);
696 check_added_monitors!(nodes[2], 1);
698 let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
699 assert!(updates.update_add_htlcs.is_empty());
700 assert!(updates.update_fulfill_htlcs.is_empty());
701 assert_eq!(updates.update_fail_htlcs.len(), 1);
702 assert!(updates.update_fail_malformed_htlcs.is_empty());
703 assert!(updates.update_fee.is_none());
704 nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
706 let bs_revoke_and_ack = commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false, true, false, true);
707 check_added_monitors!(nodes[0], 0);
709 // While the second channel is AwaitingRAA, forward a second payment to get it into the
711 let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
712 let route = nodes[0].router.get_route(&nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
713 nodes[0].node.send_payment(route, payment_hash_2, None).unwrap();
714 check_added_monitors!(nodes[0], 1);
716 let mut send_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
717 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_event.msgs[0]);
718 commitment_signed_dance!(nodes[1], nodes[0], send_event.commitment_msg, false);
720 expect_pending_htlcs_forwardable!(nodes[1]);
721 check_added_monitors!(nodes[1], 0);
722 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
724 // Now fail monitor updating.
725 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
726 nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &bs_revoke_and_ack);
727 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
728 nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Failed to update ChannelMonitor".to_string(), 1);
729 assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
730 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
731 check_added_monitors!(nodes[1], 1);
733 // Attempt to forward a third payment but fail due to the second channel being unavailable
736 let (_, payment_hash_3) = get_payment_preimage_hash!(nodes[0]);
737 let route = nodes[0].router.get_route(&nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
738 nodes[0].node.send_payment(route, payment_hash_3, None).unwrap();
739 check_added_monitors!(nodes[0], 1);
741 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(()); // We succeed in updating the monitor for the first channel
742 send_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
743 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_event.msgs[0]);
744 commitment_signed_dance!(nodes[1], nodes[0], send_event.commitment_msg, false, true);
745 check_added_monitors!(nodes[1], 0);
747 let mut events_2 = nodes[1].node.get_and_clear_pending_msg_events();
748 assert_eq!(events_2.len(), 1);
749 match events_2.remove(0) {
750 MessageSendEvent::UpdateHTLCs { node_id, updates } => {
751 assert_eq!(node_id, nodes[0].node.get_our_node_id());
752 assert!(updates.update_fulfill_htlcs.is_empty());
753 assert_eq!(updates.update_fail_htlcs.len(), 1);
754 assert!(updates.update_fail_malformed_htlcs.is_empty());
755 assert!(updates.update_add_htlcs.is_empty());
756 assert!(updates.update_fee.is_none());
758 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
759 commitment_signed_dance!(nodes[0], nodes[1], updates.commitment_signed, false, true);
761 let msg_events = nodes[0].node.get_and_clear_pending_msg_events();
762 assert_eq!(msg_events.len(), 1);
763 match msg_events[0] {
764 MessageSendEvent::PaymentFailureNetworkUpdate { update: msgs::HTLCFailChannelUpdate::ChannelUpdateMessage { ref msg }} => {
765 assert_eq!(msg.contents.short_channel_id, chan_2.0.contents.short_channel_id);
766 assert_eq!(msg.contents.flags & 2, 2); // temp disabled
768 _ => panic!("Unexpected event"),
771 let events = nodes[0].node.get_and_clear_pending_events();
772 assert_eq!(events.len(), 1);
773 if let Event::PaymentFailed { payment_hash, rejected_by_dest, .. } = events[0] {
774 assert_eq!(payment_hash, payment_hash_3);
775 assert!(!rejected_by_dest);
776 } else { panic!("Unexpected event!"); }
778 _ => panic!("Unexpected event type!"),
781 let (payment_preimage_4, payment_hash_4) = if test_ignore_second_cs {
782 // Try to route another payment backwards from 2 to make sure 1 holds off on responding
783 let (payment_preimage_4, payment_hash_4) = get_payment_preimage_hash!(nodes[0]);
784 let route = nodes[2].router.get_route(&nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
785 nodes[2].node.send_payment(route, payment_hash_4, None).unwrap();
786 check_added_monitors!(nodes[2], 1);
788 send_event = SendEvent::from_event(nodes[2].node.get_and_clear_pending_msg_events().remove(0));
789 nodes[1].node.handle_update_add_htlc(&nodes[2].node.get_our_node_id(), &send_event.msgs[0]);
790 nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &send_event.commitment_msg);
791 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
792 nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Previous monitor update failure prevented generation of RAA".to_string(), 1);
793 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
794 assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
795 (Some(payment_preimage_4), Some(payment_hash_4))
796 } else { (None, None) };
798 // Restore monitor updating, ensuring we immediately get a fail-back update and a
799 // update_add update.
800 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
801 nodes[1].node.test_restore_channel_monitor();
802 check_added_monitors!(nodes[1], 1);
803 expect_pending_htlcs_forwardable!(nodes[1]);
804 check_added_monitors!(nodes[1], 1);
806 let mut events_3 = nodes[1].node.get_and_clear_pending_msg_events();
807 if test_ignore_second_cs {
808 assert_eq!(events_3.len(), 3);
810 assert_eq!(events_3.len(), 2);
813 // Note that the ordering of the events for different nodes is non-prescriptive, though the
814 // ordering of the two events that both go to nodes[2] have to stay in the same order.
815 let messages_a = match events_3.pop().unwrap() {
816 MessageSendEvent::UpdateHTLCs { node_id, mut updates } => {
817 assert_eq!(node_id, nodes[0].node.get_our_node_id());
818 assert!(updates.update_fulfill_htlcs.is_empty());
819 assert_eq!(updates.update_fail_htlcs.len(), 1);
820 assert!(updates.update_fail_malformed_htlcs.is_empty());
821 assert!(updates.update_add_htlcs.is_empty());
822 assert!(updates.update_fee.is_none());
823 (updates.update_fail_htlcs.remove(0), updates.commitment_signed)
825 _ => panic!("Unexpected event type!"),
827 let raa = if test_ignore_second_cs {
828 match events_3.remove(1) {
829 MessageSendEvent::SendRevokeAndACK { node_id, msg } => {
830 assert_eq!(node_id, nodes[2].node.get_our_node_id());
833 _ => panic!("Unexpected event"),
836 let send_event_b = SendEvent::from_event(events_3.remove(0));
837 assert_eq!(send_event_b.node_id, nodes[2].node.get_our_node_id());
839 // Now deliver the new messages...
841 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &messages_a.0);
842 commitment_signed_dance!(nodes[0], nodes[1], messages_a.1, false);
843 let events_4 = nodes[0].node.get_and_clear_pending_events();
844 assert_eq!(events_4.len(), 1);
845 if let Event::PaymentFailed { payment_hash, rejected_by_dest, .. } = events_4[0] {
846 assert_eq!(payment_hash, payment_hash_1);
847 assert!(rejected_by_dest);
848 } else { panic!("Unexpected event!"); }
850 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &send_event_b.msgs[0]);
851 if test_ignore_second_cs {
852 nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &send_event_b.commitment_msg);
853 check_added_monitors!(nodes[2], 1);
854 let bs_revoke_and_ack = get_event_msg!(nodes[2], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
855 nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &raa.unwrap());
856 check_added_monitors!(nodes[2], 1);
857 let bs_cs = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
858 assert!(bs_cs.update_add_htlcs.is_empty());
859 assert!(bs_cs.update_fail_htlcs.is_empty());
860 assert!(bs_cs.update_fail_malformed_htlcs.is_empty());
861 assert!(bs_cs.update_fulfill_htlcs.is_empty());
862 assert!(bs_cs.update_fee.is_none());
864 nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &bs_revoke_and_ack);
865 check_added_monitors!(nodes[1], 1);
866 let as_cs = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
867 assert!(as_cs.update_add_htlcs.is_empty());
868 assert!(as_cs.update_fail_htlcs.is_empty());
869 assert!(as_cs.update_fail_malformed_htlcs.is_empty());
870 assert!(as_cs.update_fulfill_htlcs.is_empty());
871 assert!(as_cs.update_fee.is_none());
873 nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &bs_cs.commitment_signed);
874 check_added_monitors!(nodes[1], 1);
875 let as_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[2].node.get_our_node_id());
877 nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &as_cs.commitment_signed);
878 check_added_monitors!(nodes[2], 1);
879 let bs_second_raa = get_event_msg!(nodes[2], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
881 nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_raa);
882 check_added_monitors!(nodes[2], 1);
883 assert!(nodes[2].node.get_and_clear_pending_msg_events().is_empty());
885 nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &bs_second_raa);
886 check_added_monitors!(nodes[1], 1);
887 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
889 commitment_signed_dance!(nodes[2], nodes[1], send_event_b.commitment_msg, false);
892 expect_pending_htlcs_forwardable!(nodes[2]);
894 let events_6 = nodes[2].node.get_and_clear_pending_events();
895 assert_eq!(events_6.len(), 1);
897 Event::PaymentReceived { payment_hash, .. } => { assert_eq!(payment_hash, payment_hash_2); },
898 _ => panic!("Unexpected event"),
901 if test_ignore_second_cs {
902 expect_pending_htlcs_forwardable!(nodes[1]);
903 check_added_monitors!(nodes[1], 1);
905 send_event = SendEvent::from_node(&nodes[1]);
906 assert_eq!(send_event.node_id, nodes[0].node.get_our_node_id());
907 assert_eq!(send_event.msgs.len(), 1);
908 nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &send_event.msgs[0]);
909 commitment_signed_dance!(nodes[0], nodes[1], send_event.commitment_msg, false);
911 expect_pending_htlcs_forwardable!(nodes[0]);
913 let events_9 = nodes[0].node.get_and_clear_pending_events();
914 assert_eq!(events_9.len(), 1);
916 Event::PaymentReceived { payment_hash, .. } => assert_eq!(payment_hash, payment_hash_4.unwrap()),
917 _ => panic!("Unexpected event"),
919 claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_4.unwrap(), 1_000_000);
922 claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage_2, 1_000_000);
926 fn test_monitor_update_fail_raa() {
927 do_test_monitor_update_fail_raa(false);
928 do_test_monitor_update_fail_raa(true);
932 fn test_monitor_update_fail_reestablish() {
933 // Simple test for message retransmission after monitor update failure on
934 // channel_reestablish generating a monitor update (which comes from freeing holding cell
936 let node_cfgs = create_node_cfgs(3);
937 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
938 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
939 create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
940 create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
942 let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000);
944 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
945 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
947 assert!(nodes[2].node.claim_funds(our_payment_preimage, &None, 1_000_000));
948 check_added_monitors!(nodes[2], 1);
949 let mut updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
950 assert!(updates.update_add_htlcs.is_empty());
951 assert!(updates.update_fail_htlcs.is_empty());
952 assert!(updates.update_fail_malformed_htlcs.is_empty());
953 assert!(updates.update_fee.is_none());
954 assert_eq!(updates.update_fulfill_htlcs.len(), 1);
955 nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
956 check_added_monitors!(nodes[1], 1);
957 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
958 commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false);
960 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
961 nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
962 nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
964 let as_reestablish = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReestablish, nodes[1].node.get_our_node_id());
965 let bs_reestablish = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
967 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &bs_reestablish);
969 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &as_reestablish);
970 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
971 nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Failed to update ChannelMonitor".to_string(), 1);
972 check_added_monitors!(nodes[1], 1);
974 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
975 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
977 nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
978 nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
980 assert!(as_reestablish == get_event_msg!(nodes[0], MessageSendEvent::SendChannelReestablish, nodes[1].node.get_our_node_id()));
981 assert!(bs_reestablish == get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id()));
983 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &bs_reestablish);
985 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &as_reestablish);
986 check_added_monitors!(nodes[1], 0);
987 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
989 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
990 nodes[1].node.test_restore_channel_monitor();
991 check_added_monitors!(nodes[1], 1);
993 updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
994 assert!(updates.update_add_htlcs.is_empty());
995 assert!(updates.update_fail_htlcs.is_empty());
996 assert!(updates.update_fail_malformed_htlcs.is_empty());
997 assert!(updates.update_fee.is_none());
998 assert_eq!(updates.update_fulfill_htlcs.len(), 1);
999 nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
1000 commitment_signed_dance!(nodes[0], nodes[1], updates.commitment_signed, false);
1002 let events = nodes[0].node.get_and_clear_pending_events();
1003 assert_eq!(events.len(), 1);
1005 Event::PaymentSent { payment_preimage, .. } => assert_eq!(payment_preimage, our_payment_preimage),
1006 _ => panic!("Unexpected event"),
1011 fn raa_no_response_awaiting_raa_state() {
1012 // This is a rather convoluted test which ensures that if handling of an RAA does not happen
1013 // due to a previous monitor update failure, we still set AwaitingRemoteRevoke on the channel
1014 // in question (assuming it intends to respond with a CS after monitor updating is restored).
1015 // Backported from chanmon_fail_consistency fuzz tests as this used to be broken.
1016 let node_cfgs = create_node_cfgs(2);
1017 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1018 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1019 create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
1021 let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1022 let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
1023 let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
1024 let (payment_preimage_3, payment_hash_3) = get_payment_preimage_hash!(nodes[0]);
1026 // Queue up two payments - one will be delivered right away, one immediately goes into the
1027 // holding cell as nodes[0] is AwaitingRAA. Ultimately this allows us to deliver an RAA
1028 // immediately after a CS. By setting failing the monitor update failure from the CS (which
1029 // requires only an RAA response due to AwaitingRAA) we can deliver the RAA and require the CS
1030 // generation during RAA while in monitor-update-failed state.
1031 nodes[0].node.send_payment(route.clone(), payment_hash_1, None).unwrap();
1032 check_added_monitors!(nodes[0], 1);
1033 nodes[0].node.send_payment(route.clone(), payment_hash_2, None).unwrap();
1034 check_added_monitors!(nodes[0], 0);
1036 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1037 assert_eq!(events.len(), 1);
1038 let payment_event = SendEvent::from_event(events.pop().unwrap());
1039 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
1040 nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event.commitment_msg);
1041 check_added_monitors!(nodes[1], 1);
1043 let bs_responses = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1044 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_responses.0);
1045 check_added_monitors!(nodes[0], 1);
1046 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1047 assert_eq!(events.len(), 1);
1048 let payment_event = SendEvent::from_event(events.pop().unwrap());
1050 nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_responses.1);
1051 check_added_monitors!(nodes[0], 1);
1052 let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1054 // Now we have a CS queued up which adds a new HTLC (which will need a RAA/CS response from
1055 // nodes[1]) followed by an RAA. Fail the monitor updating prior to the CS, deliver the RAA,
1056 // then restore channel monitor updates.
1057 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1058 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
1059 nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event.commitment_msg);
1060 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1061 nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Failed to update ChannelMonitor".to_string(), 1);
1062 check_added_monitors!(nodes[1], 1);
1064 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
1065 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1066 nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Previous monitor update failure prevented responses to RAA".to_string(), 1);
1067 check_added_monitors!(nodes[1], 1);
1069 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
1070 nodes[1].node.test_restore_channel_monitor();
1071 // nodes[1] should be AwaitingRAA here!
1072 check_added_monitors!(nodes[1], 1);
1073 let bs_responses = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1074 expect_pending_htlcs_forwardable!(nodes[1]);
1075 expect_payment_received!(nodes[1], payment_hash_1, 1000000);
1077 // We send a third payment here, which is somewhat of a redundant test, but the
1078 // chanmon_fail_consistency test required it to actually find the bug (by seeing out-of-sync
1079 // commitment transaction states) whereas here we can explicitly check for it.
1080 nodes[0].node.send_payment(route.clone(), payment_hash_3, None).unwrap();
1081 check_added_monitors!(nodes[0], 0);
1082 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1084 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_responses.0);
1085 check_added_monitors!(nodes[0], 1);
1086 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1087 assert_eq!(events.len(), 1);
1088 let payment_event = SendEvent::from_event(events.pop().unwrap());
1090 nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_responses.1);
1091 check_added_monitors!(nodes[0], 1);
1092 let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1094 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
1095 nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event.commitment_msg);
1096 check_added_monitors!(nodes[1], 1);
1097 let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
1099 // Finally deliver the RAA to nodes[1] which results in a CS response to the last update
1100 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
1101 check_added_monitors!(nodes[1], 1);
1102 expect_pending_htlcs_forwardable!(nodes[1]);
1103 expect_payment_received!(nodes[1], payment_hash_2, 1000000);
1104 let bs_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1106 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_raa);
1107 check_added_monitors!(nodes[0], 1);
1109 nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_update.commitment_signed);
1110 check_added_monitors!(nodes[0], 1);
1111 let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1113 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
1114 check_added_monitors!(nodes[1], 1);
1115 expect_pending_htlcs_forwardable!(nodes[1]);
1116 expect_payment_received!(nodes[1], payment_hash_3, 1000000);
1118 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
1119 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
1120 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3, 1_000_000);
1124 fn claim_while_disconnected_monitor_update_fail() {
1125 // Test for claiming a payment while disconnected and then having the resulting
1126 // channel-update-generated monitor update fail. This kind of thing isn't a particularly
1127 // contrived case for nodes with network instability.
1128 // Backported from chanmon_fail_consistency fuzz tests as an unmerged version of the handling
1129 // code introduced a regression in this test (specifically, this caught a removal of the
1130 // channel_reestablish handling ensuring the order was sensical given the messages used).
1131 let node_cfgs = create_node_cfgs(2);
1132 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1133 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1134 create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
1136 // Forward a payment for B to claim
1137 let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
1139 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
1140 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
1142 assert!(nodes[1].node.claim_funds(payment_preimage_1, &None, 1_000_000));
1143 check_added_monitors!(nodes[1], 1);
1145 nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
1146 nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
1148 let as_reconnect = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReestablish, nodes[1].node.get_our_node_id());
1149 let bs_reconnect = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
1151 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &bs_reconnect);
1152 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1154 // Now deliver a's reestablish, freeing the claim from the holding cell, but fail the monitor
1156 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1158 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &as_reconnect);
1159 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1160 nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Failed to update ChannelMonitor".to_string(), 1);
1161 check_added_monitors!(nodes[1], 1);
1162 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1164 // Send a second payment from A to B, resulting in a commitment update that gets swallowed with
1165 // the monitor still failed
1166 let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1167 let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
1168 nodes[0].node.send_payment(route, payment_hash_2, None).unwrap();
1169 check_added_monitors!(nodes[0], 1);
1171 let as_updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
1172 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &as_updates.update_add_htlcs[0]);
1173 nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_updates.commitment_signed);
1174 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1175 nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Previous monitor update failure prevented generation of RAA".to_string(), 1);
1176 // Note that nodes[1] not updating monitor here is OK - it wont take action on the new HTLC
1177 // until we've test_restore_channel_monitor'd and updated for the new commitment transaction.
1179 // Now un-fail the monitor, which will result in B sending its original commitment update,
1180 // receiving the commitment update from A, and the resulting commitment dances.
1181 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
1182 nodes[1].node.test_restore_channel_monitor();
1183 check_added_monitors!(nodes[1], 1);
1185 let bs_msgs = nodes[1].node.get_and_clear_pending_msg_events();
1186 assert_eq!(bs_msgs.len(), 2);
1189 MessageSendEvent::UpdateHTLCs { ref node_id, ref updates } => {
1190 assert_eq!(*node_id, nodes[0].node.get_our_node_id());
1191 nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
1192 nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &updates.commitment_signed);
1193 check_added_monitors!(nodes[0], 1);
1195 let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1196 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
1197 check_added_monitors!(nodes[1], 1);
1199 _ => panic!("Unexpected event"),
1203 MessageSendEvent::SendRevokeAndACK { ref node_id, ref msg } => {
1204 assert_eq!(*node_id, nodes[0].node.get_our_node_id());
1205 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), msg);
1206 check_added_monitors!(nodes[0], 1);
1208 _ => panic!("Unexpected event"),
1211 let as_commitment = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
1213 let bs_commitment = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1214 nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_commitment.commitment_signed);
1215 check_added_monitors!(nodes[0], 1);
1216 let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1218 nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_commitment.commitment_signed);
1219 check_added_monitors!(nodes[1], 1);
1220 let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
1221 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
1222 check_added_monitors!(nodes[1], 1);
1224 expect_pending_htlcs_forwardable!(nodes[1]);
1225 expect_payment_received!(nodes[1], payment_hash_2, 1000000);
1227 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_raa);
1228 check_added_monitors!(nodes[0], 1);
1230 let events = nodes[0].node.get_and_clear_pending_events();
1231 assert_eq!(events.len(), 1);
1233 Event::PaymentSent { ref payment_preimage } => {
1234 assert_eq!(*payment_preimage, payment_preimage_1);
1236 _ => panic!("Unexpected event"),
1239 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
1243 fn monitor_failed_no_reestablish_response() {
1244 // Test for receiving a channel_reestablish after a monitor update failure resulted in no
1245 // response to a commitment_signed.
1246 // Backported from chanmon_fail_consistency fuzz tests as it caught a long-standing
1247 // debug_assert!() failure in channel_reestablish handling.
1248 let node_cfgs = create_node_cfgs(2);
1249 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1250 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1251 create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
1253 // Route the payment and deliver the initial commitment_signed (with a monitor update failure
1255 let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1256 let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
1257 nodes[0].node.send_payment(route, payment_hash_1, None).unwrap();
1258 check_added_monitors!(nodes[0], 1);
1260 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1261 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1262 assert_eq!(events.len(), 1);
1263 let payment_event = SendEvent::from_event(events.pop().unwrap());
1264 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
1265 nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event.commitment_msg);
1266 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1267 nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Failed to update ChannelMonitor".to_string(), 1);
1268 check_added_monitors!(nodes[1], 1);
1270 // Now disconnect and immediately reconnect, delivering the channel_reestablish while nodes[1]
1271 // is still failing to update monitors.
1272 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
1273 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
1275 nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
1276 nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
1278 let as_reconnect = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReestablish, nodes[1].node.get_our_node_id());
1279 let bs_reconnect = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
1281 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &as_reconnect);
1282 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &bs_reconnect);
1284 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
1285 nodes[1].node.test_restore_channel_monitor();
1286 check_added_monitors!(nodes[1], 1);
1287 let bs_responses = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1289 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_responses.0);
1290 check_added_monitors!(nodes[0], 1);
1291 nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_responses.1);
1292 check_added_monitors!(nodes[0], 1);
1294 let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1295 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
1296 check_added_monitors!(nodes[1], 1);
1298 expect_pending_htlcs_forwardable!(nodes[1]);
1299 expect_payment_received!(nodes[1], payment_hash_1, 1000000);
1301 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
1305 fn first_message_on_recv_ordering() {
1306 // Test that if the initial generator of a monitor-update-frozen state doesn't generate
1307 // messages, we're willing to flip the order of response messages if neccessary in resposne to
1308 // a commitment_signed which needs to send an RAA first.
1309 // At a high level, our goal is to fail monitor updating in response to an RAA which needs no
1310 // response and then handle a CS while in the failed state, requiring an RAA followed by a CS
1311 // response. To do this, we start routing two payments, with the final RAA for the first being
1312 // delivered while B is in AwaitingRAA, hence when we deliver the CS for the second B will
1313 // have no pending response but will want to send a RAA/CS (with the updates for the second
1314 // payment applied).
1315 // Backported from chanmon_fail_consistency fuzz tests as it caught a bug here.
1316 let node_cfgs = create_node_cfgs(2);
1317 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1318 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1319 create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
1321 // Route the first payment outbound, holding the last RAA for B until we are set up so that we
1322 // can deliver it and fail the monitor update.
1323 let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1324 let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
1325 nodes[0].node.send_payment(route, payment_hash_1, None).unwrap();
1326 check_added_monitors!(nodes[0], 1);
1328 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1329 assert_eq!(events.len(), 1);
1330 let payment_event = SendEvent::from_event(events.pop().unwrap());
1331 assert_eq!(payment_event.node_id, nodes[1].node.get_our_node_id());
1332 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
1333 nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event.commitment_msg);
1334 check_added_monitors!(nodes[1], 1);
1335 let bs_responses = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1337 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_responses.0);
1338 check_added_monitors!(nodes[0], 1);
1339 nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_responses.1);
1340 check_added_monitors!(nodes[0], 1);
1342 let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1344 // Route the second payment, generating an update_add_htlc/commitment_signed
1345 let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1346 let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
1347 nodes[0].node.send_payment(route, payment_hash_2, None).unwrap();
1348 check_added_monitors!(nodes[0], 1);
1349 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1350 assert_eq!(events.len(), 1);
1351 let payment_event = SendEvent::from_event(events.pop().unwrap());
1352 assert_eq!(payment_event.node_id, nodes[1].node.get_our_node_id());
1354 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1356 // Deliver the final RAA for the first payment, which does not require a response. RAAs
1357 // generally require a commitment_signed, so the fact that we're expecting an opposite response
1358 // to the next message also tests resetting the delivery order.
1359 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
1360 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1361 nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Failed to update ChannelMonitor".to_string(), 1);
1362 check_added_monitors!(nodes[1], 1);
1364 // Now deliver the update_add_htlc/commitment_signed for the second payment, which does need an
1365 // RAA/CS response, which should be generated when we call test_restore_channel_monitor (with
1366 // the appropriate HTLC acceptance).
1367 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
1368 nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event.commitment_msg);
1369 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1370 nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Previous monitor update failure prevented generation of RAA".to_string(), 1);
1372 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
1373 nodes[1].node.test_restore_channel_monitor();
1374 check_added_monitors!(nodes[1], 1);
1376 expect_pending_htlcs_forwardable!(nodes[1]);
1377 expect_payment_received!(nodes[1], payment_hash_1, 1000000);
1379 let bs_responses = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1380 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_responses.0);
1381 check_added_monitors!(nodes[0], 1);
1382 nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_responses.1);
1383 check_added_monitors!(nodes[0], 1);
1385 let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
1386 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
1387 check_added_monitors!(nodes[1], 1);
1389 expect_pending_htlcs_forwardable!(nodes[1]);
1390 expect_payment_received!(nodes[1], payment_hash_2, 1000000);
1392 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_1, 1_000_000);
1393 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
1397 fn test_monitor_update_fail_claim() {
1398 // Basic test for monitor update failures when processing claim_funds calls.
1399 // We set up a simple 3-node network, sending a payment from A to B and failing B's monitor
1400 // update to claim the payment. We then send a payment C->B->A, making the forward of this
1401 // payment from B to A fail due to the paused channel. Finally, we restore the channel monitor
1402 // updating and claim the payment on B.
1403 let node_cfgs = create_node_cfgs(3);
1404 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
1405 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1406 let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
1407 create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
1409 // Rebalance a bit so that we can send backwards from 3 to 2.
1410 send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000, 5_000_000);
1412 let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
1414 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1415 assert!(nodes[1].node.claim_funds(payment_preimage_1, &None, 1_000_000));
1416 check_added_monitors!(nodes[1], 1);
1418 let route = nodes[2].router.get_route(&nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1419 let (_, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
1420 nodes[2].node.send_payment(route, payment_hash_2, None).unwrap();
1421 check_added_monitors!(nodes[2], 1);
1423 // Successfully update the monitor on the 1<->2 channel, but the 0<->1 channel should still be
1424 // paused, so forward shouldn't succeed until we call test_restore_channel_monitor().
1425 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
1427 let mut events = nodes[2].node.get_and_clear_pending_msg_events();
1428 assert_eq!(events.len(), 1);
1429 let payment_event = SendEvent::from_event(events.pop().unwrap());
1430 nodes[1].node.handle_update_add_htlc(&nodes[2].node.get_our_node_id(), &payment_event.msgs[0]);
1431 let events = nodes[1].node.get_and_clear_pending_msg_events();
1432 assert_eq!(events.len(), 0);
1433 nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Failed to update ChannelMonitor".to_string(), 1);
1434 commitment_signed_dance!(nodes[1], nodes[2], payment_event.commitment_msg, false, true);
1436 let bs_fail_update = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
1437 nodes[2].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &bs_fail_update.update_fail_htlcs[0]);
1438 commitment_signed_dance!(nodes[2], nodes[1], bs_fail_update.commitment_signed, false, true);
1440 let msg_events = nodes[2].node.get_and_clear_pending_msg_events();
1441 assert_eq!(msg_events.len(), 1);
1442 match msg_events[0] {
1443 MessageSendEvent::PaymentFailureNetworkUpdate { update: msgs::HTLCFailChannelUpdate::ChannelUpdateMessage { ref msg }} => {
1444 assert_eq!(msg.contents.short_channel_id, chan_1.0.contents.short_channel_id);
1445 assert_eq!(msg.contents.flags & 2, 2); // temp disabled
1447 _ => panic!("Unexpected event"),
1450 let events = nodes[2].node.get_and_clear_pending_events();
1451 assert_eq!(events.len(), 1);
1452 if let Event::PaymentFailed { payment_hash, rejected_by_dest, .. } = events[0] {
1453 assert_eq!(payment_hash, payment_hash_2);
1454 assert!(!rejected_by_dest);
1455 } else { panic!("Unexpected event!"); }
1457 // Now restore monitor updating on the 0<->1 channel and claim the funds on B.
1458 nodes[1].node.test_restore_channel_monitor();
1459 check_added_monitors!(nodes[1], 1);
1461 let bs_fulfill_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1462 nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &bs_fulfill_update.update_fulfill_htlcs[0]);
1463 commitment_signed_dance!(nodes[0], nodes[1], bs_fulfill_update.commitment_signed, false);
1465 let events = nodes[0].node.get_and_clear_pending_events();
1466 assert_eq!(events.len(), 1);
1467 if let Event::PaymentSent { payment_preimage, .. } = events[0] {
1468 assert_eq!(payment_preimage, payment_preimage_1);
1469 } else { panic!("Unexpected event!"); }
1473 fn test_monitor_update_on_pending_forwards() {
1474 // Basic test for monitor update failures when processing pending HTLC fail/add forwards.
1475 // We do this with a simple 3-node network, sending a payment from A to C and one from C to A.
1476 // The payment from A to C will be failed by C and pending a back-fail to A, while the payment
1477 // from C to A will be pending a forward to A.
1478 let node_cfgs = create_node_cfgs(3);
1479 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
1480 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1481 create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
1482 create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::supported(), InitFeatures::supported());
1484 // Rebalance a bit so that we can send backwards from 3 to 1.
1485 send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 5000000, 5_000_000);
1487 let (_, payment_hash_1) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000);
1488 assert!(nodes[2].node.fail_htlc_backwards(&payment_hash_1, &None));
1489 expect_pending_htlcs_forwardable!(nodes[2]);
1490 check_added_monitors!(nodes[2], 1);
1492 let cs_fail_update = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
1493 nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &cs_fail_update.update_fail_htlcs[0]);
1494 commitment_signed_dance!(nodes[1], nodes[2], cs_fail_update.commitment_signed, true, true);
1495 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1497 let route = nodes[2].router.get_route(&nodes[0].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1498 let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
1499 nodes[2].node.send_payment(route, payment_hash_2, None).unwrap();
1500 check_added_monitors!(nodes[2], 1);
1502 let mut events = nodes[2].node.get_and_clear_pending_msg_events();
1503 assert_eq!(events.len(), 1);
1504 let payment_event = SendEvent::from_event(events.pop().unwrap());
1505 nodes[1].node.handle_update_add_htlc(&nodes[2].node.get_our_node_id(), &payment_event.msgs[0]);
1506 commitment_signed_dance!(nodes[1], nodes[2], payment_event.commitment_msg, false);
1508 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1509 expect_pending_htlcs_forwardable!(nodes[1]);
1510 check_added_monitors!(nodes[1], 1);
1511 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1512 nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Failed to update ChannelMonitor".to_string(), 1);
1514 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
1515 nodes[1].node.test_restore_channel_monitor();
1516 check_added_monitors!(nodes[1], 1);
1518 let bs_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1519 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &bs_updates.update_fail_htlcs[0]);
1520 nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &bs_updates.update_add_htlcs[0]);
1521 commitment_signed_dance!(nodes[0], nodes[1], bs_updates.commitment_signed, false, true);
1523 let events = nodes[0].node.get_and_clear_pending_events();
1524 assert_eq!(events.len(), 2);
1525 if let Event::PaymentFailed { payment_hash, rejected_by_dest, .. } = events[0] {
1526 assert_eq!(payment_hash, payment_hash_1);
1527 assert!(rejected_by_dest);
1528 } else { panic!("Unexpected event!"); }
1530 Event::PendingHTLCsForwardable { .. } => { },
1531 _ => panic!("Unexpected event"),
1533 nodes[0].node.process_pending_htlc_forwards();
1534 expect_payment_received!(nodes[0], payment_hash_2, 1000000);
1536 claim_payment(&nodes[2], &[&nodes[1], &nodes[0]], payment_preimage_2, 1_000_000);
1540 fn monitor_update_claim_fail_no_response() {
1541 // Test for claim_funds resulting in both a monitor update failure and no message response (due
1542 // to channel being AwaitingRAA).
1543 // Backported from chanmon_fail_consistency fuzz tests as an unmerged version of the handling
1545 let node_cfgs = create_node_cfgs(2);
1546 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1547 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1548 create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::supported(), InitFeatures::supported());
1550 // Forward a payment for B to claim
1551 let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
1553 // Now start forwarding a second payment, skipping the last RAA so B is in AwaitingRAA
1554 let route = nodes[0].router.get_route(&nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV).unwrap();
1555 let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
1556 nodes[0].node.send_payment(route, payment_hash_2, None).unwrap();
1557 check_added_monitors!(nodes[0], 1);
1559 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1560 assert_eq!(events.len(), 1);
1561 let payment_event = SendEvent::from_event(events.pop().unwrap());
1562 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
1563 let as_raa = commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false, true, false, true);
1565 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1566 assert!(nodes[1].node.claim_funds(payment_preimage_1, &None, 1_000_000));
1567 check_added_monitors!(nodes[1], 1);
1568 let events = nodes[1].node.get_and_clear_pending_msg_events();
1569 assert_eq!(events.len(), 0);
1570 nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Failed to update ChannelMonitor".to_string(), 1);
1572 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
1573 nodes[1].node.test_restore_channel_monitor();
1574 check_added_monitors!(nodes[1], 1);
1575 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1577 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
1578 check_added_monitors!(nodes[1], 1);
1579 expect_pending_htlcs_forwardable!(nodes[1]);
1580 expect_payment_received!(nodes[1], payment_hash_2, 1000000);
1582 let bs_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1583 nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &bs_updates.update_fulfill_htlcs[0]);
1584 commitment_signed_dance!(nodes[0], nodes[1], bs_updates.commitment_signed, false);
1586 let events = nodes[0].node.get_and_clear_pending_events();
1587 assert_eq!(events.len(), 1);
1589 Event::PaymentSent { ref payment_preimage } => {
1590 assert_eq!(*payment_preimage, payment_preimage_1);
1592 _ => panic!("Unexpected event"),
1595 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
1598 // Note that restore_between_fails with !fail_on_generate is useless
1599 // Also note that !fail_on_generate && !fail_on_signed is useless
1600 // Finally, note that !fail_on_signed is not possible with fail_on_generate && !restore_between_fails
1601 // confirm_a_first and restore_b_before_conf are wholly unrelated to earlier bools and
1602 // restore_b_before_conf has no meaning if !confirm_a_first
1603 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) {
1604 // Test that if the monitor update generated by funding_transaction_generated fails we continue
1605 // the channel setup happily after the update is restored.
1606 let node_cfgs = create_node_cfgs(2);
1607 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1608 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1610 nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 43).unwrap();
1611 nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::supported(), &get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()));
1612 nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), InitFeatures::supported(), &get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id()));
1614 let (temporary_channel_id, funding_tx, funding_output) = create_funding_transaction(&nodes[0], 100000, 43);
1616 if fail_on_generate {
1617 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1619 nodes[0].node.funding_transaction_generated(&temporary_channel_id, funding_output);
1620 check_added_monitors!(nodes[0], 1);
1622 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1623 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()));
1624 check_added_monitors!(nodes[1], 1);
1626 if restore_between_fails {
1627 assert!(fail_on_generate);
1628 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Ok(());
1629 nodes[0].node.test_restore_channel_monitor();
1630 check_added_monitors!(nodes[0], 1);
1631 assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
1632 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1636 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Err(ChannelMonitorUpdateErr::TemporaryFailure);
1638 assert!(restore_between_fails || !fail_on_generate); // We can't switch to good now (there's no monitor update)
1639 assert!(fail_on_generate); // Somebody has to fail
1641 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()));
1642 if fail_on_signed || !restore_between_fails {
1643 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1644 if fail_on_generate && !restore_between_fails {
1645 nodes[0].logger.assert_log("lightning::ln::channelmanager".to_string(), "Previous monitor update failure prevented funding_signed from allowing funding broadcast".to_string(), 1);
1646 check_added_monitors!(nodes[0], 0);
1648 nodes[0].logger.assert_log("lightning::ln::channelmanager".to_string(), "Failed to update ChannelMonitor".to_string(), 1);
1649 check_added_monitors!(nodes[0], 1);
1651 assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
1652 *nodes[0].chan_monitor.update_ret.lock().unwrap() = Ok(());
1653 nodes[0].node.test_restore_channel_monitor();
1656 check_added_monitors!(nodes[0], 1);
1658 let events = nodes[0].node.get_and_clear_pending_events();
1659 assert_eq!(events.len(), 1);
1661 Event::FundingBroadcastSafe { ref funding_txo, user_channel_id } => {
1662 assert_eq!(user_channel_id, 43);
1663 assert_eq!(*funding_txo, funding_output);
1665 _ => panic!("Unexpected event"),
1668 if confirm_a_first {
1669 confirm_transaction(&nodes[0].block_notifier, &nodes[0].chain_monitor, &funding_tx, funding_tx.version);
1670 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()));
1672 assert!(!restore_b_before_conf);
1673 confirm_transaction(&nodes[1].block_notifier, &nodes[1].chain_monitor, &funding_tx, funding_tx.version);
1674 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1677 // Make sure nodes[1] isn't stupid enough to re-send the FundingLocked on reconnect
1678 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
1679 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
1680 reconnect_nodes(&nodes[0], &nodes[1], (false, confirm_a_first), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
1681 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1682 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1684 if !restore_b_before_conf {
1685 confirm_transaction(&nodes[1].block_notifier, &nodes[1].chain_monitor, &funding_tx, funding_tx.version);
1686 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1687 assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
1690 *nodes[1].chan_monitor.update_ret.lock().unwrap() = Ok(());
1691 nodes[1].node.test_restore_channel_monitor();
1692 check_added_monitors!(nodes[1], 1);
1694 let (channel_id, (announcement, as_update, bs_update)) = if !confirm_a_first {
1695 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()));
1697 confirm_transaction(&nodes[0].block_notifier, &nodes[0].chain_monitor, &funding_tx, funding_tx.version);
1698 let (funding_locked, channel_id) = create_chan_between_nodes_with_value_confirm_second(&nodes[1], &nodes[0]);
1699 (channel_id, create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked))
1701 if restore_b_before_conf {
1702 confirm_transaction(&nodes[1].block_notifier, &nodes[1].chain_monitor, &funding_tx, funding_tx.version);
1704 let (funding_locked, channel_id) = create_chan_between_nodes_with_value_confirm_second(&nodes[0], &nodes[1]);
1705 (channel_id, create_chan_between_nodes_with_value_b(&nodes[1], &nodes[0], &funding_locked))
1707 for node in nodes.iter() {
1708 assert!(node.router.handle_channel_announcement(&announcement).unwrap());
1709 node.router.handle_channel_update(&as_update).unwrap();
1710 node.router.handle_channel_update(&bs_update).unwrap();
1713 send_payment(&nodes[0], &[&nodes[1]], 8000000, 8_000_000);
1714 close_channel(&nodes[0], &nodes[1], &channel_id, funding_tx, true);
1718 fn during_funding_monitor_fail() {
1719 do_during_funding_monitor_fail(false, false, true, true, true);
1720 do_during_funding_monitor_fail(true, false, true, false, false);
1721 do_during_funding_monitor_fail(true, true, true, true, false);
1722 do_during_funding_monitor_fail(true, true, false, false, false);