1 // This file is Copyright its original authors, visible in version control
4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
7 // You may not use this file except in accordance with one or both of these
10 //! Functional tests which test for correct behavior across node restarts.
12 use crate::chain::{ChannelMonitorUpdateStatus, Watch};
13 use crate::chain::chaininterface::LowerBoundedFeeEstimator;
14 use crate::chain::channelmonitor::{CLOSED_CHANNEL_UPDATE_ID, ChannelMonitor};
15 use crate::sign::EntropySource;
16 use crate::chain::transaction::OutPoint;
17 use crate::events::{ClosureReason, Event, HTLCDestination, MessageSendEvent, MessageSendEventsProvider};
18 use crate::ln::channelmanager::{ChannelManager, ChannelManagerReadArgs, PaymentId, RecipientOnionFields};
20 use crate::ln::msgs::{ChannelMessageHandler, RoutingMessageHandler, ErrorAction};
21 use crate::util::test_channel_signer::TestChannelSigner;
22 use crate::util::test_utils;
23 use crate::util::errors::APIError;
24 use crate::util::ser::{Writeable, ReadableArgs};
25 use crate::util::config::UserConfig;
27 use bitcoin::hash_types::BlockHash;
29 use crate::prelude::*;
30 use core::default::Default;
31 use crate::sync::Mutex;
33 use crate::ln::functional_test_utils::*;
36 fn test_funding_peer_disconnect() {
37 // Test that we can lock in our funding tx while disconnected
38 let chanmon_cfgs = create_chanmon_cfgs(2);
39 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
41 let new_chain_monitor;
43 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
44 let nodes_0_deserialized;
45 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
46 let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001);
48 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id());
49 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id());
51 confirm_transaction(&nodes[0], &tx);
52 let events_1 = nodes[0].node.get_and_clear_pending_msg_events();
53 assert!(events_1.is_empty());
55 let mut reconnect_args = ReconnectArgs::new(&nodes[0], &nodes[1]);
56 reconnect_args.send_channel_ready.1 = true;
57 reconnect_nodes(reconnect_args);
59 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id());
60 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id());
62 confirm_transaction(&nodes[1], &tx);
63 let events_2 = nodes[1].node.get_and_clear_pending_msg_events();
64 assert!(events_2.is_empty());
66 nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init {
67 features: nodes[1].node.init_features(), networks: None, remote_network_address: None
69 let as_reestablish = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap();
70 nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init {
71 features: nodes[0].node.init_features(), networks: None, remote_network_address: None
73 let bs_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap();
75 // nodes[0] hasn't yet received a channel_ready, so it only sends that on reconnect.
76 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &bs_reestablish);
77 let events_3 = nodes[0].node.get_and_clear_pending_msg_events();
78 assert_eq!(events_3.len(), 1);
79 let as_channel_ready = match events_3[0] {
80 MessageSendEvent::SendChannelReady { ref node_id, ref msg } => {
81 assert_eq!(*node_id, nodes[1].node.get_our_node_id());
84 _ => panic!("Unexpected event {:?}", events_3[0]),
87 // nodes[1] received nodes[0]'s channel_ready on the first reconnect above, so it should send
88 // announcement_signatures as well as channel_update.
89 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &as_reestablish);
90 let events_4 = nodes[1].node.get_and_clear_pending_msg_events();
91 assert_eq!(events_4.len(), 3);
93 let bs_channel_ready = match events_4[0] {
94 MessageSendEvent::SendChannelReady { ref node_id, ref msg } => {
95 assert_eq!(*node_id, nodes[0].node.get_our_node_id());
96 chan_id = msg.channel_id;
99 _ => panic!("Unexpected event {:?}", events_4[0]),
101 let bs_announcement_sigs = match events_4[1] {
102 MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } => {
103 assert_eq!(*node_id, nodes[0].node.get_our_node_id());
106 _ => panic!("Unexpected event {:?}", events_4[1]),
109 MessageSendEvent::SendChannelUpdate { ref node_id, msg: _ } => {
110 assert_eq!(*node_id, nodes[0].node.get_our_node_id());
112 _ => panic!("Unexpected event {:?}", events_4[2]),
115 // Re-deliver nodes[0]'s channel_ready, which nodes[1] can safely ignore. It currently
116 // generates a duplicative private channel_update
117 nodes[1].node.handle_channel_ready(&nodes[0].node.get_our_node_id(), &as_channel_ready);
118 let events_5 = nodes[1].node.get_and_clear_pending_msg_events();
119 assert_eq!(events_5.len(), 1);
121 MessageSendEvent::SendChannelUpdate { ref node_id, msg: _ } => {
122 assert_eq!(*node_id, nodes[0].node.get_our_node_id());
124 _ => panic!("Unexpected event {:?}", events_5[0]),
127 // When we deliver nodes[1]'s channel_ready, however, nodes[0] will generate its
128 // announcement_signatures.
129 nodes[0].node.handle_channel_ready(&nodes[1].node.get_our_node_id(), &bs_channel_ready);
130 let events_6 = nodes[0].node.get_and_clear_pending_msg_events();
131 assert_eq!(events_6.len(), 1);
132 let as_announcement_sigs = match events_6[0] {
133 MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } => {
134 assert_eq!(*node_id, nodes[1].node.get_our_node_id());
137 _ => panic!("Unexpected event {:?}", events_6[0]),
139 expect_channel_ready_event(&nodes[0], &nodes[1].node.get_our_node_id());
140 expect_channel_ready_event(&nodes[1], &nodes[0].node.get_our_node_id());
142 // When we deliver nodes[1]'s announcement_signatures to nodes[0], nodes[0] should immediately
143 // broadcast the channel announcement globally, as well as re-send its (now-public)
145 nodes[0].node.handle_announcement_signatures(&nodes[1].node.get_our_node_id(), &bs_announcement_sigs);
146 let events_7 = nodes[0].node.get_and_clear_pending_msg_events();
147 assert_eq!(events_7.len(), 1);
148 let (chan_announcement, as_update) = match events_7[0] {
149 MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } => {
150 (msg.clone(), update_msg.clone().unwrap())
152 _ => panic!("Unexpected event {:?}", events_7[0]),
155 // Finally, deliver nodes[0]'s announcement_signatures to nodes[1] and make sure it creates the
156 // same channel_announcement.
157 nodes[1].node.handle_announcement_signatures(&nodes[0].node.get_our_node_id(), &as_announcement_sigs);
158 let events_8 = nodes[1].node.get_and_clear_pending_msg_events();
159 assert_eq!(events_8.len(), 1);
160 let bs_update = match events_8[0] {
161 MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } => {
162 assert_eq!(*msg, chan_announcement);
163 update_msg.clone().unwrap()
165 _ => panic!("Unexpected event {:?}", events_8[0]),
168 // Provide the channel announcement and public updates to the network graph
169 nodes[0].gossip_sync.handle_channel_announcement(&chan_announcement).unwrap();
170 nodes[0].gossip_sync.handle_channel_update(&bs_update).unwrap();
171 nodes[0].gossip_sync.handle_channel_update(&as_update).unwrap();
173 let (route, _, _, _) = get_route_and_payment_hash!(nodes[0], nodes[1], 1000000);
174 let payment_preimage = send_along_route(&nodes[0], route, &[&nodes[1]], 1000000).0;
175 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
177 // Check that after deserialization and reconnection we can still generate an identical
178 // channel_announcement from the cached signatures.
179 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id());
181 let chan_0_monitor_serialized = get_monitor!(nodes[0], chan_id).encode();
183 reload_node!(nodes[0], &nodes[0].node.encode(), &[&chan_0_monitor_serialized], persister, new_chain_monitor, nodes_0_deserialized);
185 reconnect_nodes(ReconnectArgs::new(&nodes[0], &nodes[1]));
189 fn test_no_txn_manager_serialize_deserialize() {
190 let chanmon_cfgs = create_chanmon_cfgs(2);
191 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
193 let new_chain_monitor;
195 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
196 let nodes_0_deserialized;
197 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
199 let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001);
201 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id());
203 let chan_0_monitor_serialized =
204 get_monitor!(nodes[0], OutPoint { txid: tx.txid(), index: 0 }.to_channel_id()).encode();
205 reload_node!(nodes[0], nodes[0].node.encode(), &[&chan_0_monitor_serialized], persister, new_chain_monitor, nodes_0_deserialized);
207 nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init {
208 features: nodes[1].node.init_features(), networks: None, remote_network_address: None
210 let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
211 nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init {
212 features: nodes[0].node.init_features(), networks: None, remote_network_address: None
214 let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
216 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
217 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
218 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
219 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
221 let (channel_ready, _) = create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
222 let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &channel_ready);
223 for node in nodes.iter() {
224 assert!(node.gossip_sync.handle_channel_announcement(&announcement).unwrap());
225 node.gossip_sync.handle_channel_update(&as_update).unwrap();
226 node.gossip_sync.handle_channel_update(&bs_update).unwrap();
229 send_payment(&nodes[0], &[&nodes[1]], 1000000);
233 fn test_manager_serialize_deserialize_events() {
234 // This test makes sure the events field in ChannelManager survives de/serialization
235 let chanmon_cfgs = create_chanmon_cfgs(2);
236 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
238 let new_chain_monitor;
240 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
241 let nodes_0_deserialized;
242 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
244 // Start creating a channel, but stop right before broadcasting the funding transaction
245 let channel_value = 100000;
246 let push_msat = 10001;
247 let node_a = nodes.remove(0);
248 let node_b = nodes.remove(0);
249 node_a.node.create_channel(node_b.node.get_our_node_id(), channel_value, push_msat, 42, None, None).unwrap();
250 node_b.node.handle_open_channel(&node_a.node.get_our_node_id(), &get_event_msg!(node_a, MessageSendEvent::SendOpenChannel, node_b.node.get_our_node_id()));
251 node_a.node.handle_accept_channel(&node_b.node.get_our_node_id(), &get_event_msg!(node_b, MessageSendEvent::SendAcceptChannel, node_a.node.get_our_node_id()));
253 let (temporary_channel_id, tx, funding_output) = create_funding_transaction(&node_a, &node_b.node.get_our_node_id(), channel_value, 42);
255 node_a.node.funding_transaction_generated(&temporary_channel_id, &node_b.node.get_our_node_id(), tx.clone()).unwrap();
256 check_added_monitors!(node_a, 0);
258 node_b.node.handle_funding_created(&node_a.node.get_our_node_id(), &get_event_msg!(node_a, MessageSendEvent::SendFundingCreated, node_b.node.get_our_node_id()));
260 let mut added_monitors = node_b.chain_monitor.added_monitors.lock().unwrap();
261 assert_eq!(added_monitors.len(), 1);
262 assert_eq!(added_monitors[0].0, funding_output);
263 added_monitors.clear();
266 let bs_funding_signed = get_event_msg!(node_b, MessageSendEvent::SendFundingSigned, node_a.node.get_our_node_id());
267 node_a.node.handle_funding_signed(&node_b.node.get_our_node_id(), &bs_funding_signed);
269 let mut added_monitors = node_a.chain_monitor.added_monitors.lock().unwrap();
270 assert_eq!(added_monitors.len(), 1);
271 assert_eq!(added_monitors[0].0, funding_output);
272 added_monitors.clear();
274 // Normally, this is where node_a would broadcast the funding transaction, but the test de/serializes first instead
276 expect_channel_pending_event(&node_a, &node_b.node.get_our_node_id());
277 expect_channel_pending_event(&node_b, &node_a.node.get_our_node_id());
282 // Start the de/seriailization process mid-channel creation to check that the channel manager will hold onto events that are serialized
283 let chan_0_monitor_serialized = get_monitor!(nodes[0], bs_funding_signed.channel_id).encode();
284 reload_node!(nodes[0], nodes[0].node.encode(), &[&chan_0_monitor_serialized], persister, new_chain_monitor, nodes_0_deserialized);
286 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id());
288 // After deserializing, make sure the funding_transaction is still held by the channel manager
289 let events_4 = nodes[0].node.get_and_clear_pending_events();
290 assert_eq!(events_4.len(), 0);
291 assert_eq!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
292 assert_eq!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap()[0].txid(), funding_output.txid);
294 // Make sure the channel is functioning as though the de/serialization never happened
295 assert_eq!(nodes[0].node.list_channels().len(), 1);
297 nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init {
298 features: nodes[1].node.init_features(), networks: None, remote_network_address: None
300 let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
301 nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init {
302 features: nodes[0].node.init_features(), networks: None, remote_network_address: None
304 let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
306 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
307 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
308 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
309 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
311 let (channel_ready, _) = create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
312 let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &channel_ready);
313 for node in nodes.iter() {
314 assert!(node.gossip_sync.handle_channel_announcement(&announcement).unwrap());
315 node.gossip_sync.handle_channel_update(&as_update).unwrap();
316 node.gossip_sync.handle_channel_update(&bs_update).unwrap();
319 send_payment(&nodes[0], &[&nodes[1]], 1000000);
323 fn test_simple_manager_serialize_deserialize() {
324 let chanmon_cfgs = create_chanmon_cfgs(2);
325 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
327 let new_chain_monitor;
329 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
330 let nodes_0_deserialized;
331 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
332 let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2;
334 let (our_payment_preimage, ..) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
335 let (_, our_payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
337 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id());
339 let chan_0_monitor_serialized = get_monitor!(nodes[0], chan_id).encode();
340 reload_node!(nodes[0], nodes[0].node.encode(), &[&chan_0_monitor_serialized], persister, new_chain_monitor, nodes_0_deserialized);
342 reconnect_nodes(ReconnectArgs::new(&nodes[0], &nodes[1]));
344 fail_payment(&nodes[0], &[&nodes[1]], our_payment_hash);
345 claim_payment(&nodes[0], &[&nodes[1]], our_payment_preimage);
349 fn test_manager_serialize_deserialize_inconsistent_monitor() {
350 // Test deserializing a ChannelManager with an out-of-date ChannelMonitor
351 let chanmon_cfgs = create_chanmon_cfgs(4);
352 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
356 let new_chain_monitor;
358 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
359 let nodes_0_deserialized;
360 let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
362 let chan_id_1 = create_announced_chan_between_nodes(&nodes, 0, 1).2;
363 let chan_id_2 = create_announced_chan_between_nodes(&nodes, 2, 0).2;
364 let (_, _, channel_id, funding_tx) = create_announced_chan_between_nodes(&nodes, 0, 3);
366 let mut node_0_stale_monitors_serialized = Vec::new();
367 for chan_id_iter in &[chan_id_1, chan_id_2, channel_id] {
368 let mut writer = test_utils::TestVecWriter(Vec::new());
369 get_monitor!(nodes[0], chan_id_iter).write(&mut writer).unwrap();
370 node_0_stale_monitors_serialized.push(writer.0);
373 let (our_payment_preimage, ..) = route_payment(&nodes[2], &[&nodes[0], &nodes[1]], 1000000);
375 // Serialize the ChannelManager here, but the monitor we keep up-to-date
376 let nodes_0_serialized = nodes[0].node.encode();
378 route_payment(&nodes[0], &[&nodes[3]], 1000000);
379 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id());
380 nodes[2].node.peer_disconnected(&nodes[0].node.get_our_node_id());
381 nodes[3].node.peer_disconnected(&nodes[0].node.get_our_node_id());
383 // Now the ChannelMonitor (which is now out-of-sync with ChannelManager for channel w/
385 let mut node_0_monitors_serialized = Vec::new();
386 for chan_id_iter in &[chan_id_1, chan_id_2, channel_id] {
387 node_0_monitors_serialized.push(get_monitor!(nodes[0], chan_id_iter).encode());
390 logger = test_utils::TestLogger::new();
391 fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: Mutex::new(253) };
392 persister = test_utils::TestPersister::new();
393 let keys_manager = &chanmon_cfgs[0].keys_manager;
394 new_chain_monitor = test_utils::TestChainMonitor::new(Some(nodes[0].chain_source), nodes[0].tx_broadcaster, &logger, &fee_estimator, &persister, keys_manager);
395 nodes[0].chain_monitor = &new_chain_monitor;
398 let mut node_0_stale_monitors = Vec::new();
399 for serialized in node_0_stale_monitors_serialized.iter() {
400 let mut read = &serialized[..];
401 let (_, monitor) = <(BlockHash, ChannelMonitor<TestChannelSigner>)>::read(&mut read, (keys_manager, keys_manager)).unwrap();
402 assert!(read.is_empty());
403 node_0_stale_monitors.push(monitor);
406 let mut node_0_monitors = Vec::new();
407 for serialized in node_0_monitors_serialized.iter() {
408 let mut read = &serialized[..];
409 let (_, monitor) = <(BlockHash, ChannelMonitor<TestChannelSigner>)>::read(&mut read, (keys_manager, keys_manager)).unwrap();
410 assert!(read.is_empty());
411 node_0_monitors.push(monitor);
414 let mut nodes_0_read = &nodes_0_serialized[..];
415 if let Err(msgs::DecodeError::InvalidValue) =
416 <(BlockHash, ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestKeysInterface, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
417 default_config: UserConfig::default(),
418 entropy_source: keys_manager,
419 node_signer: keys_manager,
420 signer_provider: keys_manager,
421 fee_estimator: &fee_estimator,
422 router: &nodes[0].router,
423 chain_monitor: nodes[0].chain_monitor,
424 tx_broadcaster: nodes[0].tx_broadcaster,
426 channel_monitors: node_0_stale_monitors.iter_mut().map(|monitor| { (monitor.get_funding_txo().0, monitor) }).collect(),
428 panic!("If the monitor(s) are stale, this indicates a bug and we should get an Err return");
431 let mut nodes_0_read = &nodes_0_serialized[..];
432 let (_, nodes_0_deserialized_tmp) =
433 <(BlockHash, ChannelManager<&test_utils::TestChainMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestKeysInterface, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestRouter, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
434 default_config: UserConfig::default(),
435 entropy_source: keys_manager,
436 node_signer: keys_manager,
437 signer_provider: keys_manager,
438 fee_estimator: &fee_estimator,
439 router: nodes[0].router,
440 chain_monitor: nodes[0].chain_monitor,
441 tx_broadcaster: nodes[0].tx_broadcaster,
443 channel_monitors: node_0_monitors.iter_mut().map(|monitor| { (monitor.get_funding_txo().0, monitor) }).collect(),
445 nodes_0_deserialized = nodes_0_deserialized_tmp;
446 assert!(nodes_0_read.is_empty());
448 for monitor in node_0_monitors.drain(..) {
449 assert_eq!(nodes[0].chain_monitor.watch_channel(monitor.get_funding_txo().0, monitor),
450 Ok(ChannelMonitorUpdateStatus::Completed));
451 check_added_monitors!(nodes[0], 1);
453 nodes[0].node = &nodes_0_deserialized;
455 check_closed_event!(nodes[0], 1, ClosureReason::OutdatedChannelManager, [nodes[3].node.get_our_node_id()], 100000);
456 { // Channel close should result in a commitment tx
457 nodes[0].node.timer_tick_occurred();
458 let txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
459 assert_eq!(txn.len(), 1);
460 check_spends!(txn[0], funding_tx);
461 assert_eq!(txn[0].input[0].previous_output.txid, funding_tx.txid());
463 check_added_monitors!(nodes[0], 1);
465 // nodes[1] and nodes[2] have no lost state with nodes[0]...
466 reconnect_nodes(ReconnectArgs::new(&nodes[0], &nodes[1]));
467 reconnect_nodes(ReconnectArgs::new(&nodes[0], &nodes[2]));
468 //... and we can even still claim the payment!
469 claim_payment(&nodes[2], &[&nodes[0], &nodes[1]], our_payment_preimage);
471 nodes[3].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init {
472 features: nodes[0].node.init_features(), networks: None, remote_network_address: None
474 let reestablish = get_chan_reestablish_msgs!(nodes[3], nodes[0]).pop().unwrap();
475 nodes[0].node.peer_connected(&nodes[3].node.get_our_node_id(), &msgs::Init {
476 features: nodes[3].node.init_features(), networks: None, remote_network_address: None
478 nodes[0].node.handle_channel_reestablish(&nodes[3].node.get_our_node_id(), &reestablish);
479 let mut found_err = false;
480 for msg_event in nodes[0].node.get_and_clear_pending_msg_events() {
481 if let MessageSendEvent::HandleError { ref action, .. } = msg_event {
483 &ErrorAction::SendErrorMessage { ref msg } => {
484 assert_eq!(msg.channel_id, channel_id);
488 _ => panic!("Unexpected event!"),
495 #[cfg(feature = "std")]
496 fn do_test_data_loss_protect(reconnect_panicing: bool, substantially_old: bool, not_stale: bool) {
497 use crate::routing::router::{RouteParameters, PaymentParameters};
498 use crate::ln::channelmanager::Retry;
499 use crate::util::string::UntrustedString;
500 // When we get a data_loss_protect proving we're behind, we immediately panic as the
501 // chain::Watch API requirements have been violated (e.g. the user restored from a backup). The
502 // panic message informs the user they should force-close without broadcasting, which is tested
503 // if `reconnect_panicing` is not set.
504 let mut chanmon_cfgs = create_chanmon_cfgs(2);
505 // We broadcast during Drop because chanmon is out of sync with chanmgr, which would cause a panic
506 // during signing due to revoked tx
507 chanmon_cfgs[0].keys_manager.disable_revocation_policy_check = true;
508 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
510 let new_chain_monitor;
512 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
513 let nodes_0_deserialized;
515 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
517 let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000);
519 // Cache node A state before any channel update
520 let previous_node_state = nodes[0].node.encode();
521 let previous_chain_monitor_state = get_monitor!(nodes[0], chan.2).encode();
523 assert!(!substantially_old || !not_stale, "substantially_old and not_stale doesn't make sense");
524 if not_stale || !substantially_old {
525 // Previously, we'd only hit the data_loss_protect assertion if we had a state which
526 // revoked at least two revocations ago, not the latest revocation. Here, we use
527 // `not_stale` to test the boundary condition.
528 let pay_params = PaymentParameters::for_keysend(nodes[1].node.get_our_node_id(), 100, false);
529 let route_params = RouteParameters::from_payment_params_and_value(pay_params, 40000);
530 nodes[0].node.send_spontaneous_payment_with_retry(None, RecipientOnionFields::spontaneous_empty(), PaymentId([0; 32]), route_params, Retry::Attempts(0)).unwrap();
531 check_added_monitors(&nodes[0], 1);
532 let update_add_commit = SendEvent::from_node(&nodes[0]);
534 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &update_add_commit.msgs[0]);
535 nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &update_add_commit.commitment_msg);
536 check_added_monitors(&nodes[1], 1);
537 let (raa, cs) = get_revoke_commit_msgs(&nodes[1], &nodes[0].node.get_our_node_id());
539 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &raa);
540 check_added_monitors(&nodes[0], 1);
541 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
543 nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &cs);
544 check_added_monitors(&nodes[0], 1);
545 // A now revokes their original state, at which point reconnect should panic
546 let raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
547 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &raa);
548 check_added_monitors(&nodes[1], 1);
549 expect_pending_htlcs_forwardable_ignore!(nodes[1]);
552 send_payment(&nodes[0], &[&nodes[1]], 8000000);
553 send_payment(&nodes[0], &[&nodes[1]], 8000000);
556 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id());
557 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id());
559 reload_node!(nodes[0], previous_node_state, &[&previous_chain_monitor_state], persister, new_chain_monitor, nodes_0_deserialized);
561 if reconnect_panicing {
562 nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init {
563 features: nodes[1].node.init_features(), networks: None, remote_network_address: None
565 nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init {
566 features: nodes[0].node.init_features(), networks: None, remote_network_address: None
569 let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
571 // If A has fallen behind substantially, B should send it a message letting it know
573 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
575 if substantially_old {
576 let warn_msg = "Peer attempted to reestablish channel with a very old local commitment transaction: 0 (received) vs 4 (expected)".to_owned();
578 let warn_reestablish = nodes[1].node.get_and_clear_pending_msg_events();
579 assert_eq!(warn_reestablish.len(), 2);
580 match warn_reestablish[1] {
581 MessageSendEvent::HandleError { action: ErrorAction::SendWarningMessage { ref msg, .. }, .. } => {
582 assert_eq!(msg.data, warn_msg);
584 _ => panic!("Unexpected events: {:?}", warn_reestablish),
586 reestablish_msg = match &warn_reestablish[0] {
587 MessageSendEvent::SendChannelReestablish { msg, .. } => msg.clone(),
588 _ => panic!("Unexpected events: {:?}", warn_reestablish),
591 let msgs = nodes[1].node.get_and_clear_pending_msg_events();
592 assert!(msgs.len() >= 4);
594 Some(MessageSendEvent::SendChannelUpdate { .. }) => {},
595 _ => panic!("Unexpected events: {:?}", msgs),
597 assert!(msgs.iter().any(|msg| matches!(msg, MessageSendEvent::SendRevokeAndACK { .. })));
598 assert!(msgs.iter().any(|msg| matches!(msg, MessageSendEvent::UpdateHTLCs { .. })));
599 reestablish_msg = match &msgs[0] {
600 MessageSendEvent::SendChannelReestablish { msg, .. } => msg.clone(),
601 _ => panic!("Unexpected events: {:?}", msgs),
606 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
607 // The node B should never force-close the channel.
608 assert!(node_txn.is_empty());
611 // Check A panics upon seeing proof it has fallen behind.
612 let reconnect_res = std::panic::catch_unwind(|| {
613 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_msg);
616 assert!(reconnect_res.is_ok());
617 // At this point A gets confused because B expects a commitment state newer than A
618 // has sent, but not a newer revocation secret, so A just (correctly) closes.
619 check_closed_broadcast(&nodes[0], 1, true);
620 check_added_monitors(&nodes[0], 1);
621 check_closed_event!(nodes[0], 1, ClosureReason::ProcessingError {
622 err: "Peer attempted to reestablish channel with a future remote commitment transaction: 2 (received) vs 1 (expected)".to_owned()
623 }, [nodes[1].node.get_our_node_id()], 1000000);
625 assert!(reconnect_res.is_err());
626 // Skip the `Drop` handler for `Node`s as some may be in an invalid (panicked) state.
627 std::mem::forget(nodes);
630 assert!(!not_stale, "We only care about the stale case when not testing panicking");
632 nodes[0].node.force_close_without_broadcasting_txn(&chan.2, &nodes[1].node.get_our_node_id()).unwrap();
633 check_added_monitors!(nodes[0], 1);
634 check_closed_event!(nodes[0], 1, ClosureReason::HolderForceClosed, [nodes[1].node.get_our_node_id()], 1000000);
636 let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
637 assert_eq!(node_txn.len(), 0);
640 for msg in nodes[0].node.get_and_clear_pending_msg_events() {
641 if let MessageSendEvent::BroadcastChannelUpdate { .. } = msg {
642 } else if let MessageSendEvent::HandleError { ref action, .. } = msg {
644 &ErrorAction::DisconnectPeer { ref msg } => {
645 assert_eq!(msg.as_ref().unwrap().data, "Channel force-closed");
647 _ => panic!("Unexpected event!"),
650 panic!("Unexpected event {:?}", msg)
654 // after the warning message sent by B, we should not able to
655 // use the channel, or reconnect with success to the channel.
656 assert!(nodes[0].node.list_usable_channels().is_empty());
657 nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init {
658 features: nodes[1].node.init_features(), networks: None, remote_network_address: None
660 nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init {
661 features: nodes[0].node.init_features(), networks: None, remote_network_address: None
663 let retry_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
665 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &retry_reestablish[0]);
666 let mut err_msgs_0 = Vec::with_capacity(1);
667 if let MessageSendEvent::HandleError { ref action, .. } = nodes[0].node.get_and_clear_pending_msg_events()[1] {
669 &ErrorAction::SendErrorMessage { ref msg } => {
670 assert_eq!(msg.data, format!("Got a message for a channel from the wrong node! No such channel for the passed counterparty_node_id {}", &nodes[1].node.get_our_node_id()));
671 err_msgs_0.push(msg.clone());
673 _ => panic!("Unexpected event!"),
676 panic!("Unexpected event!");
678 assert_eq!(err_msgs_0.len(), 1);
679 nodes[1].node.handle_error(&nodes[0].node.get_our_node_id(), &err_msgs_0[0]);
680 assert!(nodes[1].node.list_usable_channels().is_empty());
681 check_added_monitors!(nodes[1], 1);
682 check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyForceClosed { peer_msg: UntrustedString(format!("Got a message for a channel from the wrong node! No such channel for the passed counterparty_node_id {}", &nodes[1].node.get_our_node_id())) }
683 , [nodes[0].node.get_our_node_id()], 1000000);
684 check_closed_broadcast!(nodes[1], false);
689 #[cfg(feature = "std")]
690 fn test_data_loss_protect() {
691 do_test_data_loss_protect(true, false, true);
692 do_test_data_loss_protect(true, true, false);
693 do_test_data_loss_protect(true, false, false);
694 do_test_data_loss_protect(false, true, false);
695 do_test_data_loss_protect(false, false, false);
699 fn test_forwardable_regen() {
700 // Tests that if we reload a ChannelManager while forwards are pending we will regenerate the
701 // PendingHTLCsForwardable event automatically, ensuring we don't forget to forward/receive
703 // We test it for both payment receipt and payment forwarding.
705 let chanmon_cfgs = create_chanmon_cfgs(3);
706 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
708 let new_chain_monitor;
709 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
710 let nodes_1_deserialized;
711 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
712 let chan_id_1 = create_announced_chan_between_nodes(&nodes, 0, 1).2;
713 let chan_id_2 = create_announced_chan_between_nodes(&nodes, 1, 2).2;
715 // First send a payment to nodes[1]
716 let (route, payment_hash, payment_preimage, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[1], 100_000);
717 nodes[0].node.send_payment_with_route(&route, payment_hash,
718 RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap();
719 check_added_monitors!(nodes[0], 1);
721 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
722 assert_eq!(events.len(), 1);
723 let payment_event = SendEvent::from_event(events.pop().unwrap());
724 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
725 commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
727 expect_pending_htlcs_forwardable_ignore!(nodes[1]);
729 // Next send a payment which is forwarded by nodes[1]
730 let (route_2, payment_hash_2, payment_preimage_2, payment_secret_2) = get_route_and_payment_hash!(nodes[0], nodes[2], 200_000);
731 nodes[0].node.send_payment_with_route(&route_2, payment_hash_2,
732 RecipientOnionFields::secret_only(payment_secret_2), PaymentId(payment_hash_2.0)).unwrap();
733 check_added_monitors!(nodes[0], 1);
735 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
736 assert_eq!(events.len(), 1);
737 let payment_event = SendEvent::from_event(events.pop().unwrap());
738 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
739 commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
741 // There is already a PendingHTLCsForwardable event "pending" so another one will not be
743 assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
745 // Now restart nodes[1] and make sure it regenerates a single PendingHTLCsForwardable
746 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id());
747 nodes[2].node.peer_disconnected(&nodes[1].node.get_our_node_id());
749 let chan_0_monitor_serialized = get_monitor!(nodes[1], chan_id_1).encode();
750 let chan_1_monitor_serialized = get_monitor!(nodes[1], chan_id_2).encode();
751 reload_node!(nodes[1], nodes[1].node.encode(), &[&chan_0_monitor_serialized, &chan_1_monitor_serialized], persister, new_chain_monitor, nodes_1_deserialized);
753 reconnect_nodes(ReconnectArgs::new(&nodes[0], &nodes[1]));
754 // Note that nodes[1] and nodes[2] resend their channel_ready here since they haven't updated
755 // the commitment state.
756 let mut reconnect_args = ReconnectArgs::new(&nodes[1], &nodes[2]);
757 reconnect_args.send_channel_ready = (true, true);
758 reconnect_nodes(reconnect_args);
760 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
762 expect_pending_htlcs_forwardable!(nodes[1]);
763 expect_payment_claimable!(nodes[1], payment_hash, payment_secret, 100_000);
764 check_added_monitors!(nodes[1], 1);
766 let mut events = nodes[1].node.get_and_clear_pending_msg_events();
767 assert_eq!(events.len(), 1);
768 let payment_event = SendEvent::from_event(events.pop().unwrap());
769 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
770 commitment_signed_dance!(nodes[2], nodes[1], payment_event.commitment_msg, false);
771 expect_pending_htlcs_forwardable!(nodes[2]);
772 expect_payment_claimable!(nodes[2], payment_hash_2, payment_secret_2, 200_000);
774 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
775 claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage_2);
778 fn do_test_partial_claim_before_restart(persist_both_monitors: bool) {
779 // Test what happens if a node receives an MPP payment, claims it, but crashes before
780 // persisting the ChannelManager. If `persist_both_monitors` is false, also crash after only
781 // updating one of the two channels' ChannelMonitors. As a result, on startup, we'll (a) still
782 // have the PaymentClaimable event, (b) have one (or two) channel(s) that goes on chain with the
783 // HTLC preimage in them, and (c) optionally have one channel that is live off-chain but does
784 // not have the preimage tied to the still-pending HTLC.
786 // To get to the correct state, on startup we should propagate the preimage to the
787 // still-off-chain channel, claiming the HTLC as soon as the peer connects, with the monitor
788 // receiving the preimage without a state update.
790 // Further, we should generate a `PaymentClaimed` event to inform the user that the payment was
791 // definitely claimed.
792 let chanmon_cfgs = create_chanmon_cfgs(4);
793 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
795 let new_chain_monitor;
797 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
798 let nodes_3_deserialized;
800 let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
802 create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100_000, 0);
803 create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 100_000, 0);
804 let chan_id_persisted = create_announced_chan_between_nodes_with_value(&nodes, 1, 3, 100_000, 0).2;
805 let chan_id_not_persisted = create_announced_chan_between_nodes_with_value(&nodes, 2, 3, 100_000, 0).2;
807 // Create an MPP route for 15k sats, more than the default htlc-max of 10%
808 let (mut route, payment_hash, payment_preimage, payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[3], 15_000_000);
809 assert_eq!(route.paths.len(), 2);
810 route.paths.sort_by(|path_a, _| {
811 // Sort the path so that the path through nodes[1] comes first
812 if path_a.hops[0].pubkey == nodes[1].node.get_our_node_id() {
813 core::cmp::Ordering::Less } else { core::cmp::Ordering::Greater }
816 nodes[0].node.send_payment_with_route(&route, payment_hash,
817 RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)).unwrap();
818 check_added_monitors!(nodes[0], 2);
820 // Send the payment through to nodes[3] *without* clearing the PaymentClaimable event
821 let mut send_events = nodes[0].node.get_and_clear_pending_msg_events();
822 assert_eq!(send_events.len(), 2);
823 let node_1_msgs = remove_first_msg_event_to_node(&nodes[1].node.get_our_node_id(), &mut send_events);
824 let node_2_msgs = remove_first_msg_event_to_node(&nodes[2].node.get_our_node_id(), &mut send_events);
825 do_pass_along_path(&nodes[0], &[&nodes[1], &nodes[3]], 15_000_000, payment_hash, Some(payment_secret), node_1_msgs, true, false, None, false);
826 do_pass_along_path(&nodes[0], &[&nodes[2], &nodes[3]], 15_000_000, payment_hash, Some(payment_secret), node_2_msgs, true, false, None, false);
828 // Now that we have an MPP payment pending, get the latest encoded copies of nodes[3]'s
829 // monitors and ChannelManager, for use later, if we don't want to persist both monitors.
830 let mut original_monitor = test_utils::TestVecWriter(Vec::new());
831 if !persist_both_monitors {
832 for outpoint in nodes[3].chain_monitor.chain_monitor.list_monitors() {
833 if outpoint.to_channel_id() == chan_id_not_persisted {
834 assert!(original_monitor.0.is_empty());
835 nodes[3].chain_monitor.chain_monitor.get_monitor(outpoint).unwrap().write(&mut original_monitor).unwrap();
840 let original_manager = nodes[3].node.encode();
842 expect_payment_claimable!(nodes[3], payment_hash, payment_secret, 15_000_000);
844 nodes[3].node.claim_funds(payment_preimage);
845 check_added_monitors!(nodes[3], 2);
846 expect_payment_claimed!(nodes[3], payment_hash, 15_000_000);
848 // Now fetch one of the two updated ChannelMonitors from nodes[3], and restart pretending we
849 // crashed in between the two persistence calls - using one old ChannelMonitor and one new one,
850 // with the old ChannelManager.
851 let mut updated_monitor = test_utils::TestVecWriter(Vec::new());
852 for outpoint in nodes[3].chain_monitor.chain_monitor.list_monitors() {
853 if outpoint.to_channel_id() == chan_id_persisted {
854 assert!(updated_monitor.0.is_empty());
855 nodes[3].chain_monitor.chain_monitor.get_monitor(outpoint).unwrap().write(&mut updated_monitor).unwrap();
858 // If `persist_both_monitors` is set, get the second monitor here as well
859 if persist_both_monitors {
860 for outpoint in nodes[3].chain_monitor.chain_monitor.list_monitors() {
861 if outpoint.to_channel_id() == chan_id_not_persisted {
862 assert!(original_monitor.0.is_empty());
863 nodes[3].chain_monitor.chain_monitor.get_monitor(outpoint).unwrap().write(&mut original_monitor).unwrap();
868 // Now restart nodes[3].
869 reload_node!(nodes[3], original_manager, &[&updated_monitor.0, &original_monitor.0], persister, new_chain_monitor, nodes_3_deserialized);
871 // On startup the preimage should have been copied into the non-persisted monitor:
872 assert!(get_monitor!(nodes[3], chan_id_persisted).get_stored_preimages().contains_key(&payment_hash));
873 assert!(get_monitor!(nodes[3], chan_id_not_persisted).get_stored_preimages().contains_key(&payment_hash));
875 nodes[1].node.peer_disconnected(&nodes[3].node.get_our_node_id());
876 nodes[2].node.peer_disconnected(&nodes[3].node.get_our_node_id());
878 // During deserialization, we should have closed one channel and broadcast its latest
879 // commitment transaction. We should also still have the original PaymentClaimable event we
880 // never finished processing.
881 let events = nodes[3].node.get_and_clear_pending_events();
882 assert_eq!(events.len(), if persist_both_monitors { 4 } else { 3 });
883 if let Event::PaymentClaimable { amount_msat: 15_000_000, .. } = events[0] { } else { panic!(); }
884 if let Event::ChannelClosed { reason: ClosureReason::OutdatedChannelManager, .. } = events[1] { } else { panic!(); }
885 if persist_both_monitors {
886 if let Event::ChannelClosed { reason: ClosureReason::OutdatedChannelManager, .. } = events[2] { } else { panic!(); }
887 check_added_monitors(&nodes[3], 2);
889 check_added_monitors(&nodes[3], 1);
892 // On restart, we should also get a duplicate PaymentClaimed event as we persisted the
893 // ChannelManager prior to handling the original one.
894 if let Event::PaymentClaimed { payment_hash: our_payment_hash, amount_msat: 15_000_000, .. } =
895 events[if persist_both_monitors { 3 } else { 2 }]
897 assert_eq!(payment_hash, our_payment_hash);
900 assert_eq!(nodes[3].node.list_channels().len(), if persist_both_monitors { 0 } else { 1 });
901 if !persist_both_monitors {
902 // If one of the two channels is still live, reveal the payment preimage over it.
904 nodes[3].node.peer_connected(&nodes[2].node.get_our_node_id(), &msgs::Init {
905 features: nodes[2].node.init_features(), networks: None, remote_network_address: None
907 let reestablish_1 = get_chan_reestablish_msgs!(nodes[3], nodes[2]);
908 nodes[2].node.peer_connected(&nodes[3].node.get_our_node_id(), &msgs::Init {
909 features: nodes[3].node.init_features(), networks: None, remote_network_address: None
911 let reestablish_2 = get_chan_reestablish_msgs!(nodes[2], nodes[3]);
913 nodes[2].node.handle_channel_reestablish(&nodes[3].node.get_our_node_id(), &reestablish_1[0]);
914 get_event_msg!(nodes[2], MessageSendEvent::SendChannelUpdate, nodes[3].node.get_our_node_id());
915 assert!(nodes[2].node.get_and_clear_pending_msg_events().is_empty());
917 nodes[3].node.handle_channel_reestablish(&nodes[2].node.get_our_node_id(), &reestablish_2[0]);
919 // Once we call `get_and_clear_pending_msg_events` the holding cell is cleared and the HTLC
921 let ds_msgs = nodes[3].node.get_and_clear_pending_msg_events();
922 check_added_monitors!(nodes[3], 1);
923 assert_eq!(ds_msgs.len(), 2);
924 if let MessageSendEvent::SendChannelUpdate { .. } = ds_msgs[0] {} else { panic!(); }
926 let cs_updates = match ds_msgs[1] {
927 MessageSendEvent::UpdateHTLCs { ref updates, .. } => {
928 nodes[2].node.handle_update_fulfill_htlc(&nodes[3].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
929 check_added_monitors!(nodes[2], 1);
930 let cs_updates = get_htlc_update_msgs!(nodes[2], nodes[0].node.get_our_node_id());
931 expect_payment_forwarded!(nodes[2], nodes[0], nodes[3], Some(1000), false, false);
932 commitment_signed_dance!(nodes[2], nodes[3], updates.commitment_signed, false, true);
938 nodes[0].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &cs_updates.update_fulfill_htlcs[0]);
939 commitment_signed_dance!(nodes[0], nodes[2], cs_updates.commitment_signed, false, true);
940 expect_payment_sent!(nodes[0], payment_preimage);
945 fn test_partial_claim_before_restart() {
946 do_test_partial_claim_before_restart(false);
947 do_test_partial_claim_before_restart(true);
950 fn do_forwarded_payment_no_manager_persistence(use_cs_commitment: bool, claim_htlc: bool, use_intercept: bool) {
951 if !use_cs_commitment { assert!(!claim_htlc); }
952 // If we go to forward a payment, and the ChannelMonitor persistence completes, but the
953 // ChannelManager does not, we shouldn't try to forward the payment again, nor should we fail
954 // it back until the ChannelMonitor decides the fate of the HTLC.
955 // This was never an issue, but it may be easy to regress here going forward.
956 let chanmon_cfgs = create_chanmon_cfgs(3);
957 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
959 let new_chain_monitor;
961 let mut intercept_forwards_config = test_default_channel_config();
962 intercept_forwards_config.accept_intercept_htlcs = true;
963 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, Some(intercept_forwards_config), None]);
964 let nodes_1_deserialized;
966 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
968 let chan_id_1 = create_announced_chan_between_nodes(&nodes, 0, 1).2;
969 let chan_id_2 = create_announced_chan_between_nodes(&nodes, 1, 2).2;
971 let intercept_scid = nodes[1].node.get_intercept_scid();
973 let (mut route, payment_hash, payment_preimage, payment_secret) =
974 get_route_and_payment_hash!(nodes[0], nodes[2], 1_000_000);
976 route.paths[0].hops[1].short_channel_id = intercept_scid;
978 let payment_id = PaymentId(nodes[0].keys_manager.backing.get_secure_random_bytes());
979 let htlc_expiry = nodes[0].best_block_info().1 + TEST_FINAL_CLTV;
980 nodes[0].node.send_payment_with_route(&route, payment_hash,
981 RecipientOnionFields::secret_only(payment_secret), payment_id).unwrap();
982 check_added_monitors!(nodes[0], 1);
984 let payment_event = SendEvent::from_node(&nodes[0]);
985 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
986 commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
988 // Store the `ChannelManager` before handling the `PendingHTLCsForwardable`/`HTLCIntercepted`
989 // events, expecting either event (and the HTLC itself) to be missing on reload even though its
990 // present when we serialized.
991 let node_encoded = nodes[1].node.encode();
993 let mut intercept_id = None;
994 let mut expected_outbound_amount_msat = None;
996 let events = nodes[1].node.get_and_clear_pending_events();
997 assert_eq!(events.len(), 1);
999 Event::HTLCIntercepted { intercept_id: ev_id, expected_outbound_amount_msat: ev_amt, .. } => {
1000 intercept_id = Some(ev_id);
1001 expected_outbound_amount_msat = Some(ev_amt);
1005 nodes[1].node.forward_intercepted_htlc(intercept_id.unwrap(), &chan_id_2,
1006 nodes[2].node.get_our_node_id(), expected_outbound_amount_msat.unwrap()).unwrap();
1009 expect_pending_htlcs_forwardable!(nodes[1]);
1011 let payment_event = SendEvent::from_node(&nodes[1]);
1012 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
1013 nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &payment_event.commitment_msg);
1014 check_added_monitors!(nodes[2], 1);
1017 get_monitor!(nodes[2], chan_id_2).provide_payment_preimage(&payment_hash, &payment_preimage,
1018 &nodes[2].tx_broadcaster, &LowerBoundedFeeEstimator(nodes[2].fee_estimator), &nodes[2].logger);
1020 assert!(nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().is_empty());
1022 let _ = nodes[2].node.get_and_clear_pending_msg_events();
1024 nodes[2].node.force_close_broadcasting_latest_txn(&chan_id_2, &nodes[1].node.get_our_node_id()).unwrap();
1025 let cs_commitment_tx = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1026 assert_eq!(cs_commitment_tx.len(), if claim_htlc { 2 } else { 1 });
1028 check_added_monitors!(nodes[2], 1);
1029 check_closed_event!(nodes[2], 1, ClosureReason::HolderForceClosed, [nodes[1].node.get_our_node_id()], 100000);
1030 check_closed_broadcast!(nodes[2], true);
1032 let chan_0_monitor_serialized = get_monitor!(nodes[1], chan_id_1).encode();
1033 let chan_1_monitor_serialized = get_monitor!(nodes[1], chan_id_2).encode();
1034 reload_node!(nodes[1], node_encoded, &[&chan_0_monitor_serialized, &chan_1_monitor_serialized], persister, new_chain_monitor, nodes_1_deserialized);
1036 // Note that this checks that this is the only event on nodes[1], implying the
1037 // `HTLCIntercepted` event has been removed in the `use_intercept` case.
1038 check_closed_event!(nodes[1], 1, ClosureReason::OutdatedChannelManager, [nodes[2].node.get_our_node_id()], 100000);
1041 // Attempt to forward the HTLC back out over nodes[1]' still-open channel, ensuring we get
1042 // a intercept-doesn't-exist error.
1043 let forward_err = nodes[1].node.forward_intercepted_htlc(intercept_id.unwrap(), &chan_id_1,
1044 nodes[0].node.get_our_node_id(), expected_outbound_amount_msat.unwrap()).unwrap_err();
1045 assert_eq!(forward_err, APIError::APIMisuseError {
1046 err: format!("Payment with intercept id {} not found", log_bytes!(intercept_id.unwrap().0))
1050 nodes[1].node.timer_tick_occurred();
1051 let bs_commitment_tx = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
1052 assert_eq!(bs_commitment_tx.len(), 1);
1053 check_added_monitors!(nodes[1], 1);
1055 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id());
1056 reconnect_nodes(ReconnectArgs::new(&nodes[0], &nodes[1]));
1058 if use_cs_commitment {
1059 // If we confirm a commitment transaction that has the HTLC on-chain, nodes[1] should wait
1060 // for an HTLC-spending transaction before it does anything with the HTLC upstream.
1061 confirm_transaction(&nodes[1], &cs_commitment_tx[0]);
1062 assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
1063 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1066 confirm_transaction(&nodes[1], &cs_commitment_tx[1]);
1068 connect_blocks(&nodes[1], htlc_expiry - nodes[1].best_block_info().1 + 1);
1069 let mut txn = nodes[1].tx_broadcaster.txn_broadcast();
1070 assert_eq!(txn.len(), if nodes[1].connect_style.borrow().updates_best_block_first() { 2 } else { 1 });
1071 let bs_htlc_timeout_tx = txn.pop().unwrap();
1072 confirm_transaction(&nodes[1], &bs_htlc_timeout_tx);
1075 confirm_transaction(&nodes[1], &bs_commitment_tx[0]);
1079 expect_pending_htlcs_forwardable_and_htlc_handling_failed!(nodes[1], [HTLCDestination::NextHopChannel { node_id: Some(nodes[2].node.get_our_node_id()), channel_id: chan_id_2 }]);
1081 expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, true);
1083 check_added_monitors!(nodes[1], 1);
1085 let events = nodes[1].node.get_and_clear_pending_msg_events();
1086 assert_eq!(events.len(), 1);
1088 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { update_fulfill_htlcs, update_fail_htlcs, commitment_signed, .. }, .. } => {
1090 nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_htlcs[0]);
1092 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlcs[0]);
1094 commitment_signed_dance!(nodes[0], nodes[1], commitment_signed, false);
1096 _ => panic!("Unexpected event"),
1100 expect_payment_sent!(nodes[0], payment_preimage);
1102 expect_payment_failed!(nodes[0], payment_hash, false);
1107 fn forwarded_payment_no_manager_persistence() {
1108 do_forwarded_payment_no_manager_persistence(true, true, false);
1109 do_forwarded_payment_no_manager_persistence(true, false, false);
1110 do_forwarded_payment_no_manager_persistence(false, false, false);
1114 fn intercepted_payment_no_manager_persistence() {
1115 do_forwarded_payment_no_manager_persistence(true, true, true);
1116 do_forwarded_payment_no_manager_persistence(true, false, true);
1117 do_forwarded_payment_no_manager_persistence(false, false, true);
1121 fn removed_payment_no_manager_persistence() {
1122 // If an HTLC is failed to us on a channel, and the ChannelMonitor persistence completes, but
1123 // the corresponding ChannelManager persistence does not, we need to ensure that the HTLC is
1124 // still failed back to the previous hop even though the ChannelMonitor now no longer is aware
1125 // of the HTLC. This was previously broken as no attempt was made to figure out which HTLCs
1126 // were left dangling when a channel was force-closed due to a stale ChannelManager.
1127 let chanmon_cfgs = create_chanmon_cfgs(3);
1128 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
1130 let new_chain_monitor;
1132 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
1133 let nodes_1_deserialized;
1135 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1137 let chan_id_1 = create_announced_chan_between_nodes(&nodes, 0, 1).2;
1138 let chan_id_2 = create_announced_chan_between_nodes(&nodes, 1, 2).2;
1140 let (_, payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1_000_000);
1142 let node_encoded = nodes[1].node.encode();
1144 nodes[2].node.fail_htlc_backwards(&payment_hash);
1145 expect_pending_htlcs_forwardable_and_htlc_handling_failed!(nodes[2], [HTLCDestination::FailedPayment { payment_hash }]);
1146 check_added_monitors!(nodes[2], 1);
1147 let events = nodes[2].node.get_and_clear_pending_msg_events();
1148 assert_eq!(events.len(), 1);
1150 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { update_fail_htlcs, commitment_signed, .. }, .. } => {
1151 nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &update_fail_htlcs[0]);
1152 commitment_signed_dance!(nodes[1], nodes[2], commitment_signed, false);
1154 _ => panic!("Unexpected event"),
1157 let chan_0_monitor_serialized = get_monitor!(nodes[1], chan_id_1).encode();
1158 let chan_1_monitor_serialized = get_monitor!(nodes[1], chan_id_2).encode();
1159 reload_node!(nodes[1], node_encoded, &[&chan_0_monitor_serialized, &chan_1_monitor_serialized], persister, new_chain_monitor, nodes_1_deserialized);
1161 match nodes[1].node.pop_pending_event().unwrap() {
1162 Event::ChannelClosed { ref reason, .. } => {
1163 assert_eq!(*reason, ClosureReason::OutdatedChannelManager);
1165 _ => panic!("Unexpected event"),
1168 nodes[1].node.test_process_background_events();
1169 check_added_monitors(&nodes[1], 1);
1171 // Now that the ChannelManager has force-closed the channel which had the HTLC removed, it is
1172 // now forgotten everywhere. The ChannelManager should have, as a side-effect of reload,
1173 // learned that the HTLC is gone from the ChannelMonitor and added it to the to-fail-back set.
1174 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id());
1175 reconnect_nodes(ReconnectArgs::new(&nodes[0], &nodes[1]));
1177 expect_pending_htlcs_forwardable_and_htlc_handling_failed!(nodes[1], [HTLCDestination::NextHopChannel { node_id: Some(nodes[2].node.get_our_node_id()), channel_id: chan_id_2 }]);
1178 check_added_monitors!(nodes[1], 1);
1179 let events = nodes[1].node.get_and_clear_pending_msg_events();
1180 assert_eq!(events.len(), 1);
1182 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { update_fail_htlcs, commitment_signed, .. }, .. } => {
1183 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlcs[0]);
1184 commitment_signed_dance!(nodes[0], nodes[1], commitment_signed, false);
1186 _ => panic!("Unexpected event"),
1189 expect_payment_failed!(nodes[0], payment_hash, false);
1193 fn test_reload_partial_funding_batch() {
1194 let chanmon_cfgs = create_chanmon_cfgs(3);
1195 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
1197 let new_chain_monitor;
1199 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
1200 let new_channel_manager;
1201 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1203 // Initiate channel opening and create the batch channel funding transaction.
1204 let (tx, funding_created_msgs) = create_batch_channel_funding(&nodes[0], &[
1205 (&nodes[1], 100_000, 0, 42, None),
1206 (&nodes[2], 200_000, 0, 43, None),
1209 // Go through the funding_created and funding_signed flow with node 1.
1210 nodes[1].node.handle_funding_created(&nodes[0].node.get_our_node_id(), &funding_created_msgs[0]);
1211 check_added_monitors(&nodes[1], 1);
1212 expect_channel_pending_event(&nodes[1], &nodes[0].node.get_our_node_id());
1214 // The monitor is persisted when receiving funding_signed.
1215 let funding_signed_msg = get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, nodes[0].node.get_our_node_id());
1216 nodes[0].node.handle_funding_signed(&nodes[1].node.get_our_node_id(), &funding_signed_msg);
1217 check_added_monitors(&nodes[0], 1);
1219 // The transaction should not have been broadcast before all channels are ready.
1220 assert_eq!(nodes[0].tx_broadcaster.txn_broadcast().len(), 0);
1222 // Reload the node while a subset of the channels in the funding batch have persisted monitors.
1223 let channel_id_1 = OutPoint { txid: tx.txid(), index: 0 }.to_channel_id();
1224 let node_encoded = nodes[0].node.encode();
1225 let channel_monitor_1_serialized = get_monitor!(nodes[0], channel_id_1).encode();
1226 reload_node!(nodes[0], node_encoded, &[&channel_monitor_1_serialized], new_persister, new_chain_monitor, new_channel_manager);
1228 // Process monitor events.
1229 assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
1231 // The monitor should become closed.
1232 check_added_monitors(&nodes[0], 1);
1234 let mut monitor_updates = nodes[0].chain_monitor.monitor_updates.lock().unwrap();
1235 let monitor_updates_1 = monitor_updates.get(&channel_id_1).unwrap();
1236 assert_eq!(monitor_updates_1.len(), 1);
1237 assert_eq!(monitor_updates_1[0].update_id, CLOSED_CHANNEL_UPDATE_ID);
1240 // The funding transaction should not have been broadcast, but we broadcast the force-close
1241 // transaction as part of closing the monitor.
1243 let broadcasted_txs = nodes[0].tx_broadcaster.txn_broadcast();
1244 assert_eq!(broadcasted_txs.len(), 1);
1245 assert!(broadcasted_txs[0].txid() != tx.txid());
1246 assert_eq!(broadcasted_txs[0].input.len(), 1);
1247 assert_eq!(broadcasted_txs[0].input[0].previous_output.txid, tx.txid());
1250 // Ensure the channels don't exist anymore.
1251 assert!(nodes[0].node.list_channels().is_empty());