Work around LND bug 6039
[rust-lightning] / lightning / src / ln / shutdown_tests.rs
1 // This file is Copyright its original authors, visible in version control
2 // history.
3 //
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
8 // licenses.
9
10 //! Tests of our shutdown and closing_signed negotiation logic.
11
12 use crate::sign::{EntropySource, SignerProvider};
13 use crate::chain::transaction::OutPoint;
14 use crate::events::{Event, MessageSendEvent, MessageSendEventsProvider, ClosureReason};
15 use crate::ln::channelmanager::{self, PaymentSendFailure, PaymentId, RecipientOnionFields, ChannelShutdownState, ChannelDetails};
16 use crate::routing::router::{PaymentParameters, get_route};
17 use crate::ln::msgs;
18 use crate::ln::msgs::{ChannelMessageHandler, ErrorAction};
19 use crate::ln::script::ShutdownScript;
20 use crate::util::test_utils;
21 use crate::util::test_utils::OnGetShutdownScriptpubkey;
22 use crate::util::errors::APIError;
23 use crate::util::config::UserConfig;
24 use crate::util::string::UntrustedString;
25
26 use bitcoin::blockdata::script::Builder;
27 use bitcoin::blockdata::opcodes;
28 use bitcoin::network::constants::Network;
29 use bitcoin::util::address::WitnessVersion;
30
31 use regex;
32
33 use core::default::Default;
34 use std::convert::TryFrom;
35
36 use crate::ln::functional_test_utils::*;
37
38 #[test]
39 fn pre_funding_lock_shutdown_test() {
40         // Test sending a shutdown prior to channel_ready after funding generation
41         let chanmon_cfgs = create_chanmon_cfgs(2);
42         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
43         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
44         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
45         let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 8000000, 0);
46         mine_transaction(&nodes[0], &tx);
47         mine_transaction(&nodes[1], &tx);
48
49         nodes[0].node.close_channel(&OutPoint { txid: tx.txid(), index: 0 }.to_channel_id(), &nodes[1].node.get_our_node_id()).unwrap();
50         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
51         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
52         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
53         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
54
55         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
56         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
57         let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
58         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
59         let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
60         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
61         let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
62         assert!(node_1_none.is_none());
63
64         assert!(nodes[0].node.list_channels().is_empty());
65         assert!(nodes[1].node.list_channels().is_empty());
66         check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 8000000);
67         check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id()], 8000000);
68 }
69
70 #[test]
71 fn expect_channel_shutdown_state() {
72         // Test sending a shutdown prior to channel_ready after funding generation
73         let chanmon_cfgs = create_chanmon_cfgs(2);
74         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
75         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
76         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
77         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
78
79         expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NotShuttingDown);
80
81         nodes[0].node.close_channel(&chan_1.2, &nodes[1].node.get_our_node_id()).unwrap();
82
83         expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ShutdownInitiated);
84         expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NotShuttingDown);
85
86         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
87         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
88
89         // node1 goes into NegotiatingClosingFee since there are no HTLCs in flight, note that it
90         // doesnt mean that node1 has sent/recved its closing signed message
91         expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ShutdownInitiated);
92         expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NegotiatingClosingFee);
93
94         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
95         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
96
97         expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NegotiatingClosingFee);
98         expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NegotiatingClosingFee);
99
100         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
101         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
102         let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
103         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
104         let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
105         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
106         let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
107         assert!(node_1_none.is_none());
108
109         assert!(nodes[0].node.list_channels().is_empty());
110         assert!(nodes[1].node.list_channels().is_empty());
111         check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
112         check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id()], 100000);
113 }
114
115 #[test]
116 fn expect_channel_shutdown_state_with_htlc() {
117         // Test sending a shutdown with outstanding updates pending.
118         let chanmon_cfgs = create_chanmon_cfgs(3);
119         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
120         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
121         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
122         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
123         let _chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
124
125         let (payment_preimage_0, payment_hash_0, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000);
126
127         expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NotShuttingDown);
128         expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NotShuttingDown);
129
130         nodes[0].node.close_channel(&chan_1.2, &nodes[1].node.get_our_node_id()).unwrap();
131
132         expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ShutdownInitiated);
133         expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NotShuttingDown);
134
135         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
136         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
137
138         expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ShutdownInitiated);
139         expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::ResolvingHTLCs);
140
141         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
142         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
143
144         expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ResolvingHTLCs);
145         expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::ResolvingHTLCs);
146
147         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
148         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
149
150         // Claim Funds on Node2
151         nodes[2].node.claim_funds(payment_preimage_0);
152         check_added_monitors!(nodes[2], 1);
153         expect_payment_claimed!(nodes[2], payment_hash_0, 100_000);
154
155         // Fulfil HTLCs on node1 and node0
156         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
157         assert!(updates.update_add_htlcs.is_empty());
158         assert!(updates.update_fail_htlcs.is_empty());
159         assert!(updates.update_fail_malformed_htlcs.is_empty());
160         assert!(updates.update_fee.is_none());
161         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
162         nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
163         expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false);
164         check_added_monitors!(nodes[1], 1);
165         let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
166         commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false);
167
168         // Still in "resolvingHTLCs" on chan1 after htlc removed on chan2
169         expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::ResolvingHTLCs);
170         expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::ResolvingHTLCs);
171
172         assert!(updates_2.update_add_htlcs.is_empty());
173         assert!(updates_2.update_fail_htlcs.is_empty());
174         assert!(updates_2.update_fail_malformed_htlcs.is_empty());
175         assert!(updates_2.update_fee.is_none());
176         assert_eq!(updates_2.update_fulfill_htlcs.len(), 1);
177         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]);
178         commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
179         expect_payment_sent!(nodes[0], payment_preimage_0);
180
181         // all htlcs removed, chan1 advances to NegotiatingClosingFee
182         expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NegotiatingClosingFee);
183         expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NegotiatingClosingFee);
184
185         // ClosingSignNegotion process
186         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
187         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
188         let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
189         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
190         let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
191         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
192         let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
193         assert!(node_1_none.is_none());
194         check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
195         check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id()], 100000);
196
197         // Shutdown basically removes the channelDetails, testing of shutdowncomplete state unnecessary
198         assert!(nodes[0].node.list_channels().is_empty());
199 }
200
201 #[test]
202 fn test_lnd_bug_6039() {
203         // LND sends a nonsense error message any time it gets a shutdown if there are still HTLCs
204         // pending. We currently swallow that error to work around LND's bug #6039. This test emulates
205         // the LND nonsense and ensures we at least kinda handle it.
206         let chanmon_cfgs = create_chanmon_cfgs(2);
207         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
208         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
209         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
210         let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
211
212         let (payment_preimage, payment_hash, _) = route_payment(&nodes[0], &[&nodes[1]], 100_000);
213
214         nodes[0].node.close_channel(&chan.2, &nodes[1].node.get_our_node_id()).unwrap();
215         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
216         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
217
218         // Generate an lnd-like error message and check that we respond by simply screaming louder to
219         // see if LND will accept our protocol compliance.
220         let err_msg = msgs::ErrorMessage { channel_id: chan.2, data: "link failed to shutdown".to_string() };
221         nodes[0].node.handle_error(&nodes[1].node.get_our_node_id(), &err_msg);
222         let _node_0_repeated_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
223
224         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
225
226         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
227         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
228
229         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage);
230
231         // Assume that LND will eventually respond to our Shutdown if we clear all the remaining HTLCs
232         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
233
234         // ClosingSignNegotion process
235         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
236         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
237         let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
238         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
239         let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
240         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
241         let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
242         assert!(node_1_none.is_none());
243         check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
244         check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id()], 100000);
245
246         // Shutdown basically removes the channelDetails, testing of shutdowncomplete state unnecessary
247         assert!(nodes[0].node.list_channels().is_empty());
248 }
249
250 #[test]
251 fn expect_channel_shutdown_state_with_force_closure() {
252         // Test sending a shutdown prior to channel_ready after funding generation
253         let chanmon_cfgs = create_chanmon_cfgs(2);
254         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
255         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
256         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
257         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
258
259         expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NotShuttingDown);
260         expect_channel_shutdown_state!(nodes[1], chan_1.2, ChannelShutdownState::NotShuttingDown);
261
262         nodes[1].node.force_close_broadcasting_latest_txn(&chan_1.2, &nodes[0].node.get_our_node_id()).unwrap();
263         check_closed_broadcast!(nodes[1], true);
264         check_added_monitors!(nodes[1], 1);
265
266         expect_channel_shutdown_state!(nodes[0], chan_1.2, ChannelShutdownState::NotShuttingDown);
267         assert!(nodes[1].node.list_channels().is_empty());
268
269         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().split_off(0);
270         assert_eq!(node_txn.len(), 1);
271         check_spends!(node_txn[0], chan_1.3);
272         mine_transaction(&nodes[0], &node_txn[0]);
273         check_added_monitors!(nodes[0], 1);
274
275         assert!(nodes[0].node.list_channels().is_empty());
276         assert!(nodes[1].node.list_channels().is_empty());
277         check_closed_broadcast!(nodes[0], true);
278         check_closed_event!(nodes[0], 1, ClosureReason::CommitmentTxConfirmed, [nodes[1].node.get_our_node_id()], 100000);
279         check_closed_event!(nodes[1], 1, ClosureReason::HolderForceClosed, [nodes[0].node.get_our_node_id()], 100000);
280 }
281
282 #[test]
283 fn updates_shutdown_wait() {
284         // Test sending a shutdown with outstanding updates pending
285         let chanmon_cfgs = create_chanmon_cfgs(3);
286         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
287         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
288         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
289         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
290         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
291         let logger = test_utils::TestLogger::new();
292         let scorer = test_utils::TestScorer::new();
293         let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
294         let random_seed_bytes = keys_manager.get_secure_random_bytes();
295
296         let (payment_preimage_0, payment_hash_0, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000);
297
298         nodes[0].node.close_channel(&chan_1.2, &nodes[1].node.get_our_node_id()).unwrap();
299         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
300         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
301         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
302         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
303
304         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
305         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
306
307         let (_, payment_hash, payment_secret) = get_payment_preimage_hash!(nodes[0]);
308
309         let payment_params_1 = PaymentParameters::from_node_id(nodes[1].node.get_our_node_id(), TEST_FINAL_CLTV).with_bolt11_features(nodes[1].node.invoice_features()).unwrap();
310         let route_1 = get_route(&nodes[0].node.get_our_node_id(), &payment_params_1, &nodes[0].network_graph.read_only(), None, 100000, &logger, &scorer, &(), &random_seed_bytes).unwrap();
311         let payment_params_2 = PaymentParameters::from_node_id(nodes[0].node.get_our_node_id(), TEST_FINAL_CLTV).with_bolt11_features(nodes[0].node.invoice_features()).unwrap();
312         let route_2 = get_route(&nodes[1].node.get_our_node_id(), &payment_params_2, &nodes[1].network_graph.read_only(), None, 100000, &logger, &scorer, &(), &random_seed_bytes).unwrap();
313         unwrap_send_err!(nodes[0].node.send_payment_with_route(&route_1, payment_hash,
314                         RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)
315                 ), true, APIError::ChannelUnavailable {..}, {});
316         unwrap_send_err!(nodes[1].node.send_payment_with_route(&route_2, payment_hash,
317                         RecipientOnionFields::secret_only(payment_secret), PaymentId(payment_hash.0)
318                 ), true, APIError::ChannelUnavailable {..}, {});
319
320         nodes[2].node.claim_funds(payment_preimage_0);
321         check_added_monitors!(nodes[2], 1);
322         expect_payment_claimed!(nodes[2], payment_hash_0, 100_000);
323
324         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
325         assert!(updates.update_add_htlcs.is_empty());
326         assert!(updates.update_fail_htlcs.is_empty());
327         assert!(updates.update_fail_malformed_htlcs.is_empty());
328         assert!(updates.update_fee.is_none());
329         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
330         nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
331         expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false);
332         check_added_monitors!(nodes[1], 1);
333         let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
334         commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false);
335
336         assert!(updates_2.update_add_htlcs.is_empty());
337         assert!(updates_2.update_fail_htlcs.is_empty());
338         assert!(updates_2.update_fail_malformed_htlcs.is_empty());
339         assert!(updates_2.update_fee.is_none());
340         assert_eq!(updates_2.update_fulfill_htlcs.len(), 1);
341         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]);
342         commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
343         expect_payment_sent!(nodes[0], payment_preimage_0);
344
345         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
346         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
347         let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
348         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
349         let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
350         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
351         let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
352         assert!(node_1_none.is_none());
353         check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
354         check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id()], 100000);
355
356         assert!(nodes[0].node.list_channels().is_empty());
357
358         assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
359         nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
360         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
361         assert!(nodes[1].node.list_channels().is_empty());
362         assert!(nodes[2].node.list_channels().is_empty());
363         check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[2].node.get_our_node_id()], 100000);
364         check_closed_event!(nodes[2], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
365 }
366
367 #[test]
368 fn htlc_fail_async_shutdown() {
369         // Test HTLCs fail if shutdown starts even if messages are delivered out-of-order
370         let chanmon_cfgs = create_chanmon_cfgs(3);
371         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
372         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
373         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
374         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
375         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
376
377         let (route, our_payment_hash, _, our_payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], 100000);
378         nodes[0].node.send_payment_with_route(&route, our_payment_hash,
379                 RecipientOnionFields::secret_only(our_payment_secret), PaymentId(our_payment_hash.0)).unwrap();
380         check_added_monitors!(nodes[0], 1);
381         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
382         assert_eq!(updates.update_add_htlcs.len(), 1);
383         assert!(updates.update_fulfill_htlcs.is_empty());
384         assert!(updates.update_fail_htlcs.is_empty());
385         assert!(updates.update_fail_malformed_htlcs.is_empty());
386         assert!(updates.update_fee.is_none());
387
388         nodes[1].node.close_channel(&chan_1.2, &nodes[0].node.get_our_node_id()).unwrap();
389         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
390         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
391         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
392
393         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
394         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &updates.commitment_signed);
395         check_added_monitors!(nodes[1], 1);
396         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
397         commitment_signed_dance!(nodes[1], nodes[0], (), false, true, false);
398
399         let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
400         assert!(updates_2.update_add_htlcs.is_empty());
401         assert!(updates_2.update_fulfill_htlcs.is_empty());
402         assert_eq!(updates_2.update_fail_htlcs.len(), 1);
403         assert!(updates_2.update_fail_malformed_htlcs.is_empty());
404         assert!(updates_2.update_fee.is_none());
405
406         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fail_htlcs[0]);
407         commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
408
409         expect_payment_failed_with_update!(nodes[0], our_payment_hash, false, chan_2.0.contents.short_channel_id, true);
410
411         let msg_events = nodes[0].node.get_and_clear_pending_msg_events();
412         assert_eq!(msg_events.len(), 1);
413         let node_0_closing_signed = match msg_events[0] {
414                 MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => {
415                         assert_eq!(*node_id, nodes[1].node.get_our_node_id());
416                         (*msg).clone()
417                 },
418                 _ => panic!("Unexpected event"),
419         };
420
421         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
422         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
423         let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
424         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
425         let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
426         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
427         let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
428         assert!(node_1_none.is_none());
429
430         assert!(nodes[0].node.list_channels().is_empty());
431
432         assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
433         nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
434         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
435         assert!(nodes[1].node.list_channels().is_empty());
436         assert!(nodes[2].node.list_channels().is_empty());
437         check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
438         check_closed_event!(nodes[1], 2, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id(), nodes[2].node.get_our_node_id()], 100000);
439         check_closed_event!(nodes[2], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
440 }
441
442 fn do_test_shutdown_rebroadcast(recv_count: u8) {
443         // Test that shutdown/closing_signed is re-sent on reconnect with a variable number of
444         // messages delivered prior to disconnect
445         let chanmon_cfgs = create_chanmon_cfgs(3);
446         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
447         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
448         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
449         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1);
450         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2);
451
452         let (payment_preimage, payment_hash, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100_000);
453
454         nodes[1].node.close_channel(&chan_1.2, &nodes[0].node.get_our_node_id()).unwrap();
455         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
456         if recv_count > 0 {
457                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
458                 let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
459                 if recv_count > 1 {
460                         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
461                 }
462         }
463
464         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id());
465         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id());
466
467         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init {
468                 features: nodes[1].node.init_features(), networks: None, remote_network_address: None
469         }, true).unwrap();
470         let node_0_reestablish = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap();
471         nodes[1].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
473         }, false).unwrap();
474         let node_1_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap();
475
476         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &node_0_reestablish);
477         let node_1_2nd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
478         assert!(node_1_shutdown == node_1_2nd_shutdown);
479
480         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &node_1_reestablish);
481         let node_0_2nd_shutdown = if recv_count > 0 {
482                 let node_0_2nd_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
483                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown);
484                 node_0_2nd_shutdown
485         } else {
486                 let node_0_chan_update = get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id());
487                 assert_eq!(node_0_chan_update.contents.flags & 2, 0); // "disabled" flag must not be set as we just reconnected.
488                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown);
489                 get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id())
490         };
491         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_2nd_shutdown);
492
493         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
494         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
495
496         nodes[2].node.claim_funds(payment_preimage);
497         check_added_monitors!(nodes[2], 1);
498         expect_payment_claimed!(nodes[2], payment_hash, 100_000);
499
500         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
501         assert!(updates.update_add_htlcs.is_empty());
502         assert!(updates.update_fail_htlcs.is_empty());
503         assert!(updates.update_fail_malformed_htlcs.is_empty());
504         assert!(updates.update_fee.is_none());
505         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
506         nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
507         expect_payment_forwarded!(nodes[1], nodes[0], nodes[2], Some(1000), false, false);
508         check_added_monitors!(nodes[1], 1);
509         let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
510         commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false);
511
512         assert!(updates_2.update_add_htlcs.is_empty());
513         assert!(updates_2.update_fail_htlcs.is_empty());
514         assert!(updates_2.update_fail_malformed_htlcs.is_empty());
515         assert!(updates_2.update_fee.is_none());
516         assert_eq!(updates_2.update_fulfill_htlcs.len(), 1);
517         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]);
518         commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
519         expect_payment_sent!(nodes[0], payment_preimage);
520
521         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
522         if recv_count > 0 {
523                 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
524                 let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
525                 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
526                 let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
527                 assert!(node_0_2nd_closing_signed.is_some());
528         }
529
530         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id());
531         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id());
532
533         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init {
534                 features: nodes[0].node.init_features(), networks: None, remote_network_address: None
535         }, true).unwrap();
536         let node_1_2nd_reestablish = get_chan_reestablish_msgs!(nodes[1], nodes[0]).pop().unwrap();
537         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init {
538                 features: nodes[1].node.init_features(), networks: None, remote_network_address: None
539         }, false).unwrap();
540         if recv_count == 0 {
541                 // If all closing_signeds weren't delivered we can just resume where we left off...
542                 let node_0_2nd_reestablish = get_chan_reestablish_msgs!(nodes[0], nodes[1]).pop().unwrap();
543
544                 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &node_1_2nd_reestablish);
545                 let node_0_msgs = nodes[0].node.get_and_clear_pending_msg_events();
546                 assert_eq!(node_0_msgs.len(), 2);
547                 let node_0_2nd_closing_signed = match node_0_msgs[1] {
548                         MessageSendEvent::SendClosingSigned { ref msg, .. } => {
549                                 assert_eq!(node_0_closing_signed, *msg);
550                                 msg.clone()
551                         },
552                         _ => panic!(),
553                 };
554
555                 let node_0_3rd_shutdown = match node_0_msgs[0] {
556                         MessageSendEvent::SendShutdown { ref msg, .. } => {
557                                 assert_eq!(node_0_2nd_shutdown, *msg);
558                                 msg.clone()
559                         },
560                         _ => panic!(),
561                 };
562                 assert!(node_0_2nd_shutdown == node_0_3rd_shutdown);
563
564                 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &node_0_2nd_reestablish);
565                 let node_1_3rd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
566                 assert!(node_1_3rd_shutdown == node_1_2nd_shutdown);
567
568                 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_3rd_shutdown);
569                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
570
571                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_3rd_shutdown);
572
573                 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed);
574                 let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
575                 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
576                 let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
577                 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
578                 let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
579                 assert!(node_1_none.is_none());
580                 check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id()], 100000);
581         } else {
582                 // If one node, however, received + responded with an identical closing_signed we end
583                 // up erroring and node[0] will try to broadcast its own latest commitment transaction.
584                 // There isn't really anything better we can do simply, but in the future we might
585                 // explore storing a set of recently-closed channels that got disconnected during
586                 // closing_signed and avoiding broadcasting local commitment txn for some timeout to
587                 // give our counterparty enough time to (potentially) broadcast a cooperative closing
588                 // transaction.
589                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
590
591                 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &node_1_2nd_reestablish);
592                 let msg_events = nodes[0].node.get_and_clear_pending_msg_events();
593                 assert_eq!(msg_events.len(), 1);
594                 if let MessageSendEvent::HandleError { ref action, .. } = msg_events[0] {
595                         match action {
596                                 &ErrorAction::SendErrorMessage { ref msg } => {
597                                         nodes[1].node.handle_error(&nodes[0].node.get_our_node_id(), &msg);
598                                         assert_eq!(msg.channel_id, chan_1.2);
599                                 },
600                                 _ => panic!("Unexpected event!"),
601                         }
602                 } else { panic!("Needed SendErrorMessage close"); }
603
604                 // get_closing_signed_broadcast usually eats the BroadcastChannelUpdate for us and
605                 // checks it, but in this case nodes[1] didn't ever get a chance to receive a
606                 // closing_signed so we do it ourselves
607                 check_closed_broadcast!(nodes[1], false);
608                 check_added_monitors!(nodes[1], 1);
609                 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())) }
610                         , [nodes[0].node.get_our_node_id()], 100000);
611         }
612
613         assert!(nodes[0].node.list_channels().is_empty());
614
615         assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
616         nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
617         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
618         assert!(nodes[1].node.list_channels().is_empty());
619         assert!(nodes[2].node.list_channels().is_empty());
620         check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
621         check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[2].node.get_our_node_id()], 100000);
622         check_closed_event!(nodes[2], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
623 }
624
625 #[test]
626 fn test_shutdown_rebroadcast() {
627         do_test_shutdown_rebroadcast(0);
628         do_test_shutdown_rebroadcast(1);
629         do_test_shutdown_rebroadcast(2);
630 }
631
632 #[test]
633 fn test_upfront_shutdown_script() {
634         // BOLT 2 : Option upfront shutdown script, if peer commit its closing_script at channel opening
635         // enforce it at shutdown message
636
637         let mut config = UserConfig::default();
638         config.channel_handshake_config.announced_channel = true;
639         config.channel_handshake_limits.force_announced_channel_preference = false;
640         config.channel_handshake_config.commit_upfront_shutdown_pubkey = false;
641         let user_cfgs = [None, Some(config), None];
642         let chanmon_cfgs = create_chanmon_cfgs(3);
643         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
644         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
645         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
646
647         // We test that in case of peer committing upfront to a script, if it changes at closing, we refuse to sign
648         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1000000, 1000000);
649         nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[2].node.get_our_node_id()).unwrap();
650         let node_0_orig_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id());
651         let mut node_0_shutdown = node_0_orig_shutdown.clone();
652         node_0_shutdown.scriptpubkey = Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script().to_p2sh();
653         // Test we enforce upfront_scriptpbukey if by providing a different one at closing that we warn
654         // the peer and ignore the message.
655         nodes[2].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
656         assert!(regex::Regex::new(r"Got shutdown request with a scriptpubkey \([A-Fa-f0-9]+\) which did not match their previous scriptpubkey.")
657                         .unwrap().is_match(&check_warn_msg!(nodes[2], nodes[0].node.get_our_node_id(), chan.2)));
658         // This allows nodes[2] to retry the shutdown message, which should get a response:
659         nodes[2].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_orig_shutdown);
660         get_event_msg!(nodes[2], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
661
662         // We test that in case of peer committing upfront to a script, if it doesn't change at closing, we sign
663         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1000000, 1000000);
664         nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[2].node.get_our_node_id()).unwrap();
665         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id());
666         // We test that in case of peer committing upfront to a script, if it oesn't change at closing, we sign
667         nodes[2].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
668         let events = nodes[2].node.get_and_clear_pending_msg_events();
669         assert_eq!(events.len(), 1);
670         match events[0] {
671                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[0].node.get_our_node_id()) }
672                 _ => panic!("Unexpected event"),
673         }
674
675         // We test that if case of peer non-signaling we don't enforce committed script at channel opening
676         *nodes[0].override_init_features.borrow_mut() = Some(nodes[0].node.init_features().clear_upfront_shutdown_script());
677         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000);
678         nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[1].node.get_our_node_id()).unwrap();
679         let node_1_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
680         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_1_shutdown);
681         check_added_monitors!(nodes[1], 1);
682         let events = nodes[1].node.get_and_clear_pending_msg_events();
683         assert_eq!(events.len(), 1);
684         match events[0] {
685                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[0].node.get_our_node_id()) }
686                 _ => panic!("Unexpected event"),
687         }
688
689         // We test that if user opt-out, we provide a zero-length script at channel opening and we are able to close
690         // channel smoothly, opt-out is from channel initiator here
691         *nodes[0].override_init_features.borrow_mut() = None;
692         let chan = create_announced_chan_between_nodes_with_value(&nodes, 1, 0, 1000000, 1000000);
693         nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[0].node.get_our_node_id()).unwrap();
694         check_added_monitors!(nodes[1], 1);
695         let node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
696         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_0_shutdown);
697         let events = nodes[0].node.get_and_clear_pending_msg_events();
698         assert_eq!(events.len(), 1);
699         match events[0] {
700                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
701                 _ => panic!("Unexpected event"),
702         }
703
704         //// We test that if user opt-out, we provide a zero-length script at channel opening and we are able to close
705         //// channel smoothly
706         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000);
707         nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[0].node.get_our_node_id()).unwrap();
708         check_added_monitors!(nodes[1], 1);
709         let node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
710         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_0_shutdown);
711         let events = nodes[0].node.get_and_clear_pending_msg_events();
712         assert_eq!(events.len(), 2);
713         match events[0] {
714                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
715                 _ => panic!("Unexpected event"),
716         }
717         match events[1] {
718                 MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
719                 _ => panic!("Unexpected event"),
720         }
721 }
722
723 #[test]
724 fn test_unsupported_anysegwit_upfront_shutdown_script() {
725         let chanmon_cfgs = create_chanmon_cfgs(2);
726         let mut node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
727         // Clear shutdown_anysegwit on initiator
728         *node_cfgs[0].override_init_features.borrow_mut() = Some(channelmanager::provided_init_features(&test_default_channel_config()).clear_shutdown_anysegwit());
729         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
730         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
731
732         // Use a non-v0 segwit script supported by option_shutdown_anysegwit
733         let anysegwit_shutdown_script = Builder::new()
734                 .push_int(16)
735                 .push_slice(&[0, 40])
736                 .into_script();
737
738         // Check script when handling an open_channel message
739         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None).unwrap();
740         let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
741         open_channel.shutdown_scriptpubkey = Some(anysegwit_shutdown_script.clone());
742         nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), &open_channel);
743
744         let events = nodes[1].node.get_and_clear_pending_msg_events();
745         assert_eq!(events.len(), 1);
746         match events[0] {
747                 MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id } => {
748                         assert_eq!(node_id, nodes[0].node.get_our_node_id());
749                         assert_eq!(msg.data, "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: Script(OP_PUSHNUM_16 OP_PUSHBYTES_2 0028)");
750                 },
751                 _ => panic!("Unexpected event"),
752         }
753
754         let chanmon_cfgs = create_chanmon_cfgs(2);
755         let mut node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
756         // Clear shutdown_anysegwit on responder
757         *node_cfgs[1].override_init_features.borrow_mut() = Some(channelmanager::provided_init_features(&test_default_channel_config()).clear_shutdown_anysegwit());
758         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
759         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
760
761         // Check script when handling an accept_channel message
762         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None).unwrap();
763         let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
764         nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), &open_channel);
765         let mut accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
766         accept_channel.shutdown_scriptpubkey = Some(anysegwit_shutdown_script.clone());
767         nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), &accept_channel);
768
769         let events = nodes[0].node.get_and_clear_pending_msg_events();
770         assert_eq!(events.len(), 1);
771         match events[0] {
772                 MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id } => {
773                         assert_eq!(node_id, nodes[1].node.get_our_node_id());
774                         assert_eq!(msg.data, "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: Script(OP_PUSHNUM_16 OP_PUSHBYTES_2 0028)");
775                 },
776                 _ => panic!("Unexpected event"),
777         }
778         check_closed_event!(nodes[0], 1, ClosureReason::ProcessingError { err: "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: Script(OP_PUSHNUM_16 OP_PUSHBYTES_2 0028)".to_string() }
779                 , [nodes[1].node.get_our_node_id()], 100000);
780 }
781
782 #[test]
783 fn test_invalid_upfront_shutdown_script() {
784         let chanmon_cfgs = create_chanmon_cfgs(2);
785         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
786         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
787         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
788
789         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None).unwrap();
790
791         // Use a segwit v0 script with an unsupported witness program
792         let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
793         open_channel.shutdown_scriptpubkey = Some(Builder::new().push_int(0)
794                 .push_slice(&[0, 0])
795                 .into_script());
796         nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), &open_channel);
797
798         let events = nodes[1].node.get_and_clear_pending_msg_events();
799         assert_eq!(events.len(), 1);
800         match events[0] {
801                 MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id } => {
802                         assert_eq!(node_id, nodes[0].node.get_our_node_id());
803                         assert_eq!(msg.data, "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: Script(OP_0 OP_PUSHBYTES_2 0000)");
804                 },
805                 _ => panic!("Unexpected event"),
806         }
807 }
808
809 #[test]
810 fn test_segwit_v0_shutdown_script() {
811         let mut config = UserConfig::default();
812         config.channel_handshake_config.announced_channel = true;
813         config.channel_handshake_limits.force_announced_channel_preference = false;
814         config.channel_handshake_config.commit_upfront_shutdown_pubkey = false;
815         let user_cfgs = [None, Some(config), None];
816         let chanmon_cfgs = create_chanmon_cfgs(3);
817         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
818         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
819         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
820
821         let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
822         nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[0].node.get_our_node_id()).unwrap();
823         check_added_monitors!(nodes[1], 1);
824
825         // Use a segwit v0 script supported even without option_shutdown_anysegwit
826         let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
827         node_0_shutdown.scriptpubkey = Builder::new().push_int(0)
828                 .push_slice(&[0; 20])
829                 .into_script();
830         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_0_shutdown);
831
832         let events = nodes[0].node.get_and_clear_pending_msg_events();
833         assert_eq!(events.len(), 2);
834         match events[0] {
835                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
836                 _ => panic!("Unexpected event"),
837         }
838         match events[1] {
839                 MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
840                 _ => panic!("Unexpected event"),
841         }
842 }
843
844 #[test]
845 fn test_anysegwit_shutdown_script() {
846         let mut config = UserConfig::default();
847         config.channel_handshake_config.announced_channel = true;
848         config.channel_handshake_limits.force_announced_channel_preference = false;
849         config.channel_handshake_config.commit_upfront_shutdown_pubkey = false;
850         let user_cfgs = [None, Some(config), None];
851         let chanmon_cfgs = create_chanmon_cfgs(3);
852         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
853         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
854         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
855
856         let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
857         nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[0].node.get_our_node_id()).unwrap();
858         check_added_monitors!(nodes[1], 1);
859
860         // Use a non-v0 segwit script supported by option_shutdown_anysegwit
861         let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
862         node_0_shutdown.scriptpubkey = Builder::new().push_int(16)
863                 .push_slice(&[0, 0])
864                 .into_script();
865         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_0_shutdown);
866
867         let events = nodes[0].node.get_and_clear_pending_msg_events();
868         assert_eq!(events.len(), 2);
869         match events[0] {
870                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
871                 _ => panic!("Unexpected event"),
872         }
873         match events[1] {
874                 MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
875                 _ => panic!("Unexpected event"),
876         }
877 }
878
879 #[test]
880 fn test_unsupported_anysegwit_shutdown_script() {
881         let mut config = UserConfig::default();
882         config.channel_handshake_config.announced_channel = true;
883         config.channel_handshake_limits.force_announced_channel_preference = false;
884         config.channel_handshake_config.commit_upfront_shutdown_pubkey = false;
885         let user_cfgs = [None, Some(config), None];
886         let chanmon_cfgs = create_chanmon_cfgs(3);
887         let mut node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
888         *node_cfgs[0].override_init_features.borrow_mut() = Some(channelmanager::provided_init_features(&config).clear_shutdown_anysegwit());
889         *node_cfgs[1].override_init_features.borrow_mut() = Some(channelmanager::provided_init_features(&config).clear_shutdown_anysegwit());
890         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
891         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
892
893         // Check that using an unsupported shutdown script fails and a supported one succeeds.
894         let supported_shutdown_script = chanmon_cfgs[1].keys_manager.get_shutdown_scriptpubkey().unwrap();
895         let unsupported_shutdown_script =
896                 ShutdownScript::new_witness_program(WitnessVersion::V16, &[0, 40]).unwrap();
897         chanmon_cfgs[1].keys_manager
898                 .expect(OnGetShutdownScriptpubkey { returns: unsupported_shutdown_script.clone() })
899                 .expect(OnGetShutdownScriptpubkey { returns: supported_shutdown_script });
900
901         let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
902         match nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[0].node.get_our_node_id()) {
903                 Err(APIError::IncompatibleShutdownScript { script }) => {
904                         assert_eq!(script.into_inner(), unsupported_shutdown_script.clone().into_inner());
905                 },
906                 Err(e) => panic!("Unexpected error: {:?}", e),
907                 Ok(_) => panic!("Expected error"),
908         }
909         nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[0].node.get_our_node_id()).unwrap();
910         check_added_monitors!(nodes[1], 1);
911
912         // Use a non-v0 segwit script unsupported without option_shutdown_anysegwit
913         let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
914         node_0_shutdown.scriptpubkey = unsupported_shutdown_script.into_inner();
915         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_0_shutdown);
916
917         assert_eq!(&check_warn_msg!(nodes[0], nodes[1].node.get_our_node_id(), chan.2),
918                         "Got a nonstandard scriptpubkey (60020028) from remote peer");
919 }
920
921 #[test]
922 fn test_invalid_shutdown_script() {
923         let mut config = UserConfig::default();
924         config.channel_handshake_config.announced_channel = true;
925         config.channel_handshake_limits.force_announced_channel_preference = false;
926         config.channel_handshake_config.commit_upfront_shutdown_pubkey = false;
927         let user_cfgs = [None, Some(config), None];
928         let chanmon_cfgs = create_chanmon_cfgs(3);
929         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
930         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
931         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
932
933         let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
934         nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[0].node.get_our_node_id()).unwrap();
935         check_added_monitors!(nodes[1], 1);
936
937         // Use a segwit v0 script with an unsupported witness program
938         let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
939         node_0_shutdown.scriptpubkey = Builder::new().push_int(0)
940                 .push_slice(&[0, 0])
941                 .into_script();
942         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_0_shutdown);
943
944         assert_eq!(&check_warn_msg!(nodes[0], nodes[1].node.get_our_node_id(), chan.2),
945                         "Got a nonstandard scriptpubkey (00020000) from remote peer");
946 }
947
948 #[test]
949 fn test_user_shutdown_script() {
950         let mut config = test_default_channel_config();
951         config.channel_handshake_config.announced_channel = true;
952         config.channel_handshake_limits.force_announced_channel_preference = false;
953         config.channel_handshake_config.commit_upfront_shutdown_pubkey = false;
954         let user_cfgs = [None, Some(config), None];
955         let chanmon_cfgs = create_chanmon_cfgs(3);
956         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
957         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
958         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
959
960         // Segwit v0 script of the form OP_0 <20-byte hash>
961         let script = Builder::new().push_int(0)
962                 .push_slice(&[0; 20])
963                 .into_script();
964
965         let shutdown_script = ShutdownScript::try_from(script.clone()).unwrap();
966
967         let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
968         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();
969         check_added_monitors!(nodes[1], 1);
970
971         let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
972
973         assert_eq!(node_0_shutdown.scriptpubkey, script);
974 }
975
976 #[test]
977 fn test_already_set_user_shutdown_script() {
978         let mut config = test_default_channel_config();
979         config.channel_handshake_config.announced_channel = true;
980         config.channel_handshake_limits.force_announced_channel_preference = false;
981         let user_cfgs = [None, Some(config), None];
982         let chanmon_cfgs = create_chanmon_cfgs(3);
983         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
984         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
985         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
986
987         // Segwit v0 script of the form OP_0 <20-byte hash>
988         let script = Builder::new().push_int(0)
989                 .push_slice(&[0; 20])
990                 .into_script();
991
992         let shutdown_script = ShutdownScript::try_from(script).unwrap();
993
994         let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
995         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));
996
997         assert_eq!(result, Err(APIError::APIMisuseError { err: "Cannot override shutdown script for a channel with one already set".to_string() }));
998 }
999
1000 #[derive(PartialEq)]
1001 enum TimeoutStep {
1002         AfterShutdown,
1003         AfterClosingSigned,
1004         NoTimeout,
1005 }
1006
1007 fn do_test_closing_signed_reinit_timeout(timeout_step: TimeoutStep) {
1008         // The range-based closing signed negotiation allows the funder to restart the process with a
1009         // new range if the previous range did not overlap. This allows implementations to request user
1010         // intervention allowing users to enter a new fee range. We do not implement the sending side
1011         // of this, instead opting to allow users to enter an explicit "willing to pay up to X to avoid
1012         // force-closing" value and relying on that instead.
1013         //
1014         // Here we run test the fundee side of that restart mechanism, implementing the funder side of
1015         // it manually.
1016         let chanmon_cfgs = create_chanmon_cfgs(2);
1017         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1018         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1019         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1020         let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1).2;
1021
1022         send_payment(&nodes[0], &[&nodes[1]], 8_000_000);
1023
1024         nodes[0].node.close_channel(&chan_id, &nodes[1].node.get_our_node_id()).unwrap();
1025         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1026         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
1027         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1028         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
1029
1030         {
1031                 // Now we set nodes[1] to require a relatively high feerate for closing. This should result
1032                 // in it rejecting nodes[0]'s initial closing_signed, giving nodes[0] a chance to try
1033                 // again.
1034                 let mut feerate_lock = chanmon_cfgs[1].fee_estimator.sat_per_kw.lock().unwrap();
1035                 *feerate_lock *= 10;
1036         }
1037
1038         let mut node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
1039         // nodes[0] should use a "reasonable" feerate, well under the 10 sat/vByte that nodes[1] thinks
1040         // is the current prevailing feerate.
1041         assert!(node_0_closing_signed.fee_satoshis <= 500);
1042
1043         if timeout_step != TimeoutStep::AfterShutdown {
1044                 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
1045                 assert!(check_warn_msg!(nodes[1], nodes[0].node.get_our_node_id(), chan_id)
1046                         .starts_with("Unable to come to consensus about closing feerate"));
1047
1048                 // Now deliver a mutated closing_signed indicating a higher acceptable fee range, which
1049                 // nodes[1] should happily accept and respond to.
1050                 node_0_closing_signed.fee_range.as_mut().unwrap().max_fee_satoshis *= 10;
1051                 {
1052                         let mut node_0_per_peer_lock;
1053                         let mut node_0_peer_state_lock;
1054                         get_channel_ref!(nodes[0], nodes[1], node_0_per_peer_lock, node_0_peer_state_lock, chan_id).context.closing_fee_limits.as_mut().unwrap().1 *= 10;
1055                 }
1056                 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
1057                 let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
1058                 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
1059                 let node_0_2nd_closing_signed = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
1060                 if timeout_step == TimeoutStep::NoTimeout {
1061                         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.1.unwrap());
1062                         check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id()], 100000);
1063                 }
1064                 check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
1065         }
1066
1067         if timeout_step != TimeoutStep::NoTimeout {
1068                 assert!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().is_empty());
1069         } else {
1070                 assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
1071         }
1072
1073         nodes[1].node.timer_tick_occurred();
1074         nodes[1].node.timer_tick_occurred();
1075
1076         let txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
1077         assert_eq!(txn.len(), 1);
1078         assert_eq!(txn[0].output.len(), 2);
1079
1080         if timeout_step != TimeoutStep::NoTimeout {
1081                 assert!((txn[0].output[0].script_pubkey.is_v0_p2wpkh() &&
1082                          txn[0].output[1].script_pubkey.is_v0_p2wsh()) ||
1083                         (txn[0].output[1].script_pubkey.is_v0_p2wpkh() &&
1084                          txn[0].output[0].script_pubkey.is_v0_p2wsh()));
1085                 check_closed_broadcast!(nodes[1], true);
1086                 check_added_monitors!(nodes[1], 1);
1087                 check_closed_event!(nodes[1], 1, ClosureReason::ProcessingError { err: "closing_signed negotiation failed to finish within two timer ticks".to_string() }
1088                         , [nodes[0].node.get_our_node_id()], 100000);
1089         } else {
1090                 assert!(txn[0].output[0].script_pubkey.is_v0_p2wpkh());
1091                 assert!(txn[0].output[1].script_pubkey.is_v0_p2wpkh());
1092
1093                 let events = nodes[1].node.get_and_clear_pending_msg_events();
1094                 assert_eq!(events.len(), 1);
1095                 match events[0] {
1096                         MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
1097                                 assert_eq!(msg.contents.flags & 2, 2);
1098                         },
1099                         _ => panic!("Unexpected event"),
1100                 }
1101         }
1102 }
1103
1104 #[test]
1105 fn test_closing_signed_reinit_timeout() {
1106         do_test_closing_signed_reinit_timeout(TimeoutStep::AfterShutdown);
1107         do_test_closing_signed_reinit_timeout(TimeoutStep::AfterClosingSigned);
1108         do_test_closing_signed_reinit_timeout(TimeoutStep::NoTimeout);
1109 }
1110
1111 fn do_simple_legacy_shutdown_test(high_initiator_fee: bool) {
1112         // A simpe test of the legacy shutdown fee negotiation logic.
1113         let chanmon_cfgs = create_chanmon_cfgs(2);
1114         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1115         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1116         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1117
1118         let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
1119
1120         if high_initiator_fee {
1121                 // If high_initiator_fee is set, set nodes[0]'s feerate significantly higher. This
1122                 // shouldn't impact the flow at all given nodes[1] will happily accept the higher fee.
1123                 let mut feerate_lock = chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap();
1124                 *feerate_lock *= 10;
1125         }
1126
1127         nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id(), &nodes[1].node.get_our_node_id()).unwrap();
1128         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1129         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
1130         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1131         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
1132
1133         let mut node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
1134         node_0_closing_signed.fee_range = None;
1135         if high_initiator_fee {
1136                 assert!(node_0_closing_signed.fee_satoshis > 500);
1137         } else {
1138                 assert!(node_0_closing_signed.fee_satoshis < 500);
1139         }
1140
1141         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
1142         let (_, mut node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
1143         node_1_closing_signed.as_mut().unwrap().fee_range = None;
1144
1145         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap());
1146         let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
1147         assert!(node_0_none.is_none());
1148         check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
1149         check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id()], 100000);
1150 }
1151
1152 #[test]
1153 fn simple_legacy_shutdown_test() {
1154         do_simple_legacy_shutdown_test(false);
1155         do_simple_legacy_shutdown_test(true);
1156 }
1157
1158 #[test]
1159 fn simple_target_feerate_shutdown() {
1160         // Simple test of target in `close_channel_with_target_feerate`.
1161         let chanmon_cfgs = create_chanmon_cfgs(2);
1162         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1163         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1164         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1165
1166         let chan = create_announced_chan_between_nodes(&nodes, 0, 1);
1167         let chan_id = OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id();
1168
1169         nodes[0].node.close_channel_with_feerate_and_script(&chan_id, &nodes[1].node.get_our_node_id(), Some(253 * 10), None).unwrap();
1170         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1171         nodes[1].node.close_channel_with_feerate_and_script(&chan_id, &nodes[0].node.get_our_node_id(), Some(253 * 5), None).unwrap();
1172         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1173
1174         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
1175         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
1176
1177         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
1178         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
1179         let (_, node_1_closing_signed_opt) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
1180         let node_1_closing_signed = node_1_closing_signed_opt.unwrap();
1181
1182         // nodes[1] was passed a target which was larger than the current channel feerate, which it
1183         // should ignore in favor of the channel fee, as there is no use demanding a minimum higher
1184         // than what will be paid on a force-close transaction. Note that we have to consider rounding,
1185         // so only check that we're within 10 sats.
1186         assert!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis >=
1187                 node_1_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis * 10 - 5);
1188         assert!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis <=
1189                 node_1_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis * 10 + 5);
1190
1191         // Further, because nodes[0]'s target fee is larger than the `Normal` fee estimation plus our
1192         // force-closure-avoidance buffer, min should equal max, and the nodes[1]-selected fee should
1193         // be the nodes[0] only available fee.
1194         assert_eq!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis,
1195                    node_0_closing_signed.fee_range.as_ref().unwrap().max_fee_satoshis);
1196         assert_eq!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis,
1197                    node_0_closing_signed.fee_satoshis);
1198         assert_eq!(node_0_closing_signed.fee_satoshis, node_1_closing_signed.fee_satoshis);
1199
1200         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
1201         let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
1202         assert!(node_0_none.is_none());
1203         check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure, [nodes[1].node.get_our_node_id()], 100000);
1204         check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure, [nodes[0].node.get_our_node_id()], 100000);
1205 }