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 //! Tests of our shutdown and closing_signed negotiation logic as well as some assorted force-close
13 use crate::sign::{EntropySource, SignerProvider};
14 use crate::chain::ChannelMonitorUpdateStatus;
15 use crate::chain::transaction::OutPoint;
16 use crate::events::{Event, MessageSendEvent, HTLCDestination, MessageSendEventsProvider, ClosureReason};
17 use crate::ln::channelmanager::{self, PaymentSendFailure, PaymentId, RecipientOnionFields, Retry, ChannelShutdownState, ChannelDetails};
18 use crate::routing::router::{PaymentParameters, get_route, RouteParameters};
19 use crate::ln::{ChannelId, msgs};
20 use crate::ln::msgs::{ChannelMessageHandler, ErrorAction};
21 use crate::ln::onion_utils::INVALID_ONION_BLINDING;
22 use crate::ln::script::ShutdownScript;
23 use crate::util::test_utils;
24 use crate::util::test_utils::OnGetShutdownScriptpubkey;
25 use crate::util::errors::APIError;
26 use crate::util::config::UserConfig;
27 use crate::util::string::UntrustedString;
29 use bitcoin::{Transaction, TxOut};
30 use bitcoin::blockdata::locktime::absolute::LockTime;
31 use bitcoin::blockdata::script::Builder;
32 use bitcoin::blockdata::opcodes;
33 use bitcoin::network::constants::Network;
34 use bitcoin::address::{WitnessProgram, WitnessVersion};
38 use core::default::Default;
39 use std::convert::TryFrom;
41 use crate::ln::functional_test_utils::*;
44 fn pre_funding_lock_shutdown_test() {
45 // Test sending a shutdown prior to channel_ready after funding generation
46 let chanmon_cfgs = create_chanmon_cfgs(2);
47 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
48 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
49 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
50 let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 8000000, 0);
51 mine_transaction(&nodes[0], &tx);
52 mine_transaction(&nodes[1], &tx);
54 nodes[0].node.close_channel(&OutPoint { txid: tx.txid(), index: 0 }.to_channel_id(), &nodes[1].node.get_our_node_id()).unwrap();
55 let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
56 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
57 let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
58 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
60 let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
61 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
62 let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
63 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
64 let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
65 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
66 let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
67 assert!(node_1_none.is_none());
69 assert!(nodes[0].node.list_channels().is_empty());
70 assert!(nodes[1].node.list_channels().is_empty());
71 check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 8000000);
72 check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id()], 8000000);
76 fn expect_channel_shutdown_state() {
77 // Test sending a shutdown prior to channel_ready after funding generation
78 let chanmon_cfgs = create_chanmon_cfgs(2);
79 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
80 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
81 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
82 let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
84 expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NotShuttingDown);
86 nodes[0].node.close_channel(&chan_1.2, &nodes[1].node.get_our_node_id()).unwrap();
88 expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ShutdownInitiated);
89 expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NotShuttingDown);
91 let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
92 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
94 // node1 goes into NegotiatingClosingFee since there are no HTLCs in flight, note that it
95 // doesnt mean that node1 has sent/recved its closing signed message
96 expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ShutdownInitiated);
97 expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NegotiatingClosingFee);
99 let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
100 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
102 expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NegotiatingClosingFee);
103 expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NegotiatingClosingFee);
105 let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
106 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
107 let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
108 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
109 let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
110 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
111 let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
112 assert!(node_1_none.is_none());
114 assert!(nodes[0].node.list_channels().is_empty());
115 assert!(nodes[1].node.list_channels().is_empty());
116 check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
117 check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id()], 100000);
121 fn expect_channel_shutdown_state_with_htlc() {
122 // Test sending a shutdown with outstanding updates pending.
123 let chanmon_cfgs = create_chanmon_cfgs(3);
124 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
125 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
126 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
127 let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
128 let _chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
130 let (payment_preimage_0, payment_hash_0, ..) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000);
132 expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NotShuttingDown);
133 expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NotShuttingDown);
135 nodes[0].node.close_channel(&chan_1.2, &nodes[1].node.get_our_node_id()).unwrap();
137 expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ShutdownInitiated);
138 expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NotShuttingDown);
140 let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
141 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
143 expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ShutdownInitiated);
144 expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::ResolvingHTLCs);
146 let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
147 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
149 expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ResolvingHTLCs);
150 expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::ResolvingHTLCs);
152 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
153 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
155 // Claim Funds on Node2
156 nodes[2].node.claim_funds(payment_preimage_0);
157 check_added_monitors!(nodes[2], 1);
158 expect_payment_claimed!(nodes[2], payment_hash_0, 100_000);
160 // Fulfil HTLCs on node1 and node0
161 let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
162 assert!(updates.update_add_htlcs.is_empty());
163 assert!(updates.update_fail_htlcs.is_empty());
164 assert!(updates.update_fail_malformed_htlcs.is_empty());
165 assert!(updates.update_fee.is_none());
166 assert_eq!(updates.update_fulfill_htlcs.len(), 1);
167 nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
168 expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false);
169 check_added_monitors!(nodes[1], 1);
170 let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
171 commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false);
173 // Still in "resolvingHTLCs" on chan1 after htlc removed on chan2
174 expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ResolvingHTLCs);
175 expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::ResolvingHTLCs);
177 assert!(updates_2.update_add_htlcs.is_empty());
178 assert!(updates_2.update_fail_htlcs.is_empty());
179 assert!(updates_2.update_fail_malformed_htlcs.is_empty());
180 assert!(updates_2.update_fee.is_none());
181 assert_eq!(updates_2.update_fulfill_htlcs.len(), 1);
182 nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]);
183 commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
184 expect_payment_sent!(nodes[0], payment_preimage_0);
186 // all htlcs removed, chan1 advances to NegotiatingClosingFee
187 expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NegotiatingClosingFee);
188 expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NegotiatingClosingFee);
190 // ClosingSignNegotion process
191 let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
192 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
193 let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
194 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
195 let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
196 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
197 let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
198 assert!(node_1_none.is_none());
199 check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
200 check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id()], 100000);
202 // Shutdown basically removes the channelDetails, testing of shutdowncomplete state unnecessary
203 assert!(nodes[0].node.list_channels().is_empty());
207 fn test_lnd_bug_6039() {
208 // LND sends a nonsense error message any time it gets a shutdown if there are still HTLCs
209 // pending. We currently swallow that error to work around LND's bug #6039. This test emulates
210 // the LND nonsense and ensures we at least kinda handle it.
211 let chanmon_cfgs = create_chanmon_cfgs(2);
212 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
213 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
214 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
215 let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
217 let (payment_preimage, ..) = route_payment(&nodes[0], &[&nodes[1]], 100_000);
219 nodes[0].node.close_channel(&chan.2, &nodes[1].node.get_our_node_id()).unwrap();
220 let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
221 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
223 // Generate an lnd-like error message and check that we respond by simply screaming louder to
224 // see if LND will accept our protocol compliance.
225 let err_msg = msgs::ErrorMessage { channel_id: chan.2, data: "link failed to shutdown".to_string() };
226 nodes[0].node.handle_error(&nodes[1].node.get_our_node_id(), &err_msg);
227 let node_a_responses = nodes[0].node.get_and_clear_pending_msg_events();
228 assert_eq!(node_a_responses[0], MessageSendEvent::SendShutdown {
229 node_id: nodes[1].node.get_our_node_id(),
230 msg: node_0_shutdown,
232 if let MessageSendEvent::HandleError { action: msgs::ErrorAction::SendWarningMessage { .. }, .. }
233 = node_a_responses[1] {} else { panic!(); }
235 let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
237 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
238 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
240 claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
242 // Assume that LND will eventually respond to our Shutdown if we clear all the remaining HTLCs
243 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
245 // ClosingSignNegotion process
246 let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
247 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
248 let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
249 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
250 let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
251 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
252 let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
253 assert!(node_1_none.is_none());
254 check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
255 check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id()], 100000);
257 // Shutdown basically removes the channelDetails, testing of shutdowncomplete state unnecessary
258 assert!(nodes[0].node.list_channels().is_empty());
262 fn shutdown_on_unfunded_channel() {
263 // Test receiving a shutdown prior to funding generation
264 let chanmon_cfgs = create_chanmon_cfgs(2);
265 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
266 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
267 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
269 nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 1_000_000, 100_000, 0, None, None).unwrap();
270 let open_chan = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
272 // Create a dummy P2WPKH script
273 let script = Builder::new().push_int(0)
274 .push_slice(&[0; 20])
277 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &msgs::Shutdown {
278 channel_id: open_chan.temporary_channel_id, scriptpubkey: script,
280 check_closed_event!(nodes[0], 1, ClosureReason::CounterpartyCoopClosedUnfundedChannel, [nodes[1].node.get_our_node_id()], 1_000_000);
284 fn close_on_unfunded_channel() {
285 // Test the user asking us to close prior to funding generation
286 let chanmon_cfgs = create_chanmon_cfgs(2);
287 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
288 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
289 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
291 let chan_id = nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 1_000_000, 100_000, 0, None, None).unwrap();
292 let _open_chan = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
294 nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap();
295 check_closed_event!(nodes[0], 1, ClosureReason::HolderForceClosed, [nodes[1].node.get_our_node_id()], 1_000_000);
299 fn expect_channel_shutdown_state_with_force_closure() {
300 // Test sending a shutdown prior to channel_ready after funding generation
301 let chanmon_cfgs = create_chanmon_cfgs(2);
302 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
303 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
304 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
305 let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
307 expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NotShuttingDown);
308 expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NotShuttingDown);
310 nodes[1].node.force_close_broadcasting_latest_txn(&chan_1.2, &nodes[0].node.get_our_node_id()).unwrap();
311 check_closed_broadcast!(nodes[1], true);
312 check_added_monitors!(nodes[1], 1);
314 expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NotShuttingDown);
315 assert!(nodes[1].node.list_channels().is_empty());
317 let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
318 assert_eq!(node_txn.len(), 1);
319 check_spends!(node_txn[0], chan_1.3);
320 mine_transaction(&nodes[0], &node_txn[0]);
321 check_added_monitors!(nodes[0], 1);
323 assert!(nodes[0].node.list_channels().is_empty());
324 assert!(nodes[1].node.list_channels().is_empty());
325 check_closed_broadcast!(nodes[0], true);
326 check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed, [nodes[1].node.get_our_node_id()], 100000);
327 check_closed_event!(nodes[1], 1, ClosureReason::HolderForceClosed, [nodes[0].node.get_our_node_id()], 100000);
331 fn updates_shutdown_wait() {
332 // Test sending a shutdown with outstanding updates pending
333 let chanmon_cfgs = create_chanmon_cfgs(3);
334 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
335 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
336 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
337 let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
338 let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
339 let logger = test_utils::TestLogger::new();
340 let scorer = test_utils::TestScorer::new();
341 let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
342 let random_seed_bytes = keys_manager.get_secure_random_bytes();
344 let (payment_preimage_0, payment_hash_0, ..) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000);
346 nodes[0].node.close_channel(&chan_1.2, &nodes[1].node.get_our_node_id()).unwrap();
347 let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
348 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
349 let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
350 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
352 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
353 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
355 let (_, payment_hash, payment_secret) = get_payment_preimage_hash!(nodes[0]);
357 let payment_params_1 = PaymentParameters::from_node_id(nodes[1].node.get_our_node_id(), TEST_FINAL_CLTV)
358 .with_bolt11_features(nodes[1].node.bolt11_invoice_features()).unwrap();
359 let route_params = RouteParameters::from_payment_params_and_value(payment_params_1, 100_000);
360 let route_1 = get_route(&nodes[0].node.get_our_node_id(), &route_params,
361 &nodes[0].network_graph.read_only(), None, &logger, &scorer, &Default::default(), &random_seed_bytes).unwrap();
362 let payment_params_2 = PaymentParameters::from_node_id(nodes[0].node.get_our_node_id(), TEST_FINAL_CLTV)
363 .with_bolt11_features(nodes[0].node.bolt11_invoice_features()).unwrap();
364 let route_params = RouteParameters::from_payment_params_and_value(payment_params_2, 100_000);
365 let route_2 = get_route(&nodes[1].node.get_our_node_id(), &route_params,
366 &nodes[1].network_graph.read_only(), None, &logger, &scorer, &Default::default(), &random_seed_bytes).unwrap();
367 unwrap_send_err!(nodes[0].node.send_payment_with_route(&route_1, payment_hash,
368 RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)
369 ), true, APIError::ChannelUnavailable {..}, {});
370 unwrap_send_err!(nodes[1].node.send_payment_with_route(&route_2, payment_hash,
371 RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)
372 ), true, APIError::ChannelUnavailable {..}, {});
374 nodes[2].node.claim_funds(payment_preimage_0);
375 check_added_monitors!(nodes[2], 1);
376 expect_payment_claimed!(nodes[2], payment_hash_0, 100_000);
378 let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
379 assert!(updates.update_add_htlcs.is_empty());
380 assert!(updates.update_fail_htlcs.is_empty());
381 assert!(updates.update_fail_malformed_htlcs.is_empty());
382 assert!(updates.update_fee.is_none());
383 assert_eq!(updates.update_fulfill_htlcs.len(), 1);
384 nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
385 expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false);
386 check_added_monitors!(nodes[1], 1);
387 let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
388 commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false);
390 assert!(updates_2.update_add_htlcs.is_empty());
391 assert!(updates_2.update_fail_htlcs.is_empty());
392 assert!(updates_2.update_fail_malformed_htlcs.is_empty());
393 assert!(updates_2.update_fee.is_none());
394 assert_eq!(updates_2.update_fulfill_htlcs.len(), 1);
395 nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]);
396 commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
397 expect_payment_sent!(nodes[0], payment_preimage_0);
399 let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
400 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
401 let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
402 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
403 let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
404 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
405 let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
406 assert!(node_1_none.is_none());
407 check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
408 check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id()], 100000);
410 assert!(nodes[0].node.list_channels().is_empty());
412 assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
413 nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
414 close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
415 assert!(nodes[1].node.list_channels().is_empty());
416 assert!(nodes[2].node.list_channels().is_empty());
417 check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[2].node.get_our_node_id()], 100000);
418 check_closed_event!(nodes[2], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
422 fn htlc_fail_async_shutdown() {
423 do_htlc_fail_async_shutdown(true);
424 do_htlc_fail_async_shutdown(false);
427 fn do_htlc_fail_async_shutdown(blinded_recipient: bool) {
428 // Test HTLCs fail if shutdown starts even if messages are delivered out-of-order
429 let chanmon_cfgs = create_chanmon_cfgs(3);
430 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
431 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
432 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
433 let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
434 let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
436 let amt_msat = 100000;
437 let (_, our_payment_hash, our_payment_secret) = get_payment_preimage_hash(&nodes[2], Some(amt_msat), None);
438 let route_params = if blinded_recipient {
439 crate::ln::blinded_payment_tests::get_blinded_route_parameters(
440 amt_msat, our_payment_secret,
441 nodes.iter().skip(1).map(|n| n.node.get_our_node_id()).collect(), &[&chan_2.0.contents],
442 &chanmon_cfgs[2].keys_manager)
444 RouteParameters::from_payment_params_and_value(
445 PaymentParameters::from_node_id(nodes[2].node.get_our_node_id(), TEST_FINAL_CLTV), amt_msat)
447 nodes[0].node.send_payment(our_payment_hash,
448 RecipientOnionFields::secret_only(our_payment_secret),
449 PaymentId(our_payment_hash.0), route_params, Retry::Attempts(0)).unwrap();
450 check_added_monitors!(nodes[0], 1);
451 let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
452 assert_eq!(updates.update_add_htlcs.len(), 1);
453 assert!(updates.update_fulfill_htlcs.is_empty());
454 assert!(updates.update_fail_htlcs.is_empty());
455 assert!(updates.update_fail_malformed_htlcs.is_empty());
456 assert!(updates.update_fee.is_none());
458 nodes[1].node.close_channel(&chan_1.2, &nodes[0].node.get_our_node_id()).unwrap();
459 let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
460 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
461 let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
463 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
464 nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &updates.commitment_signed);
465 check_added_monitors!(nodes[1], 1);
466 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
467 commitment_signed_dance!(nodes[1], nodes[0], (), false, true, false, false);
469 let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
470 assert!(updates_2.update_add_htlcs.is_empty());
471 assert!(updates_2.update_fulfill_htlcs.is_empty());
472 assert_eq!(updates_2.update_fail_htlcs.len(), 1);
473 assert!(updates_2.update_fail_malformed_htlcs.is_empty());
474 assert!(updates_2.update_fee.is_none());
476 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fail_htlcs[0]);
477 commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
479 if blinded_recipient {
480 expect_payment_failed_conditions(&nodes[0], our_payment_hash, false,
481 PaymentFailedConditions::new().expected_htlc_error_data(INVALID_ONION_BLINDING, &[0; 32]));
483 expect_payment_failed_with_update!(nodes[0], our_payment_hash, false, chan_2.0.contents.short_channel_id, true);
486 let msg_events = nodes[0].node.get_and_clear_pending_msg_events();
487 assert_eq!(msg_events.len(), 1);
488 let node_0_closing_signed = match msg_events[0] {
489 MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => {
490 assert_eq!(*node_id, nodes[1].node.get_our_node_id());
493 _ => panic!("Unexpected event"),
496 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
497 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
498 let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
499 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
500 let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
501 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
502 let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
503 assert!(node_1_none.is_none());
505 assert!(nodes[0].node.list_channels().is_empty());
507 assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
508 nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
509 close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
510 assert!(nodes[1].node.list_channels().is_empty());
511 assert!(nodes[2].node.list_channels().is_empty());
512 check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
513 check_closed_event!(nodes[1], 2, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id(), nodes[2].node.get_our_node_id()], 100000);
514 check_closed_event!(nodes[2], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
517 fn do_test_shutdown_rebroadcast(recv_count: u8) {
518 // Test that shutdown/closing_signed is re-sent on reconnect with a variable number of
519 // messages delivered prior to disconnect
520 let chanmon_cfgs = create_chanmon_cfgs(3);
521 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
522 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
523 let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
524 let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
525 let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
527 let (payment_preimage, payment_hash, ..) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000);
529 nodes[1].node.close_channel(&chan_1.2, &nodes[0].node.get_our_node_id()).unwrap();
530 let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
532 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
533 let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
535 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
539 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id());
540 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id());
542 nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init {
543 features: nodes[1].node.init_features(), networks: None, remote_network_address: None
545 let node_0_reestablish = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap();
546 nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init {
547 features: nodes[0].node.init_features(), networks: None, remote_network_address: None
549 let node_1_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap();
551 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &node_0_reestablish);
552 let node_1_2nd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
553 assert!(node_1_shutdown == node_1_2nd_shutdown);
555 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &node_1_reestablish);
556 let node_0_2nd_shutdown = if recv_count > 0 {
557 let node_0_2nd_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
558 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown);
561 let node_0_chan_update = get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id());
562 assert_eq!(node_0_chan_update.contents.flags & 2, 0); // "disabled" flag must not be set as we just reconnected.
563 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown);
564 get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id())
566 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_2nd_shutdown);
568 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
569 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
571 nodes[2].node.claim_funds(payment_preimage);
572 check_added_monitors!(nodes[2], 1);
573 expect_payment_claimed!(nodes[2], payment_hash, 100_000);
575 let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
576 assert!(updates.update_add_htlcs.is_empty());
577 assert!(updates.update_fail_htlcs.is_empty());
578 assert!(updates.update_fail_malformed_htlcs.is_empty());
579 assert!(updates.update_fee.is_none());
580 assert_eq!(updates.update_fulfill_htlcs.len(), 1);
581 nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
582 expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false);
583 check_added_monitors!(nodes[1], 1);
584 let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
585 commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false);
587 assert!(updates_2.update_add_htlcs.is_empty());
588 assert!(updates_2.update_fail_htlcs.is_empty());
589 assert!(updates_2.update_fail_malformed_htlcs.is_empty());
590 assert!(updates_2.update_fee.is_none());
591 assert_eq!(updates_2.update_fulfill_htlcs.len(), 1);
592 nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]);
593 commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
594 expect_payment_sent!(nodes[0], payment_preimage);
596 let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
598 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
599 let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
600 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
601 let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
602 assert!(node_0_2nd_closing_signed.is_some());
605 nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id());
606 nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id());
608 nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init {
609 features: nodes[0].node.init_features(), networks: None, remote_network_address: None
611 let node_1_2nd_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap();
612 nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init {
613 features: nodes[1].node.init_features(), networks: None, remote_network_address: None
616 // If all closing_signeds weren't delivered we can just resume where we left off...
617 let node_0_2nd_reestablish = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap();
619 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &node_1_2nd_reestablish);
620 let node_0_msgs = nodes[0].node.get_and_clear_pending_msg_events();
621 assert_eq!(node_0_msgs.len(), 2);
622 let node_0_2nd_closing_signed = match node_0_msgs[1] {
623 MessageSendEvent::SendClosingSigned { ref msg, .. } => {
624 assert_eq!(node_0_closing_signed, *msg);
630 let node_0_3rd_shutdown = match node_0_msgs[0] {
631 MessageSendEvent::SendShutdown { ref msg, .. } => {
632 assert_eq!(node_0_2nd_shutdown, *msg);
637 assert!(node_0_2nd_shutdown == node_0_3rd_shutdown);
639 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &node_0_2nd_reestablish);
640 let node_1_3rd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
641 assert!(node_1_3rd_shutdown == node_1_2nd_shutdown);
643 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_3rd_shutdown);
644 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
646 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_3rd_shutdown);
648 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed);
649 let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
650 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
651 let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
652 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
653 let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
654 assert!(node_1_none.is_none());
655 check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id()], 100000);
657 // If one node, however, received + responded with an identical closing_signed we end
658 // up erroring and node[0] will try to broadcast its own latest commitment transaction.
659 // There isn't really anything better we can do simply, but in the future we might
660 // explore storing a set of recently-closed channels that got disconnected during
661 // closing_signed and avoiding broadcasting local commitment txn for some timeout to
662 // give our counterparty enough time to (potentially) broadcast a cooperative closing
664 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
666 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &node_1_2nd_reestablish);
667 let msg_events = nodes[0].node.get_and_clear_pending_msg_events();
668 assert_eq!(msg_events.len(), 2);
669 if let MessageSendEvent::HandleError { ref action, .. } = msg_events[1] {
671 &ErrorAction::SendErrorMessage { ref msg } => {
672 nodes[1].node.handle_error(&nodes[0].node.get_our_node_id(), &msg);
673 assert_eq!(msg.channel_id, chan_1.2);
675 _ => panic!("Unexpected event!"),
677 } else { panic!("Needed SendErrorMessage close"); }
679 // get_closing_signed_broadcast usually eats the BroadcastChannelUpdate for us and
680 // checks it, but in this case nodes[1] didn't ever get a chance to receive a
681 // closing_signed so we do it ourselves
682 check_closed_broadcast!(nodes[1], false);
683 check_added_monitors!(nodes[1], 1);
684 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())) }
685 , [nodes[0].node.get_our_node_id()], 100000);
688 assert!(nodes[0].node.list_channels().is_empty());
690 assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
691 nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
692 close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
693 assert!(nodes[1].node.list_channels().is_empty());
694 assert!(nodes[2].node.list_channels().is_empty());
695 check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
696 check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[2].node.get_our_node_id()], 100000);
697 check_closed_event!(nodes[2], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
701 fn test_shutdown_rebroadcast() {
702 do_test_shutdown_rebroadcast(0);
703 do_test_shutdown_rebroadcast(1);
704 do_test_shutdown_rebroadcast(2);
708 fn test_upfront_shutdown_script() {
709 // BOLT 2 : Option upfront shutdown script, if peer commit its closing_script at channel opening
710 // enforce it at shutdown message
712 let mut config = UserConfig::default();
713 config.channel_handshake_config.announced_channel = true;
714 config.channel_handshake_limits.force_announced_channel_preference = false;
715 config.channel_handshake_config.commit_upfront_shutdown_pubkey = false;
716 let user_cfgs = [None, Some(config), None];
717 let chanmon_cfgs = create_chanmon_cfgs(3);
718 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
719 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
720 let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
722 // We test that in case of peer committing upfront to a script, if it changes at closing, we refuse to sign
723 let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1000000, 1000000);
724 nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[2].node.get_our_node_id()).unwrap();
725 let node_0_orig_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id());
726 let mut node_0_shutdown = node_0_orig_shutdown.clone();
727 node_0_shutdown.scriptpubkey = Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script().to_p2sh();
728 // Test we enforce upfront_scriptpbukey if by providing a different one at closing that we warn
729 // the peer and ignore the message.
730 nodes[2].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
731 assert!(regex::Regex::new(r"Got shutdown request with a scriptpubkey \([A-Fa-f0-9]+\) which did not match their previous scriptpubkey.")
732 .unwrap().is_match(&check_warn_msg!(nodes[2], nodes[0].node.get_our_node_id(), chan.2)));
733 // This allows nodes[2] to retry the shutdown message, which should get a response:
734 nodes[2].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_orig_shutdown);
735 get_event_msg!(nodes[2], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
737 // We test that in case of peer committing upfront to a script, if it doesn't change at closing, we sign
738 let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1000000, 1000000);
739 nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[2].node.get_our_node_id()).unwrap();
740 let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id());
741 // We test that in case of peer committing upfront to a script, if it oesn't change at closing, we sign
742 nodes[2].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
743 let events = nodes[2].node.get_and_clear_pending_msg_events();
744 assert_eq!(events.len(), 1);
746 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[0].node.get_our_node_id()) }
747 _ => panic!("Unexpected event"),
750 // We test that if case of peer non-signaling we don't enforce committed script at channel opening
751 *nodes[0].override_init_features.borrow_mut() = Some(nodes[0].node.init_features().clear_upfront_shutdown_script());
752 let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000);
753 nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[1].node.get_our_node_id()).unwrap();
754 let node_1_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
755 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_1_shutdown);
756 check_added_monitors!(nodes[1], 1);
757 let events = nodes[1].node.get_and_clear_pending_msg_events();
758 assert_eq!(events.len(), 1);
760 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[0].node.get_our_node_id()) }
761 _ => panic!("Unexpected event"),
764 // We test that if user opt-out, we provide a zero-length script at channel opening and we are able to close
765 // channel smoothly, opt-out is from channel initiator here
766 *nodes[0].override_init_features.borrow_mut() = None;
767 let chan = create_announced_chan_between_nodes_with_value(&nodes, 1, 0, 1000000, 1000000);
768 nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[0].node.get_our_node_id()).unwrap();
769 check_added_monitors!(nodes[1], 1);
770 let node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
771 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_0_shutdown);
772 let events = nodes[0].node.get_and_clear_pending_msg_events();
773 assert_eq!(events.len(), 1);
775 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
776 _ => panic!("Unexpected event"),
779 //// We test that if user opt-out, we provide a zero-length script at channel opening and we are able to close
780 //// channel smoothly
781 let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000);
782 nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[0].node.get_our_node_id()).unwrap();
783 check_added_monitors!(nodes[1], 1);
784 let node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
785 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_0_shutdown);
786 let events = nodes[0].node.get_and_clear_pending_msg_events();
787 assert_eq!(events.len(), 2);
789 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
790 _ => panic!("Unexpected event"),
793 MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
794 _ => panic!("Unexpected event"),
799 fn test_unsupported_anysegwit_upfront_shutdown_script() {
800 let chanmon_cfgs = create_chanmon_cfgs(2);
801 let mut node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
802 // Clear shutdown_anysegwit on initiator
803 *node_cfgs[0].override_init_features.borrow_mut() = Some(channelmanager::provided_init_features(&test_default_channel_config()).clear_shutdown_anysegwit());
804 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
805 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
807 // Use a non-v0 segwit script supported by option_shutdown_anysegwit
808 let anysegwit_shutdown_script = Builder::new()
810 .push_slice(&[0, 40])
813 // Check script when handling an open_channel message
814 nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap();
815 let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
816 open_channel.shutdown_scriptpubkey = Some(anysegwit_shutdown_script.clone());
817 nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), &open_channel);
819 let events = nodes[1].node.get_and_clear_pending_msg_events();
820 assert_eq!(events.len(), 1);
822 MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id } => {
823 assert_eq!(node_id, nodes[0].node.get_our_node_id());
824 assert_eq!(msg.data, "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: OP_PUSHNUM_16 OP_PUSHBYTES_2 0028");
826 _ => panic!("Unexpected event"),
829 let chanmon_cfgs = create_chanmon_cfgs(2);
830 let mut node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
831 // Clear shutdown_anysegwit on responder
832 *node_cfgs[1].override_init_features.borrow_mut() = Some(channelmanager::provided_init_features(&test_default_channel_config()).clear_shutdown_anysegwit());
833 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
834 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
836 // Check script when handling an accept_channel message
837 nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap();
838 let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
839 nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), &open_channel);
840 let mut accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
841 accept_channel.shutdown_scriptpubkey = Some(anysegwit_shutdown_script.clone());
842 nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), &accept_channel);
844 let events = nodes[0].node.get_and_clear_pending_msg_events();
845 assert_eq!(events.len(), 1);
847 MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id } => {
848 assert_eq!(node_id, nodes[1].node.get_our_node_id());
849 assert_eq!(msg.data, "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: OP_PUSHNUM_16 OP_PUSHBYTES_2 0028");
851 _ => panic!("Unexpected event"),
853 check_closed_event!(nodes[0], 1, ClosureReason::ProcessingError { err: "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: OP_PUSHNUM_16 OP_PUSHBYTES_2 0028".to_string() }
854 , [nodes[1].node.get_our_node_id()], 100000);
858 fn test_invalid_upfront_shutdown_script() {
859 let chanmon_cfgs = create_chanmon_cfgs(2);
860 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
861 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
862 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
864 nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None, None).unwrap();
866 // Use a segwit v0 script with an unsupported witness program
867 let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
868 open_channel.shutdown_scriptpubkey = Some(Builder::new().push_int(0)
871 nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), &open_channel);
873 let events = nodes[1].node.get_and_clear_pending_msg_events();
874 assert_eq!(events.len(), 1);
876 MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id } => {
877 assert_eq!(node_id, nodes[0].node.get_our_node_id());
878 assert_eq!(msg.data, "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: OP_0 OP_PUSHBYTES_2 0000");
880 _ => panic!("Unexpected event"),
885 fn test_segwit_v0_shutdown_script() {
886 let mut config = UserConfig::default();
887 config.channel_handshake_config.announced_channel = true;
888 config.channel_handshake_limits.force_announced_channel_preference = false;
889 config.channel_handshake_config.commit_upfront_shutdown_pubkey = false;
890 let user_cfgs = [None, Some(config), None];
891 let chanmon_cfgs = create_chanmon_cfgs(3);
892 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
893 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
894 let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
896 let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
897 nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[0].node.get_our_node_id()).unwrap();
898 check_added_monitors!(nodes[1], 1);
900 // Use a segwit v0 script supported even without option_shutdown_anysegwit
901 let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
902 node_0_shutdown.scriptpubkey = Builder::new().push_int(0)
903 .push_slice(&[0; 20])
905 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_0_shutdown);
907 let events = nodes[0].node.get_and_clear_pending_msg_events();
908 assert_eq!(events.len(), 2);
910 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
911 _ => panic!("Unexpected event"),
914 MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
915 _ => panic!("Unexpected event"),
920 fn test_anysegwit_shutdown_script() {
921 let mut config = UserConfig::default();
922 config.channel_handshake_config.announced_channel = true;
923 config.channel_handshake_limits.force_announced_channel_preference = false;
924 config.channel_handshake_config.commit_upfront_shutdown_pubkey = false;
925 let user_cfgs = [None, Some(config), None];
926 let chanmon_cfgs = create_chanmon_cfgs(3);
927 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
928 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
929 let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
931 let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
932 nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[0].node.get_our_node_id()).unwrap();
933 check_added_monitors!(nodes[1], 1);
935 // Use a non-v0 segwit script supported by option_shutdown_anysegwit
936 let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
937 node_0_shutdown.scriptpubkey = Builder::new().push_int(16)
940 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_0_shutdown);
942 let events = nodes[0].node.get_and_clear_pending_msg_events();
943 assert_eq!(events.len(), 2);
945 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
946 _ => panic!("Unexpected event"),
949 MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
950 _ => panic!("Unexpected event"),
955 fn test_unsupported_anysegwit_shutdown_script() {
956 let mut config = UserConfig::default();
957 config.channel_handshake_config.announced_channel = true;
958 config.channel_handshake_limits.force_announced_channel_preference = false;
959 config.channel_handshake_config.commit_upfront_shutdown_pubkey = false;
960 let user_cfgs = [None, Some(config), None];
961 let chanmon_cfgs = create_chanmon_cfgs(3);
962 let mut node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
963 *node_cfgs[0].override_init_features.borrow_mut() = Some(channelmanager::provided_init_features(&config).clear_shutdown_anysegwit());
964 *node_cfgs[1].override_init_features.borrow_mut() = Some(channelmanager::provided_init_features(&config).clear_shutdown_anysegwit());
965 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
966 let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
968 // Check that using an unsupported shutdown script fails and a supported one succeeds.
969 let supported_shutdown_script = chanmon_cfgs[1].keys_manager.get_shutdown_scriptpubkey().unwrap();
970 let unsupported_witness_program = WitnessProgram::new(WitnessVersion::V16, &[0, 40]).unwrap();
971 let unsupported_shutdown_script =
972 ShutdownScript::new_witness_program(&unsupported_witness_program).unwrap();
973 chanmon_cfgs[1].keys_manager
974 .expect(OnGetShutdownScriptpubkey { returns: unsupported_shutdown_script.clone() })
975 .expect(OnGetShutdownScriptpubkey { returns: supported_shutdown_script });
977 let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
978 match nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[0].node.get_our_node_id()) {
979 Err(APIError::IncompatibleShutdownScript { script }) => {
980 assert_eq!(script.into_inner(), unsupported_shutdown_script.clone().into_inner());
982 Err(e) => panic!("Unexpected error: {:?}", e),
983 Ok(_) => panic!("Expected error"),
985 nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[0].node.get_our_node_id()).unwrap();
986 check_added_monitors!(nodes[1], 1);
988 // Use a non-v0 segwit script unsupported without option_shutdown_anysegwit
989 let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
990 node_0_shutdown.scriptpubkey = unsupported_shutdown_script.into_inner();
991 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_0_shutdown);
993 assert_eq!(&check_warn_msg!(nodes[0], nodes[1].node.get_our_node_id(), chan.2),
994 "Got a nonstandard scriptpubkey (60020028) from remote peer");
998 fn test_invalid_shutdown_script() {
999 let mut config = UserConfig::default();
1000 config.channel_handshake_config.announced_channel = true;
1001 config.channel_handshake_limits.force_announced_channel_preference = false;
1002 config.channel_handshake_config.commit_upfront_shutdown_pubkey = false;
1003 let user_cfgs = [None, Some(config), None];
1004 let chanmon_cfgs = create_chanmon_cfgs(3);
1005 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
1006 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
1007 let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1009 let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
1010 nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[0].node.get_our_node_id()).unwrap();
1011 check_added_monitors!(nodes[1], 1);
1013 // Use a segwit v0 script with an unsupported witness program
1014 let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1015 node_0_shutdown.scriptpubkey = Builder::new().push_int(0)
1016 .push_slice(&[0, 0])
1018 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_0_shutdown);
1020 assert_eq!(&check_warn_msg!(nodes[0], nodes[1].node.get_our_node_id(), chan.2),
1021 "Got a nonstandard scriptpubkey (00020000) from remote peer");
1025 fn test_user_shutdown_script() {
1026 let mut config = test_default_channel_config();
1027 config.channel_handshake_config.announced_channel = true;
1028 config.channel_handshake_limits.force_announced_channel_preference = false;
1029 config.channel_handshake_config.commit_upfront_shutdown_pubkey = false;
1030 let user_cfgs = [None, Some(config), None];
1031 let chanmon_cfgs = create_chanmon_cfgs(3);
1032 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
1033 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
1034 let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1036 // Segwit v0 script of the form OP_0 <20-byte hash>
1037 let script = Builder::new().push_int(0)
1038 .push_slice(&[0; 20])
1041 let shutdown_script = ShutdownScript::try_from(script.clone()).unwrap();
1043 let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
1044 nodes[1].node.close_channel_with_feerate_and_script(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[0].node.get_our_node_id(), None, Some(shutdown_script)).unwrap();
1045 check_added_monitors!(nodes[1], 1);
1047 let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1049 assert_eq!(node_0_shutdown.scriptpubkey, script);
1053 fn test_already_set_user_shutdown_script() {
1054 let mut config = test_default_channel_config();
1055 config.channel_handshake_config.announced_channel = true;
1056 config.channel_handshake_limits.force_announced_channel_preference = false;
1057 let user_cfgs = [None, Some(config), None];
1058 let chanmon_cfgs = create_chanmon_cfgs(3);
1059 let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
1060 let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
1061 let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1063 // Segwit v0 script of the form OP_0 <20-byte hash>
1064 let script = Builder::new().push_int(0)
1065 .push_slice(&[0; 20])
1068 let shutdown_script = ShutdownScript::try_from(script).unwrap();
1070 let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
1071 let result = nodes[1].node.close_channel_with_feerate_and_script(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[0].node.get_our_node_id(), None, Some(shutdown_script));
1073 assert_eq!(result, Err(APIError::APIMisuseError { err: "Cannot override shutdown script for a channel with one already set".to_string() }));
1076 #[derive(PartialEq)]
1083 fn do_test_closing_signed_reinit_timeout(timeout_step: TimeoutStep) {
1084 // The range-based closing signed negotiation allows the funder to restart the process with a
1085 // new range if the previous range did not overlap. This allows implementations to request user
1086 // intervention allowing users to enter a new fee range. We do not implement the sending side
1087 // of this, instead opting to allow users to enter an explicit "willing to pay up to X to avoid
1088 // force-closing" value and relying on that instead.
1090 // Here we run test the fundee side of that restart mechanism, implementing the funder side of
1092 let chanmon_cfgs = create_chanmon_cfgs(2);
1093 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1094 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1095 let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1096 let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2;
1098 send_payment(&nodes[0], &[&nodes[1]], 8_000_000);
1100 nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap();
1101 let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1102 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
1103 let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1104 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
1107 // Now we set nodes[1] to require a relatively high feerate for closing. This should result
1108 // in it rejecting nodes[0]'s initial closing_signed, giving nodes[0] a chance to try
1110 let mut feerate_lock = chanmon_cfgs[1].fee_estimator.sat_per_kw.lock().unwrap();
1111 *feerate_lock *= 10;
1114 let mut node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
1115 // nodes[0] should use a "reasonable" feerate, well under the 10 sat/vByte that nodes[1] thinks
1116 // is the current prevailing feerate.
1117 assert!(node_0_closing_signed.fee_satoshis <= 500);
1119 if timeout_step != TimeoutStep::AfterShutdown {
1120 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
1121 assert!(check_warn_msg!(nodes[1], nodes[0].node.get_our_node_id(), chan_id)
1122 .starts_with("Unable to come to consensus about closing feerate"));
1124 // Now deliver a mutated closing_signed indicating a higher acceptable fee range, which
1125 // nodes[1] should happily accept and respond to.
1126 node_0_closing_signed.fee_range.as_mut().unwrap().max_fee_satoshis *= 10;
1128 let mut node_0_per_peer_lock;
1129 let mut node_0_peer_state_lock;
1130 get_channel_ref!(nodes[0], nodes[1], node_0_per_peer_lock, node_0_peer_state_lock, chan_id).context_mut().closing_fee_limits.as_mut().unwrap().1 *= 10;
1132 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
1133 let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
1134 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
1135 let node_0_2nd_closing_signed = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
1136 if timeout_step == TimeoutStep::NoTimeout {
1137 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.1.unwrap());
1138 check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id()], 100000);
1140 check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
1143 if timeout_step != TimeoutStep::NoTimeout {
1144 assert!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().is_empty());
1146 assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
1149 nodes[1].node.timer_tick_occurred();
1150 nodes[1].node.timer_tick_occurred();
1152 let txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
1153 assert_eq!(txn.len(), 1);
1154 assert_eq!(txn[0].output.len(), 2);
1156 if timeout_step != TimeoutStep::NoTimeout {
1157 assert!((txn[0].output[0].script_pubkey.is_v0_p2wpkh() &&
1158 txn[0].output[1].script_pubkey.is_v0_p2wsh()) ||
1159 (txn[0].output[1].script_pubkey.is_v0_p2wpkh() &&
1160 txn[0].output[0].script_pubkey.is_v0_p2wsh()));
1161 check_closed_broadcast!(nodes[1], true);
1162 check_added_monitors!(nodes[1], 1);
1163 check_closed_event!(nodes[1], 1, ClosureReason::ProcessingError { err: "closing_signed negotiation failed to finish within two timer ticks".to_string() }
1164 , [nodes[0].node.get_our_node_id()], 100000);
1166 assert!(txn[0].output[0].script_pubkey.is_v0_p2wpkh());
1167 assert!(txn[0].output[1].script_pubkey.is_v0_p2wpkh());
1169 let events = nodes[1].node.get_and_clear_pending_msg_events();
1170 assert_eq!(events.len(), 1);
1172 MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
1173 assert_eq!(msg.contents.flags & 2, 2);
1175 _ => panic!("Unexpected event"),
1181 fn test_closing_signed_reinit_timeout() {
1182 do_test_closing_signed_reinit_timeout(TimeoutStep::AfterShutdown);
1183 do_test_closing_signed_reinit_timeout(TimeoutStep::AfterClosingSigned);
1184 do_test_closing_signed_reinit_timeout(TimeoutStep::NoTimeout);
1187 fn do_simple_legacy_shutdown_test(high_initiator_fee: bool) {
1188 // A simpe test of the legacy shutdown fee negotiation logic.
1189 let chanmon_cfgs = create_chanmon_cfgs(2);
1190 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1191 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1192 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1194 let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
1196 if high_initiator_fee {
1197 // If high_initiator_fee is set, set nodes[0]'s feerate significantly higher. This
1198 // shouldn't impact the flow at all given nodes[1] will happily accept the higher fee.
1199 let mut feerate_lock = chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap();
1200 *feerate_lock *= 10;
1203 nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[1].node.get_our_node_id()).unwrap();
1204 let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1205 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
1206 let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1207 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
1209 let mut node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
1210 node_0_closing_signed.fee_range = None;
1211 if high_initiator_fee {
1212 assert!(node_0_closing_signed.fee_satoshis > 500);
1214 assert!(node_0_closing_signed.fee_satoshis < 500);
1217 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
1218 let (_, mut node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
1219 node_1_closing_signed.as_mut().unwrap().fee_range = None;
1221 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap());
1222 let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
1223 assert!(node_0_none.is_none());
1224 check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
1225 check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id()], 100000);
1229 fn simple_legacy_shutdown_test() {
1230 do_simple_legacy_shutdown_test(false);
1231 do_simple_legacy_shutdown_test(true);
1235 fn simple_target_feerate_shutdown() {
1236 // Simple test of target in `close_channel_with_target_feerate`.
1237 let chanmon_cfgs = create_chanmon_cfgs(2);
1238 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1239 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1240 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1242 let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
1243 let chan_id = OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id();
1245 nodes[0].node.close_channel_with_feerate_and_script(&chan_id, &nodes[1].node.get_our_node_id(), Some(253 * 10), None).unwrap();
1246 let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1247 nodes[1].node.close_channel_with_feerate_and_script(&chan_id, &nodes[0].node.get_our_node_id(), Some(253 * 5), None).unwrap();
1248 let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1250 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
1251 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
1253 let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
1254 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
1255 let (_, node_1_closing_signed_opt) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
1256 let node_1_closing_signed = node_1_closing_signed_opt.unwrap();
1258 // nodes[1] was passed a target which was larger than the current channel feerate, which it
1259 // should ignore in favor of the channel fee, as there is no use demanding a minimum higher
1260 // than what will be paid on a force-close transaction. Note that we have to consider rounding,
1261 // so only check that we're within 10 sats.
1262 assert!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis >=
1263 node_1_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis * 10 - 5);
1264 assert!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis <=
1265 node_1_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis * 10 + 5);
1267 // Further, because nodes[0]'s target fee is larger than the `Normal` fee estimation plus our
1268 // force-closure-avoidance buffer, min should equal max, and the nodes[1]-selected fee should
1269 // be the nodes[0] only available fee.
1270 assert_eq!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis,
1271 node_0_closing_signed.fee_range.as_ref().unwrap().max_fee_satoshis);
1272 assert_eq!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis,
1273 node_0_closing_signed.fee_satoshis);
1274 assert_eq!(node_0_closing_signed.fee_satoshis, node_1_closing_signed.fee_satoshis);
1276 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
1277 let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
1278 assert!(node_0_none.is_none());
1279 check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
1280 check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id()], 100000);
1283 fn do_outbound_update_no_early_closing_signed(use_htlc: bool) {
1284 // Previously, if we have a pending inbound HTLC (or fee update) on a channel which has
1285 // initiated shutdown, we'd send our initial closing_signed immediately after receiving the
1286 // peer's last RAA to remove the HTLC/fee update, but before receiving their final
1287 // commitment_signed for a commitment without the HTLC/with the new fee. This caused at least
1288 // LDK peers to force-close as we initiated closing_signed prior to the channel actually being
1289 // fully empty of pending updates/HTLCs.
1290 let chanmon_cfgs = create_chanmon_cfgs(2);
1291 let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1292 let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1293 let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1295 let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2;
1297 send_payment(&nodes[0], &[&nodes[1]], 1_000_000);
1298 let payment_hash_opt = if use_htlc {
1299 Some(route_payment(&nodes[1], &[&nodes[0]], 10_000).1)
1305 nodes[0].node.fail_htlc_backwards(&payment_hash_opt.unwrap());
1306 expect_pending_htlcs_forwardable_and_htlc_handling_failed!(nodes[0],
1307 [HTLCDestination::FailedPayment { payment_hash: payment_hash_opt.unwrap() }]);
1309 *chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap() *= 10;
1310 nodes[0].node.timer_tick_occurred();
1312 let updates = get_htlc_update_msgs(&nodes[0], &nodes[1].node.get_our_node_id());
1313 check_added_monitors(&nodes[0], 1);
1315 nodes[1].node.close_channel(&chan_id, &nodes[0].node.get_our_node_id()).unwrap();
1316 let node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1317 nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap();
1318 let node_1_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1320 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_0_shutdown);
1321 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_1_shutdown);
1324 nodes[1].node.handle_update_fail_htlc(&nodes[0].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
1326 nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &updates.update_fee.unwrap());
1328 nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &updates.commitment_signed);
1329 check_added_monitors(&nodes[1], 1);
1330 let (bs_raa, bs_cs) = get_revoke_commit_msgs(&nodes[1], &nodes[0].node.get_our_node_id());
1332 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_raa);
1333 check_added_monitors(&nodes[0], 1);
1335 // At this point the Channel on nodes[0] has no record of any HTLCs but the latest
1336 // broadcastable commitment does contain the HTLC (but only the ChannelMonitor knows this).
1337 // Thus, the channel should not yet initiate closing_signed negotiation (but previously did).
1338 assert_eq!(nodes[0].node.get_and_clear_pending_msg_events(), Vec::new());
1340 chanmon_cfgs[0].persister.set_update_ret(ChannelMonitorUpdateStatus::InProgress);
1341 nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_cs);
1342 check_added_monitors(&nodes[0], 1);
1343 assert_eq!(nodes[0].node.get_and_clear_pending_msg_events(), Vec::new());
1345 expect_channel_shutdown_state!(nodes[0], chan_id, ChannelShutdownState::ResolvingHTLCs);
1346 assert_eq!(nodes[0].node.get_and_clear_pending_msg_events(), Vec::new());
1347 let (outpoint, latest_update, _) = nodes[0].chain_monitor.latest_monitor_update_id.lock().unwrap().get(&chan_id).unwrap().clone();
1348 nodes[0].chain_monitor.chain_monitor.force_channel_monitor_updated(outpoint, latest_update);
1350 let as_raa_closing_signed = nodes[0].node.get_and_clear_pending_msg_events();
1351 assert_eq!(as_raa_closing_signed.len(), 2);
1353 if let MessageSendEvent::SendRevokeAndACK { msg, .. } = &as_raa_closing_signed[0] {
1354 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &msg);
1355 check_added_monitors(&nodes[1], 1);
1357 expect_payment_failed!(nodes[1], payment_hash_opt.unwrap(), true);
1359 } else { panic!("Unexpected message {:?}", as_raa_closing_signed[0]); }
1361 if let MessageSendEvent::SendClosingSigned { msg, .. } = &as_raa_closing_signed[1] {
1362 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &msg);
1363 } else { panic!("Unexpected message {:?}", as_raa_closing_signed[1]); }
1365 let bs_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
1366 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &bs_closing_signed);
1367 let (_, as_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
1368 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &as_2nd_closing_signed.unwrap());
1369 let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
1370 assert!(node_1_none.is_none());
1372 check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
1373 check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id()], 100000);
1377 fn outbound_update_no_early_closing_signed() {
1378 do_outbound_update_no_early_closing_signed(true);
1379 do_outbound_update_no_early_closing_signed(false);
1383 fn batch_funding_failure() {
1384 // Provides test coverage of batch funding failure, which previously deadlocked
1385 let chanmon_cfgs = create_chanmon_cfgs(4);
1386 let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
1387 let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
1388 let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
1390 exchange_open_accept_chan(&nodes[0], &nodes[1], 1_000_000, 0);
1391 exchange_open_accept_chan(&nodes[0], &nodes[2], 1_000_000, 0);
1393 let events = nodes[0].node.get_and_clear_pending_events();
1394 assert_eq!(events.len(), 2);
1395 // Build a transaction which only has the output for one of the two channels we're trying to
1396 // confirm. Previously this led to a deadlock in channel closure handling.
1397 let mut tx = Transaction { version: 2, lock_time: LockTime::ZERO, input: Vec::new(), output: Vec::new() };
1398 let mut chans = Vec::new();
1399 for (idx, ev) in events.iter().enumerate() {
1400 if let Event::FundingGenerationReady { temporary_channel_id, counterparty_node_id, output_script, .. } = ev {
1402 tx.output.push(TxOut { value: 1_000_000, script_pubkey: output_script.clone() });
1404 chans.push((temporary_channel_id, counterparty_node_id));
1405 } else { panic!(); }
1408 // We should probably end up with an error for both channels, but currently we don't generate
1409 // an error for the failing channel itself.
1410 let err = "Error in transaction funding: Misuse error: No output matched the script_pubkey and value in the FundingGenerationReady event".to_string();
1411 let close = [ExpectedCloseEvent::from_id_reason(ChannelId::v1_from_funding_txid(tx.txid().as_ref(), 0), true, ClosureReason::ProcessingError { err })];
1413 nodes[0].node.batch_funding_transaction_generated(&chans, tx).unwrap_err();
1415 get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id());
1416 check_closed_events(&nodes[0], &close);
1417 assert_eq!(nodes[0].node.list_channels().len(), 0);