_ Git - rust-lightning/blob - 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 chain::keysinterface::KeysInterface;
  13 use chain::transaction::OutPoint;
  14 use ln::channelmanager::PaymentSendFailure;
  15 use routing::router::{PaymentParameters, get_route};
  16 use ln::features::{InitFeatures, InvoiceFeatures};
  17 use ln::msgs;
  18 use ln::msgs::{ChannelMessageHandler, ErrorAction};
  19 use ln::script::ShutdownScript;
  20 use util::test_utils;
  21 use util::test_utils::OnGetShutdownScriptpubkey;
  22 use util::events::{Event, MessageSendEvent, MessageSendEventsProvider, ClosureReason};
  23 use util::errors::APIError;
  24 use util::config::UserConfig;
  25
  26 use bitcoin::blockdata::script::Builder;
  27 use bitcoin::blockdata::opcodes;
  28 use bitcoin::network::constants::Network;
  29
  30 use regex;
  31
  32 use core::default::Default;
  33 use core::num::NonZeroU8;
  34
  35 use ln::functional_test_utils::*;
  36 use ln::msgs::OptionalField::Present;
  37
  38 #[test]
  39 fn pre_funding_lock_shutdown_test() {
  40         // Test sending a shutdown prior to funding_locked 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, InitFeatures::known(), InitFeatures::known());
  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()).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(), &InitFeatures::known(), &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(), &InitFeatures::known(), &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);
  67         check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure);
  68 }
  69
  70 #[test]
  71 fn updates_shutdown_wait() {
  72         // Test sending a shutdown with outstanding updates pending
  73         let chanmon_cfgs = create_chanmon_cfgs(3);
  74         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
  75         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
  76         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
  77         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
  78         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
  79         let logger = test_utils::TestLogger::new();
  80         let scorer = test_utils::TestScorer::with_penalty(0);
  81         let keys_manager = test_utils::TestKeysInterface::new(&[0u8; 32], Network::Testnet);
  82         let random_seed_bytes = keys_manager.get_secure_random_bytes();
  83
  84         let (payment_preimage, _, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
  85
  86         nodes[0].node.close_channel(&chan_1.2).unwrap();
  87         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
  88         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &InitFeatures::known(), &node_0_shutdown);
  89         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
  90         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &InitFeatures::known(), &node_1_shutdown);
  91
  92         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
  93         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
  94
  95         let (_, payment_hash, payment_secret) = get_payment_preimage_hash!(nodes[0]);
  96
  97         let payment_params_1 = PaymentParameters::from_node_id(nodes[1].node.get_our_node_id()).with_features(InvoiceFeatures::known());
  98         let route_1 = get_route(&nodes[0].node.get_our_node_id(), &payment_params_1, &nodes[0].network_graph.read_only(), None, 100000, TEST_FINAL_CLTV, &logger, &scorer, &random_seed_bytes).unwrap();
  99         let payment_params_2 = PaymentParameters::from_node_id(nodes[0].node.get_our_node_id()).with_features(InvoiceFeatures::known());
 100         let route_2 = get_route(&nodes[1].node.get_our_node_id(), &payment_params_2, &nodes[1].network_graph.read_only(), None, 100000, TEST_FINAL_CLTV, &logger, &scorer, &random_seed_bytes).unwrap();
 101         unwrap_send_err!(nodes[0].node.send_payment(&route_1, payment_hash, &Some(payment_secret)), true, APIError::ChannelUnavailable {..}, {});
 102         unwrap_send_err!(nodes[1].node.send_payment(&route_2, payment_hash, &Some(payment_secret)), true, APIError::ChannelUnavailable {..}, {});
 103
 104         assert!(nodes[2].node.claim_funds(payment_preimage));
 105         check_added_monitors!(nodes[2], 1);
 106         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
 107         assert!(updates.update_add_htlcs.is_empty());
 108         assert!(updates.update_fail_htlcs.is_empty());
 109         assert!(updates.update_fail_malformed_htlcs.is_empty());
 110         assert!(updates.update_fee.is_none());
 111         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
 112         nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
 113         expect_payment_forwarded!(nodes[1], nodes[0], Some(1000), false);
 114         check_added_monitors!(nodes[1], 1);
 115         let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 116         commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false);
 117
 118         assert!(updates_2.update_add_htlcs.is_empty());
 119         assert!(updates_2.update_fail_htlcs.is_empty());
 120         assert!(updates_2.update_fail_malformed_htlcs.is_empty());
 121         assert!(updates_2.update_fee.is_none());
 122         assert_eq!(updates_2.update_fulfill_htlcs.len(), 1);
 123         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]);
 124         commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
 125         expect_payment_sent!(nodes[0], payment_preimage);
 126
 127         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
 128         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
 129         let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
 130         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
 131         let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
 132         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
 133         let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
 134         assert!(node_1_none.is_none());
 135         check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure);
 136         check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure);
 137
 138         assert!(nodes[0].node.list_channels().is_empty());
 139
 140         assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
 141         nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
 142         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
 143         assert!(nodes[1].node.list_channels().is_empty());
 144         assert!(nodes[2].node.list_channels().is_empty());
 145         check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure);
 146         check_closed_event!(nodes[2], 1, ClosureReason::CooperativeClosure);
 147 }
 148
 149 #[test]
 150 fn htlc_fail_async_shutdown() {
 151         // Test HTLCs fail if shutdown starts even if messages are delivered out-of-order
 152         let chanmon_cfgs = create_chanmon_cfgs(3);
 153         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
 154         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
 155         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
 156         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 157         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
 158
 159         let (route, our_payment_hash, _, our_payment_secret) = get_route_and_payment_hash!(nodes[0], nodes[2], 100000);
 160         nodes[0].node.send_payment(&route, our_payment_hash, &Some(our_payment_secret)).unwrap();
 161         check_added_monitors!(nodes[0], 1);
 162         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 163         assert_eq!(updates.update_add_htlcs.len(), 1);
 164         assert!(updates.update_fulfill_htlcs.is_empty());
 165         assert!(updates.update_fail_htlcs.is_empty());
 166         assert!(updates.update_fail_malformed_htlcs.is_empty());
 167         assert!(updates.update_fee.is_none());
 168
 169         nodes[1].node.close_channel(&chan_1.2).unwrap();
 170         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 171         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &InitFeatures::known(), &node_1_shutdown);
 172         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
 173
 174         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
 175         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &updates.commitment_signed);
 176         check_added_monitors!(nodes[1], 1);
 177         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &InitFeatures::known(), &node_0_shutdown);
 178         commitment_signed_dance!(nodes[1], nodes[0], (), false, true, false);
 179
 180         let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 181         assert!(updates_2.update_add_htlcs.is_empty());
 182         assert!(updates_2.update_fulfill_htlcs.is_empty());
 183         assert_eq!(updates_2.update_fail_htlcs.len(), 1);
 184         assert!(updates_2.update_fail_malformed_htlcs.is_empty());
 185         assert!(updates_2.update_fee.is_none());
 186
 187         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fail_htlcs[0]);
 188         commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
 189
 190         expect_payment_failed_with_update!(nodes[0], our_payment_hash, false, chan_2.0.contents.short_channel_id, true);
 191
 192         let msg_events = nodes[0].node.get_and_clear_pending_msg_events();
 193         assert_eq!(msg_events.len(), 1);
 194         let node_0_closing_signed = match msg_events[0] {
 195                 MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => {
 196                         assert_eq!(*node_id, nodes[1].node.get_our_node_id());
 197                         (*msg).clone()
 198                 },
 199                 _ => panic!("Unexpected event"),
 200         };
 201
 202         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 203         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
 204         let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
 205         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
 206         let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
 207         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
 208         let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
 209         assert!(node_1_none.is_none());
 210
 211         assert!(nodes[0].node.list_channels().is_empty());
 212
 213         assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
 214         nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
 215         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
 216         assert!(nodes[1].node.list_channels().is_empty());
 217         assert!(nodes[2].node.list_channels().is_empty());
 218         check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure);
 219         check_closed_event!(nodes[1], 2, ClosureReason::CooperativeClosure);
 220         check_closed_event!(nodes[2], 1, ClosureReason::CooperativeClosure);
 221 }
 222
 223 fn do_test_shutdown_rebroadcast(recv_count: u8) {
 224         // Test that shutdown/closing_signed is re-sent on reconnect with a variable number of
 225         // messages delivered prior to disconnect
 226         let chanmon_cfgs = create_chanmon_cfgs(3);
 227         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
 228         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
 229         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
 230         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 231         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
 232
 233         let (payment_preimage, _, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
 234
 235         nodes[1].node.close_channel(&chan_1.2).unwrap();
 236         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 237         if recv_count > 0 {
 238                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &InitFeatures::known(), &node_1_shutdown);
 239                 let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
 240                 if recv_count > 1 {
 241                         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &InitFeatures::known(), &node_0_shutdown);
 242                 }
 243         }
 244
 245         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
 246         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
 247
 248         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty(), remote_network_address: None });
 249         let node_0_reestablish = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReestablish, nodes[1].node.get_our_node_id());
 250         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty(), remote_network_address: None });
 251         let node_1_reestablish = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
 252
 253         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &node_0_reestablish);
 254         let node_1_2nd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 255         assert!(node_1_shutdown == node_1_2nd_shutdown);
 256
 257         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &node_1_reestablish);
 258         let node_0_2nd_shutdown = if recv_count > 0 {
 259                 let node_0_2nd_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
 260                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &InitFeatures::known(), &node_1_2nd_shutdown);
 261                 node_0_2nd_shutdown
 262         } else {
 263                 let node_0_chan_update = get_event_msg!(nodes[0], MessageSendEvent::SendChannelUpdate, nodes[1].node.get_our_node_id());
 264                 assert_eq!(node_0_chan_update.contents.flags & 2, 0); // "disabled" flag must not be set as we just reconnected.
 265                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &InitFeatures::known(), &node_1_2nd_shutdown);
 266                 get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id())
 267         };
 268         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &InitFeatures::known(), &node_0_2nd_shutdown);
 269
 270         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 271         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 272
 273         assert!(nodes[2].node.claim_funds(payment_preimage));
 274         check_added_monitors!(nodes[2], 1);
 275         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
 276         assert!(updates.update_add_htlcs.is_empty());
 277         assert!(updates.update_fail_htlcs.is_empty());
 278         assert!(updates.update_fail_malformed_htlcs.is_empty());
 279         assert!(updates.update_fee.is_none());
 280         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
 281         nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
 282         expect_payment_forwarded!(nodes[1], nodes[0], Some(1000), false);
 283         check_added_monitors!(nodes[1], 1);
 284         let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 285         commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false);
 286
 287         assert!(updates_2.update_add_htlcs.is_empty());
 288         assert!(updates_2.update_fail_htlcs.is_empty());
 289         assert!(updates_2.update_fail_malformed_htlcs.is_empty());
 290         assert!(updates_2.update_fee.is_none());
 291         assert_eq!(updates_2.update_fulfill_htlcs.len(), 1);
 292         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]);
 293         commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
 294         expect_payment_sent!(nodes[0], payment_preimage);
 295
 296         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
 297         if recv_count > 0 {
 298                 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
 299                 let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
 300                 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
 301                 let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
 302                 assert!(node_0_2nd_closing_signed.is_some());
 303         }
 304
 305         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
 306         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
 307
 308         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty(), remote_network_address: None });
 309         let node_1_2nd_reestablish = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
 310         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty(), remote_network_address: None });
 311         if recv_count == 0 {
 312                 // If all closing_signeds weren't delivered we can just resume where we left off...
 313                 let node_0_2nd_reestablish = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReestablish, nodes[1].node.get_our_node_id());
 314
 315                 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &node_1_2nd_reestablish);
 316                 let node_0_msgs = nodes[0].node.get_and_clear_pending_msg_events();
 317                 assert_eq!(node_0_msgs.len(), 2);
 318                 let node_0_2nd_closing_signed = match node_0_msgs[1] {
 319                         MessageSendEvent::SendClosingSigned { ref msg, .. } => {
 320                                 assert_eq!(node_0_closing_signed, *msg);
 321                                 msg.clone()
 322                         },
 323                         _ => panic!(),
 324                 };
 325
 326                 let node_0_3rd_shutdown = match node_0_msgs[0] {
 327                         MessageSendEvent::SendShutdown { ref msg, .. } => {
 328                                 assert_eq!(node_0_2nd_shutdown, *msg);
 329                                 msg.clone()
 330                         },
 331                         _ => panic!(),
 332                 };
 333                 assert!(node_0_2nd_shutdown == node_0_3rd_shutdown);
 334
 335                 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &node_0_2nd_reestablish);
 336                 let node_1_3rd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 337                 assert!(node_1_3rd_shutdown == node_1_2nd_shutdown);
 338
 339                 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &InitFeatures::known(), &node_0_3rd_shutdown);
 340                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 341
 342                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &InitFeatures::known(), &node_1_3rd_shutdown);
 343
 344                 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed);
 345                 let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
 346                 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
 347                 let (_, node_0_2nd_closing_signed) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
 348                 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.unwrap());
 349                 let (_, node_1_none) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
 350                 assert!(node_1_none.is_none());
 351                 check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure);
 352         } else {
 353                 // If one node, however, received + responded with an identical closing_signed we end
 354                 // up erroring and node[0] will try to broadcast its own latest commitment transaction.
 355                 // There isn't really anything better we can do simply, but in the future we might
 356                 // explore storing a set of recently-closed channels that got disconnected during
 357                 // closing_signed and avoiding broadcasting local commitment txn for some timeout to
 358                 // give our counterparty enough time to (potentially) broadcast a cooperative closing
 359                 // transaction.
 360                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 361
 362                 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &node_1_2nd_reestablish);
 363                 let msg_events = nodes[0].node.get_and_clear_pending_msg_events();
 364                 assert_eq!(msg_events.len(), 1);
 365                 if let MessageSendEvent::HandleError { ref action, .. } = msg_events[0] {
 366                         match action {
 367                                 &ErrorAction::SendErrorMessage { ref msg } => {
 368                                         nodes[1].node.handle_error(&nodes[0].node.get_our_node_id(), &msg);
 369                                         assert_eq!(msg.channel_id, chan_1.2);
 370                                 },
 371                                 _ => panic!("Unexpected event!"),
 372                         }
 373                 } else { panic!("Needed SendErrorMessage close"); }
 374
 375                 // get_closing_signed_broadcast usually eats the BroadcastChannelUpdate for us and
 376                 // checks it, but in this case nodes[1] didn't ever get a chance to receive a
 377                 // closing_signed so we do it ourselves
 378                 check_closed_broadcast!(nodes[1], false);
 379                 check_added_monitors!(nodes[1], 1);
 380                 check_closed_event!(nodes[1], 1, ClosureReason::CounterpartyForceClosed { peer_msg: "Failed to find corresponding channel".to_string() });
 381         }
 382
 383         assert!(nodes[0].node.list_channels().is_empty());
 384
 385         assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
 386         nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
 387         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
 388         assert!(nodes[1].node.list_channels().is_empty());
 389         assert!(nodes[2].node.list_channels().is_empty());
 390         check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure);
 391         check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure);
 392         check_closed_event!(nodes[2], 1, ClosureReason::CooperativeClosure);
 393 }
 394
 395 #[test]
 396 fn test_shutdown_rebroadcast() {
 397         do_test_shutdown_rebroadcast(0);
 398         do_test_shutdown_rebroadcast(1);
 399         do_test_shutdown_rebroadcast(2);
 400 }
 401
 402 #[test]
 403 fn test_upfront_shutdown_script() {
 404         // BOLT 2 : Option upfront shutdown script, if peer commit its closing_script at channel opening
 405         // enforce it at shutdown message
 406
 407         let mut config = UserConfig::default();
 408         config.channel_options.announced_channel = true;
 409         config.peer_channel_config_limits.force_announced_channel_preference = false;
 410         config.channel_options.commit_upfront_shutdown_pubkey = false;
 411         let user_cfgs = [None, Some(config), None];
 412         let chanmon_cfgs = create_chanmon_cfgs(3);
 413         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
 414         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
 415         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
 416
 417         // We test that in case of peer committing upfront to a script, if it changes at closing, we refuse to sign
 418         let flags = InitFeatures::known();
 419         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1000000, 1000000, flags.clone(), flags.clone());
 420         nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
 421         let node_0_orig_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id());
 422         let mut node_0_shutdown = node_0_orig_shutdown.clone();
 423         node_0_shutdown.scriptpubkey = Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script().to_p2sh();
 424         // Test we enforce upfront_scriptpbukey if by providing a different one at closing that we warn
 425         // the peer and ignore the message.
 426         nodes[2].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &InitFeatures::known(), &node_0_shutdown);
 427         assert!(regex::Regex::new(r"Got shutdown request with a scriptpubkey \([A-Fa-f0-9]+\) which did not match their previous scriptpubkey.")
 428                         .unwrap().is_match(&check_warn_msg!(nodes[2], nodes[0].node.get_our_node_id(), chan.2)));
 429         // This allows nodes[2] to retry the shutdown message, which should get a response:
 430         nodes[2].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &InitFeatures::known(), &node_0_orig_shutdown);
 431         get_event_msg!(nodes[2], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 432
 433         // We test that in case of peer committing upfront to a script, if it doesn't change at closing, we sign
 434         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1000000, 1000000, flags.clone(), flags.clone());
 435         nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
 436         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id());
 437         // We test that in case of peer committing upfront to a script, if it oesn't change at closing, we sign
 438         nodes[2].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &InitFeatures::known(), &node_0_shutdown);
 439         let events = nodes[2].node.get_and_clear_pending_msg_events();
 440         assert_eq!(events.len(), 1);
 441         match events[0] {
 442                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[0].node.get_our_node_id()) }
 443                 _ => panic!("Unexpected event"),
 444         }
 445
 446         // We test that if case of peer non-signaling we don't enforce committed script at channel opening
 447         let flags_no = InitFeatures::known().clear_upfront_shutdown_script();
 448         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, flags_no, flags.clone());
 449         nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
 450         let node_1_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
 451         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &InitFeatures::known(), &node_1_shutdown);
 452         check_added_monitors!(nodes[1], 1);
 453         let events = nodes[1].node.get_and_clear_pending_msg_events();
 454         assert_eq!(events.len(), 1);
 455         match events[0] {
 456                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[0].node.get_our_node_id()) }
 457                 _ => panic!("Unexpected event"),
 458         }
 459
 460         // We test that if user opt-out, we provide a zero-length script at channel opening and we are able to close
 461         // channel smoothly, opt-out is from channel initiator here
 462         let chan = create_announced_chan_between_nodes_with_value(&nodes, 1, 0, 1000000, 1000000, flags.clone(), flags.clone());
 463         nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
 464         check_added_monitors!(nodes[1], 1);
 465         let node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 466         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &InitFeatures::known(), &node_0_shutdown);
 467         let events = nodes[0].node.get_and_clear_pending_msg_events();
 468         assert_eq!(events.len(), 1);
 469         match events[0] {
 470                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
 471                 _ => panic!("Unexpected event"),
 472         }
 473
 474         //// We test that if user opt-out, we provide a zero-length script at channel opening and we are able to close
 475         //// channel smoothly
 476         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, flags.clone(), flags.clone());
 477         nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
 478         check_added_monitors!(nodes[1], 1);
 479         let node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 480         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &InitFeatures::known(), &node_0_shutdown);
 481         let events = nodes[0].node.get_and_clear_pending_msg_events();
 482         assert_eq!(events.len(), 2);
 483         match events[0] {
 484                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
 485                 _ => panic!("Unexpected event"),
 486         }
 487         match events[1] {
 488                 MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
 489                 _ => panic!("Unexpected event"),
 490         }
 491 }
 492
 493 #[test]
 494 fn test_unsupported_anysegwit_upfront_shutdown_script() {
 495         let chanmon_cfgs = create_chanmon_cfgs(2);
 496         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 497         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 498         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 499
 500         // Use a non-v0 segwit script supported by option_shutdown_anysegwit
 501         let node_features = InitFeatures::known().clear_shutdown_anysegwit();
 502         let anysegwit_shutdown_script = Builder::new()
 503                 .push_int(16)
 504                 .push_slice(&[0, 40])
 505                 .into_script();
 506
 507         // Check script when handling an open_channel message
 508         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None).unwrap();
 509         let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
 510         open_channel.shutdown_scriptpubkey = Present(anysegwit_shutdown_script.clone());
 511         nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), node_features.clone(), &open_channel);
 512
 513         let events = nodes[1].node.get_and_clear_pending_msg_events();
 514         assert_eq!(events.len(), 1);
 515         match events[0] {
 516                 MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id } => {
 517                         assert_eq!(node_id, nodes[0].node.get_our_node_id());
 518                         assert_eq!(msg.data, "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: Script(OP_PUSHNUM_16 OP_PUSHBYTES_2 0028)");
 519                 },
 520                 _ => panic!("Unexpected event"),
 521         }
 522
 523         // Check script when handling an accept_channel message
 524         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None).unwrap();
 525         let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
 526         nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &open_channel);
 527         let mut accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
 528         accept_channel.shutdown_scriptpubkey = Present(anysegwit_shutdown_script.clone());
 529         nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), node_features, &accept_channel);
 530
 531         let events = nodes[0].node.get_and_clear_pending_msg_events();
 532         assert_eq!(events.len(), 1);
 533         match events[0] {
 534                 MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id } => {
 535                         assert_eq!(node_id, nodes[1].node.get_our_node_id());
 536                         assert_eq!(msg.data, "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: Script(OP_PUSHNUM_16 OP_PUSHBYTES_2 0028)");
 537                 },
 538                 _ => panic!("Unexpected event"),
 539         }
 540         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() });
 541 }
 542
 543 #[test]
 544 fn test_invalid_upfront_shutdown_script() {
 545         let chanmon_cfgs = create_chanmon_cfgs(2);
 546         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 547         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 548         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 549
 550         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None).unwrap();
 551
 552         // Use a segwit v0 script with an unsupported witness program
 553         let mut open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
 554         open_channel.shutdown_scriptpubkey = Present(Builder::new().push_int(0)
 555                 .push_slice(&[0, 0])
 556                 .into_script());
 557         nodes[0].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &open_channel);
 558
 559         let events = nodes[0].node.get_and_clear_pending_msg_events();
 560         assert_eq!(events.len(), 1);
 561         match events[0] {
 562                 MessageSendEvent::HandleError { action: ErrorAction::SendErrorMessage { ref msg }, node_id } => {
 563                         assert_eq!(node_id, nodes[0].node.get_our_node_id());
 564                         assert_eq!(msg.data, "Peer is signaling upfront_shutdown but has provided an unacceptable scriptpubkey format: Script(OP_0 OP_PUSHBYTES_2 0000)");
 565                 },
 566                 _ => panic!("Unexpected event"),
 567         }
 568 }
 569
 570 #[test]
 571 fn test_segwit_v0_shutdown_script() {
 572         let mut config = UserConfig::default();
 573         config.channel_options.announced_channel = true;
 574         config.peer_channel_config_limits.force_announced_channel_preference = false;
 575         config.channel_options.commit_upfront_shutdown_pubkey = false;
 576         let user_cfgs = [None, Some(config), None];
 577         let chanmon_cfgs = create_chanmon_cfgs(3);
 578         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
 579         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
 580         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
 581
 582         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 583         nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
 584         check_added_monitors!(nodes[1], 1);
 585
 586         // Use a segwit v0 script supported even without option_shutdown_anysegwit
 587         let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 588         node_0_shutdown.scriptpubkey = Builder::new().push_int(0)
 589                 .push_slice(&[0; 20])
 590                 .into_script();
 591         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &InitFeatures::known(), &node_0_shutdown);
 592
 593         let events = nodes[0].node.get_and_clear_pending_msg_events();
 594         assert_eq!(events.len(), 2);
 595         match events[0] {
 596                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
 597                 _ => panic!("Unexpected event"),
 598         }
 599         match events[1] {
 600                 MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
 601                 _ => panic!("Unexpected event"),
 602         }
 603 }
 604
 605 #[test]
 606 fn test_anysegwit_shutdown_script() {
 607         let mut config = UserConfig::default();
 608         config.channel_options.announced_channel = true;
 609         config.peer_channel_config_limits.force_announced_channel_preference = false;
 610         config.channel_options.commit_upfront_shutdown_pubkey = false;
 611         let user_cfgs = [None, Some(config), None];
 612         let chanmon_cfgs = create_chanmon_cfgs(3);
 613         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
 614         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
 615         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
 616
 617         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 618         nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
 619         check_added_monitors!(nodes[1], 1);
 620
 621         // Use a non-v0 segwit script supported by option_shutdown_anysegwit
 622         let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 623         node_0_shutdown.scriptpubkey = Builder::new().push_int(16)
 624                 .push_slice(&[0, 0])
 625                 .into_script();
 626         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &InitFeatures::known(), &node_0_shutdown);
 627
 628         let events = nodes[0].node.get_and_clear_pending_msg_events();
 629         assert_eq!(events.len(), 2);
 630         match events[0] {
 631                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
 632                 _ => panic!("Unexpected event"),
 633         }
 634         match events[1] {
 635                 MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
 636                 _ => panic!("Unexpected event"),
 637         }
 638 }
 639
 640 #[test]
 641 fn test_unsupported_anysegwit_shutdown_script() {
 642         let mut config = UserConfig::default();
 643         config.channel_options.announced_channel = true;
 644         config.peer_channel_config_limits.force_announced_channel_preference = false;
 645         config.channel_options.commit_upfront_shutdown_pubkey = false;
 646         let user_cfgs = [None, Some(config), None];
 647         let chanmon_cfgs = create_chanmon_cfgs(3);
 648         let mut node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
 649         node_cfgs[0].features = InitFeatures::known().clear_shutdown_anysegwit();
 650         node_cfgs[1].features = InitFeatures::known().clear_shutdown_anysegwit();
 651         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
 652         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
 653
 654         // Check that using an unsupported shutdown script fails and a supported one succeeds.
 655         let supported_shutdown_script = chanmon_cfgs[1].keys_manager.get_shutdown_scriptpubkey();
 656         let unsupported_shutdown_script =
 657                 ShutdownScript::new_witness_program(NonZeroU8::new(16).unwrap(), &[0, 40]).unwrap();
 658         chanmon_cfgs[1].keys_manager
 659                 .expect(OnGetShutdownScriptpubkey { returns: unsupported_shutdown_script.clone() })
 660                 .expect(OnGetShutdownScriptpubkey { returns: supported_shutdown_script });
 661
 662         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, node_cfgs[0].features.clone(), node_cfgs[1].features.clone());
 663         match nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()) {
 664                 Err(APIError::IncompatibleShutdownScript { script }) => {
 665                         assert_eq!(script.into_inner(), unsupported_shutdown_script.clone().into_inner());
 666                 },
 667                 Err(e) => panic!("Unexpected error: {:?}", e),
 668                 Ok(_) => panic!("Expected error"),
 669         }
 670         nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
 671         check_added_monitors!(nodes[1], 1);
 672
 673         // Use a non-v0 segwit script unsupported without option_shutdown_anysegwit
 674         let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 675         node_0_shutdown.scriptpubkey = unsupported_shutdown_script.into_inner();
 676         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_cfgs[1].features, &node_0_shutdown);
 677
 678         assert_eq!(&check_warn_msg!(nodes[0], nodes[1].node.get_our_node_id(), chan.2),
 679                         "Got a nonstandard scriptpubkey (60020028) from remote peer");
 680 }
 681
 682 #[test]
 683 fn test_invalid_shutdown_script() {
 684         let mut config = UserConfig::default();
 685         config.channel_options.announced_channel = true;
 686         config.peer_channel_config_limits.force_announced_channel_preference = false;
 687         config.channel_options.commit_upfront_shutdown_pubkey = false;
 688         let user_cfgs = [None, Some(config), None];
 689         let chanmon_cfgs = create_chanmon_cfgs(3);
 690         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
 691         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
 692         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
 693
 694         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 695         nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
 696         check_added_monitors!(nodes[1], 1);
 697
 698         // Use a segwit v0 script with an unsupported witness program
 699         let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 700         node_0_shutdown.scriptpubkey = Builder::new().push_int(0)
 701                 .push_slice(&[0, 0])
 702                 .into_script();
 703         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &InitFeatures::known(), &node_0_shutdown);
 704
 705         assert_eq!(&check_warn_msg!(nodes[0], nodes[1].node.get_our_node_id(), chan.2),
 706                         "Got a nonstandard scriptpubkey (00020000) from remote peer");
 707 }
 708
 709 #[derive(PartialEq)]
 710 enum TimeoutStep {
 711         AfterShutdown,
 712         AfterClosingSigned,
 713         NoTimeout,
 714 }
 715
 716 fn do_test_closing_signed_reinit_timeout(timeout_step: TimeoutStep) {
 717         // The range-based closing signed negotiation allows the funder to restart the process with a
 718         // new range if the previous range did not overlap. This allows implementations to request user
 719         // intervention allowing users to enter a new fee range. We do not implement the sending side
 720         // of this, instead opting to allow users to enter an explicit "willing to pay up to X to avoid
 721         // force-closing" value and relying on that instead.
 722         //
 723         // Here we run test the fundee side of that restart mechanism, implementing the funder side of
 724         // it manually.
 725         let chanmon_cfgs = create_chanmon_cfgs(2);
 726         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 727         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 728         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 729         let chan_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).2;
 730
 731         send_payment(&nodes[0], &[&nodes[1]], 8_000_000);
 732
 733         nodes[0].node.close_channel(&chan_id).unwrap();
 734         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
 735         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &InitFeatures::known(), &node_0_shutdown);
 736         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 737         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &InitFeatures::known(), &node_1_shutdown);
 738
 739         {
 740                 // Now we set nodes[1] to require a relatively high feerate for closing. This should result
 741                 // in it rejecting nodes[0]'s initial closing_signed, giving nodes[0] a chance to try
 742                 // again.
 743                 let mut feerate_lock = chanmon_cfgs[1].fee_estimator.sat_per_kw.lock().unwrap();
 744                 *feerate_lock *= 10;
 745         }
 746
 747         let mut node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
 748         // nodes[0] should use a "reasonable" feerate, well under the 10 sat/vByte that nodes[1] thinks
 749         // is the current prevailing feerate.
 750         assert!(node_0_closing_signed.fee_satoshis <= 500);
 751
 752         if timeout_step != TimeoutStep::AfterShutdown {
 753                 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
 754                 assert!(check_warn_msg!(nodes[1], nodes[0].node.get_our_node_id(), chan_id)
 755                         .starts_with("Unable to come to consensus about closing feerate"));
 756
 757                 // Now deliver a mutated closing_signed indicating a higher acceptable fee range, which
 758                 // nodes[1] should happily accept and respond to.
 759                 node_0_closing_signed.fee_range.as_mut().unwrap().max_fee_satoshis *= 10;
 760                 {
 761                         let mut lock;
 762                         get_channel_ref!(nodes[0], lock, chan_id).closing_fee_limits.as_mut().unwrap().1 *= 10;
 763                 }
 764                 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
 765                 let node_1_closing_signed = get_event_msg!(nodes[1], MessageSendEvent::SendClosingSigned, nodes[0].node.get_our_node_id());
 766                 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
 767                 let node_0_2nd_closing_signed = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
 768                 if timeout_step == TimeoutStep::NoTimeout {
 769                         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed.1.unwrap());
 770                         check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure);
 771                 }
 772                 check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure);
 773         }
 774
 775         if timeout_step != TimeoutStep::NoTimeout {
 776                 assert!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().is_empty());
 777         } else {
 778                 assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
 779         }
 780
 781         nodes[1].node.timer_tick_occurred();
 782         nodes[1].node.timer_tick_occurred();
 783
 784         let txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
 785         assert_eq!(txn.len(), 1);
 786         assert_eq!(txn[0].output.len(), 2);
 787
 788         if timeout_step != TimeoutStep::NoTimeout {
 789                 assert!((txn[0].output[0].script_pubkey.is_v0_p2wpkh() &&
 790                          txn[0].output[1].script_pubkey.is_v0_p2wsh()) ||
 791                         (txn[0].output[1].script_pubkey.is_v0_p2wpkh() &&
 792                          txn[0].output[0].script_pubkey.is_v0_p2wsh()));
 793                 check_closed_broadcast!(nodes[1], true);
 794                 check_added_monitors!(nodes[1], 1);
 795                 check_closed_event!(nodes[1], 1, ClosureReason::ProcessingError { err: "closing_signed negotiation failed to finish within two timer ticks".to_string() });
 796         } else {
 797                 assert!(txn[0].output[0].script_pubkey.is_v0_p2wpkh());
 798                 assert!(txn[0].output[1].script_pubkey.is_v0_p2wpkh());
 799
 800                 let events = nodes[1].node.get_and_clear_pending_msg_events();
 801                 assert_eq!(events.len(), 1);
 802                 match events[0] {
 803                         MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
 804                                 assert_eq!(msg.contents.flags & 2, 2);
 805                         },
 806                         _ => panic!("Unexpected event"),
 807                 }
 808         }
 809 }
 810
 811 #[test]
 812 fn test_closing_signed_reinit_timeout() {
 813         do_test_closing_signed_reinit_timeout(TimeoutStep::AfterShutdown);
 814         do_test_closing_signed_reinit_timeout(TimeoutStep::AfterClosingSigned);
 815         do_test_closing_signed_reinit_timeout(TimeoutStep::NoTimeout);
 816 }
 817
 818 fn do_simple_legacy_shutdown_test(high_initiator_fee: bool) {
 819         // A simpe test of the legacy shutdown fee negotiation logic.
 820         let chanmon_cfgs = create_chanmon_cfgs(2);
 821         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 822         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 823         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 824
 825         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 826
 827         if high_initiator_fee {
 828                 // If high_initiator_fee is set, set nodes[0]'s feerate significantly higher. This
 829                 // shouldn't impact the flow at all given nodes[1] will happily accept the higher fee.
 830                 let mut feerate_lock = chanmon_cfgs[0].fee_estimator.sat_per_kw.lock().unwrap();
 831                 *feerate_lock *= 10;
 832         }
 833
 834         nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
 835         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
 836         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &InitFeatures::known(), &node_0_shutdown);
 837         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 838         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &InitFeatures::known(), &node_1_shutdown);
 839
 840         let mut node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
 841         node_0_closing_signed.fee_range = None;
 842         if high_initiator_fee {
 843                 assert!(node_0_closing_signed.fee_satoshis > 500);
 844         } else {
 845                 assert!(node_0_closing_signed.fee_satoshis < 500);
 846         }
 847
 848         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
 849         let (_, mut node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
 850         node_1_closing_signed.as_mut().unwrap().fee_range = None;
 851
 852         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap());
 853         let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
 854         assert!(node_0_none.is_none());
 855         check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure);
 856         check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure);
 857 }
 858
 859 #[test]
 860 fn simple_legacy_shutdown_test() {
 861         do_simple_legacy_shutdown_test(false);
 862         do_simple_legacy_shutdown_test(true);
 863 }
 864
 865 #[test]
 866 fn simple_target_feerate_shutdown() {
 867         // Simple test of target in `close_channel_with_target_feerate`.
 868         let chanmon_cfgs = create_chanmon_cfgs(2);
 869         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 870         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 871         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 872
 873         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 874         let chan_id = OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id();
 875
 876         nodes[0].node.close_channel_with_target_feerate(&chan_id, 253 * 10).unwrap();
 877         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
 878         nodes[1].node.close_channel_with_target_feerate(&chan_id, 253 * 5).unwrap();
 879         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 880
 881         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &InitFeatures::known(), &node_0_shutdown);
 882         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &InitFeatures::known(), &node_1_shutdown);
 883
 884         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
 885         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
 886         let (_, node_1_closing_signed_opt) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
 887         let node_1_closing_signed = node_1_closing_signed_opt.unwrap();
 888
 889         // nodes[1] was passed a target which was larger than the current channel feerate, which it
 890         // should ignore in favor of the channel fee, as there is no use demanding a minimum higher
 891         // than what will be paid on a force-close transaction. Note that we have to consider rounding,
 892         // so only check that we're within 10 sats.
 893         assert!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis >=
 894                 node_1_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis * 10 - 5);
 895         assert!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis <=
 896                 node_1_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis * 10 + 5);
 897
 898         // Further, because nodes[0]'s target fee is larger than the `Normal` fee estimation plus our
 899         // force-closure-avoidance buffer, min should equal max, and the nodes[1]-selected fee should
 900         // be the nodes[0] only available fee.
 901         assert_eq!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis,
 902                    node_0_closing_signed.fee_range.as_ref().unwrap().max_fee_satoshis);
 903         assert_eq!(node_0_closing_signed.fee_range.as_ref().unwrap().min_fee_satoshis,
 904                    node_0_closing_signed.fee_satoshis);
 905         assert_eq!(node_0_closing_signed.fee_satoshis, node_1_closing_signed.fee_satoshis);
 906
 907         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed);
 908         let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
 909         assert!(node_0_none.is_none());
 910         check_closed_event!(nodes[0], 1, ClosureReason::CooperativeClosure);
 911         check_closed_event!(nodes[1], 1, ClosureReason::CooperativeClosure);
 912 }