_ Git - rust-lightning/blob - lightning/src/ln/functional_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 that test standing up a network of ChannelManagers, creating channels, sending
  11 //! payments/messages between them, and often checking the resulting ChannelMonitors are able to
  12 //! claim outputs on-chain.
  13
  14 use chain::transaction::OutPoint;
  15 use chain::keysinterface::{ChannelKeys, KeysInterface, SpendableOutputDescriptor};
  16 use chain::chaininterface;
  17 use chain::chaininterface::{ChainListener, ChainWatchInterfaceUtil, BlockNotifier};
  18 use ln::channel::{COMMITMENT_TX_BASE_WEIGHT, COMMITMENT_TX_WEIGHT_PER_HTLC};
  19 use ln::channelmanager::{ChannelManager,ChannelManagerReadArgs,HTLCForwardInfo,RAACommitmentOrder, PaymentPreimage, PaymentHash, PaymentSecret, PaymentSendFailure, BREAKDOWN_TIMEOUT};
  20 use ln::channelmonitor::{ChannelMonitor, CLTV_CLAIM_BUFFER, LATENCY_GRACE_PERIOD_BLOCKS, ManyChannelMonitor, ANTI_REORG_DELAY};
  21 use ln::channelmonitor;
  22 use ln::channel::{Channel, ChannelError};
  23 use ln::{chan_utils, onion_utils};
  24 use routing::router::{Route, RouteHop, get_route};
  25 use ln::features::{ChannelFeatures, InitFeatures, NodeFeatures};
  26 use ln::msgs;
  27 use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler,HTLCFailChannelUpdate, ErrorAction, OptionalField};
  28 use util::enforcing_trait_impls::EnforcingChannelKeys;
  29 use util::{byte_utils, test_utils};
  30 use util::events::{Event, EventsProvider, MessageSendEvent, MessageSendEventsProvider};
  31 use util::errors::APIError;
  32 use util::ser::{Writeable, Writer, ReadableArgs, Readable};
  33 use util::config::UserConfig;
  34
  35 use bitcoin::util::hash::BitcoinHash;
  36 use bitcoin::hashes::sha256d::Hash as Sha256dHash;
  37 use bitcoin::hashes::HashEngine;
  38 use bitcoin::hash_types::{Txid, BlockHash, WPubkeyHash};
  39 use bitcoin::util::bip143;
  40 use bitcoin::util::address::Address;
  41 use bitcoin::util::bip32::{ChildNumber, ExtendedPubKey, ExtendedPrivKey};
  42 use bitcoin::blockdata::block::{Block, BlockHeader};
  43 use bitcoin::blockdata::transaction::{Transaction, TxOut, TxIn, SigHashType, OutPoint as BitcoinOutPoint};
  44 use bitcoin::blockdata::script::{Builder, Script};
  45 use bitcoin::blockdata::opcodes;
  46 use bitcoin::blockdata::constants::genesis_block;
  47 use bitcoin::network::constants::Network;
  48
  49 use bitcoin::hashes::sha256::Hash as Sha256;
  50 use bitcoin::hashes::Hash;
  51
  52 use bitcoin::secp256k1::{Secp256k1, Message};
  53 use bitcoin::secp256k1::key::{PublicKey,SecretKey};
  54
  55 use regex;
  56
  57 use std::collections::{BTreeSet, HashMap, HashSet};
  58 use std::default::Default;
  59 use std::sync::{Arc, Mutex};
  60 use std::sync::atomic::Ordering;
  61 use std::{mem, io};
  62
  63 use ln::functional_test_utils::*;
  64 use ln::chan_utils::PreCalculatedTxCreationKeys;
  65
  66 #[test]
  67 fn test_insane_channel_opens() {
  68         // Stand up a network of 2 nodes
  69         let chanmon_cfgs = create_chanmon_cfgs(2);
  70         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
  71         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
  72         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  73
  74         // Instantiate channel parameters where we push the maximum msats given our
  75         // funding satoshis
  76         let channel_value_sat = 31337; // same as funding satoshis
  77         let channel_reserve_satoshis = Channel::<EnforcingChannelKeys>::get_remote_channel_reserve_satoshis(channel_value_sat);
  78         let push_msat = (channel_value_sat - channel_reserve_satoshis) * 1000;
  79
  80         // Have node0 initiate a channel to node1 with aforementioned parameters
  81         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_sat, push_msat, 42, None).unwrap();
  82
  83         // Extract the channel open message from node0 to node1
  84         let open_channel_message = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
  85
  86         // Test helper that asserts we get the correct error string given a mutator
  87         // that supposedly makes the channel open message insane
  88         let insane_open_helper = |expected_error_str: &str, message_mutator: fn(msgs::OpenChannel) -> msgs::OpenChannel| {
  89                 nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &message_mutator(open_channel_message.clone()));
  90                 let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
  91                 assert_eq!(msg_events.len(), 1);
  92                 let expected_regex = regex::Regex::new(expected_error_str).unwrap();
  93                 if let MessageSendEvent::HandleError { ref action, .. } = msg_events[0] {
  94                         match action {
  95                                 &ErrorAction::SendErrorMessage { .. } => {
  96                                         nodes[1].logger.assert_log_regex("lightning::ln::channelmanager".to_string(), expected_regex, 1);
  97                                 },
  98                                 _ => panic!("unexpected event!"),
  99                         }
 100                 } else { assert!(false); }
 101         };
 102
 103         use ln::channel::MAX_FUNDING_SATOSHIS;
 104         use ln::channelmanager::MAX_LOCAL_BREAKDOWN_TIMEOUT;
 105
 106         // Test all mutations that would make the channel open message insane
 107         insane_open_helper(format!("Funding must be smaller than {}. It was {}", MAX_FUNDING_SATOSHIS, MAX_FUNDING_SATOSHIS).as_str(), |mut msg| { msg.funding_satoshis = MAX_FUNDING_SATOSHIS; msg });
 108
 109         insane_open_helper("Bogus channel_reserve_satoshis", |mut msg| { msg.channel_reserve_satoshis = msg.funding_satoshis + 1; msg });
 110
 111         insane_open_helper(r"push_msat \d+ was larger than funding value \d+", |mut msg| { msg.push_msat = (msg.funding_satoshis - msg.channel_reserve_satoshis) * 1000 + 1; msg });
 112
 113         insane_open_helper("Peer never wants payout outputs?", |mut msg| { msg.dust_limit_satoshis = msg.funding_satoshis + 1 ; msg });
 114
 115         insane_open_helper(r"Bogus; channel reserve \(\d+\) is less than dust limit \(\d+\)", |mut msg| { msg.dust_limit_satoshis = msg.channel_reserve_satoshis + 1; msg });
 116
 117         insane_open_helper(r"Minimum htlc value \(\d+\) was larger than full channel value \(\d+\)", |mut msg| { msg.htlc_minimum_msat = (msg.funding_satoshis - msg.channel_reserve_satoshis) * 1000; msg });
 118
 119         insane_open_helper("They wanted our payments to be delayed by a needlessly long period", |mut msg| { msg.to_self_delay = MAX_LOCAL_BREAKDOWN_TIMEOUT + 1; msg });
 120
 121         insane_open_helper("0 max_accepted_htlcs makes for a useless channel", |mut msg| { msg.max_accepted_htlcs = 0; msg });
 122
 123         insane_open_helper("max_accepted_htlcs was 484. It must not be larger than 483", |mut msg| { msg.max_accepted_htlcs = 484; msg });
 124 }
 125
 126 #[test]
 127 fn test_async_inbound_update_fee() {
 128         let chanmon_cfgs = create_chanmon_cfgs(2);
 129         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 130         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 131         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 132         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 133         let logger = test_utils::TestLogger::new();
 134         let channel_id = chan.2;
 135
 136         // balancing
 137         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 138
 139         // A                                        B
 140         // update_fee                            ->
 141         // send (1) commitment_signed            -.
 142         //                                       <- update_add_htlc/commitment_signed
 143         // send (2) RAA (awaiting remote revoke) -.
 144         // (1) commitment_signed is delivered    ->
 145         //                                       .- send (3) RAA (awaiting remote revoke)
 146         // (2) RAA is delivered                  ->
 147         //                                       .- send (4) commitment_signed
 148         //                                       <- (3) RAA is delivered
 149         // send (5) commitment_signed            -.
 150         //                                       <- (4) commitment_signed is delivered
 151         // send (6) RAA                          -.
 152         // (5) commitment_signed is delivered    ->
 153         //                                       <- RAA
 154         // (6) RAA is delivered                  ->
 155
 156         // First nodes[0] generates an update_fee
 157         nodes[0].node.update_fee(channel_id, get_feerate!(nodes[0], channel_id) + 20).unwrap();
 158         check_added_monitors!(nodes[0], 1);
 159
 160         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 161         assert_eq!(events_0.len(), 1);
 162         let (update_msg, commitment_signed) = match events_0[0] { // (1)
 163                 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fee, ref commitment_signed, .. }, .. } => {
 164                         (update_fee.as_ref(), commitment_signed)
 165                 },
 166                 _ => panic!("Unexpected event"),
 167         };
 168
 169         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
 170
 171         // ...but before it's delivered, nodes[1] starts to send a payment back to nodes[0]...
 172         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 173         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 174         nodes[1].node.send_payment(&get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), None, &Vec::new(), 40000, TEST_FINAL_CLTV, &logger).unwrap(), our_payment_hash, &None).unwrap();
 175         check_added_monitors!(nodes[1], 1);
 176
 177         let payment_event = {
 178                 let mut events_1 = nodes[1].node.get_and_clear_pending_msg_events();
 179                 assert_eq!(events_1.len(), 1);
 180                 SendEvent::from_event(events_1.remove(0))
 181         };
 182         assert_eq!(payment_event.node_id, nodes[0].node.get_our_node_id());
 183         assert_eq!(payment_event.msgs.len(), 1);
 184
 185         // ...now when the messages get delivered everyone should be happy
 186         nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
 187         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &payment_event.commitment_msg); // (2)
 188         let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 189         // nodes[0] is awaiting nodes[1] revoke_and_ack so get_event_msg's assert(len == 1) passes
 190         check_added_monitors!(nodes[0], 1);
 191
 192         // deliver(1), generate (3):
 193         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed);
 194         let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
 195         // nodes[1] is awaiting nodes[0] revoke_and_ack so get_event_msg's assert(len == 1) passes
 196         check_added_monitors!(nodes[1], 1);
 197
 198         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_and_ack); // deliver (2)
 199         let bs_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 200         assert!(bs_update.update_add_htlcs.is_empty()); // (4)
 201         assert!(bs_update.update_fulfill_htlcs.is_empty()); // (4)
 202         assert!(bs_update.update_fail_htlcs.is_empty()); // (4)
 203         assert!(bs_update.update_fail_malformed_htlcs.is_empty()); // (4)
 204         assert!(bs_update.update_fee.is_none()); // (4)
 205         check_added_monitors!(nodes[1], 1);
 206
 207         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack); // deliver (3)
 208         let as_update = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 209         assert!(as_update.update_add_htlcs.is_empty()); // (5)
 210         assert!(as_update.update_fulfill_htlcs.is_empty()); // (5)
 211         assert!(as_update.update_fail_htlcs.is_empty()); // (5)
 212         assert!(as_update.update_fail_malformed_htlcs.is_empty()); // (5)
 213         assert!(as_update.update_fee.is_none()); // (5)
 214         check_added_monitors!(nodes[0], 1);
 215
 216         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_update.commitment_signed); // deliver (4)
 217         let as_second_revoke = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 218         // only (6) so get_event_msg's assert(len == 1) passes
 219         check_added_monitors!(nodes[0], 1);
 220
 221         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_update.commitment_signed); // deliver (5)
 222         let bs_second_revoke = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
 223         check_added_monitors!(nodes[1], 1);
 224
 225         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_second_revoke);
 226         check_added_monitors!(nodes[0], 1);
 227
 228         let events_2 = nodes[0].node.get_and_clear_pending_events();
 229         assert_eq!(events_2.len(), 1);
 230         match events_2[0] {
 231                 Event::PendingHTLCsForwardable {..} => {}, // If we actually processed we'd receive the payment
 232                 _ => panic!("Unexpected event"),
 233         }
 234
 235         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_second_revoke); // deliver (6)
 236         check_added_monitors!(nodes[1], 1);
 237 }
 238
 239 #[test]
 240 fn test_update_fee_unordered_raa() {
 241         // Just the intro to the previous test followed by an out-of-order RAA (which caused a
 242         // crash in an earlier version of the update_fee patch)
 243         let chanmon_cfgs = create_chanmon_cfgs(2);
 244         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 245         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 246         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 247         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 248         let channel_id = chan.2;
 249         let logger = test_utils::TestLogger::new();
 250
 251         // balancing
 252         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 253
 254         // First nodes[0] generates an update_fee
 255         nodes[0].node.update_fee(channel_id, get_feerate!(nodes[0], channel_id) + 20).unwrap();
 256         check_added_monitors!(nodes[0], 1);
 257
 258         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 259         assert_eq!(events_0.len(), 1);
 260         let update_msg = match events_0[0] { // (1)
 261                 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fee, .. }, .. } => {
 262                         update_fee.as_ref()
 263                 },
 264                 _ => panic!("Unexpected event"),
 265         };
 266
 267         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
 268
 269         // ...but before it's delivered, nodes[1] starts to send a payment back to nodes[0]...
 270         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 271         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 272         nodes[1].node.send_payment(&get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), None, &Vec::new(), 40000, TEST_FINAL_CLTV, &logger).unwrap(), our_payment_hash, &None).unwrap();
 273         check_added_monitors!(nodes[1], 1);
 274
 275         let payment_event = {
 276                 let mut events_1 = nodes[1].node.get_and_clear_pending_msg_events();
 277                 assert_eq!(events_1.len(), 1);
 278                 SendEvent::from_event(events_1.remove(0))
 279         };
 280         assert_eq!(payment_event.node_id, nodes[0].node.get_our_node_id());
 281         assert_eq!(payment_event.msgs.len(), 1);
 282
 283         // ...now when the messages get delivered everyone should be happy
 284         nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
 285         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &payment_event.commitment_msg); // (2)
 286         let as_revoke_msg = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 287         // nodes[0] is awaiting nodes[1] revoke_and_ack so get_event_msg's assert(len == 1) passes
 288         check_added_monitors!(nodes[0], 1);
 289
 290         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_msg); // deliver (2)
 291         check_added_monitors!(nodes[1], 1);
 292
 293         // We can't continue, sadly, because our (1) now has a bogus signature
 294 }
 295
 296 #[test]
 297 fn test_multi_flight_update_fee() {
 298         let chanmon_cfgs = create_chanmon_cfgs(2);
 299         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 300         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 301         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 302         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 303         let channel_id = chan.2;
 304
 305         // A                                        B
 306         // update_fee/commitment_signed          ->
 307         //                                       .- send (1) RAA and (2) commitment_signed
 308         // update_fee (never committed)          ->
 309         // (3) update_fee                        ->
 310         // We have to manually generate the above update_fee, it is allowed by the protocol but we
 311         // don't track which updates correspond to which revoke_and_ack responses so we're in
 312         // AwaitingRAA mode and will not generate the update_fee yet.
 313         //                                       <- (1) RAA delivered
 314         // (3) is generated and send (4) CS      -.
 315         // Note that A cannot generate (4) prior to (1) being delivered as it otherwise doesn't
 316         // know the per_commitment_point to use for it.
 317         //                                       <- (2) commitment_signed delivered
 318         // revoke_and_ack                        ->
 319         //                                          B should send no response here
 320         // (4) commitment_signed delivered       ->
 321         //                                       <- RAA/commitment_signed delivered
 322         // revoke_and_ack                        ->
 323
 324         // First nodes[0] generates an update_fee
 325         let initial_feerate = get_feerate!(nodes[0], channel_id);
 326         nodes[0].node.update_fee(channel_id, initial_feerate + 20).unwrap();
 327         check_added_monitors!(nodes[0], 1);
 328
 329         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 330         assert_eq!(events_0.len(), 1);
 331         let (update_msg_1, commitment_signed_1) = match events_0[0] { // (1)
 332                 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fee, ref commitment_signed, .. }, .. } => {
 333                         (update_fee.as_ref().unwrap(), commitment_signed)
 334                 },
 335                 _ => panic!("Unexpected event"),
 336         };
 337
 338         // Deliver first update_fee/commitment_signed pair, generating (1) and (2):
 339         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg_1);
 340         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed_1);
 341         let (bs_revoke_msg, bs_commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 342         check_added_monitors!(nodes[1], 1);
 343
 344         // nodes[0] is awaiting a revoke from nodes[1] before it will create a new commitment
 345         // transaction:
 346         nodes[0].node.update_fee(channel_id, initial_feerate + 40).unwrap();
 347         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
 348         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 349
 350         // Create the (3) update_fee message that nodes[0] will generate before it does...
 351         let mut update_msg_2 = msgs::UpdateFee {
 352                 channel_id: update_msg_1.channel_id.clone(),
 353                 feerate_per_kw: (initial_feerate + 30) as u32,
 354         };
 355
 356         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &update_msg_2);
 357
 358         update_msg_2.feerate_per_kw = (initial_feerate + 40) as u32;
 359         // Deliver (3)
 360         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &update_msg_2);
 361
 362         // Deliver (1), generating (3) and (4)
 363         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_msg);
 364         let as_second_update = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 365         check_added_monitors!(nodes[0], 1);
 366         assert!(as_second_update.update_add_htlcs.is_empty());
 367         assert!(as_second_update.update_fulfill_htlcs.is_empty());
 368         assert!(as_second_update.update_fail_htlcs.is_empty());
 369         assert!(as_second_update.update_fail_malformed_htlcs.is_empty());
 370         // Check that the update_fee newly generated matches what we delivered:
 371         assert_eq!(as_second_update.update_fee.as_ref().unwrap().channel_id, update_msg_2.channel_id);
 372         assert_eq!(as_second_update.update_fee.as_ref().unwrap().feerate_per_kw, update_msg_2.feerate_per_kw);
 373
 374         // Deliver (2) commitment_signed
 375         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_commitment_signed);
 376         let as_revoke_msg = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 377         check_added_monitors!(nodes[0], 1);
 378         // No commitment_signed so get_event_msg's assert(len == 1) passes
 379
 380         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_msg);
 381         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 382         check_added_monitors!(nodes[1], 1);
 383
 384         // Delever (4)
 385         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_second_update.commitment_signed);
 386         let (bs_second_revoke, bs_second_commitment) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 387         check_added_monitors!(nodes[1], 1);
 388
 389         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_second_revoke);
 390         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 391         check_added_monitors!(nodes[0], 1);
 392
 393         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_second_commitment);
 394         let as_second_revoke = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 395         // No commitment_signed so get_event_msg's assert(len == 1) passes
 396         check_added_monitors!(nodes[0], 1);
 397
 398         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_second_revoke);
 399         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 400         check_added_monitors!(nodes[1], 1);
 401 }
 402
 403 #[test]
 404 fn test_1_conf_open() {
 405         // Previously, if the minium_depth config was set to 1, we'd never send a funding_locked. This
 406         // tests that we properly send one in that case.
 407         let mut alice_config = UserConfig::default();
 408         alice_config.own_channel_config.minimum_depth = 1;
 409         alice_config.channel_options.announced_channel = true;
 410         alice_config.peer_channel_config_limits.force_announced_channel_preference = false;
 411         let mut bob_config = UserConfig::default();
 412         bob_config.own_channel_config.minimum_depth = 1;
 413         bob_config.channel_options.announced_channel = true;
 414         bob_config.peer_channel_config_limits.force_announced_channel_preference = false;
 415         let chanmon_cfgs = create_chanmon_cfgs(2);
 416         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 417         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(alice_config), Some(bob_config)]);
 418         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 419
 420         let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::known(), InitFeatures::known());
 421         assert!(nodes[0].chain_monitor.does_match_tx(&tx));
 422         assert!(nodes[1].chain_monitor.does_match_tx(&tx));
 423
 424         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
 425         nodes[1].block_notifier.block_connected_checked(&header, 1, &[&tx; 1], &[tx.version as usize; 1]);
 426         nodes[0].node.handle_funding_locked(&nodes[1].node.get_our_node_id(), &get_event_msg!(nodes[1], MessageSendEvent::SendFundingLocked, nodes[0].node.get_our_node_id()));
 427
 428         nodes[0].block_notifier.block_connected_checked(&header, 1, &[&tx; 1], &[tx.version as usize; 1]);
 429         let (funding_locked, _) = create_chan_between_nodes_with_value_confirm_second(&nodes[1], &nodes[0]);
 430         let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked);
 431
 432         for node in nodes {
 433                 assert!(node.net_graph_msg_handler.handle_channel_announcement(&announcement).unwrap());
 434                 node.net_graph_msg_handler.handle_channel_update(&as_update).unwrap();
 435                 node.net_graph_msg_handler.handle_channel_update(&bs_update).unwrap();
 436         }
 437 }
 438
 439 fn do_test_sanity_on_in_flight_opens(steps: u8) {
 440         // Previously, we had issues deserializing channels when we hadn't connected the first block
 441         // after creation. To catch that and similar issues, we lean on the Node::drop impl to test
 442         // serialization round-trips and simply do steps towards opening a channel and then drop the
 443         // Node objects.
 444
 445         let chanmon_cfgs = create_chanmon_cfgs(2);
 446         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 447         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 448         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 449
 450         if steps & 0b1000_0000 != 0{
 451                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
 452                 nodes[0].block_notifier.block_connected_checked(&header, 1, &Vec::new(), &[0; 0]);
 453                 nodes[1].block_notifier.block_connected_checked(&header, 1, &Vec::new(), &[0; 0]);
 454         }
 455
 456         if steps & 0x0f == 0 { return; }
 457         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None).unwrap();
 458         let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
 459
 460         if steps & 0x0f == 1 { return; }
 461         nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &open_channel);
 462         let accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
 463
 464         if steps & 0x0f == 2 { return; }
 465         nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), InitFeatures::known(), &accept_channel);
 466
 467         let (temporary_channel_id, tx, funding_output) = create_funding_transaction(&nodes[0], 100000, 42);
 468
 469         if steps & 0x0f == 3 { return; }
 470         nodes[0].node.funding_transaction_generated(&temporary_channel_id, funding_output);
 471         check_added_monitors!(nodes[0], 0);
 472         let funding_created = get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id());
 473
 474         if steps & 0x0f == 4 { return; }
 475         nodes[1].node.handle_funding_created(&nodes[0].node.get_our_node_id(), &funding_created);
 476         {
 477                 let mut added_monitors = nodes[1].chan_monitor.added_monitors.lock().unwrap();
 478                 assert_eq!(added_monitors.len(), 1);
 479                 assert_eq!(added_monitors[0].0, funding_output);
 480                 added_monitors.clear();
 481         }
 482         let funding_signed = get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, nodes[0].node.get_our_node_id());
 483
 484         if steps & 0x0f == 5 { return; }
 485         nodes[0].node.handle_funding_signed(&nodes[1].node.get_our_node_id(), &funding_signed);
 486         {
 487                 let mut added_monitors = nodes[0].chan_monitor.added_monitors.lock().unwrap();
 488                 assert_eq!(added_monitors.len(), 1);
 489                 assert_eq!(added_monitors[0].0, funding_output);
 490                 added_monitors.clear();
 491         }
 492
 493         let events_4 = nodes[0].node.get_and_clear_pending_events();
 494         assert_eq!(events_4.len(), 1);
 495         match events_4[0] {
 496                 Event::FundingBroadcastSafe { ref funding_txo, user_channel_id } => {
 497                         assert_eq!(user_channel_id, 42);
 498                         assert_eq!(*funding_txo, funding_output);
 499                 },
 500                 _ => panic!("Unexpected event"),
 501         };
 502
 503         if steps & 0x0f == 6 { return; }
 504         create_chan_between_nodes_with_value_confirm_first(&nodes[0], &nodes[1], &tx);
 505
 506         if steps & 0x0f == 7 { return; }
 507         confirm_transaction(&nodes[0].block_notifier, &nodes[0].chain_monitor, &tx, tx.version);
 508         create_chan_between_nodes_with_value_confirm_second(&nodes[1], &nodes[0]);
 509 }
 510
 511 #[test]
 512 fn test_sanity_on_in_flight_opens() {
 513         do_test_sanity_on_in_flight_opens(0);
 514         do_test_sanity_on_in_flight_opens(0 | 0b1000_0000);
 515         do_test_sanity_on_in_flight_opens(1);
 516         do_test_sanity_on_in_flight_opens(1 | 0b1000_0000);
 517         do_test_sanity_on_in_flight_opens(2);
 518         do_test_sanity_on_in_flight_opens(2 | 0b1000_0000);
 519         do_test_sanity_on_in_flight_opens(3);
 520         do_test_sanity_on_in_flight_opens(3 | 0b1000_0000);
 521         do_test_sanity_on_in_flight_opens(4);
 522         do_test_sanity_on_in_flight_opens(4 | 0b1000_0000);
 523         do_test_sanity_on_in_flight_opens(5);
 524         do_test_sanity_on_in_flight_opens(5 | 0b1000_0000);
 525         do_test_sanity_on_in_flight_opens(6);
 526         do_test_sanity_on_in_flight_opens(6 | 0b1000_0000);
 527         do_test_sanity_on_in_flight_opens(7);
 528         do_test_sanity_on_in_flight_opens(7 | 0b1000_0000);
 529         do_test_sanity_on_in_flight_opens(8);
 530         do_test_sanity_on_in_flight_opens(8 | 0b1000_0000);
 531 }
 532
 533 #[test]
 534 fn test_update_fee_vanilla() {
 535         let chanmon_cfgs = create_chanmon_cfgs(2);
 536         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 537         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 538         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 539         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 540         let channel_id = chan.2;
 541
 542         let feerate = get_feerate!(nodes[0], channel_id);
 543         nodes[0].node.update_fee(channel_id, feerate+25).unwrap();
 544         check_added_monitors!(nodes[0], 1);
 545
 546         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 547         assert_eq!(events_0.len(), 1);
 548         let (update_msg, commitment_signed) = match events_0[0] {
 549                         MessageSendEvent::UpdateHTLCs { node_id:_, updates: msgs::CommitmentUpdate { update_add_htlcs:_, update_fulfill_htlcs:_, update_fail_htlcs:_, update_fail_malformed_htlcs:_, ref update_fee, ref commitment_signed } } => {
 550                         (update_fee.as_ref(), commitment_signed)
 551                 },
 552                 _ => panic!("Unexpected event"),
 553         };
 554         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
 555
 556         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed);
 557         let (revoke_msg, commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 558         check_added_monitors!(nodes[1], 1);
 559
 560         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke_msg);
 561         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 562         check_added_monitors!(nodes[0], 1);
 563
 564         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_signed);
 565         let revoke_msg = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 566         // No commitment_signed so get_event_msg's assert(len == 1) passes
 567         check_added_monitors!(nodes[0], 1);
 568
 569         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &revoke_msg);
 570         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 571         check_added_monitors!(nodes[1], 1);
 572 }
 573
 574 #[test]
 575 fn test_update_fee_that_funder_cannot_afford() {
 576         let chanmon_cfgs = create_chanmon_cfgs(2);
 577         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 578         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 579         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 580         let channel_value = 1888;
 581         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, channel_value, 700000, InitFeatures::known(), InitFeatures::known());
 582         let channel_id = chan.2;
 583
 584         let feerate = 260;
 585         nodes[0].node.update_fee(channel_id, feerate).unwrap();
 586         check_added_monitors!(nodes[0], 1);
 587         let update_msg = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 588
 589         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &update_msg.update_fee.unwrap());
 590
 591         commitment_signed_dance!(nodes[1], nodes[0], update_msg.commitment_signed, false);
 592
 593         //Confirm that the new fee based on the last local commitment txn is what we expected based on the feerate of 260 set above.
 594         //This value results in a fee that is exactly what the funder can afford (277 sat + 1000 sat channel reserve)
 595         {
 596                 let commitment_tx = get_local_commitment_txn!(nodes[1], channel_id)[0].clone();
 597
 598                 //We made sure neither party's funds are below the dust limit so -2 non-HTLC txns from number of outputs
 599                 let num_htlcs = commitment_tx.output.len() - 2;
 600                 let total_fee: u64 = feerate as u64 * (COMMITMENT_TX_BASE_WEIGHT + (num_htlcs as u64) * COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000;
 601                 let mut actual_fee = commitment_tx.output.iter().fold(0, |acc, output| acc + output.value);
 602                 actual_fee = channel_value - actual_fee;
 603                 assert_eq!(total_fee, actual_fee);
 604         }
 605
 606         //Add 2 to the previous fee rate to the final fee increases by 1 (with no HTLCs the fee is essentially
 607         //fee_rate*(724/1000) so the increment of 1*0.724 is rounded back down)
 608         nodes[0].node.update_fee(channel_id, feerate+2).unwrap();
 609         check_added_monitors!(nodes[0], 1);
 610
 611         let update2_msg = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 612
 613         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &update2_msg.update_fee.unwrap());
 614
 615         //While producing the commitment_signed response after handling a received update_fee request the
 616         //check to see if the funder, who sent the update_fee request, can afford the new fee (funder_balance >= fee+channel_reserve)
 617         //Should produce and error.
 618         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &update2_msg.commitment_signed);
 619         nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Funding remote cannot afford proposed new fee".to_string(), 1);
 620         check_added_monitors!(nodes[1], 1);
 621         check_closed_broadcast!(nodes[1], true);
 622 }
 623
 624 #[test]
 625 fn test_update_fee_with_fundee_update_add_htlc() {
 626         let chanmon_cfgs = create_chanmon_cfgs(2);
 627         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 628         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 629         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 630         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 631         let channel_id = chan.2;
 632         let logger = test_utils::TestLogger::new();
 633
 634         // balancing
 635         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 636
 637         let feerate = get_feerate!(nodes[0], channel_id);
 638         nodes[0].node.update_fee(channel_id, feerate+20).unwrap();
 639         check_added_monitors!(nodes[0], 1);
 640
 641         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 642         assert_eq!(events_0.len(), 1);
 643         let (update_msg, commitment_signed) = match events_0[0] {
 644                         MessageSendEvent::UpdateHTLCs { node_id:_, updates: msgs::CommitmentUpdate { update_add_htlcs:_, update_fulfill_htlcs:_, update_fail_htlcs:_, update_fail_malformed_htlcs:_, ref update_fee, ref commitment_signed } } => {
 645                         (update_fee.as_ref(), commitment_signed)
 646                 },
 647                 _ => panic!("Unexpected event"),
 648         };
 649         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
 650         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed);
 651         let (revoke_msg, commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 652         check_added_monitors!(nodes[1], 1);
 653
 654         let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[1]);
 655         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 656         let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), None, &Vec::new(), 800000, TEST_FINAL_CLTV, &logger).unwrap();
 657
 658         // nothing happens since node[1] is in AwaitingRemoteRevoke
 659         nodes[1].node.send_payment(&route, our_payment_hash, &None).unwrap();
 660         {
 661                 let mut added_monitors = nodes[0].chan_monitor.added_monitors.lock().unwrap();
 662                 assert_eq!(added_monitors.len(), 0);
 663                 added_monitors.clear();
 664         }
 665         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
 666         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 667         // node[1] has nothing to do
 668
 669         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke_msg);
 670         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 671         check_added_monitors!(nodes[0], 1);
 672
 673         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_signed);
 674         let revoke_msg = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 675         // No commitment_signed so get_event_msg's assert(len == 1) passes
 676         check_added_monitors!(nodes[0], 1);
 677         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &revoke_msg);
 678         check_added_monitors!(nodes[1], 1);
 679         // AwaitingRemoteRevoke ends here
 680
 681         let commitment_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 682         assert_eq!(commitment_update.update_add_htlcs.len(), 1);
 683         assert_eq!(commitment_update.update_fulfill_htlcs.len(), 0);
 684         assert_eq!(commitment_update.update_fail_htlcs.len(), 0);
 685         assert_eq!(commitment_update.update_fail_malformed_htlcs.len(), 0);
 686         assert_eq!(commitment_update.update_fee.is_none(), true);
 687
 688         nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &commitment_update.update_add_htlcs[0]);
 689         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_update.commitment_signed);
 690         check_added_monitors!(nodes[0], 1);
 691         let (revoke, commitment_signed) = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 692
 693         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &revoke);
 694         check_added_monitors!(nodes[1], 1);
 695         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 696
 697         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &commitment_signed);
 698         check_added_monitors!(nodes[1], 1);
 699         let revoke = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
 700         // No commitment_signed so get_event_msg's assert(len == 1) passes
 701
 702         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke);
 703         check_added_monitors!(nodes[0], 1);
 704         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 705
 706         expect_pending_htlcs_forwardable!(nodes[0]);
 707
 708         let events = nodes[0].node.get_and_clear_pending_events();
 709         assert_eq!(events.len(), 1);
 710         match events[0] {
 711                 Event::PaymentReceived { .. } => { },
 712                 _ => panic!("Unexpected event"),
 713         };
 714
 715         claim_payment(&nodes[1], &vec!(&nodes[0])[..], our_payment_preimage, 800_000);
 716
 717         send_payment(&nodes[1], &vec!(&nodes[0])[..], 800000, 800_000);
 718         send_payment(&nodes[0], &vec!(&nodes[1])[..], 800000, 800_000);
 719         close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true);
 720 }
 721
 722 #[test]
 723 fn test_update_fee() {
 724         let chanmon_cfgs = create_chanmon_cfgs(2);
 725         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 726         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 727         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 728         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 729         let channel_id = chan.2;
 730
 731         // A                                        B
 732         // (1) update_fee/commitment_signed      ->
 733         //                                       <- (2) revoke_and_ack
 734         //                                       .- send (3) commitment_signed
 735         // (4) update_fee/commitment_signed      ->
 736         //                                       .- send (5) revoke_and_ack (no CS as we're awaiting a revoke)
 737         //                                       <- (3) commitment_signed delivered
 738         // send (6) revoke_and_ack               -.
 739         //                                       <- (5) deliver revoke_and_ack
 740         // (6) deliver revoke_and_ack            ->
 741         //                                       .- send (7) commitment_signed in response to (4)
 742         //                                       <- (7) deliver commitment_signed
 743         // revoke_and_ack                        ->
 744
 745         // Create and deliver (1)...
 746         let feerate = get_feerate!(nodes[0], channel_id);
 747         nodes[0].node.update_fee(channel_id, feerate+20).unwrap();
 748         check_added_monitors!(nodes[0], 1);
 749
 750         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 751         assert_eq!(events_0.len(), 1);
 752         let (update_msg, commitment_signed) = match events_0[0] {
 753                         MessageSendEvent::UpdateHTLCs { node_id:_, updates: msgs::CommitmentUpdate { update_add_htlcs:_, update_fulfill_htlcs:_, update_fail_htlcs:_, update_fail_malformed_htlcs:_, ref update_fee, ref commitment_signed } } => {
 754                         (update_fee.as_ref(), commitment_signed)
 755                 },
 756                 _ => panic!("Unexpected event"),
 757         };
 758         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
 759
 760         // Generate (2) and (3):
 761         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed);
 762         let (revoke_msg, commitment_signed_0) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 763         check_added_monitors!(nodes[1], 1);
 764
 765         // Deliver (2):
 766         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke_msg);
 767         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 768         check_added_monitors!(nodes[0], 1);
 769
 770         // Create and deliver (4)...
 771         nodes[0].node.update_fee(channel_id, feerate+30).unwrap();
 772         check_added_monitors!(nodes[0], 1);
 773         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 774         assert_eq!(events_0.len(), 1);
 775         let (update_msg, commitment_signed) = match events_0[0] {
 776                         MessageSendEvent::UpdateHTLCs { node_id:_, updates: msgs::CommitmentUpdate { update_add_htlcs:_, update_fulfill_htlcs:_, update_fail_htlcs:_, update_fail_malformed_htlcs:_, ref update_fee, ref commitment_signed } } => {
 777                         (update_fee.as_ref(), commitment_signed)
 778                 },
 779                 _ => panic!("Unexpected event"),
 780         };
 781
 782         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
 783         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed);
 784         check_added_monitors!(nodes[1], 1);
 785         // ... creating (5)
 786         let revoke_msg = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
 787         // No commitment_signed so get_event_msg's assert(len == 1) passes
 788
 789         // Handle (3), creating (6):
 790         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_signed_0);
 791         check_added_monitors!(nodes[0], 1);
 792         let revoke_msg_0 = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 793         // No commitment_signed so get_event_msg's assert(len == 1) passes
 794
 795         // Deliver (5):
 796         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke_msg);
 797         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 798         check_added_monitors!(nodes[0], 1);
 799
 800         // Deliver (6), creating (7):
 801         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &revoke_msg_0);
 802         let commitment_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 803         assert!(commitment_update.update_add_htlcs.is_empty());
 804         assert!(commitment_update.update_fulfill_htlcs.is_empty());
 805         assert!(commitment_update.update_fail_htlcs.is_empty());
 806         assert!(commitment_update.update_fail_malformed_htlcs.is_empty());
 807         assert!(commitment_update.update_fee.is_none());
 808         check_added_monitors!(nodes[1], 1);
 809
 810         // Deliver (7)
 811         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_update.commitment_signed);
 812         check_added_monitors!(nodes[0], 1);
 813         let revoke_msg = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 814         // No commitment_signed so get_event_msg's assert(len == 1) passes
 815
 816         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &revoke_msg);
 817         check_added_monitors!(nodes[1], 1);
 818         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 819
 820         assert_eq!(get_feerate!(nodes[0], channel_id), feerate + 30);
 821         assert_eq!(get_feerate!(nodes[1], channel_id), feerate + 30);
 822         close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true);
 823 }
 824
 825 #[test]
 826 fn pre_funding_lock_shutdown_test() {
 827         // Test sending a shutdown prior to funding_locked after funding generation
 828         let chanmon_cfgs = create_chanmon_cfgs(2);
 829         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 830         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 831         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 832         let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 8000000, 0, InitFeatures::known(), InitFeatures::known());
 833         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
 834         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![tx.clone()]}, 1);
 835         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![tx.clone()]}, 1);
 836
 837         nodes[0].node.close_channel(&OutPoint { txid: tx.txid(), index: 0 }.to_channel_id()).unwrap();
 838         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
 839         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
 840         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 841         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
 842
 843         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
 844         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
 845         let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
 846         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap());
 847         let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
 848         assert!(node_0_none.is_none());
 849
 850         assert!(nodes[0].node.list_channels().is_empty());
 851         assert!(nodes[1].node.list_channels().is_empty());
 852 }
 853
 854 #[test]
 855 fn updates_shutdown_wait() {
 856         // Test sending a shutdown with outstanding updates pending
 857         let chanmon_cfgs = create_chanmon_cfgs(3);
 858         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
 859         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
 860         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
 861         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 862         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
 863         let logger = test_utils::TestLogger::new();
 864
 865         let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
 866
 867         nodes[0].node.close_channel(&chan_1.2).unwrap();
 868         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
 869         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
 870         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 871         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
 872
 873         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 874         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 875
 876         let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
 877
 878         let net_graph_msg_handler0 = &nodes[0].net_graph_msg_handler;
 879         let net_graph_msg_handler1 = &nodes[1].net_graph_msg_handler;
 880         let route_1 = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler0.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 881         let route_2 = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler1.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 882         unwrap_send_err!(nodes[0].node.send_payment(&route_1, payment_hash, &None), true, APIError::ChannelUnavailable {..}, {});
 883         unwrap_send_err!(nodes[1].node.send_payment(&route_2, payment_hash, &None), true, APIError::ChannelUnavailable {..}, {});
 884
 885         assert!(nodes[2].node.claim_funds(our_payment_preimage, &None, 100_000));
 886         check_added_monitors!(nodes[2], 1);
 887         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
 888         assert!(updates.update_add_htlcs.is_empty());
 889         assert!(updates.update_fail_htlcs.is_empty());
 890         assert!(updates.update_fail_malformed_htlcs.is_empty());
 891         assert!(updates.update_fee.is_none());
 892         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
 893         nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
 894         check_added_monitors!(nodes[1], 1);
 895         let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 896         commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false);
 897
 898         assert!(updates_2.update_add_htlcs.is_empty());
 899         assert!(updates_2.update_fail_htlcs.is_empty());
 900         assert!(updates_2.update_fail_malformed_htlcs.is_empty());
 901         assert!(updates_2.update_fee.is_none());
 902         assert_eq!(updates_2.update_fulfill_htlcs.len(), 1);
 903         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]);
 904         commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
 905
 906         let events = nodes[0].node.get_and_clear_pending_events();
 907         assert_eq!(events.len(), 1);
 908         match events[0] {
 909                 Event::PaymentSent { ref payment_preimage } => {
 910                         assert_eq!(our_payment_preimage, *payment_preimage);
 911                 },
 912                 _ => panic!("Unexpected event"),
 913         }
 914
 915         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
 916         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
 917         let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
 918         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap());
 919         let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
 920         assert!(node_0_none.is_none());
 921
 922         assert!(nodes[0].node.list_channels().is_empty());
 923
 924         assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
 925         nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
 926         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
 927         assert!(nodes[1].node.list_channels().is_empty());
 928         assert!(nodes[2].node.list_channels().is_empty());
 929 }
 930
 931 #[test]
 932 fn htlc_fail_async_shutdown() {
 933         // Test HTLCs fail if shutdown starts even if messages are delivered out-of-order
 934         let chanmon_cfgs = create_chanmon_cfgs(3);
 935         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
 936         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
 937         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
 938         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 939         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
 940         let logger = test_utils::TestLogger::new();
 941
 942         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 943         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 944         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
 945         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
 946         check_added_monitors!(nodes[0], 1);
 947         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 948         assert_eq!(updates.update_add_htlcs.len(), 1);
 949         assert!(updates.update_fulfill_htlcs.is_empty());
 950         assert!(updates.update_fail_htlcs.is_empty());
 951         assert!(updates.update_fail_malformed_htlcs.is_empty());
 952         assert!(updates.update_fee.is_none());
 953
 954         nodes[1].node.close_channel(&chan_1.2).unwrap();
 955         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 956         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
 957         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
 958
 959         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
 960         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &updates.commitment_signed);
 961         check_added_monitors!(nodes[1], 1);
 962         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
 963         commitment_signed_dance!(nodes[1], nodes[0], (), false, true, false);
 964
 965         let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 966         assert!(updates_2.update_add_htlcs.is_empty());
 967         assert!(updates_2.update_fulfill_htlcs.is_empty());
 968         assert_eq!(updates_2.update_fail_htlcs.len(), 1);
 969         assert!(updates_2.update_fail_malformed_htlcs.is_empty());
 970         assert!(updates_2.update_fee.is_none());
 971
 972         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fail_htlcs[0]);
 973         commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
 974
 975         expect_payment_failed!(nodes[0], our_payment_hash, false);
 976
 977         let msg_events = nodes[0].node.get_and_clear_pending_msg_events();
 978         assert_eq!(msg_events.len(), 2);
 979         let node_0_closing_signed = match msg_events[0] {
 980                 MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => {
 981                         assert_eq!(*node_id, nodes[1].node.get_our_node_id());
 982                         (*msg).clone()
 983                 },
 984                 _ => panic!("Unexpected event"),
 985         };
 986         match msg_events[1] {
 987                 MessageSendEvent::PaymentFailureNetworkUpdate { update: msgs::HTLCFailChannelUpdate::ChannelUpdateMessage { ref msg }} => {
 988                         assert_eq!(msg.contents.short_channel_id, chan_1.0.contents.short_channel_id);
 989                 },
 990                 _ => panic!("Unexpected event"),
 991         }
 992
 993         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 994         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
 995         let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
 996         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap());
 997         let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
 998         assert!(node_0_none.is_none());
 999
1000         assert!(nodes[0].node.list_channels().is_empty());
1001
1002         assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
1003         nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
1004         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
1005         assert!(nodes[1].node.list_channels().is_empty());
1006         assert!(nodes[2].node.list_channels().is_empty());
1007 }
1008
1009 fn do_test_shutdown_rebroadcast(recv_count: u8) {
1010         // Test that shutdown/closing_signed is re-sent on reconnect with a variable number of
1011         // messages delivered prior to disconnect
1012         let chanmon_cfgs = create_chanmon_cfgs(3);
1013         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
1014         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
1015         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1016         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
1017         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
1018
1019         let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
1020
1021         nodes[1].node.close_channel(&chan_1.2).unwrap();
1022         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1023         if recv_count > 0 {
1024                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
1025                 let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1026                 if recv_count > 1 {
1027                         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
1028                 }
1029         }
1030
1031         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
1032         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
1033
1034         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
1035         let node_0_reestablish = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReestablish, nodes[1].node.get_our_node_id());
1036         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
1037         let node_1_reestablish = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
1038
1039         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &node_0_reestablish);
1040         let node_1_2nd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1041         assert!(node_1_shutdown == node_1_2nd_shutdown);
1042
1043         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &node_1_reestablish);
1044         let node_0_2nd_shutdown = if recv_count > 0 {
1045                 let node_0_2nd_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1046                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown);
1047                 node_0_2nd_shutdown
1048         } else {
1049                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1050                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown);
1051                 get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id())
1052         };
1053         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_2nd_shutdown);
1054
1055         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1056         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1057
1058         assert!(nodes[2].node.claim_funds(our_payment_preimage, &None, 100_000));
1059         check_added_monitors!(nodes[2], 1);
1060         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
1061         assert!(updates.update_add_htlcs.is_empty());
1062         assert!(updates.update_fail_htlcs.is_empty());
1063         assert!(updates.update_fail_malformed_htlcs.is_empty());
1064         assert!(updates.update_fee.is_none());
1065         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
1066         nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
1067         check_added_monitors!(nodes[1], 1);
1068         let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1069         commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false);
1070
1071         assert!(updates_2.update_add_htlcs.is_empty());
1072         assert!(updates_2.update_fail_htlcs.is_empty());
1073         assert!(updates_2.update_fail_malformed_htlcs.is_empty());
1074         assert!(updates_2.update_fee.is_none());
1075         assert_eq!(updates_2.update_fulfill_htlcs.len(), 1);
1076         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]);
1077         commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
1078
1079         let events = nodes[0].node.get_and_clear_pending_events();
1080         assert_eq!(events.len(), 1);
1081         match events[0] {
1082                 Event::PaymentSent { ref payment_preimage } => {
1083                         assert_eq!(our_payment_preimage, *payment_preimage);
1084                 },
1085                 _ => panic!("Unexpected event"),
1086         }
1087
1088         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
1089         if recv_count > 0 {
1090                 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
1091                 let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
1092                 assert!(node_1_closing_signed.is_some());
1093         }
1094
1095         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
1096         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
1097
1098         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
1099         let node_0_2nd_reestablish = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReestablish, nodes[1].node.get_our_node_id());
1100         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
1101         if recv_count == 0 {
1102                 // If all closing_signeds weren't delivered we can just resume where we left off...
1103                 let node_1_2nd_reestablish = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
1104
1105                 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &node_1_2nd_reestablish);
1106                 let node_0_3rd_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1107                 assert!(node_0_2nd_shutdown == node_0_3rd_shutdown);
1108
1109                 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &node_0_2nd_reestablish);
1110                 let node_1_3rd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1111                 assert!(node_1_3rd_shutdown == node_1_2nd_shutdown);
1112
1113                 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_3rd_shutdown);
1114                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1115
1116                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_3rd_shutdown);
1117                 let node_0_2nd_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
1118                 assert!(node_0_closing_signed == node_0_2nd_closing_signed);
1119
1120                 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed);
1121                 let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
1122                 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap());
1123                 let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
1124                 assert!(node_0_none.is_none());
1125         } else {
1126                 // If one node, however, received + responded with an identical closing_signed we end
1127                 // up erroring and node[0] will try to broadcast its own latest commitment transaction.
1128                 // There isn't really anything better we can do simply, but in the future we might
1129                 // explore storing a set of recently-closed channels that got disconnected during
1130                 // closing_signed and avoiding broadcasting local commitment txn for some timeout to
1131                 // give our counterparty enough time to (potentially) broadcast a cooperative closing
1132                 // transaction.
1133                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1134
1135                 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &node_0_2nd_reestablish);
1136                 let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
1137                 assert_eq!(msg_events.len(), 1);
1138                 if let MessageSendEvent::HandleError { ref action, .. } = msg_events[0] {
1139                         match action {
1140                                 &ErrorAction::SendErrorMessage { ref msg } => {
1141                                         nodes[0].node.handle_error(&nodes[1].node.get_our_node_id(), &msg);
1142                                         assert_eq!(msg.channel_id, chan_1.2);
1143                                 },
1144                                 _ => panic!("Unexpected event!"),
1145                         }
1146                 } else { panic!("Needed SendErrorMessage close"); }
1147
1148                 // get_closing_signed_broadcast usually eats the BroadcastChannelUpdate for us and
1149                 // checks it, but in this case nodes[0] didn't ever get a chance to receive a
1150                 // closing_signed so we do it ourselves
1151                 check_closed_broadcast!(nodes[0], false);
1152                 check_added_monitors!(nodes[0], 1);
1153         }
1154
1155         assert!(nodes[0].node.list_channels().is_empty());
1156
1157         assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
1158         nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
1159         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
1160         assert!(nodes[1].node.list_channels().is_empty());
1161         assert!(nodes[2].node.list_channels().is_empty());
1162 }
1163
1164 #[test]
1165 fn test_shutdown_rebroadcast() {
1166         do_test_shutdown_rebroadcast(0);
1167         do_test_shutdown_rebroadcast(1);
1168         do_test_shutdown_rebroadcast(2);
1169 }
1170
1171 #[test]
1172 fn fake_network_test() {
1173         // Simple test which builds a network of ChannelManagers, connects them to each other, and
1174         // tests that payments get routed and transactions broadcast in semi-reasonable ways.
1175         let chanmon_cfgs = create_chanmon_cfgs(4);
1176         let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
1177         let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
1178         let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
1179
1180         // Create some initial channels
1181         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
1182         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
1183         let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
1184
1185         // Rebalance the network a bit by relaying one payment through all the channels...
1186         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
1187         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
1188         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
1189         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
1190
1191         // Send some more payments
1192         send_payment(&nodes[1], &vec!(&nodes[2], &nodes[3])[..], 1000000, 1_000_000);
1193         send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1], &nodes[0])[..], 1000000, 1_000_000);
1194         send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1])[..], 1000000, 1_000_000);
1195
1196         // Test failure packets
1197         let payment_hash_1 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 1000000).1;
1198         fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], payment_hash_1);
1199
1200         // Add a new channel that skips 3
1201         let chan_4 = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known());
1202
1203         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 1000000, 1_000_000);
1204         send_payment(&nodes[2], &vec!(&nodes[3])[..], 1000000, 1_000_000);
1205         send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
1206         send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
1207         send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
1208         send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
1209         send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
1210
1211         // Do some rebalance loop payments, simultaneously
1212         let mut hops = Vec::with_capacity(3);
1213         hops.push(RouteHop {
1214                 pubkey: nodes[2].node.get_our_node_id(),
1215                 node_features: NodeFeatures::empty(),
1216                 short_channel_id: chan_2.0.contents.short_channel_id,
1217                 channel_features: ChannelFeatures::empty(),
1218                 fee_msat: 0,
1219                 cltv_expiry_delta: chan_3.0.contents.cltv_expiry_delta as u32
1220         });
1221         hops.push(RouteHop {
1222                 pubkey: nodes[3].node.get_our_node_id(),
1223                 node_features: NodeFeatures::empty(),
1224                 short_channel_id: chan_3.0.contents.short_channel_id,
1225                 channel_features: ChannelFeatures::empty(),
1226                 fee_msat: 0,
1227                 cltv_expiry_delta: chan_4.1.contents.cltv_expiry_delta as u32
1228         });
1229         hops.push(RouteHop {
1230                 pubkey: nodes[1].node.get_our_node_id(),
1231                 node_features: NodeFeatures::empty(),
1232                 short_channel_id: chan_4.0.contents.short_channel_id,
1233                 channel_features: ChannelFeatures::empty(),
1234                 fee_msat: 1000000,
1235                 cltv_expiry_delta: TEST_FINAL_CLTV,
1236         });
1237         hops[1].fee_msat = chan_4.1.contents.fee_base_msat as u64 + chan_4.1.contents.fee_proportional_millionths as u64 * hops[2].fee_msat as u64 / 1000000;
1238         hops[0].fee_msat = chan_3.0.contents.fee_base_msat as u64 + chan_3.0.contents.fee_proportional_millionths as u64 * hops[1].fee_msat as u64 / 1000000;
1239         let payment_preimage_1 = send_along_route(&nodes[1], Route { paths: vec![hops] }, &vec!(&nodes[2], &nodes[3], &nodes[1])[..], 1000000).0;
1240
1241         let mut hops = Vec::with_capacity(3);
1242         hops.push(RouteHop {
1243                 pubkey: nodes[3].node.get_our_node_id(),
1244                 node_features: NodeFeatures::empty(),
1245                 short_channel_id: chan_4.0.contents.short_channel_id,
1246                 channel_features: ChannelFeatures::empty(),
1247                 fee_msat: 0,
1248                 cltv_expiry_delta: chan_3.1.contents.cltv_expiry_delta as u32
1249         });
1250         hops.push(RouteHop {
1251                 pubkey: nodes[2].node.get_our_node_id(),
1252                 node_features: NodeFeatures::empty(),
1253                 short_channel_id: chan_3.0.contents.short_channel_id,
1254                 channel_features: ChannelFeatures::empty(),
1255                 fee_msat: 0,
1256                 cltv_expiry_delta: chan_2.1.contents.cltv_expiry_delta as u32
1257         });
1258         hops.push(RouteHop {
1259                 pubkey: nodes[1].node.get_our_node_id(),
1260                 node_features: NodeFeatures::empty(),
1261                 short_channel_id: chan_2.0.contents.short_channel_id,
1262                 channel_features: ChannelFeatures::empty(),
1263                 fee_msat: 1000000,
1264                 cltv_expiry_delta: TEST_FINAL_CLTV,
1265         });
1266         hops[1].fee_msat = chan_2.1.contents.fee_base_msat as u64 + chan_2.1.contents.fee_proportional_millionths as u64 * hops[2].fee_msat as u64 / 1000000;
1267         hops[0].fee_msat = chan_3.1.contents.fee_base_msat as u64 + chan_3.1.contents.fee_proportional_millionths as u64 * hops[1].fee_msat as u64 / 1000000;
1268         let payment_hash_2 = send_along_route(&nodes[1], Route { paths: vec![hops] }, &vec!(&nodes[3], &nodes[2], &nodes[1])[..], 1000000).1;
1269
1270         // Claim the rebalances...
1271         fail_payment(&nodes[1], &vec!(&nodes[3], &nodes[2], &nodes[1])[..], payment_hash_2);
1272         claim_payment(&nodes[1], &vec!(&nodes[2], &nodes[3], &nodes[1])[..], payment_preimage_1, 1_000_000);
1273
1274         // Add a duplicate new channel from 2 to 4
1275         let chan_5 = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known());
1276
1277         // Send some payments across both channels
1278         let payment_preimage_3 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000).0;
1279         let payment_preimage_4 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000).0;
1280         let payment_preimage_5 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000).0;
1281
1282
1283         route_over_limit(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000);
1284         let events = nodes[0].node.get_and_clear_pending_msg_events();
1285         assert_eq!(events.len(), 0);
1286         nodes[0].logger.assert_log_regex("lightning::ln::channelmanager".to_string(), regex::Regex::new(r"Cannot send value that would put us over the max HTLC value in flight our peer will accept \(\d+\)").unwrap(), 1);
1287
1288         //TODO: Test that routes work again here as we've been notified that the channel is full
1289
1290         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_3, 3_000_000);
1291         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_4, 3_000_000);
1292         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_5, 3_000_000);
1293
1294         // Close down the channels...
1295         close_channel(&nodes[0], &nodes[1], &chan_1.2, chan_1.3, true);
1296         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, false);
1297         close_channel(&nodes[2], &nodes[3], &chan_3.2, chan_3.3, true);
1298         close_channel(&nodes[1], &nodes[3], &chan_4.2, chan_4.3, false);
1299         close_channel(&nodes[1], &nodes[3], &chan_5.2, chan_5.3, false);
1300 }
1301
1302 #[test]
1303 fn holding_cell_htlc_counting() {
1304         // Tests that HTLCs in the holding cell count towards the pending HTLC limits on outbound HTLCs
1305         // to ensure we don't end up with HTLCs sitting around in our holding cell for several
1306         // commitment dance rounds.
1307         let chanmon_cfgs = create_chanmon_cfgs(3);
1308         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
1309         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
1310         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1311         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
1312         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
1313         let logger = test_utils::TestLogger::new();
1314
1315         let mut payments = Vec::new();
1316         for _ in 0..::ln::channel::OUR_MAX_HTLCS {
1317                 let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[0]);
1318                 let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
1319                 let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
1320                 nodes[1].node.send_payment(&route, payment_hash, &None).unwrap();
1321                 payments.push((payment_preimage, payment_hash));
1322         }
1323         check_added_monitors!(nodes[1], 1);
1324
1325         let mut events = nodes[1].node.get_and_clear_pending_msg_events();
1326         assert_eq!(events.len(), 1);
1327         let initial_payment_event = SendEvent::from_event(events.pop().unwrap());
1328         assert_eq!(initial_payment_event.node_id, nodes[2].node.get_our_node_id());
1329
1330         // There is now one HTLC in an outbound commitment transaction and (OUR_MAX_HTLCS - 1) HTLCs in
1331         // the holding cell waiting on B's RAA to send. At this point we should not be able to add
1332         // another HTLC.
1333         let (_, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
1334         {
1335                 let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
1336                 let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
1337                 unwrap_send_err!(nodes[1].node.send_payment(&route, payment_hash_1, &None), true, APIError::ChannelUnavailable { ref err },
1338                         assert!(regex::Regex::new(r"Cannot push more than their max accepted HTLCs \(\d+\)").unwrap().is_match(err)));
1339                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1340                 nodes[1].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot push more than their max accepted HTLCs".to_string(), 1);
1341         }
1342
1343         // This should also be true if we try to forward a payment.
1344         let (_, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
1345         {
1346                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
1347                 let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
1348                 nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap();
1349                 check_added_monitors!(nodes[0], 1);
1350         }
1351
1352         let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1353         assert_eq!(events.len(), 1);
1354         let payment_event = SendEvent::from_event(events.pop().unwrap());
1355         assert_eq!(payment_event.node_id, nodes[1].node.get_our_node_id());
1356
1357         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
1358         commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
1359         // We have to forward pending HTLCs twice - once tries to forward the payment forward (and
1360         // fails), the second will process the resulting failure and fail the HTLC backward.
1361         expect_pending_htlcs_forwardable!(nodes[1]);
1362         expect_pending_htlcs_forwardable!(nodes[1]);
1363         check_added_monitors!(nodes[1], 1);
1364
1365         let bs_fail_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1366         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &bs_fail_updates.update_fail_htlcs[0]);
1367         commitment_signed_dance!(nodes[0], nodes[1], bs_fail_updates.commitment_signed, false, true);
1368
1369         let events = nodes[0].node.get_and_clear_pending_msg_events();
1370         assert_eq!(events.len(), 1);
1371         match events[0] {
1372                 MessageSendEvent::PaymentFailureNetworkUpdate { update: msgs::HTLCFailChannelUpdate::ChannelUpdateMessage { ref msg }} => {
1373                         assert_eq!(msg.contents.short_channel_id, chan_2.0.contents.short_channel_id);
1374                 },
1375                 _ => panic!("Unexpected event"),
1376         }
1377
1378         expect_payment_failed!(nodes[0], payment_hash_2, false);
1379
1380         // Now forward all the pending HTLCs and claim them back
1381         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &initial_payment_event.msgs[0]);
1382         nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &initial_payment_event.commitment_msg);
1383         check_added_monitors!(nodes[2], 1);
1384
1385         let (bs_revoke_and_ack, bs_commitment_signed) = get_revoke_commit_msgs!(nodes[2], nodes[1].node.get_our_node_id());
1386         nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &bs_revoke_and_ack);
1387         check_added_monitors!(nodes[1], 1);
1388         let as_updates = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
1389
1390         nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &bs_commitment_signed);
1391         check_added_monitors!(nodes[1], 1);
1392         let as_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[2].node.get_our_node_id());
1393
1394         for ref update in as_updates.update_add_htlcs.iter() {
1395                 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), update);
1396         }
1397         nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &as_updates.commitment_signed);
1398         check_added_monitors!(nodes[2], 1);
1399         nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_raa);
1400         check_added_monitors!(nodes[2], 1);
1401         let (bs_revoke_and_ack, bs_commitment_signed) = get_revoke_commit_msgs!(nodes[2], nodes[1].node.get_our_node_id());
1402
1403         nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &bs_revoke_and_ack);
1404         check_added_monitors!(nodes[1], 1);
1405         nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &bs_commitment_signed);
1406         check_added_monitors!(nodes[1], 1);
1407         let as_final_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[2].node.get_our_node_id());
1408
1409         nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_final_raa);
1410         check_added_monitors!(nodes[2], 1);
1411
1412         expect_pending_htlcs_forwardable!(nodes[2]);
1413
1414         let events = nodes[2].node.get_and_clear_pending_events();
1415         assert_eq!(events.len(), payments.len());
1416         for (event, &(_, ref hash)) in events.iter().zip(payments.iter()) {
1417                 match event {
1418                         &Event::PaymentReceived { ref payment_hash, .. } => {
1419                                 assert_eq!(*payment_hash, *hash);
1420                         },
1421                         _ => panic!("Unexpected event"),
1422                 };
1423         }
1424
1425         for (preimage, _) in payments.drain(..) {
1426                 claim_payment(&nodes[1], &[&nodes[2]], preimage, 100_000);
1427         }
1428
1429         send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000, 1_000_000);
1430 }
1431
1432 #[test]
1433 fn duplicate_htlc_test() {
1434         // Test that we accept duplicate payment_hash HTLCs across the network and that
1435         // claiming/failing them are all separate and don't affect each other
1436         let chanmon_cfgs = create_chanmon_cfgs(6);
1437         let node_cfgs = create_node_cfgs(6, &chanmon_cfgs);
1438         let node_chanmgrs = create_node_chanmgrs(6, &node_cfgs, &[None, None, None, None, None, None]);
1439         let mut nodes = create_network(6, &node_cfgs, &node_chanmgrs);
1440
1441         // Create some initial channels to route via 3 to 4/5 from 0/1/2
1442         create_announced_chan_between_nodes(&nodes, 0, 3, InitFeatures::known(), InitFeatures::known());
1443         create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known());
1444         create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
1445         create_announced_chan_between_nodes(&nodes, 3, 4, InitFeatures::known(), InitFeatures::known());
1446         create_announced_chan_between_nodes(&nodes, 3, 5, InitFeatures::known(), InitFeatures::known());
1447
1448         let (payment_preimage, payment_hash) = route_payment(&nodes[0], &vec!(&nodes[3], &nodes[4])[..], 1000000);
1449
1450         *nodes[0].network_payment_count.borrow_mut() -= 1;
1451         assert_eq!(route_payment(&nodes[1], &vec!(&nodes[3])[..], 1000000).0, payment_preimage);
1452
1453         *nodes[0].network_payment_count.borrow_mut() -= 1;
1454         assert_eq!(route_payment(&nodes[2], &vec!(&nodes[3], &nodes[5])[..], 1000000).0, payment_preimage);
1455
1456         claim_payment(&nodes[0], &vec!(&nodes[3], &nodes[4])[..], payment_preimage, 1_000_000);
1457         fail_payment(&nodes[2], &vec!(&nodes[3], &nodes[5])[..], payment_hash);
1458         claim_payment(&nodes[1], &vec!(&nodes[3])[..], payment_preimage, 1_000_000);
1459 }
1460
1461 #[test]
1462 fn test_duplicate_htlc_different_direction_onchain() {
1463         // Test that ChannelMonitor doesn't generate 2 preimage txn
1464         // when we have 2 HTLCs with same preimage that go across a node
1465         // in opposite directions.
1466         let chanmon_cfgs = create_chanmon_cfgs(2);
1467         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1468         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1469         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1470
1471         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
1472         let logger = test_utils::TestLogger::new();
1473
1474         // balancing
1475         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
1476
1477         let (payment_preimage, payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 900_000);
1478
1479         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
1480         let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), None, &Vec::new(), 800_000, TEST_FINAL_CLTV, &logger).unwrap();
1481         send_along_route_with_hash(&nodes[1], route, &vec!(&nodes[0])[..], 800_000, payment_hash);
1482
1483         // Provide preimage to node 0 by claiming payment
1484         nodes[0].node.claim_funds(payment_preimage, &None, 800_000);
1485         check_added_monitors!(nodes[0], 1);
1486
1487         // Broadcast node 1 commitment txn
1488         let remote_txn = get_local_commitment_txn!(nodes[1], chan_1.2);
1489
1490         assert_eq!(remote_txn[0].output.len(), 4); // 1 local, 1 remote, 1 htlc inbound, 1 htlc outbound
1491         let mut has_both_htlcs = 0; // check htlcs match ones committed
1492         for outp in remote_txn[0].output.iter() {
1493                 if outp.value == 800_000 / 1000 {
1494                         has_both_htlcs += 1;
1495                 } else if outp.value == 900_000 / 1000 {
1496                         has_both_htlcs += 1;
1497                 }
1498         }
1499         assert_eq!(has_both_htlcs, 2);
1500
1501         let header = BlockHeader { version: 0x2000_0000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
1502         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![remote_txn[0].clone()] }, 1);
1503         check_added_monitors!(nodes[0], 1);
1504
1505         // Check we only broadcast 1 timeout tx
1506         let claim_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
1507         let htlc_pair = if claim_txn[0].output[0].value == 800_000 / 1000 { (claim_txn[0].clone(), claim_txn[1].clone()) } else { (claim_txn[1].clone(), claim_txn[0].clone()) };
1508         assert_eq!(claim_txn.len(), 5);
1509         check_spends!(claim_txn[2], chan_1.3);
1510         check_spends!(claim_txn[3], claim_txn[2]);
1511         assert_eq!(htlc_pair.0.input.len(), 1);
1512         assert_eq!(htlc_pair.0.input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT); // HTLC 1 <--> 0, preimage tx
1513         check_spends!(htlc_pair.0, remote_txn[0]);
1514         assert_eq!(htlc_pair.1.input.len(), 1);
1515         assert_eq!(htlc_pair.1.input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT); // HTLC 0 <--> 1, timeout tx
1516         check_spends!(htlc_pair.1, remote_txn[0]);
1517
1518         let events = nodes[0].node.get_and_clear_pending_msg_events();
1519         assert_eq!(events.len(), 2);
1520         for e in events {
1521                 match e {
1522                         MessageSendEvent::BroadcastChannelUpdate { .. } => {},
1523                         MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, .. } } => {
1524                                 assert!(update_add_htlcs.is_empty());
1525                                 assert!(update_fail_htlcs.is_empty());
1526                                 assert_eq!(update_fulfill_htlcs.len(), 1);
1527                                 assert!(update_fail_malformed_htlcs.is_empty());
1528                                 assert_eq!(nodes[1].node.get_our_node_id(), *node_id);
1529                         },
1530                         _ => panic!("Unexpected event"),
1531                 }
1532         }
1533 }
1534
1535 #[test]
1536 fn test_basic_channel_reserve() {
1537         let chanmon_cfgs = create_chanmon_cfgs(2);
1538         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1539         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1540         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1541         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
1542         let logger = test_utils::TestLogger::new();
1543
1544         let chan_stat = get_channel_value_stat!(nodes[0], chan.2);
1545         let channel_reserve = chan_stat.channel_reserve_msat;
1546
1547         // The 2* and +1 are for the fee spike reserve.
1548         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
1549         let commit_tx_fee = 2 * commit_tx_fee_msat(get_feerate!(nodes[0], chan.2), 1 + 1);
1550         let max_can_send = 5000000 - channel_reserve - commit_tx_fee;
1551         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
1552         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes.last().unwrap().node.get_our_node_id(), None, &Vec::new(), max_can_send + 1, TEST_FINAL_CLTV, &logger).unwrap();
1553         let err = nodes[0].node.send_payment(&route, our_payment_hash, &None).err().unwrap();
1554         match err {
1555                 PaymentSendFailure::AllFailedRetrySafe(ref fails) => {
1556                         match &fails[0] {
1557                                 &APIError::ChannelUnavailable{ref err} =>
1558                                         assert!(regex::Regex::new(r"Cannot send value that would put us under local channel reserve value \(\d+\)").unwrap().is_match(err)),
1559                                 _ => panic!("Unexpected error variant"),
1560                         }
1561                 },
1562                 _ => panic!("Unexpected error variant"),
1563         }
1564         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1565         nodes[0].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot send value that would put us under local channel reserve value".to_string(), 1);
1566
1567         send_payment(&nodes[0], &vec![&nodes[1]], max_can_send, max_can_send);
1568 }
1569
1570 #[test]
1571 fn test_fee_spike_violation_fails_htlc() {
1572         let chanmon_cfgs = create_chanmon_cfgs(2);
1573         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1574         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1575         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1576         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
1577         let logger = test_utils::TestLogger::new();
1578
1579         macro_rules! get_route_and_payment_hash {
1580                 ($recv_value: expr) => {{
1581                         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[1]);
1582                         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler.network_graph.read().unwrap();
1583                         let route = get_route(&nodes[0].node.get_our_node_id(), net_graph_msg_handler, &nodes.last().unwrap().node.get_our_node_id(), None, &Vec::new(), $recv_value, TEST_FINAL_CLTV, &logger).unwrap();
1584                         (route, payment_hash, payment_preimage)
1585                 }}
1586         };
1587
1588         let (route, payment_hash, _) = get_route_and_payment_hash!(3460001);
1589         // Need to manually create the update_add_htlc message to go around the channel reserve check in send_htlc()
1590         let secp_ctx = Secp256k1::new();
1591         let session_priv = SecretKey::from_slice(&[42; 32]).expect("RNG is bad!");
1592
1593         let cur_height = nodes[1].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
1594
1595         let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route.paths[0], &session_priv).unwrap();
1596         let (onion_payloads, htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 3460001, &None, cur_height).unwrap();
1597         let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash);
1598         let msg = msgs::UpdateAddHTLC {
1599                 channel_id: chan.2,
1600                 htlc_id: 0,
1601                 amount_msat: htlc_msat,
1602                 payment_hash: payment_hash,
1603                 cltv_expiry: htlc_cltv,
1604                 onion_routing_packet: onion_packet,
1605         };
1606
1607         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &msg);
1608
1609         // Now manually create the commitment_signed message corresponding to the update_add
1610         // nodes[0] just sent. In the code for construction of this message, "local" refers
1611         // to the sender of the message, and "remote" refers to the receiver.
1612
1613         let feerate_per_kw = get_feerate!(nodes[0], chan.2);
1614
1615         const INITIAL_COMMITMENT_NUMBER: u64 = (1 << 48) - 1;
1616
1617         // Get the EnforcingChannelKeys for each channel, which will be used to (1) get the keys
1618         // needed to sign the new commitment tx and (2) sign the new commitment tx.
1619         let (local_revocation_basepoint, local_htlc_basepoint, local_payment_point, local_secret, local_secret2) = {
1620                 let chan_lock = nodes[0].node.channel_state.lock().unwrap();
1621                 let local_chan = chan_lock.by_id.get(&chan.2).unwrap();
1622                 let chan_keys = local_chan.get_local_keys();
1623                 let pubkeys = chan_keys.pubkeys();
1624                 (pubkeys.revocation_basepoint, pubkeys.htlc_basepoint, pubkeys.payment_point,
1625                  chan_keys.release_commitment_secret(INITIAL_COMMITMENT_NUMBER), chan_keys.release_commitment_secret(INITIAL_COMMITMENT_NUMBER - 2))
1626         };
1627         let (remote_delayed_payment_basepoint, remote_htlc_basepoint, remote_payment_point, remote_secret1) = {
1628                 let chan_lock = nodes[1].node.channel_state.lock().unwrap();
1629                 let remote_chan = chan_lock.by_id.get(&chan.2).unwrap();
1630                 let chan_keys = remote_chan.get_local_keys();
1631                 let pubkeys = chan_keys.pubkeys();
1632                 (pubkeys.delayed_payment_basepoint, pubkeys.htlc_basepoint, pubkeys.payment_point,
1633                  chan_keys.release_commitment_secret(INITIAL_COMMITMENT_NUMBER - 1))
1634         };
1635
1636         // Assemble the set of keys we can use for signatures for our commitment_signed message.
1637         let commitment_secret = SecretKey::from_slice(&remote_secret1).unwrap();
1638         let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &commitment_secret);
1639         let commit_tx_keys = chan_utils::TxCreationKeys::new(&secp_ctx, &per_commitment_point, &remote_delayed_payment_basepoint,
1640                 &remote_htlc_basepoint, &local_revocation_basepoint, &local_htlc_basepoint).unwrap();
1641
1642         // Build the remote commitment transaction so we can sign it, and then later use the
1643         // signature for the commitment_signed message.
1644         let local_chan_balance = 1313;
1645         let static_payment_pk = local_payment_point.serialize();
1646         let remote_commit_tx_output = TxOut {
1647                                 script_pubkey: Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0)
1648                                                              .push_slice(&WPubkeyHash::hash(&static_payment_pk)[..])
1649                                                              .into_script(),
1650                 value: local_chan_balance as u64
1651         };
1652
1653         let local_commit_tx_output = TxOut {
1654                 script_pubkey: chan_utils::get_revokeable_redeemscript(&commit_tx_keys.revocation_key,
1655                                                                                BREAKDOWN_TIMEOUT,
1656                                                                                &commit_tx_keys.a_delayed_payment_key).to_v0_p2wsh(),
1657                                 value: 95000,
1658         };
1659
1660         let accepted_htlc_info = chan_utils::HTLCOutputInCommitment {
1661                 offered: false,
1662                 amount_msat: 3460001,
1663                 cltv_expiry: htlc_cltv,
1664                 payment_hash: payment_hash,
1665                 transaction_output_index: Some(1),
1666         };
1667
1668         let htlc_output = TxOut {
1669                 script_pubkey: chan_utils::get_htlc_redeemscript(&accepted_htlc_info, &commit_tx_keys).to_v0_p2wsh(),
1670                 value: 3460001 / 1000
1671         };
1672
1673         let commit_tx_obscure_factor = {
1674                 let mut sha = Sha256::engine();
1675                 let remote_payment_point = &remote_payment_point.serialize();
1676                 sha.input(&local_payment_point.serialize());
1677                 sha.input(remote_payment_point);
1678                 let res = Sha256::from_engine(sha).into_inner();
1679
1680                 ((res[26] as u64) << 5*8) |
1681                 ((res[27] as u64) << 4*8) |
1682                 ((res[28] as u64) << 3*8) |
1683                 ((res[29] as u64) << 2*8) |
1684                 ((res[30] as u64) << 1*8) |
1685                 ((res[31] as u64) << 0*8)
1686         };
1687         let commitment_number = 1;
1688         let obscured_commitment_transaction_number = commit_tx_obscure_factor ^ commitment_number;
1689         let lock_time = ((0x20 as u32) << 8*3) | ((obscured_commitment_transaction_number & 0xffffffu64) as u32);
1690         let input = TxIn {
1691                 previous_output: BitcoinOutPoint { txid: chan.3.txid(), vout: 0 },
1692                 script_sig: Script::new(),
1693                 sequence: ((0x80 as u32) << 8*3) | ((obscured_commitment_transaction_number >> 3*8) as u32),
1694                 witness: Vec::new(),
1695         };
1696
1697         let commit_tx = Transaction {
1698                 version: 2,
1699                 lock_time,
1700                 input: vec![input],
1701                 output: vec![remote_commit_tx_output, htlc_output, local_commit_tx_output],
1702         };
1703         let res = {
1704                 let local_chan_lock = nodes[0].node.channel_state.lock().unwrap();
1705                 let local_chan = local_chan_lock.by_id.get(&chan.2).unwrap();
1706                 let local_chan_keys = local_chan.get_local_keys();
1707                 let pre_commit_tx_keys = PreCalculatedTxCreationKeys::new(commit_tx_keys);
1708                 local_chan_keys.sign_remote_commitment(feerate_per_kw, &commit_tx, &pre_commit_tx_keys, &[&accepted_htlc_info], &secp_ctx).unwrap()
1709         };
1710
1711         let commit_signed_msg = msgs::CommitmentSigned {
1712                 channel_id: chan.2,
1713                 signature: res.0,
1714                 htlc_signatures: res.1
1715         };
1716
1717         // Send the commitment_signed message to the nodes[1].
1718         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &commit_signed_msg);
1719         let _ = nodes[1].node.get_and_clear_pending_msg_events();
1720
1721         // Send the RAA to nodes[1].
1722         let per_commitment_secret = local_secret;
1723         let next_secret = SecretKey::from_slice(&local_secret2).unwrap();
1724         let next_per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &next_secret);
1725         let raa_msg = msgs::RevokeAndACK{ channel_id: chan.2, per_commitment_secret, next_per_commitment_point};
1726         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &raa_msg);
1727
1728         let events = nodes[1].node.get_and_clear_pending_msg_events();
1729         assert_eq!(events.len(), 1);
1730         // Make sure the HTLC failed in the way we expect.
1731         match events[0] {
1732                 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fail_htlcs, .. }, .. } => {
1733                         assert_eq!(update_fail_htlcs.len(), 1);
1734                         update_fail_htlcs[0].clone()
1735                 },
1736                 _ => panic!("Unexpected event"),
1737         };
1738         nodes[1].logger.assert_log("lightning::ln::channel".to_string(), "Attempting to fail HTLC due to fee spike buffer violation".to_string(), 1);
1739
1740         check_added_monitors!(nodes[1], 2);
1741 }
1742
1743 #[test]
1744 fn test_chan_reserve_violation_outbound_htlc_inbound_chan() {
1745         let mut chanmon_cfgs = create_chanmon_cfgs(2);
1746         // Set the fee rate for the channel very high, to the point where the fundee
1747         // sending any amount would result in a channel reserve violation. In this test
1748         // we check that we would be prevented from sending an HTLC in this situation.
1749         chanmon_cfgs[0].fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 6000 };
1750         chanmon_cfgs[1].fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 6000 };
1751         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1752         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1753         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1754         let _ = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
1755         let logger = test_utils::TestLogger::new();
1756
1757         macro_rules! get_route_and_payment_hash {
1758                 ($recv_value: expr) => {{
1759                         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[1]);
1760                         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
1761                         let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes.first().unwrap().node.get_our_node_id(), None, &Vec::new(), $recv_value, TEST_FINAL_CLTV, &logger).unwrap();
1762                         (route, payment_hash, payment_preimage)
1763                 }}
1764         };
1765
1766         let (route, our_payment_hash, _) = get_route_and_payment_hash!(1000);
1767         unwrap_send_err!(nodes[1].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
1768                 assert_eq!(err, "Cannot send value that would put them under remote channel reserve value"));
1769         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1770         nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Cannot send value that would put them under remote channel reserve value".to_string(), 1);
1771 }
1772
1773 #[test]
1774 fn test_chan_reserve_violation_inbound_htlc_outbound_channel() {
1775         let mut chanmon_cfgs = create_chanmon_cfgs(2);
1776         // Set the fee rate for the channel very high, to the point where the funder
1777         // receiving 1 update_add_htlc would result in them closing the channel due
1778         // to channel reserve violation. This close could also happen if the fee went
1779         // up a more realistic amount, but many HTLCs were outstanding at the time of
1780         // the update_add_htlc.
1781         chanmon_cfgs[0].fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 6000 };
1782         chanmon_cfgs[1].fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 6000 };
1783         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1784         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1785         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1786         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
1787         let logger = test_utils::TestLogger::new();
1788
1789         macro_rules! get_route_and_payment_hash {
1790                 ($recv_value: expr) => {{
1791                         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[1]);
1792                         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
1793                         let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes.first().unwrap().node.get_our_node_id(), None, &Vec::new(), $recv_value, TEST_FINAL_CLTV, &logger).unwrap();
1794                         (route, payment_hash, payment_preimage)
1795                 }}
1796         };
1797
1798         let (route, payment_hash, _) = get_route_and_payment_hash!(1000);
1799         // Need to manually create the update_add_htlc message to go around the channel reserve check in send_htlc()
1800         let secp_ctx = Secp256k1::new();
1801         let session_priv = SecretKey::from_slice(&[42; 32]).unwrap();
1802         let cur_height = nodes[1].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
1803         let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route.paths[0], &session_priv).unwrap();
1804         let (onion_payloads, htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 1000, &None, cur_height).unwrap();
1805         let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash);
1806         let msg = msgs::UpdateAddHTLC {
1807                 channel_id: chan.2,
1808                 htlc_id: 1,
1809                 amount_msat: htlc_msat + 1,
1810                 payment_hash: payment_hash,
1811                 cltv_expiry: htlc_cltv,
1812                 onion_routing_packet: onion_packet,
1813         };
1814
1815         nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &msg);
1816         // Check that the payment failed and the channel is closed in response to the malicious UpdateAdd.
1817         nodes[0].logger.assert_log("lightning::ln::channelmanager".to_string(), "Cannot receive value that would put us under local channel reserve value".to_string(), 1);
1818         assert_eq!(nodes[0].node.list_channels().len(), 0);
1819         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
1820         assert_eq!(err_msg.data, "Cannot receive value that would put us under local channel reserve value");
1821         check_added_monitors!(nodes[0], 1);
1822 }
1823
1824 #[test]
1825 fn test_chan_reserve_violation_inbound_htlc_inbound_chan() {
1826         let chanmon_cfgs = create_chanmon_cfgs(3);
1827         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
1828         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
1829         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1830         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
1831         let _ = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
1832         let logger = test_utils::TestLogger::new();
1833
1834         macro_rules! get_route_and_payment_hash {
1835                 ($recv_value: expr) => {{
1836                         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[0]);
1837                         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
1838                         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes.last().unwrap().node.get_our_node_id(), None, &Vec::new(), $recv_value, TEST_FINAL_CLTV, &logger).unwrap();
1839                         (route, payment_hash, payment_preimage)
1840                 }}
1841         };
1842
1843         let feemsat = 239;
1844         let total_routing_fee_msat = (nodes.len() - 2) as u64 * feemsat;
1845         let chan_stat = get_channel_value_stat!(nodes[0], chan.2);
1846         let feerate = get_feerate!(nodes[0], chan.2);
1847
1848         // Add a 2* and +1 for the fee spike reserve.
1849         let commit_tx_fee_2_htlc = 2*commit_tx_fee_msat(feerate, 2 + 1);
1850         let recv_value_1 = (chan_stat.value_to_self_msat - chan_stat.channel_reserve_msat - total_routing_fee_msat - commit_tx_fee_2_htlc)/2;
1851         let amt_msat_1 = recv_value_1 + total_routing_fee_msat;
1852
1853         // Add a pending HTLC.
1854         let (route_1, our_payment_hash_1, _) = get_route_and_payment_hash!(amt_msat_1);
1855         let payment_event_1 = {
1856                 nodes[0].node.send_payment(&route_1, our_payment_hash_1, &None).unwrap();
1857                 check_added_monitors!(nodes[0], 1);
1858
1859                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1860                 assert_eq!(events.len(), 1);
1861                 SendEvent::from_event(events.remove(0))
1862         };
1863         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event_1.msgs[0]);
1864
1865         // Attempt to trigger a channel reserve violation --> payment failure.
1866         let commit_tx_fee_2_htlcs = commit_tx_fee_msat(feerate, 2);
1867         let recv_value_2 = chan_stat.value_to_self_msat - amt_msat_1 - chan_stat.channel_reserve_msat - total_routing_fee_msat - commit_tx_fee_2_htlcs + 1;
1868         let amt_msat_2 = recv_value_2 + total_routing_fee_msat;
1869         let (route_2, _, _) = get_route_and_payment_hash!(amt_msat_2);
1870
1871         // Need to manually create the update_add_htlc message to go around the channel reserve check in send_htlc()
1872         let secp_ctx = Secp256k1::new();
1873         let session_priv = SecretKey::from_slice(&[42; 32]).unwrap();
1874         let cur_height = nodes[0].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
1875         let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route_2.paths[0], &session_priv).unwrap();
1876         let (onion_payloads, htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route_2.paths[0], recv_value_2, &None, cur_height).unwrap();
1877         let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &our_payment_hash_1);
1878         let msg = msgs::UpdateAddHTLC {
1879                 channel_id: chan.2,
1880                 htlc_id: 1,
1881                 amount_msat: htlc_msat + 1,
1882                 payment_hash: our_payment_hash_1,
1883                 cltv_expiry: htlc_cltv,
1884                 onion_routing_packet: onion_packet,
1885         };
1886
1887         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &msg);
1888         // Check that the payment failed and the channel is closed in response to the malicious UpdateAdd.
1889         nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Remote HTLC add would put them under remote reserve value".to_string(), 1);
1890         assert_eq!(nodes[1].node.list_channels().len(), 1);
1891         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
1892         assert_eq!(err_msg.data, "Remote HTLC add would put them under remote reserve value");
1893         check_added_monitors!(nodes[1], 1);
1894 }
1895
1896 fn commit_tx_fee_msat(feerate: u32, num_htlcs: u64) -> u64 {
1897         (COMMITMENT_TX_BASE_WEIGHT + num_htlcs * COMMITMENT_TX_WEIGHT_PER_HTLC) * feerate as u64 / 1000 * 1000
1898 }
1899
1900 #[test]
1901 fn test_channel_reserve_holding_cell_htlcs() {
1902         let chanmon_cfgs = create_chanmon_cfgs(3);
1903         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
1904         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
1905         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1906         let chan_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 190000, 1001, InitFeatures::known(), InitFeatures::known());
1907         let chan_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 190000, 1001, InitFeatures::known(), InitFeatures::known());
1908         let logger = test_utils::TestLogger::new();
1909
1910         let mut stat01 = get_channel_value_stat!(nodes[0], chan_1.2);
1911         let mut stat11 = get_channel_value_stat!(nodes[1], chan_1.2);
1912
1913         let mut stat12 = get_channel_value_stat!(nodes[1], chan_2.2);
1914         let mut stat22 = get_channel_value_stat!(nodes[2], chan_2.2);
1915
1916         macro_rules! get_route_and_payment_hash {
1917                 ($recv_value: expr) => {{
1918                         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[0]);
1919                         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
1920                         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes.last().unwrap().node.get_our_node_id(), None, &Vec::new(), $recv_value, TEST_FINAL_CLTV, &logger).unwrap();
1921                         (route, payment_hash, payment_preimage)
1922                 }}
1923         };
1924
1925         macro_rules! expect_forward {
1926                 ($node: expr) => {{
1927                         let mut events = $node.node.get_and_clear_pending_msg_events();
1928                         assert_eq!(events.len(), 1);
1929                         check_added_monitors!($node, 1);
1930                         let payment_event = SendEvent::from_event(events.remove(0));
1931                         payment_event
1932                 }}
1933         }
1934
1935         let feemsat = 239; // somehow we know?
1936         let total_fee_msat = (nodes.len() - 2) as u64 * feemsat;
1937         let feerate = get_feerate!(nodes[0], chan_1.2);
1938
1939         let recv_value_0 = stat01.their_max_htlc_value_in_flight_msat - total_fee_msat;
1940
1941         // attempt to send amt_msat > their_max_htlc_value_in_flight_msat
1942         {
1943                 let (route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value_0 + 1);
1944                 assert!(route.paths[0].iter().rev().skip(1).all(|h| h.fee_msat == feemsat));
1945                 unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
1946                         assert!(regex::Regex::new(r"Cannot send value that would put us over the max HTLC value in flight our peer will accept \(\d+\)").unwrap().is_match(err)));
1947                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1948                 nodes[0].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot send value that would put us over the max HTLC value in flight our peer will accept".to_string(), 1);
1949         }
1950
1951         // channel reserve is bigger than their_max_htlc_value_in_flight_msat so loop to deplete
1952         // nodes[0]'s wealth
1953         loop {
1954                 let amt_msat = recv_value_0 + total_fee_msat;
1955                 // 3 for the 3 HTLCs that will be sent, 2* and +1 for the fee spike reserve.
1956                 // Also, ensure that each payment has enough to be over the dust limit to
1957                 // ensure it'll be included in each commit tx fee calculation.
1958                 let commit_tx_fee_all_htlcs = 2*commit_tx_fee_msat(feerate, 3 + 1);
1959                 let ensure_htlc_amounts_above_dust_buffer = 3 * (stat01.their_dust_limit_msat + 1000);
1960                 if stat01.value_to_self_msat < stat01.channel_reserve_msat + commit_tx_fee_all_htlcs + ensure_htlc_amounts_above_dust_buffer + amt_msat {
1961                         break;
1962                 }
1963                 send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_0, recv_value_0);
1964
1965                 let (stat01_, stat11_, stat12_, stat22_) = (
1966                         get_channel_value_stat!(nodes[0], chan_1.2),
1967                         get_channel_value_stat!(nodes[1], chan_1.2),
1968                         get_channel_value_stat!(nodes[1], chan_2.2),
1969                         get_channel_value_stat!(nodes[2], chan_2.2),
1970                 );
1971
1972                 assert_eq!(stat01_.value_to_self_msat, stat01.value_to_self_msat - amt_msat);
1973                 assert_eq!(stat11_.value_to_self_msat, stat11.value_to_self_msat + amt_msat);
1974                 assert_eq!(stat12_.value_to_self_msat, stat12.value_to_self_msat - (amt_msat - feemsat));
1975                 assert_eq!(stat22_.value_to_self_msat, stat22.value_to_self_msat + (amt_msat - feemsat));
1976                 stat01 = stat01_; stat11 = stat11_; stat12 = stat12_; stat22 = stat22_;
1977         }
1978
1979         // adding pending output.
1980         // 2* and +1 HTLCs on the commit tx fee for the fee spike reserve.
1981         // The reason we're dividing by two here is as follows: the dividend is the total outbound liquidity
1982         // after fees, the channel reserve, and the fee spike buffer are removed. We eventually want to
1983         // divide this quantity into 3 portions, that will each be sent in an HTLC. This allows us
1984         // to test channel channel reserve policy at the edges of what amount is sendable, i.e.
1985         // cases where 1 msat over X amount will cause a payment failure, but anything less than
1986         // that can be sent successfully. So, dividing by two is a somewhat arbitrary way of getting
1987         // the amount of the first of these aforementioned 3 payments. The reason we split into 3 payments
1988         // is to test the behavior of the holding cell with respect to channel reserve and commit tx fee
1989         // policy.
1990         let commit_tx_fee_2_htlcs = 2*commit_tx_fee_msat(feerate, 2 + 1);
1991         let recv_value_1 = (stat01.value_to_self_msat - stat01.channel_reserve_msat - total_fee_msat - commit_tx_fee_2_htlcs)/2;
1992         let amt_msat_1 = recv_value_1 + total_fee_msat;
1993
1994         let (route_1, our_payment_hash_1, our_payment_preimage_1) = get_route_and_payment_hash!(recv_value_1);
1995         let payment_event_1 = {
1996                 nodes[0].node.send_payment(&route_1, our_payment_hash_1, &None).unwrap();
1997                 check_added_monitors!(nodes[0], 1);
1998
1999                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
2000                 assert_eq!(events.len(), 1);
2001                 SendEvent::from_event(events.remove(0))
2002         };
2003         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event_1.msgs[0]);
2004
2005         // channel reserve test with htlc pending output > 0
2006         let recv_value_2 = stat01.value_to_self_msat - amt_msat_1 - stat01.channel_reserve_msat - total_fee_msat - commit_tx_fee_2_htlcs;
2007         {
2008                 let (route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value_2 + 1);
2009                 unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
2010                         assert!(regex::Regex::new(r"Cannot send value that would put us under local channel reserve value \(\d+\)").unwrap().is_match(err)));
2011                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
2012         }
2013
2014         // split the rest to test holding cell
2015         let commit_tx_fee_3_htlcs = 2*commit_tx_fee_msat(feerate, 3 + 1);
2016         let additional_htlc_cost_msat = commit_tx_fee_3_htlcs - commit_tx_fee_2_htlcs;
2017         let recv_value_21 = recv_value_2/2 - additional_htlc_cost_msat/2;
2018         let recv_value_22 = recv_value_2 - recv_value_21 - total_fee_msat - additional_htlc_cost_msat;
2019         {
2020                 let stat = get_channel_value_stat!(nodes[0], chan_1.2);
2021                 assert_eq!(stat.value_to_self_msat - (stat.pending_outbound_htlcs_amount_msat + recv_value_21 + recv_value_22 + total_fee_msat + total_fee_msat + commit_tx_fee_3_htlcs), stat.channel_reserve_msat);
2022         }
2023
2024         // now see if they go through on both sides
2025         let (route_21, our_payment_hash_21, our_payment_preimage_21) = get_route_and_payment_hash!(recv_value_21);
2026         // but this will stuck in the holding cell
2027         nodes[0].node.send_payment(&route_21, our_payment_hash_21, &None).unwrap();
2028         check_added_monitors!(nodes[0], 0);
2029         let events = nodes[0].node.get_and_clear_pending_events();
2030         assert_eq!(events.len(), 0);
2031
2032         // test with outbound holding cell amount > 0
2033         {
2034                 let (route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value_22+1);
2035                 unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
2036                         assert!(regex::Regex::new(r"Cannot send value that would put us under local channel reserve value \(\d+\)").unwrap().is_match(err)));
2037                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
2038                 nodes[0].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot send value that would put us under local channel reserve value".to_string(), 2);
2039         }
2040
2041         let (route_22, our_payment_hash_22, our_payment_preimage_22) = get_route_and_payment_hash!(recv_value_22);
2042         // this will also stuck in the holding cell
2043         nodes[0].node.send_payment(&route_22, our_payment_hash_22, &None).unwrap();
2044         check_added_monitors!(nodes[0], 0);
2045         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
2046         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
2047
2048         // flush the pending htlc
2049         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event_1.commitment_msg);
2050         let (as_revoke_and_ack, as_commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
2051         check_added_monitors!(nodes[1], 1);
2052
2053         // the pending htlc should be promoted to committed
2054         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_revoke_and_ack);
2055         check_added_monitors!(nodes[0], 1);
2056         let commitment_update_2 = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
2057
2058         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &as_commitment_signed);
2059         let bs_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
2060         // No commitment_signed so get_event_msg's assert(len == 1) passes
2061         check_added_monitors!(nodes[0], 1);
2062
2063         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &bs_revoke_and_ack);
2064         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
2065         check_added_monitors!(nodes[1], 1);
2066
2067         expect_pending_htlcs_forwardable!(nodes[1]);
2068
2069         let ref payment_event_11 = expect_forward!(nodes[1]);
2070         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_11.msgs[0]);
2071         commitment_signed_dance!(nodes[2], nodes[1], payment_event_11.commitment_msg, false);
2072
2073         expect_pending_htlcs_forwardable!(nodes[2]);
2074         expect_payment_received!(nodes[2], our_payment_hash_1, recv_value_1);
2075
2076         // flush the htlcs in the holding cell
2077         assert_eq!(commitment_update_2.update_add_htlcs.len(), 2);
2078         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &commitment_update_2.update_add_htlcs[0]);
2079         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &commitment_update_2.update_add_htlcs[1]);
2080         commitment_signed_dance!(nodes[1], nodes[0], &commitment_update_2.commitment_signed, false);
2081         expect_pending_htlcs_forwardable!(nodes[1]);
2082
2083         let ref payment_event_3 = expect_forward!(nodes[1]);
2084         assert_eq!(payment_event_3.msgs.len(), 2);
2085         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_3.msgs[0]);
2086         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_3.msgs[1]);
2087
2088         commitment_signed_dance!(nodes[2], nodes[1], &payment_event_3.commitment_msg, false);
2089         expect_pending_htlcs_forwardable!(nodes[2]);
2090
2091         let events = nodes[2].node.get_and_clear_pending_events();
2092         assert_eq!(events.len(), 2);
2093         match events[0] {
2094                 Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
2095                         assert_eq!(our_payment_hash_21, *payment_hash);
2096                         assert_eq!(*payment_secret, None);
2097                         assert_eq!(recv_value_21, amt);
2098                 },
2099                 _ => panic!("Unexpected event"),
2100         }
2101         match events[1] {
2102                 Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
2103                         assert_eq!(our_payment_hash_22, *payment_hash);
2104                         assert_eq!(None, *payment_secret);
2105                         assert_eq!(recv_value_22, amt);
2106                 },
2107                 _ => panic!("Unexpected event"),
2108         }
2109
2110         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_1, recv_value_1);
2111         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_21, recv_value_21);
2112         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_22, recv_value_22);
2113
2114         let commit_tx_fee_0_htlcs = 2*commit_tx_fee_msat(feerate, 1);
2115         let recv_value_3 = commit_tx_fee_2_htlcs - commit_tx_fee_0_htlcs - total_fee_msat;
2116         {
2117                 let (route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value_3 + 1);
2118                 let err = nodes[0].node.send_payment(&route, our_payment_hash, &None).err().unwrap();
2119                 match err {
2120                         PaymentSendFailure::AllFailedRetrySafe(ref fails) => {
2121                                 match &fails[0] {
2122                                         &APIError::ChannelUnavailable{ref err} =>
2123                                                 assert!(regex::Regex::new(r"Cannot send value that would put us under local channel reserve value \(\d+\)").unwrap().is_match(err)),
2124                                         _ => panic!("Unexpected error variant"),
2125                                 }
2126                         },
2127                         _ => panic!("Unexpected error variant"),
2128                 }
2129                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
2130                 nodes[0].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot send value that would put us under local channel reserve value".to_string(), 3);
2131         }
2132
2133         send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_3, recv_value_3);
2134
2135         let commit_tx_fee_1_htlc = 2*commit_tx_fee_msat(feerate, 1 + 1);
2136         let expected_value_to_self = stat01.value_to_self_msat - (recv_value_1 + total_fee_msat) - (recv_value_21 + total_fee_msat) - (recv_value_22 + total_fee_msat) - (recv_value_3 + total_fee_msat);
2137         let stat0 = get_channel_value_stat!(nodes[0], chan_1.2);
2138         assert_eq!(stat0.value_to_self_msat, expected_value_to_self);
2139         assert_eq!(stat0.value_to_self_msat, stat0.channel_reserve_msat + commit_tx_fee_1_htlc);
2140
2141         let stat2 = get_channel_value_stat!(nodes[2], chan_2.2);
2142         assert_eq!(stat2.value_to_self_msat, stat22.value_to_self_msat + recv_value_1 + recv_value_21 + recv_value_22 + recv_value_3);
2143 }
2144
2145 #[test]
2146 fn channel_reserve_in_flight_removes() {
2147         // In cases where one side claims an HTLC, it thinks it has additional available funds that it
2148         // can send to its counterparty, but due to update ordering, the other side may not yet have
2149         // considered those HTLCs fully removed.
2150         // This tests that we don't count HTLCs which will not be included in the next remote
2151         // commitment transaction towards the reserve value (as it implies no commitment transaction
2152         // will be generated which violates the remote reserve value).
2153         // This was broken previously, and discovered by the chanmon_fail_consistency fuzz test.
2154         // To test this we:
2155         //  * route two HTLCs from A to B (note that, at a high level, this test is checking that, when
2156         //    you consider the values of both of these HTLCs, B may not send an HTLC back to A, but if
2157         //    you only consider the value of the first HTLC, it may not),
2158         //  * start routing a third HTLC from A to B,
2159         //  * claim the first two HTLCs (though B will generate an update_fulfill for one, and put
2160         //    the other claim in its holding cell, as it immediately goes into AwaitingRAA),
2161         //  * deliver the first fulfill from B
2162         //  * deliver the update_add and an RAA from A, resulting in B freeing the second holding cell
2163         //    claim,
2164         //  * deliver A's response CS and RAA.
2165         //    This results in A having the second HTLC in AwaitingRemovedRemoteRevoke, but B having
2166         //    removed it fully. B now has the push_msat plus the first two HTLCs in value.
2167         //  * Now B happily sends another HTLC, potentially violating its reserve value from A's point
2168         //    of view (if A counts the AwaitingRemovedRemoteRevoke HTLC).
2169         let chanmon_cfgs = create_chanmon_cfgs(2);
2170         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2171         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
2172         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2173         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2174         let logger = test_utils::TestLogger::new();
2175
2176         let b_chan_values = get_channel_value_stat!(nodes[1], chan_1.2);
2177         // Route the first two HTLCs.
2178         let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], b_chan_values.channel_reserve_msat - b_chan_values.value_to_self_msat - 10000);
2179         let (payment_preimage_2, _) = route_payment(&nodes[0], &[&nodes[1]], 20000);
2180
2181         // Start routing the third HTLC (this is just used to get everyone in the right state).
2182         let (payment_preimage_3, payment_hash_3) = get_payment_preimage_hash!(nodes[0]);
2183         let send_1 = {
2184                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
2185                 let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
2186                 nodes[0].node.send_payment(&route, payment_hash_3, &None).unwrap();
2187                 check_added_monitors!(nodes[0], 1);
2188                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
2189                 assert_eq!(events.len(), 1);
2190                 SendEvent::from_event(events.remove(0))
2191         };
2192
2193         // Now claim both of the first two HTLCs on B's end, putting B in AwaitingRAA and generating an
2194         // initial fulfill/CS.
2195         assert!(nodes[1].node.claim_funds(payment_preimage_1, &None, b_chan_values.channel_reserve_msat - b_chan_values.value_to_self_msat - 10000));
2196         check_added_monitors!(nodes[1], 1);
2197         let bs_removes = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
2198
2199         // This claim goes in B's holding cell, allowing us to have a pending B->A RAA which does not
2200         // remove the second HTLC when we send the HTLC back from B to A.
2201         assert!(nodes[1].node.claim_funds(payment_preimage_2, &None, 20000));
2202         check_added_monitors!(nodes[1], 1);
2203         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
2204
2205         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &bs_removes.update_fulfill_htlcs[0]);
2206         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_removes.commitment_signed);
2207         check_added_monitors!(nodes[0], 1);
2208         let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
2209         expect_payment_sent!(nodes[0], payment_preimage_1);
2210
2211         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_1.msgs[0]);
2212         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &send_1.commitment_msg);
2213         check_added_monitors!(nodes[1], 1);
2214         // B is already AwaitingRAA, so cant generate a CS here
2215         let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
2216
2217         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
2218         check_added_monitors!(nodes[1], 1);
2219         let bs_cs = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
2220
2221         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_raa);
2222         check_added_monitors!(nodes[0], 1);
2223         let as_cs = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
2224
2225         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_cs.commitment_signed);
2226         check_added_monitors!(nodes[1], 1);
2227         let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
2228
2229         // The second HTLCis removed, but as A is in AwaitingRAA it can't generate a CS here, so the
2230         // RAA that B generated above doesn't fully resolve the second HTLC from A's point of view.
2231         // However, the RAA A generates here *does* fully resolve the HTLC from B's point of view (as A
2232         // can no longer broadcast a commitment transaction with it and B has the preimage so can go
2233         // on-chain as necessary).
2234         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &bs_cs.update_fulfill_htlcs[0]);
2235         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_cs.commitment_signed);
2236         check_added_monitors!(nodes[0], 1);
2237         let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
2238         expect_payment_sent!(nodes[0], payment_preimage_2);
2239
2240         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
2241         check_added_monitors!(nodes[1], 1);
2242         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
2243
2244         expect_pending_htlcs_forwardable!(nodes[1]);
2245         expect_payment_received!(nodes[1], payment_hash_3, 100000);
2246
2247         // Note that as this RAA was generated before the delivery of the update_fulfill it shouldn't
2248         // resolve the second HTLC from A's point of view.
2249         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_raa);
2250         check_added_monitors!(nodes[0], 1);
2251         let as_cs = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
2252
2253         // Now that B doesn't have the second RAA anymore, but A still does, send a payment from B back
2254         // to A to ensure that A doesn't count the almost-removed HTLC in update_add processing.
2255         let (payment_preimage_4, payment_hash_4) = get_payment_preimage_hash!(nodes[1]);
2256         let send_2 = {
2257                 let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
2258                 let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), None, &[], 10000, TEST_FINAL_CLTV, &logger).unwrap();
2259                 nodes[1].node.send_payment(&route, payment_hash_4, &None).unwrap();
2260                 check_added_monitors!(nodes[1], 1);
2261                 let mut events = nodes[1].node.get_and_clear_pending_msg_events();
2262                 assert_eq!(events.len(), 1);
2263                 SendEvent::from_event(events.remove(0))
2264         };
2265
2266         nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &send_2.msgs[0]);
2267         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &send_2.commitment_msg);
2268         check_added_monitors!(nodes[0], 1);
2269         let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
2270
2271         // Now just resolve all the outstanding messages/HTLCs for completeness...
2272
2273         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_cs.commitment_signed);
2274         check_added_monitors!(nodes[1], 1);
2275         let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
2276
2277         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
2278         check_added_monitors!(nodes[1], 1);
2279
2280         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_raa);
2281         check_added_monitors!(nodes[0], 1);
2282         let as_cs = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
2283
2284         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_cs.commitment_signed);
2285         check_added_monitors!(nodes[1], 1);
2286         let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
2287
2288         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_raa);
2289         check_added_monitors!(nodes[0], 1);
2290
2291         expect_pending_htlcs_forwardable!(nodes[0]);
2292         expect_payment_received!(nodes[0], payment_hash_4, 10000);
2293
2294         claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_4, 10_000);
2295         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3, 100_000);
2296 }
2297
2298 #[test]
2299 fn channel_monitor_network_test() {
2300         // Simple test which builds a network of ChannelManagers, connects them to each other, and
2301         // tests that ChannelMonitor is able to recover from various states.
2302         let chanmon_cfgs = create_chanmon_cfgs(5);
2303         let node_cfgs = create_node_cfgs(5, &chanmon_cfgs);
2304         let node_chanmgrs = create_node_chanmgrs(5, &node_cfgs, &[None, None, None, None, None]);
2305         let nodes = create_network(5, &node_cfgs, &node_chanmgrs);
2306
2307         // Create some initial channels
2308         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2309         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
2310         let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
2311         let chan_4 = create_announced_chan_between_nodes(&nodes, 3, 4, InitFeatures::known(), InitFeatures::known());
2312
2313         // Rebalance the network a bit by relaying one payment through all the channels...
2314         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
2315         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
2316         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
2317         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
2318
2319         // Simple case with no pending HTLCs:
2320         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), true);
2321         check_added_monitors!(nodes[1], 1);
2322         {
2323                 let mut node_txn = test_txn_broadcast(&nodes[1], &chan_1, None, HTLCType::NONE);
2324                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2325                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![node_txn.drain(..).next().unwrap()] }, 1);
2326                 check_added_monitors!(nodes[0], 1);
2327                 test_txn_broadcast(&nodes[0], &chan_1, None, HTLCType::NONE);
2328         }
2329         get_announce_close_broadcast_events(&nodes, 0, 1);
2330         assert_eq!(nodes[0].node.list_channels().len(), 0);
2331         assert_eq!(nodes[1].node.list_channels().len(), 1);
2332
2333         // One pending HTLC is discarded by the force-close:
2334         let payment_preimage_1 = route_payment(&nodes[1], &vec!(&nodes[2], &nodes[3])[..], 3000000).0;
2335
2336         // Simple case of one pending HTLC to HTLC-Timeout
2337         nodes[1].node.peer_disconnected(&nodes[2].node.get_our_node_id(), true);
2338         check_added_monitors!(nodes[1], 1);
2339         {
2340                 let mut node_txn = test_txn_broadcast(&nodes[1], &chan_2, None, HTLCType::TIMEOUT);
2341                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2342                 nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![node_txn.drain(..).next().unwrap()] }, 1);
2343                 check_added_monitors!(nodes[2], 1);
2344                 test_txn_broadcast(&nodes[2], &chan_2, None, HTLCType::NONE);
2345         }
2346         get_announce_close_broadcast_events(&nodes, 1, 2);
2347         assert_eq!(nodes[1].node.list_channels().len(), 0);
2348         assert_eq!(nodes[2].node.list_channels().len(), 1);
2349
2350         macro_rules! claim_funds {
2351                 ($node: expr, $prev_node: expr, $preimage: expr, $amount: expr) => {
2352                         {
2353                                 assert!($node.node.claim_funds($preimage, &None, $amount));
2354                                 check_added_monitors!($node, 1);
2355
2356                                 let events = $node.node.get_and_clear_pending_msg_events();
2357                                 assert_eq!(events.len(), 1);
2358                                 match events[0] {
2359                                         MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fail_htlcs, .. } } => {
2360                                                 assert!(update_add_htlcs.is_empty());
2361                                                 assert!(update_fail_htlcs.is_empty());
2362                                                 assert_eq!(*node_id, $prev_node.node.get_our_node_id());
2363                                         },
2364                                         _ => panic!("Unexpected event"),
2365                                 };
2366                         }
2367                 }
2368         }
2369
2370         // nodes[3] gets the preimage, but nodes[2] already disconnected, resulting in a nodes[2]
2371         // HTLC-Timeout and a nodes[3] claim against it (+ its own announces)
2372         nodes[2].node.peer_disconnected(&nodes[3].node.get_our_node_id(), true);
2373         check_added_monitors!(nodes[2], 1);
2374         let node2_commitment_txid;
2375         {
2376                 let node_txn = test_txn_broadcast(&nodes[2], &chan_3, None, HTLCType::TIMEOUT);
2377                 node2_commitment_txid = node_txn[0].txid();
2378
2379                 // Claim the payment on nodes[3], giving it knowledge of the preimage
2380                 claim_funds!(nodes[3], nodes[2], payment_preimage_1, 3_000_000);
2381
2382                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2383                 nodes[3].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone()] }, 1);
2384                 check_added_monitors!(nodes[3], 1);
2385
2386                 check_preimage_claim(&nodes[3], &node_txn);
2387         }
2388         get_announce_close_broadcast_events(&nodes, 2, 3);
2389         assert_eq!(nodes[2].node.list_channels().len(), 0);
2390         assert_eq!(nodes[3].node.list_channels().len(), 1);
2391
2392         { // Cheat and reset nodes[4]'s height to 1
2393                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2394                 nodes[4].block_notifier.block_connected(&Block { header, txdata: vec![] }, 1);
2395         }
2396
2397         assert_eq!(nodes[3].node.latest_block_height.load(Ordering::Acquire), 1);
2398         assert_eq!(nodes[4].node.latest_block_height.load(Ordering::Acquire), 1);
2399         // One pending HTLC to time out:
2400         let payment_preimage_2 = route_payment(&nodes[3], &vec!(&nodes[4])[..], 3000000).0;
2401         // CLTV expires at TEST_FINAL_CLTV + 1 (current height) + 1 (added in send_payment for
2402         // buffer space).
2403
2404         {
2405                 let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2406                 nodes[3].block_notifier.block_connected_checked(&header, 2, &Vec::new()[..], &[0; 0]);
2407                 for i in 3..TEST_FINAL_CLTV + 2 + LATENCY_GRACE_PERIOD_BLOCKS + 1 {
2408                         header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2409                         nodes[3].block_notifier.block_connected_checked(&header, i, &Vec::new()[..], &[0; 0]);
2410                 }
2411                 check_added_monitors!(nodes[3], 1);
2412
2413                 // Clear bumped claiming txn spending node 2 commitment tx. Bumped txn are generated after reaching some height timer.
2414                 {
2415                         let mut node_txn = nodes[3].tx_broadcaster.txn_broadcasted.lock().unwrap();
2416                         node_txn.retain(|tx| {
2417                                 if tx.input[0].previous_output.txid == node2_commitment_txid {
2418                                         false
2419                                 } else { true }
2420                         });
2421                 }
2422
2423                 let node_txn = test_txn_broadcast(&nodes[3], &chan_4, None, HTLCType::TIMEOUT);
2424
2425                 // Claim the payment on nodes[4], giving it knowledge of the preimage
2426                 claim_funds!(nodes[4], nodes[3], payment_preimage_2, 3_000_000);
2427
2428                 header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2429
2430                 nodes[4].block_notifier.block_connected_checked(&header, 2, &Vec::new()[..], &[0; 0]);
2431                 for i in 3..TEST_FINAL_CLTV + 2 - CLTV_CLAIM_BUFFER + 1 {
2432                         header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2433                         nodes[4].block_notifier.block_connected_checked(&header, i, &Vec::new()[..], &[0; 0]);
2434                 }
2435
2436                 check_added_monitors!(nodes[4], 1);
2437                 test_txn_broadcast(&nodes[4], &chan_4, None, HTLCType::SUCCESS);
2438
2439                 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2440                 nodes[4].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone()] }, TEST_FINAL_CLTV - 5);
2441
2442                 check_preimage_claim(&nodes[4], &node_txn);
2443         }
2444         get_announce_close_broadcast_events(&nodes, 3, 4);
2445         assert_eq!(nodes[3].node.list_channels().len(), 0);
2446         assert_eq!(nodes[4].node.list_channels().len(), 0);
2447 }
2448
2449 #[test]
2450 fn test_justice_tx() {
2451         // Test justice txn built on revoked HTLC-Success tx, against both sides
2452         let mut alice_config = UserConfig::default();
2453         alice_config.channel_options.announced_channel = true;
2454         alice_config.peer_channel_config_limits.force_announced_channel_preference = false;
2455         alice_config.own_channel_config.our_to_self_delay = 6 * 24 * 5;
2456         let mut bob_config = UserConfig::default();
2457         bob_config.channel_options.announced_channel = true;
2458         bob_config.peer_channel_config_limits.force_announced_channel_preference = false;
2459         bob_config.own_channel_config.our_to_self_delay = 6 * 24 * 3;
2460         let user_cfgs = [Some(alice_config), Some(bob_config)];
2461         let chanmon_cfgs = create_chanmon_cfgs(2);
2462         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2463         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &user_cfgs);
2464         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2465         // Create some new channels:
2466         let chan_5 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2467
2468         // A pending HTLC which will be revoked:
2469         let payment_preimage_3 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
2470         // Get the will-be-revoked local txn from nodes[0]
2471         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_5.2);
2472         assert_eq!(revoked_local_txn.len(), 2); // First commitment tx, then HTLC tx
2473         assert_eq!(revoked_local_txn[0].input.len(), 1);
2474         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_5.3.txid());
2475         assert_eq!(revoked_local_txn[0].output.len(), 2); // Only HTLC and output back to 0 are present
2476         assert_eq!(revoked_local_txn[1].input.len(), 1);
2477         assert_eq!(revoked_local_txn[1].input[0].previous_output.txid, revoked_local_txn[0].txid());
2478         assert_eq!(revoked_local_txn[1].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT); // HTLC-Timeout
2479         // Revoke the old state
2480         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3, 3_000_000);
2481
2482         {
2483                 let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2484                 nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2485                 {
2486                         let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2487                         assert_eq!(node_txn.len(), 2); // ChannelMonitor: penalty tx, ChannelManager: local commitment tx
2488                         assert_eq!(node_txn[0].input.len(), 2); // We should claim the revoked output and the HTLC output
2489
2490                         check_spends!(node_txn[0], revoked_local_txn[0]);
2491                         node_txn.swap_remove(0);
2492                         node_txn.truncate(1);
2493                 }
2494                 check_added_monitors!(nodes[1], 1);
2495                 test_txn_broadcast(&nodes[1], &chan_5, None, HTLCType::NONE);
2496
2497                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2498                 // Verify broadcast of revoked HTLC-timeout
2499                 let node_txn = test_txn_broadcast(&nodes[0], &chan_5, Some(revoked_local_txn[0].clone()), HTLCType::TIMEOUT);
2500                 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2501                 check_added_monitors!(nodes[0], 1);
2502                 // Broadcast revoked HTLC-timeout on node 1
2503                 nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[1].clone()] }, 1);
2504                 test_revoked_htlc_claim_txn_broadcast(&nodes[1], node_txn[1].clone(), revoked_local_txn[0].clone());
2505         }
2506         get_announce_close_broadcast_events(&nodes, 0, 1);
2507
2508         assert_eq!(nodes[0].node.list_channels().len(), 0);
2509         assert_eq!(nodes[1].node.list_channels().len(), 0);
2510
2511         // We test justice_tx build by A on B's revoked HTLC-Success tx
2512         // Create some new channels:
2513         let chan_6 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2514         {
2515                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2516                 node_txn.clear();
2517         }
2518
2519         // A pending HTLC which will be revoked:
2520         let payment_preimage_4 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
2521         // Get the will-be-revoked local txn from B
2522         let revoked_local_txn = get_local_commitment_txn!(nodes[1], chan_6.2);
2523         assert_eq!(revoked_local_txn.len(), 1); // Only commitment tx
2524         assert_eq!(revoked_local_txn[0].input.len(), 1);
2525         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_6.3.txid());
2526         assert_eq!(revoked_local_txn[0].output.len(), 2); // Only HTLC and output back to A are present
2527         // Revoke the old state
2528         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_4, 3_000_000);
2529         {
2530                 let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2531                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2532                 {
2533                         let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
2534                         assert_eq!(node_txn.len(), 2); //ChannelMonitor: penalty tx, ChannelManager: local commitment tx
2535                         assert_eq!(node_txn[0].input.len(), 1); // We claim the received HTLC output
2536
2537                         check_spends!(node_txn[0], revoked_local_txn[0]);
2538                         node_txn.swap_remove(0);
2539                 }
2540                 check_added_monitors!(nodes[0], 1);
2541                 test_txn_broadcast(&nodes[0], &chan_6, None, HTLCType::NONE);
2542
2543                 nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2544                 let node_txn = test_txn_broadcast(&nodes[1], &chan_6, Some(revoked_local_txn[0].clone()), HTLCType::SUCCESS);
2545                 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2546                 check_added_monitors!(nodes[1], 1);
2547                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[1].clone()] }, 1);
2548                 test_revoked_htlc_claim_txn_broadcast(&nodes[0], node_txn[1].clone(), revoked_local_txn[0].clone());
2549         }
2550         get_announce_close_broadcast_events(&nodes, 0, 1);
2551         assert_eq!(nodes[0].node.list_channels().len(), 0);
2552         assert_eq!(nodes[1].node.list_channels().len(), 0);
2553 }
2554
2555 #[test]
2556 fn revoked_output_claim() {
2557         // Simple test to ensure a node will claim a revoked output when a stale remote commitment
2558         // transaction is broadcast by its counterparty
2559         let chanmon_cfgs = create_chanmon_cfgs(2);
2560         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2561         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
2562         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2563         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2564         // node[0] is gonna to revoke an old state thus node[1] should be able to claim the revoked output
2565         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
2566         assert_eq!(revoked_local_txn.len(), 1);
2567         // Only output is the full channel value back to nodes[0]:
2568         assert_eq!(revoked_local_txn[0].output.len(), 1);
2569         // Send a payment through, updating everyone's latest commitment txn
2570         send_payment(&nodes[0], &vec!(&nodes[1])[..], 5000000, 5_000_000);
2571
2572         // Inform nodes[1] that nodes[0] broadcast a stale tx
2573         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2574         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2575         check_added_monitors!(nodes[1], 1);
2576         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2577         assert_eq!(node_txn.len(), 2); // ChannelMonitor: justice tx against revoked to_local output, ChannelManager: local commitment tx
2578
2579         check_spends!(node_txn[0], revoked_local_txn[0]);
2580         check_spends!(node_txn[1], chan_1.3);
2581
2582         // Inform nodes[0] that a watchtower cheated on its behalf, so it will force-close the chan
2583         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2584         get_announce_close_broadcast_events(&nodes, 0, 1);
2585         check_added_monitors!(nodes[0], 1)
2586 }
2587
2588 #[test]
2589 fn claim_htlc_outputs_shared_tx() {
2590         // Node revoked old state, htlcs haven't time out yet, claim them in shared justice tx
2591         let chanmon_cfgs = create_chanmon_cfgs(2);
2592         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2593         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
2594         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2595
2596         // Create some new channel:
2597         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2598
2599         // Rebalance the network to generate htlc in the two directions
2600         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
2601         // node[0] is gonna to revoke an old state thus node[1] should be able to claim both offered/received HTLC outputs on top of commitment tx
2602         let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
2603         let (_payment_preimage_2, payment_hash_2) = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000);
2604
2605         // Get the will-be-revoked local txn from node[0]
2606         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
2607         assert_eq!(revoked_local_txn.len(), 2); // commitment tx + 1 HTLC-Timeout tx
2608         assert_eq!(revoked_local_txn[0].input.len(), 1);
2609         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
2610         assert_eq!(revoked_local_txn[1].input.len(), 1);
2611         assert_eq!(revoked_local_txn[1].input[0].previous_output.txid, revoked_local_txn[0].txid());
2612         assert_eq!(revoked_local_txn[1].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT); // HTLC-Timeout
2613         check_spends!(revoked_local_txn[1], revoked_local_txn[0]);
2614
2615         //Revoke the old state
2616         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1, 3_000_000);
2617
2618         {
2619                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2620                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2621                 check_added_monitors!(nodes[0], 1);
2622                 nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2623                 check_added_monitors!(nodes[1], 1);
2624                 connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
2625                 expect_payment_failed!(nodes[1], payment_hash_2, true);
2626
2627                 let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2628                 assert_eq!(node_txn.len(), 3); // ChannelMonitor: penalty tx, ChannelManager: local commitment + HTLC-timeout
2629
2630                 assert_eq!(node_txn[0].input.len(), 3); // Claim the revoked output + both revoked HTLC outputs
2631                 check_spends!(node_txn[0], revoked_local_txn[0]);
2632
2633                 let mut witness_lens = BTreeSet::new();
2634                 witness_lens.insert(node_txn[0].input[0].witness.last().unwrap().len());
2635                 witness_lens.insert(node_txn[0].input[1].witness.last().unwrap().len());
2636                 witness_lens.insert(node_txn[0].input[2].witness.last().unwrap().len());
2637                 assert_eq!(witness_lens.len(), 3);
2638                 assert_eq!(*witness_lens.iter().skip(0).next().unwrap(), 77); // revoked to_local
2639                 assert_eq!(*witness_lens.iter().skip(1).next().unwrap(), OFFERED_HTLC_SCRIPT_WEIGHT); // revoked offered HTLC
2640                 assert_eq!(*witness_lens.iter().skip(2).next().unwrap(), ACCEPTED_HTLC_SCRIPT_WEIGHT); // revoked received HTLC
2641
2642                 // Next nodes[1] broadcasts its current local tx state:
2643                 assert_eq!(node_txn[1].input.len(), 1);
2644                 assert_eq!(node_txn[1].input[0].previous_output.txid, chan_1.3.txid()); //Spending funding tx unique txouput, tx broadcasted by ChannelManager
2645
2646                 assert_eq!(node_txn[2].input.len(), 1);
2647                 let witness_script = node_txn[2].clone().input[0].witness.pop().unwrap();
2648                 assert_eq!(witness_script.len(), OFFERED_HTLC_SCRIPT_WEIGHT); //Spending an offered htlc output
2649                 assert_eq!(node_txn[2].input[0].previous_output.txid, node_txn[1].txid());
2650                 assert_ne!(node_txn[2].input[0].previous_output.txid, node_txn[0].input[0].previous_output.txid);
2651                 assert_ne!(node_txn[2].input[0].previous_output.txid, node_txn[0].input[1].previous_output.txid);
2652         }
2653         get_announce_close_broadcast_events(&nodes, 0, 1);
2654         assert_eq!(nodes[0].node.list_channels().len(), 0);
2655         assert_eq!(nodes[1].node.list_channels().len(), 0);
2656 }
2657
2658 #[test]
2659 fn claim_htlc_outputs_single_tx() {
2660         // Node revoked old state, htlcs have timed out, claim each of them in separated justice tx
2661         let chanmon_cfgs = create_chanmon_cfgs(2);
2662         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2663         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
2664         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2665
2666         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2667
2668         // Rebalance the network to generate htlc in the two directions
2669         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
2670         // node[0] is gonna to revoke an old state thus node[1] should be able to claim both offered/received HTLC outputs on top of commitment tx, but this
2671         // time as two different claim transactions as we're gonna to timeout htlc with given a high current height
2672         let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
2673         let (_payment_preimage_2, payment_hash_2) = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000);
2674
2675         // Get the will-be-revoked local txn from node[0]
2676         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
2677
2678         //Revoke the old state
2679         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1, 3_000_000);
2680
2681         {
2682                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2683                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 200);
2684                 check_added_monitors!(nodes[0], 1);
2685                 nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 200);
2686                 check_added_monitors!(nodes[1], 1);
2687                 expect_pending_htlcs_forwardable_ignore!(nodes[0]);
2688
2689                 connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 200, true, header.bitcoin_hash());
2690                 expect_payment_failed!(nodes[1], payment_hash_2, true);
2691
2692                 let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2693                 assert_eq!(node_txn.len(), 9);
2694                 // ChannelMonitor: justice tx revoked offered htlc, justice tx revoked received htlc, justice tx revoked to_local (3)
2695                 // ChannelManager: local commmitment + local HTLC-timeout (2)
2696                 // ChannelMonitor: bumped justice tx, after one increase, bumps on HTLC aren't generated not being substantial anymore, bump on revoked to_local isn't generated due to more room for expiration (2)
2697                 // ChannelMonitor: local commitment + local HTLC-timeout (2)
2698
2699                 // Check the pair local commitment and HTLC-timeout broadcast due to HTLC expiration
2700                 assert_eq!(node_txn[2].input.len(), 1);
2701                 check_spends!(node_txn[2], chan_1.3);
2702                 assert_eq!(node_txn[3].input.len(), 1);
2703                 let witness_script = node_txn[3].input[0].witness.last().unwrap();
2704                 assert_eq!(witness_script.len(), OFFERED_HTLC_SCRIPT_WEIGHT); //Spending an offered htlc output
2705                 check_spends!(node_txn[3], node_txn[2]);
2706
2707                 // Justice transactions are indices 1-2-4
2708                 assert_eq!(node_txn[0].input.len(), 1);
2709                 assert_eq!(node_txn[1].input.len(), 1);
2710                 assert_eq!(node_txn[4].input.len(), 1);
2711
2712                 check_spends!(node_txn[0], revoked_local_txn[0]);
2713                 check_spends!(node_txn[1], revoked_local_txn[0]);
2714                 check_spends!(node_txn[4], revoked_local_txn[0]);
2715
2716                 let mut witness_lens = BTreeSet::new();
2717                 witness_lens.insert(node_txn[0].input[0].witness.last().unwrap().len());
2718                 witness_lens.insert(node_txn[1].input[0].witness.last().unwrap().len());
2719                 witness_lens.insert(node_txn[4].input[0].witness.last().unwrap().len());
2720                 assert_eq!(witness_lens.len(), 3);
2721                 assert_eq!(*witness_lens.iter().skip(0).next().unwrap(), 77); // revoked to_local
2722                 assert_eq!(*witness_lens.iter().skip(1).next().unwrap(), OFFERED_HTLC_SCRIPT_WEIGHT); // revoked offered HTLC
2723                 assert_eq!(*witness_lens.iter().skip(2).next().unwrap(), ACCEPTED_HTLC_SCRIPT_WEIGHT); // revoked received HTLC
2724         }
2725         get_announce_close_broadcast_events(&nodes, 0, 1);
2726         assert_eq!(nodes[0].node.list_channels().len(), 0);
2727         assert_eq!(nodes[1].node.list_channels().len(), 0);
2728 }
2729
2730 #[test]
2731 fn test_htlc_on_chain_success() {
2732         // Test that in case of a unilateral close onchain, we detect the state of output thanks to
2733         // ChainWatchInterface and pass the preimage backward accordingly. So here we test that ChannelManager is
2734         // broadcasting the right event to other nodes in payment path.
2735         // We test with two HTLCs simultaneously as that was not handled correctly in the past.
2736         // A --------------------> B ----------------------> C (preimage)
2737         // First, C should claim the HTLC outputs via HTLC-Success when its own latest local
2738         // commitment transaction was broadcast.
2739         // Then, B should learn the preimage from said transactions, attempting to claim backwards
2740         // towards B.
2741         // B should be able to claim via preimage if A then broadcasts its local tx.
2742         // Finally, when A sees B's latest local commitment transaction it should be able to claim
2743         // the HTLC outputs via the preimage it learned (which, once confirmed should generate a
2744         // PaymentSent event).
2745
2746         let chanmon_cfgs = create_chanmon_cfgs(3);
2747         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
2748         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
2749         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
2750
2751         // Create some initial channels
2752         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2753         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
2754
2755         // Rebalance the network a bit by relaying one payment through all the channels...
2756         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
2757         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
2758
2759         let (our_payment_preimage, _payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
2760         let (our_payment_preimage_2, _payment_hash_2) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
2761         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
2762
2763         // Broadcast legit commitment tx from C on B's chain
2764         // Broadcast HTLC Success transaction by C on received output from C's commitment tx on B's chain
2765         let commitment_tx = get_local_commitment_txn!(nodes[2], chan_2.2);
2766         assert_eq!(commitment_tx.len(), 1);
2767         check_spends!(commitment_tx[0], chan_2.3);
2768         nodes[2].node.claim_funds(our_payment_preimage, &None, 3_000_000);
2769         nodes[2].node.claim_funds(our_payment_preimage_2, &None, 3_000_000);
2770         check_added_monitors!(nodes[2], 2);
2771         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
2772         assert!(updates.update_add_htlcs.is_empty());
2773         assert!(updates.update_fail_htlcs.is_empty());
2774         assert!(updates.update_fail_malformed_htlcs.is_empty());
2775         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
2776
2777         nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
2778         check_closed_broadcast!(nodes[2], false);
2779         check_added_monitors!(nodes[2], 1);
2780         let node_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 3 (commitment tx, 2*htlc-success tx), ChannelMonitor : 2 (2 * HTLC-Success tx)
2781         assert_eq!(node_txn.len(), 5);
2782         assert_eq!(node_txn[0], node_txn[3]);
2783         assert_eq!(node_txn[1], node_txn[4]);
2784         assert_eq!(node_txn[2], commitment_tx[0]);
2785         check_spends!(node_txn[0], commitment_tx[0]);
2786         check_spends!(node_txn[1], commitment_tx[0]);
2787         assert_eq!(node_txn[0].input[0].witness.clone().last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
2788         assert_eq!(node_txn[1].input[0].witness.clone().last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
2789         assert!(node_txn[0].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2790         assert!(node_txn[1].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2791         assert_eq!(node_txn[0].lock_time, 0);
2792         assert_eq!(node_txn[1].lock_time, 0);
2793
2794         // Verify that B's ChannelManager is able to extract preimage from HTLC Success tx and pass it backward
2795         nodes[1].block_notifier.block_connected(&Block { header, txdata: node_txn}, 1);
2796         {
2797                 let mut added_monitors = nodes[1].chan_monitor.added_monitors.lock().unwrap();
2798                 assert_eq!(added_monitors.len(), 1);
2799                 assert_eq!(added_monitors[0].0.txid, chan_2.3.txid());
2800                 added_monitors.clear();
2801         }
2802         let events = nodes[1].node.get_and_clear_pending_msg_events();
2803         {
2804                 let mut added_monitors = nodes[1].chan_monitor.added_monitors.lock().unwrap();
2805                 assert_eq!(added_monitors.len(), 2);
2806                 assert_eq!(added_monitors[0].0.txid, chan_1.3.txid());
2807                 assert_eq!(added_monitors[1].0.txid, chan_1.3.txid());
2808                 added_monitors.clear();
2809         }
2810         assert_eq!(events.len(), 2);
2811         match events[0] {
2812                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
2813                 _ => panic!("Unexpected event"),
2814         }
2815         match events[1] {
2816                 MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fail_htlcs, ref update_fulfill_htlcs, ref update_fail_malformed_htlcs, .. } } => {
2817                         assert!(update_add_htlcs.is_empty());
2818                         assert!(update_fail_htlcs.is_empty());
2819                         assert_eq!(update_fulfill_htlcs.len(), 1);
2820                         assert!(update_fail_malformed_htlcs.is_empty());
2821                         assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
2822                 },
2823                 _ => panic!("Unexpected event"),
2824         };
2825         macro_rules! check_tx_local_broadcast {
2826                 ($node: expr, $htlc_offered: expr, $commitment_tx: expr, $chan_tx: expr) => { {
2827                         let mut node_txn = $node.tx_broadcaster.txn_broadcasted.lock().unwrap();
2828                         assert_eq!(node_txn.len(), 5);
2829                         // Node[1]: ChannelManager: 3 (commitment tx, 2*HTLC-Timeout tx), ChannelMonitor: 2 (timeout tx)
2830                         // Node[0]: ChannelManager: 3 (commtiemtn tx, 2*HTLC-Timeout tx), ChannelMonitor: 2 HTLC-timeout
2831                         check_spends!(node_txn[0], $commitment_tx);
2832                         check_spends!(node_txn[1], $commitment_tx);
2833                         assert_ne!(node_txn[0].lock_time, 0);
2834                         assert_ne!(node_txn[1].lock_time, 0);
2835                         if $htlc_offered {
2836                                 assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2837                                 assert_eq!(node_txn[1].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2838                                 assert!(node_txn[0].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2839                                 assert!(node_txn[1].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2840                         } else {
2841                                 assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
2842                                 assert_eq!(node_txn[1].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
2843                                 assert!(node_txn[0].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
2844                                 assert!(node_txn[1].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
2845                         }
2846                         check_spends!(node_txn[2], $chan_tx);
2847                         check_spends!(node_txn[3], node_txn[2]);
2848                         check_spends!(node_txn[4], node_txn[2]);
2849                         assert_eq!(node_txn[2].input[0].witness.last().unwrap().len(), 71);
2850                         assert_eq!(node_txn[3].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2851                         assert_eq!(node_txn[4].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2852                         assert!(node_txn[3].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2853                         assert!(node_txn[4].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2854                         assert_ne!(node_txn[3].lock_time, 0);
2855                         assert_ne!(node_txn[4].lock_time, 0);
2856                         node_txn.clear();
2857                 } }
2858         }
2859         // nodes[1] now broadcasts its own local state as a fallback, suggesting an alternate
2860         // commitment transaction with a corresponding HTLC-Timeout transactions, as well as a
2861         // timeout-claim of the output that nodes[2] just claimed via success.
2862         check_tx_local_broadcast!(nodes[1], false, commitment_tx[0], chan_2.3);
2863
2864         // Broadcast legit commitment tx from A on B's chain
2865         // Broadcast preimage tx by B on offered output from A commitment tx  on A's chain
2866         let commitment_tx = get_local_commitment_txn!(nodes[0], chan_1.2);
2867         check_spends!(commitment_tx[0], chan_1.3);
2868         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
2869         check_closed_broadcast!(nodes[1], false);
2870         check_added_monitors!(nodes[1], 1);
2871         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 3 (commitment tx + HTLC-Sucess * 2), ChannelMonitor : 1 (HTLC-Success)
2872         assert_eq!(node_txn.len(), 4);
2873         check_spends!(node_txn[0], commitment_tx[0]);
2874         assert_eq!(node_txn[0].input.len(), 2);
2875         assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2876         assert_eq!(node_txn[0].input[1].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2877         assert_eq!(node_txn[0].lock_time, 0);
2878         assert!(node_txn[0].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
2879         check_spends!(node_txn[1], chan_1.3);
2880         assert_eq!(node_txn[1].input[0].witness.clone().last().unwrap().len(), 71);
2881         check_spends!(node_txn[2], node_txn[1]);
2882         check_spends!(node_txn[3], node_txn[1]);
2883         // We don't bother to check that B can claim the HTLC output on its commitment tx here as
2884         // we already checked the same situation with A.
2885
2886         // Verify that A's ChannelManager is able to extract preimage from preimage tx and generate PaymentSent
2887         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone(), node_txn[0].clone()] }, 1);
2888         check_closed_broadcast!(nodes[0], false);
2889         check_added_monitors!(nodes[0], 1);
2890         let events = nodes[0].node.get_and_clear_pending_events();
2891         assert_eq!(events.len(), 2);
2892         let mut first_claimed = false;
2893         for event in events {
2894                 match event {
2895                         Event::PaymentSent { payment_preimage } => {
2896                                 if payment_preimage == our_payment_preimage {
2897                                         assert!(!first_claimed);
2898                                         first_claimed = true;
2899                                 } else {
2900                                         assert_eq!(payment_preimage, our_payment_preimage_2);
2901                                 }
2902                         },
2903                         _ => panic!("Unexpected event"),
2904                 }
2905         }
2906         check_tx_local_broadcast!(nodes[0], true, commitment_tx[0], chan_1.3);
2907 }
2908
2909 #[test]
2910 fn test_htlc_on_chain_timeout() {
2911         // Test that in case of a unilateral close onchain, we detect the state of output thanks to
2912         // ChainWatchInterface and timeout the HTLC backward accordingly. So here we test that ChannelManager is
2913         // broadcasting the right event to other nodes in payment path.
2914         // A ------------------> B ----------------------> C (timeout)
2915         //    B's commitment tx                 C's commitment tx
2916         //            \                                  \
2917         //         B's HTLC timeout tx               B's timeout tx
2918
2919         let chanmon_cfgs = create_chanmon_cfgs(3);
2920         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
2921         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
2922         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
2923
2924         // Create some intial channels
2925         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2926         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
2927
2928         // Rebalance the network a bit by relaying one payment thorugh all the channels...
2929         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
2930         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
2931
2932         let (_payment_preimage, payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
2933         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
2934
2935         // Broadcast legit commitment tx from C on B's chain
2936         let commitment_tx = get_local_commitment_txn!(nodes[2], chan_2.2);
2937         check_spends!(commitment_tx[0], chan_2.3);
2938         nodes[2].node.fail_htlc_backwards(&payment_hash, &None);
2939         check_added_monitors!(nodes[2], 0);
2940         expect_pending_htlcs_forwardable!(nodes[2]);
2941         check_added_monitors!(nodes[2], 1);
2942
2943         let events = nodes[2].node.get_and_clear_pending_msg_events();
2944         assert_eq!(events.len(), 1);
2945         match events[0] {
2946                 MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, .. } } => {
2947                         assert!(update_add_htlcs.is_empty());
2948                         assert!(!update_fail_htlcs.is_empty());
2949                         assert!(update_fulfill_htlcs.is_empty());
2950                         assert!(update_fail_malformed_htlcs.is_empty());
2951                         assert_eq!(nodes[1].node.get_our_node_id(), *node_id);
2952                 },
2953                 _ => panic!("Unexpected event"),
2954         };
2955         nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
2956         check_closed_broadcast!(nodes[2], false);
2957         check_added_monitors!(nodes[2], 1);
2958         let node_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 1 (commitment tx)
2959         assert_eq!(node_txn.len(), 1);
2960         check_spends!(node_txn[0], chan_2.3);
2961         assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), 71);
2962
2963         // Broadcast timeout transaction by B on received output from C's commitment tx on B's chain
2964         // Verify that B's ChannelManager is able to detect that HTLC is timeout by its own tx and react backward in consequence
2965         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 200);
2966         let timeout_tx;
2967         {
2968                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2969                 assert_eq!(node_txn.len(), 5); // ChannelManager : 2 (commitment tx, HTLC-Timeout tx), ChannelMonitor : 2 (local commitment tx + HTLC-timeout), 1 timeout tx
2970                 assert_eq!(node_txn[1], node_txn[3]);
2971                 assert_eq!(node_txn[2], node_txn[4]);
2972
2973                 check_spends!(node_txn[0], commitment_tx[0]);
2974                 assert_eq!(node_txn[0].clone().input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
2975
2976                 check_spends!(node_txn[1], chan_2.3);
2977                 check_spends!(node_txn[2], node_txn[1]);
2978                 assert_eq!(node_txn[1].clone().input[0].witness.last().unwrap().len(), 71);
2979                 assert_eq!(node_txn[2].clone().input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2980
2981                 timeout_tx = node_txn[0].clone();
2982                 node_txn.clear();
2983         }
2984
2985         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![timeout_tx]}, 1);
2986         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
2987         check_added_monitors!(nodes[1], 1);
2988         check_closed_broadcast!(nodes[1], false);
2989
2990         expect_pending_htlcs_forwardable!(nodes[1]);
2991         check_added_monitors!(nodes[1], 1);
2992         let events = nodes[1].node.get_and_clear_pending_msg_events();
2993         assert_eq!(events.len(), 1);
2994         match events[0] {
2995                 MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fail_htlcs, ref update_fulfill_htlcs, ref update_fail_malformed_htlcs, .. } } => {
2996                         assert!(update_add_htlcs.is_empty());
2997                         assert!(!update_fail_htlcs.is_empty());
2998                         assert!(update_fulfill_htlcs.is_empty());
2999                         assert!(update_fail_malformed_htlcs.is_empty());
3000                         assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
3001                 },
3002                 _ => panic!("Unexpected event"),
3003         };
3004         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // Well... here we detect our own htlc_timeout_tx so no tx to be generated
3005         assert_eq!(node_txn.len(), 0);
3006
3007         // Broadcast legit commitment tx from B on A's chain
3008         let commitment_tx = get_local_commitment_txn!(nodes[1], chan_1.2);
3009         check_spends!(commitment_tx[0], chan_1.3);
3010
3011         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 200);
3012         check_closed_broadcast!(nodes[0], false);
3013         check_added_monitors!(nodes[0], 1);
3014         let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 2 (commitment tx, HTLC-Timeout tx), ChannelMonitor : 1 timeout tx
3015         assert_eq!(node_txn.len(), 3);
3016         check_spends!(node_txn[0], commitment_tx[0]);
3017         assert_eq!(node_txn[0].clone().input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
3018         check_spends!(node_txn[1], chan_1.3);
3019         check_spends!(node_txn[2], node_txn[1]);
3020         assert_eq!(node_txn[1].clone().input[0].witness.last().unwrap().len(), 71);
3021         assert_eq!(node_txn[2].clone().input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
3022 }
3023
3024 #[test]
3025 fn test_simple_commitment_revoked_fail_backward() {
3026         // Test that in case of a revoked commitment tx, we detect the resolution of output by justice tx
3027         // and fail backward accordingly.
3028
3029         let chanmon_cfgs = create_chanmon_cfgs(3);
3030         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
3031         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
3032         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
3033
3034         // Create some initial channels
3035         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3036         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
3037
3038         let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
3039         // Get the will-be-revoked local txn from nodes[2]
3040         let revoked_local_txn = get_local_commitment_txn!(nodes[2], chan_2.2);
3041         // Revoke the old state
3042         claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage, 3_000_000);
3043
3044         let (_, payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
3045
3046         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
3047         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
3048         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
3049         check_added_monitors!(nodes[1], 1);
3050         check_closed_broadcast!(nodes[1], false);
3051
3052         expect_pending_htlcs_forwardable!(nodes[1]);
3053         check_added_monitors!(nodes[1], 1);
3054         let events = nodes[1].node.get_and_clear_pending_msg_events();
3055         assert_eq!(events.len(), 1);
3056         match events[0] {
3057                 MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fail_htlcs, ref update_fulfill_htlcs, ref update_fail_malformed_htlcs, ref commitment_signed, .. } } => {
3058                         assert!(update_add_htlcs.is_empty());
3059                         assert_eq!(update_fail_htlcs.len(), 1);
3060                         assert!(update_fulfill_htlcs.is_empty());
3061                         assert!(update_fail_malformed_htlcs.is_empty());
3062                         assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
3063
3064                         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlcs[0]);
3065                         commitment_signed_dance!(nodes[0], nodes[1], commitment_signed, false, true);
3066
3067                         let events = nodes[0].node.get_and_clear_pending_msg_events();
3068                         assert_eq!(events.len(), 1);
3069                         match events[0] {
3070                                 MessageSendEvent::PaymentFailureNetworkUpdate { .. } => {},
3071                                 _ => panic!("Unexpected event"),
3072                         }
3073                         expect_payment_failed!(nodes[0], payment_hash, false);
3074                 },
3075                 _ => panic!("Unexpected event"),
3076         }
3077 }
3078
3079 fn do_test_commitment_revoked_fail_backward_exhaustive(deliver_bs_raa: bool, use_dust: bool, no_to_remote: bool) {
3080         // Test that if our counterparty broadcasts a revoked commitment transaction we fail all
3081         // pending HTLCs on that channel backwards even if the HTLCs aren't present in our latest
3082         // commitment transaction anymore.
3083         // To do this, we have the peer which will broadcast a revoked commitment transaction send
3084         // a number of update_fail/commitment_signed updates without ever sending the RAA in
3085         // response to our commitment_signed. This is somewhat misbehavior-y, though not
3086         // technically disallowed and we should probably handle it reasonably.
3087         // Note that this is pretty exhaustive as an outbound HTLC which we haven't yet
3088         // failed/fulfilled backwards must be in at least one of the latest two remote commitment
3089         // transactions:
3090         // * Once we move it out of our holding cell/add it, we will immediately include it in a
3091         //   commitment_signed (implying it will be in the latest remote commitment transaction).
3092         // * Once they remove it, we will send a (the first) commitment_signed without the HTLC,
3093         //   and once they revoke the previous commitment transaction (allowing us to send a new
3094         //   commitment_signed) we will be free to fail/fulfill the HTLC backwards.
3095         let chanmon_cfgs = create_chanmon_cfgs(3);
3096         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
3097         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
3098         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
3099
3100         // Create some initial channels
3101         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3102         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
3103
3104         let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], if no_to_remote { 10_000 } else { 3_000_000 });
3105         // Get the will-be-revoked local txn from nodes[2]
3106         let revoked_local_txn = get_local_commitment_txn!(nodes[2], chan_2.2);
3107         assert_eq!(revoked_local_txn[0].output.len(), if no_to_remote { 1 } else { 2 });
3108         // Revoke the old state
3109         claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage, if no_to_remote { 10_000 } else { 3_000_000});
3110
3111         let value = if use_dust {
3112                 // The dust limit applied to HTLC outputs considers the fee of the HTLC transaction as
3113                 // well, so HTLCs at exactly the dust limit will not be included in commitment txn.
3114                 nodes[2].node.channel_state.lock().unwrap().by_id.get(&chan_2.2).unwrap().our_dust_limit_satoshis * 1000
3115         } else { 3000000 };
3116
3117         let (_, first_payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], value);
3118         let (_, second_payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], value);
3119         let (_, third_payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], value);
3120
3121         assert!(nodes[2].node.fail_htlc_backwards(&first_payment_hash, &None));
3122         expect_pending_htlcs_forwardable!(nodes[2]);
3123         check_added_monitors!(nodes[2], 1);
3124         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
3125         assert!(updates.update_add_htlcs.is_empty());
3126         assert!(updates.update_fulfill_htlcs.is_empty());
3127         assert!(updates.update_fail_malformed_htlcs.is_empty());
3128         assert_eq!(updates.update_fail_htlcs.len(), 1);
3129         assert!(updates.update_fee.is_none());
3130         nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
3131         let bs_raa = commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false, true, false, true);
3132         // Drop the last RAA from 3 -> 2
3133
3134         assert!(nodes[2].node.fail_htlc_backwards(&second_payment_hash, &None));
3135         expect_pending_htlcs_forwardable!(nodes[2]);
3136         check_added_monitors!(nodes[2], 1);
3137         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
3138         assert!(updates.update_add_htlcs.is_empty());
3139         assert!(updates.update_fulfill_htlcs.is_empty());
3140         assert!(updates.update_fail_malformed_htlcs.is_empty());
3141         assert_eq!(updates.update_fail_htlcs.len(), 1);
3142         assert!(updates.update_fee.is_none());
3143         nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
3144         nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &updates.commitment_signed);
3145         check_added_monitors!(nodes[1], 1);
3146         // Note that nodes[1] is in AwaitingRAA, so won't send a CS
3147         let as_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[2].node.get_our_node_id());
3148         nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_raa);
3149         check_added_monitors!(nodes[2], 1);
3150
3151         assert!(nodes[2].node.fail_htlc_backwards(&third_payment_hash, &None));
3152         expect_pending_htlcs_forwardable!(nodes[2]);
3153         check_added_monitors!(nodes[2], 1);
3154         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
3155         assert!(updates.update_add_htlcs.is_empty());
3156         assert!(updates.update_fulfill_htlcs.is_empty());
3157         assert!(updates.update_fail_malformed_htlcs.is_empty());
3158         assert_eq!(updates.update_fail_htlcs.len(), 1);
3159         assert!(updates.update_fee.is_none());
3160         nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
3161         // At this point first_payment_hash has dropped out of the latest two commitment
3162         // transactions that nodes[1] is tracking...
3163         nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &updates.commitment_signed);
3164         check_added_monitors!(nodes[1], 1);
3165         // Note that nodes[1] is (still) in AwaitingRAA, so won't send a CS
3166         let as_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[2].node.get_our_node_id());
3167         nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_raa);
3168         check_added_monitors!(nodes[2], 1);
3169
3170         // Add a fourth HTLC, this one will get sequestered away in nodes[1]'s holding cell waiting
3171         // on nodes[2]'s RAA.
3172         let (_, fourth_payment_hash) = get_payment_preimage_hash!(nodes[0]);
3173         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
3174         let logger = test_utils::TestLogger::new();
3175         let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
3176         nodes[1].node.send_payment(&route, fourth_payment_hash, &None).unwrap();
3177         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
3178         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
3179         check_added_monitors!(nodes[1], 0);
3180
3181         if deliver_bs_raa {
3182                 nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &bs_raa);
3183                 // One monitor for the new revocation preimage, no second on as we won't generate a new
3184                 // commitment transaction for nodes[0] until process_pending_htlc_forwards().
3185                 check_added_monitors!(nodes[1], 1);
3186                 let events = nodes[1].node.get_and_clear_pending_events();
3187                 assert_eq!(events.len(), 1);
3188                 match events[0] {
3189                         Event::PendingHTLCsForwardable { .. } => { },
3190                         _ => panic!("Unexpected event"),
3191                 };
3192                 // Deliberately don't process the pending fail-back so they all fail back at once after
3193                 // block connection just like the !deliver_bs_raa case
3194         }
3195
3196         let mut failed_htlcs = HashSet::new();
3197         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
3198
3199         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
3200         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
3201         check_added_monitors!(nodes[1], 1);
3202         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
3203
3204         let events = nodes[1].node.get_and_clear_pending_events();
3205         assert_eq!(events.len(), if deliver_bs_raa { 1 } else { 2 });
3206         match events[0] {
3207                 Event::PaymentFailed { ref payment_hash, .. } => {
3208                         assert_eq!(*payment_hash, fourth_payment_hash);
3209                 },
3210                 _ => panic!("Unexpected event"),
3211         }
3212         if !deliver_bs_raa {
3213                 match events[1] {
3214                         Event::PendingHTLCsForwardable { .. } => { },
3215                         _ => panic!("Unexpected event"),
3216                 };
3217         }
3218         nodes[1].node.process_pending_htlc_forwards();
3219         check_added_monitors!(nodes[1], 1);
3220
3221         let events = nodes[1].node.get_and_clear_pending_msg_events();
3222         assert_eq!(events.len(), if deliver_bs_raa { 3 } else { 2 });
3223         match events[if deliver_bs_raa { 1 } else { 0 }] {
3224                 MessageSendEvent::BroadcastChannelUpdate { msg: msgs::ChannelUpdate { .. } } => {},
3225                 _ => panic!("Unexpected event"),
3226         }
3227         if deliver_bs_raa {
3228                 match events[0] {
3229                         MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fail_htlcs, ref update_fulfill_htlcs, ref update_fail_malformed_htlcs, .. } } => {
3230                                 assert_eq!(nodes[2].node.get_our_node_id(), *node_id);
3231                                 assert_eq!(update_add_htlcs.len(), 1);
3232                                 assert!(update_fulfill_htlcs.is_empty());
3233                                 assert!(update_fail_htlcs.is_empty());
3234                                 assert!(update_fail_malformed_htlcs.is_empty());
3235                         },
3236                         _ => panic!("Unexpected event"),
3237                 }
3238         }
3239         match events[if deliver_bs_raa { 2 } else { 1 }] {
3240                 MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fail_htlcs, ref update_fulfill_htlcs, ref update_fail_malformed_htlcs, ref commitment_signed, .. } } => {
3241                         assert!(update_add_htlcs.is_empty());
3242                         assert_eq!(update_fail_htlcs.len(), 3);
3243                         assert!(update_fulfill_htlcs.is_empty());
3244                         assert!(update_fail_malformed_htlcs.is_empty());
3245                         assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
3246
3247                         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlcs[0]);
3248                         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlcs[1]);
3249                         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlcs[2]);
3250
3251                         commitment_signed_dance!(nodes[0], nodes[1], commitment_signed, false, true);
3252
3253                         let events = nodes[0].node.get_and_clear_pending_msg_events();
3254                         // If we delivered B's RAA we got an unknown preimage error, not something
3255                         // that we should update our routing table for.
3256                         assert_eq!(events.len(), if deliver_bs_raa { 2 } else { 3 });
3257                         for event in events {
3258                                 match event {
3259                                         MessageSendEvent::PaymentFailureNetworkUpdate { .. } => {},
3260                                         _ => panic!("Unexpected event"),
3261                                 }
3262                         }
3263                         let events = nodes[0].node.get_and_clear_pending_events();
3264                         assert_eq!(events.len(), 3);
3265                         match events[0] {
3266                                 Event::PaymentFailed { ref payment_hash, .. } => {
3267                                         assert!(failed_htlcs.insert(payment_hash.0));
3268                                 },
3269                                 _ => panic!("Unexpected event"),
3270                         }
3271                         match events[1] {
3272                                 Event::PaymentFailed { ref payment_hash, .. } => {
3273                                         assert!(failed_htlcs.insert(payment_hash.0));
3274                                 },
3275                                 _ => panic!("Unexpected event"),
3276                         }
3277                         match events[2] {
3278                                 Event::PaymentFailed { ref payment_hash, .. } => {
3279                                         assert!(failed_htlcs.insert(payment_hash.0));
3280                                 },
3281                                 _ => panic!("Unexpected event"),
3282                         }
3283                 },
3284                 _ => panic!("Unexpected event"),
3285         }
3286
3287         assert!(failed_htlcs.contains(&first_payment_hash.0));
3288         assert!(failed_htlcs.contains(&second_payment_hash.0));
3289         assert!(failed_htlcs.contains(&third_payment_hash.0));
3290 }
3291
3292 #[test]
3293 fn test_commitment_revoked_fail_backward_exhaustive_a() {
3294         do_test_commitment_revoked_fail_backward_exhaustive(false, true, false);
3295         do_test_commitment_revoked_fail_backward_exhaustive(true, true, false);
3296         do_test_commitment_revoked_fail_backward_exhaustive(false, false, false);
3297         do_test_commitment_revoked_fail_backward_exhaustive(true, false, false);
3298 }
3299
3300 #[test]
3301 fn test_commitment_revoked_fail_backward_exhaustive_b() {
3302         do_test_commitment_revoked_fail_backward_exhaustive(false, true, true);
3303         do_test_commitment_revoked_fail_backward_exhaustive(true, true, true);
3304         do_test_commitment_revoked_fail_backward_exhaustive(false, false, true);
3305         do_test_commitment_revoked_fail_backward_exhaustive(true, false, true);
3306 }
3307
3308 #[test]
3309 fn fail_backward_pending_htlc_upon_channel_failure() {
3310         let chanmon_cfgs = create_chanmon_cfgs(2);
3311         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
3312         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
3313         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
3314         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000, InitFeatures::known(), InitFeatures::known());
3315         let logger = test_utils::TestLogger::new();
3316
3317         // Alice -> Bob: Route a payment but without Bob sending revoke_and_ack.
3318         {
3319                 let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
3320                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3321                 let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &Vec::new(), 50_000, TEST_FINAL_CLTV, &logger).unwrap();
3322                 nodes[0].node.send_payment(&route, payment_hash, &None).unwrap();
3323                 check_added_monitors!(nodes[0], 1);
3324
3325                 let payment_event = {
3326                         let mut events = nodes[0].node.get_and_clear_pending_msg_events();
3327                         assert_eq!(events.len(), 1);
3328                         SendEvent::from_event(events.remove(0))
3329                 };
3330                 assert_eq!(payment_event.node_id, nodes[1].node.get_our_node_id());
3331                 assert_eq!(payment_event.msgs.len(), 1);
3332         }
3333
3334         // Alice -> Bob: Route another payment but now Alice waits for Bob's earlier revoke_and_ack.
3335         let (_, failed_payment_hash) = get_payment_preimage_hash!(nodes[0]);
3336         {
3337                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3338                 let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &Vec::new(), 50_000, TEST_FINAL_CLTV, &logger).unwrap();
3339                 nodes[0].node.send_payment(&route, failed_payment_hash, &None).unwrap();
3340                 check_added_monitors!(nodes[0], 0);
3341
3342                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
3343         }
3344
3345         // Alice <- Bob: Send a malformed update_add_htlc so Alice fails the channel.
3346         {
3347                 let (_, payment_hash) = get_payment_preimage_hash!(nodes[1]);
3348
3349                 let secp_ctx = Secp256k1::new();
3350                 let session_priv = SecretKey::from_slice(&[42; 32]).unwrap();
3351                 let current_height = nodes[1].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
3352                 let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
3353                 let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), None, &Vec::new(), 50_000, TEST_FINAL_CLTV, &logger).unwrap();
3354                 let (onion_payloads, _amount_msat, cltv_expiry) = onion_utils::build_onion_payloads(&route.paths[0], 50_000, &None, current_height).unwrap();
3355                 let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route.paths[0], &session_priv).unwrap();
3356                 let onion_routing_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash);
3357
3358                 // Send a 0-msat update_add_htlc to fail the channel.
3359                 let update_add_htlc = msgs::UpdateAddHTLC {
3360                         channel_id: chan.2,
3361                         htlc_id: 0,
3362                         amount_msat: 0,
3363                         payment_hash,
3364                         cltv_expiry,
3365                         onion_routing_packet,
3366                 };
3367                 nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &update_add_htlc);
3368         }
3369
3370         // Check that Alice fails backward the pending HTLC from the second payment.
3371         expect_payment_failed!(nodes[0], failed_payment_hash, true);
3372         check_closed_broadcast!(nodes[0], true);
3373         check_added_monitors!(nodes[0], 1);
3374 }
3375
3376 #[test]
3377 fn test_htlc_ignore_latest_remote_commitment() {
3378         // Test that HTLC transactions spending the latest remote commitment transaction are simply
3379         // ignored if we cannot claim them. This originally tickled an invalid unwrap().
3380         let chanmon_cfgs = create_chanmon_cfgs(2);
3381         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
3382         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
3383         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
3384         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3385
3386         route_payment(&nodes[0], &[&nodes[1]], 10000000);
3387         nodes[0].node.force_close_channel(&nodes[0].node.list_channels()[0].channel_id);
3388         check_closed_broadcast!(nodes[0], false);
3389         check_added_monitors!(nodes[0], 1);
3390
3391         let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
3392         assert_eq!(node_txn.len(), 2);
3393
3394         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
3395         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone(), node_txn[1].clone()]}, 1);
3396         check_closed_broadcast!(nodes[1], false);
3397         check_added_monitors!(nodes[1], 1);
3398
3399         // Duplicate the block_connected call since this may happen due to other listeners
3400         // registering new transactions
3401         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone(), node_txn[1].clone()]}, 1);
3402 }
3403
3404 #[test]
3405 fn test_force_close_fail_back() {
3406         // Check which HTLCs are failed-backwards on channel force-closure
3407         let chanmon_cfgs = create_chanmon_cfgs(3);
3408         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
3409         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
3410         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
3411         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3412         create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
3413         let logger = test_utils::TestLogger::new();
3414
3415         let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
3416
3417         let mut payment_event = {
3418                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3419                 let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, &Vec::new(), 1000000, 42, &logger).unwrap();
3420                 nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
3421                 check_added_monitors!(nodes[0], 1);
3422
3423                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
3424                 assert_eq!(events.len(), 1);
3425                 SendEvent::from_event(events.remove(0))
3426         };
3427
3428         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
3429         commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
3430
3431         expect_pending_htlcs_forwardable!(nodes[1]);
3432
3433         let mut events_2 = nodes[1].node.get_and_clear_pending_msg_events();
3434         assert_eq!(events_2.len(), 1);
3435         payment_event = SendEvent::from_event(events_2.remove(0));
3436         assert_eq!(payment_event.msgs.len(), 1);
3437
3438         check_added_monitors!(nodes[1], 1);
3439         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
3440         nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &payment_event.commitment_msg);
3441         check_added_monitors!(nodes[2], 1);
3442         let (_, _) = get_revoke_commit_msgs!(nodes[2], nodes[1].node.get_our_node_id());
3443
3444         // nodes[2] now has the latest commitment transaction, but hasn't revoked its previous
3445         // state or updated nodes[1]' state. Now force-close and broadcast that commitment/HTLC
3446         // transaction and ensure nodes[1] doesn't fail-backwards (this was originally a bug!).
3447
3448         nodes[2].node.force_close_channel(&payment_event.commitment_msg.channel_id);
3449         check_closed_broadcast!(nodes[2], false);
3450         check_added_monitors!(nodes[2], 1);
3451         let tx = {
3452                 let mut node_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap();
3453                 // Note that we don't bother broadcasting the HTLC-Success transaction here as we don't
3454                 // have a use for it unless nodes[2] learns the preimage somehow, the funds will go
3455                 // back to nodes[1] upon timeout otherwise.
3456                 assert_eq!(node_txn.len(), 1);
3457                 node_txn.remove(0)
3458         };
3459
3460         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
3461         nodes[1].block_notifier.block_connected_checked(&header, 1, &[&tx], &[1]);
3462
3463         // Note no UpdateHTLCs event here from nodes[1] to nodes[0]!
3464         check_closed_broadcast!(nodes[1], false);
3465         check_added_monitors!(nodes[1], 1);
3466
3467         // Now check that if we add the preimage to ChannelMonitor it broadcasts our HTLC-Success..
3468         {
3469                 let mut monitors = nodes[2].chan_monitor.simple_monitor.monitors.lock().unwrap();
3470                 monitors.get_mut(&OutPoint{ txid: Txid::from_slice(&payment_event.commitment_msg.channel_id[..]).unwrap(), index: 0 }).unwrap()
3471                         .provide_payment_preimage(&our_payment_hash, &our_payment_preimage);
3472         }
3473         nodes[2].block_notifier.block_connected_checked(&header, 1, &[&tx], &[1]);
3474         let node_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap();
3475         assert_eq!(node_txn.len(), 1);
3476         assert_eq!(node_txn[0].input.len(), 1);
3477         assert_eq!(node_txn[0].input[0].previous_output.txid, tx.txid());
3478         assert_eq!(node_txn[0].lock_time, 0); // Must be an HTLC-Success
3479         assert_eq!(node_txn[0].input[0].witness.len(), 5); // Must be an HTLC-Success
3480
3481         check_spends!(node_txn[0], tx);
3482 }
3483
3484 #[test]
3485 fn test_unconf_chan() {
3486         // After creating a chan between nodes, we disconnect all blocks previously seen to force a channel close on nodes[0] side
3487         let chanmon_cfgs = create_chanmon_cfgs(2);
3488         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
3489         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
3490         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
3491         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3492
3493         let channel_state = nodes[0].node.channel_state.lock().unwrap();
3494         assert_eq!(channel_state.by_id.len(), 1);
3495         assert_eq!(channel_state.short_to_id.len(), 1);
3496         mem::drop(channel_state);
3497
3498         let mut headers = Vec::new();
3499         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
3500         headers.push(header.clone());
3501         for _i in 2..100 {
3502                 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
3503                 headers.push(header.clone());
3504         }
3505         let mut height = 99;
3506         while !headers.is_empty() {
3507                 nodes[0].node.block_disconnected(&headers.pop().unwrap(), height);
3508                 height -= 1;
3509         }
3510         check_closed_broadcast!(nodes[0], false);
3511         check_added_monitors!(nodes[0], 1);
3512         let channel_state = nodes[0].node.channel_state.lock().unwrap();
3513         assert_eq!(channel_state.by_id.len(), 0);
3514         assert_eq!(channel_state.short_to_id.len(), 0);
3515 }
3516
3517 #[test]
3518 fn test_simple_peer_disconnect() {
3519         // Test that we can reconnect when there are no lost messages
3520         let chanmon_cfgs = create_chanmon_cfgs(3);
3521         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
3522         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
3523         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
3524         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3525         create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
3526
3527         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3528         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3529         reconnect_nodes(&nodes[0], &nodes[1], (true, true), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3530
3531         let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).0;
3532         let payment_hash_2 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).1;
3533         fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_hash_2);
3534         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_1, 1_000_000);
3535
3536         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3537         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3538         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3539
3540         let payment_preimage_3 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).0;
3541         let payment_preimage_4 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).0;
3542         let payment_hash_5 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).1;
3543         let payment_hash_6 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).1;
3544
3545         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3546         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3547
3548         claim_payment_along_route(&nodes[0], &vec!(&nodes[1], &nodes[2]), true, payment_preimage_3, 1_000_000);
3549         fail_payment_along_route(&nodes[0], &[&nodes[1], &nodes[2]], true, payment_hash_5);
3550
3551         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (1, 0), (1, 0), (false, false));
3552         {
3553                 let events = nodes[0].node.get_and_clear_pending_events();
3554                 assert_eq!(events.len(), 2);
3555                 match events[0] {
3556                         Event::PaymentSent { payment_preimage } => {
3557                                 assert_eq!(payment_preimage, payment_preimage_3);
3558                         },
3559                         _ => panic!("Unexpected event"),
3560                 }
3561                 match events[1] {
3562                         Event::PaymentFailed { payment_hash, rejected_by_dest, .. } => {
3563                                 assert_eq!(payment_hash, payment_hash_5);
3564                                 assert!(rejected_by_dest);
3565                         },
3566                         _ => panic!("Unexpected event"),
3567                 }
3568         }
3569
3570         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_4, 1_000_000);
3571         fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_hash_6);
3572 }
3573
3574 fn do_test_drop_messages_peer_disconnect(messages_delivered: u8) {
3575         // Test that we can reconnect when in-flight HTLC updates get dropped
3576         let chanmon_cfgs = create_chanmon_cfgs(2);
3577         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
3578         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
3579         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
3580         if messages_delivered == 0 {
3581                 create_chan_between_nodes_with_value_a(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::known(), InitFeatures::known());
3582                 // nodes[1] doesn't receive the funding_locked message (it'll be re-sent on reconnect)
3583         } else {
3584                 create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3585         }
3586
3587         let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
3588
3589         let logger = test_utils::TestLogger::new();
3590         let payment_event = {
3591                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3592                 let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(&nodes[0].node.list_usable_channels()), &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
3593                 nodes[0].node.send_payment(&route, payment_hash_1, &None).unwrap();
3594                 check_added_monitors!(nodes[0], 1);
3595
3596                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
3597                 assert_eq!(events.len(), 1);
3598                 SendEvent::from_event(events.remove(0))
3599         };
3600         assert_eq!(nodes[1].node.get_our_node_id(), payment_event.node_id);
3601
3602         if messages_delivered < 2 {
3603                 // Drop the payment_event messages, and let them get re-generated in reconnect_nodes!
3604         } else {
3605                 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
3606                 if messages_delivered >= 3 {
3607                         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event.commitment_msg);
3608                         check_added_monitors!(nodes[1], 1);
3609                         let (bs_revoke_and_ack, bs_commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
3610
3611                         if messages_delivered >= 4 {
3612                                 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack);
3613                                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
3614                                 check_added_monitors!(nodes[0], 1);
3615
3616                                 if messages_delivered >= 5 {
3617                                         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_commitment_signed);
3618                                         let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
3619                                         // No commitment_signed so get_event_msg's assert(len == 1) passes
3620                                         check_added_monitors!(nodes[0], 1);
3621
3622                                         if messages_delivered >= 6 {
3623                                                 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_and_ack);
3624                                                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
3625                                                 check_added_monitors!(nodes[1], 1);
3626                                         }
3627                                 }
3628                         }
3629                 }
3630         }
3631
3632         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3633         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3634         if messages_delivered < 3 {
3635                 // Even if the funding_locked messages get exchanged, as long as nothing further was
3636                 // received on either side, both sides will need to resend them.
3637                 reconnect_nodes(&nodes[0], &nodes[1], (true, true), (0, 1), (0, 0), (0, 0), (0, 0), (false, false));
3638         } else if messages_delivered == 3 {
3639                 // nodes[0] still wants its RAA + commitment_signed
3640                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (-1, 0), (0, 0), (0, 0), (0, 0), (true, false));
3641         } else if messages_delivered == 4 {
3642                 // nodes[0] still wants its commitment_signed
3643                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (-1, 0), (0, 0), (0, 0), (0, 0), (false, false));
3644         } else if messages_delivered == 5 {
3645                 // nodes[1] still wants its final RAA
3646                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, true));
3647         } else if messages_delivered == 6 {
3648                 // Everything was delivered...
3649                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3650         }
3651
3652         let events_1 = nodes[1].node.get_and_clear_pending_events();
3653         assert_eq!(events_1.len(), 1);
3654         match events_1[0] {
3655                 Event::PendingHTLCsForwardable { .. } => { },
3656                 _ => panic!("Unexpected event"),
3657         };
3658
3659         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3660         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3661         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3662
3663         nodes[1].node.process_pending_htlc_forwards();
3664
3665         let events_2 = nodes[1].node.get_and_clear_pending_events();
3666         assert_eq!(events_2.len(), 1);
3667         match events_2[0] {
3668                 Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
3669                         assert_eq!(payment_hash_1, *payment_hash);
3670                         assert_eq!(*payment_secret, None);
3671                         assert_eq!(amt, 1000000);
3672                 },
3673                 _ => panic!("Unexpected event"),
3674         }
3675
3676         nodes[1].node.claim_funds(payment_preimage_1, &None, 1_000_000);
3677         check_added_monitors!(nodes[1], 1);
3678
3679         let events_3 = nodes[1].node.get_and_clear_pending_msg_events();
3680         assert_eq!(events_3.len(), 1);
3681         let (update_fulfill_htlc, commitment_signed) = match events_3[0] {
3682                 MessageSendEvent::UpdateHTLCs { ref node_id, ref updates } => {
3683                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
3684                         assert!(updates.update_add_htlcs.is_empty());
3685                         assert!(updates.update_fail_htlcs.is_empty());
3686                         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
3687                         assert!(updates.update_fail_malformed_htlcs.is_empty());
3688                         assert!(updates.update_fee.is_none());
3689                         (updates.update_fulfill_htlcs[0].clone(), updates.commitment_signed.clone())
3690                 },
3691                 _ => panic!("Unexpected event"),
3692         };
3693
3694         if messages_delivered >= 1 {
3695                 nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_htlc);
3696
3697                 let events_4 = nodes[0].node.get_and_clear_pending_events();
3698                 assert_eq!(events_4.len(), 1);
3699                 match events_4[0] {
3700                         Event::PaymentSent { ref payment_preimage } => {
3701                                 assert_eq!(payment_preimage_1, *payment_preimage);
3702                         },
3703                         _ => panic!("Unexpected event"),
3704                 }
3705
3706                 if messages_delivered >= 2 {
3707                         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_signed);
3708                         check_added_monitors!(nodes[0], 1);
3709                         let (as_revoke_and_ack, as_commitment_signed) = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
3710
3711                         if messages_delivered >= 3 {
3712                                 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_and_ack);
3713                                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
3714                                 check_added_monitors!(nodes[1], 1);
3715
3716                                 if messages_delivered >= 4 {
3717                                         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_commitment_signed);
3718                                         let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
3719                                         // No commitment_signed so get_event_msg's assert(len == 1) passes
3720                                         check_added_monitors!(nodes[1], 1);
3721
3722                                         if messages_delivered >= 5 {
3723                                                 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack);
3724                                                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
3725                                                 check_added_monitors!(nodes[0], 1);
3726                                         }
3727                                 }
3728                         }
3729                 }
3730         }
3731
3732         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3733         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3734         if messages_delivered < 2 {
3735                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (1, 0), (0, 0), (0, 0), (false, false));
3736                 //TODO: Deduplicate PaymentSent events, then enable this if:
3737                 //if messages_delivered < 1 {
3738                         let events_4 = nodes[0].node.get_and_clear_pending_events();
3739                         assert_eq!(events_4.len(), 1);
3740                         match events_4[0] {
3741                                 Event::PaymentSent { ref payment_preimage } => {
3742                                         assert_eq!(payment_preimage_1, *payment_preimage);
3743                                 },
3744                                 _ => panic!("Unexpected event"),
3745                         }
3746                 //}
3747         } else if messages_delivered == 2 {
3748                 // nodes[0] still wants its RAA + commitment_signed
3749                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, -1), (0, 0), (0, 0), (0, 0), (false, true));
3750         } else if messages_delivered == 3 {
3751                 // nodes[0] still wants its commitment_signed
3752                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, -1), (0, 0), (0, 0), (0, 0), (false, false));
3753         } else if messages_delivered == 4 {
3754                 // nodes[1] still wants its final RAA
3755                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (true, false));
3756         } else if messages_delivered == 5 {
3757                 // Everything was delivered...
3758                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3759         }
3760
3761         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3762         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3763         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3764
3765         // Channel should still work fine...
3766         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3767         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), Some(&nodes[0].node.list_usable_channels()), &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
3768         let payment_preimage_2 = send_along_route(&nodes[0], route, &[&nodes[1]], 1000000).0;
3769         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
3770 }
3771
3772 #[test]
3773 fn test_drop_messages_peer_disconnect_a() {
3774         do_test_drop_messages_peer_disconnect(0);
3775         do_test_drop_messages_peer_disconnect(1);
3776         do_test_drop_messages_peer_disconnect(2);
3777         do_test_drop_messages_peer_disconnect(3);
3778 }
3779
3780 #[test]
3781 fn test_drop_messages_peer_disconnect_b() {
3782         do_test_drop_messages_peer_disconnect(4);
3783         do_test_drop_messages_peer_disconnect(5);
3784         do_test_drop_messages_peer_disconnect(6);
3785 }
3786
3787 #[test]
3788 fn test_funding_peer_disconnect() {
3789         // Test that we can lock in our funding tx while disconnected
3790         let chanmon_cfgs = create_chanmon_cfgs(2);
3791         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
3792         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
3793         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
3794         let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::known(), InitFeatures::known());
3795
3796         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3797         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3798
3799         confirm_transaction(&nodes[0].block_notifier, &nodes[0].chain_monitor, &tx, tx.version);
3800         let events_1 = nodes[0].node.get_and_clear_pending_msg_events();
3801         assert_eq!(events_1.len(), 1);
3802         match events_1[0] {
3803                 MessageSendEvent::SendFundingLocked { ref node_id, msg: _ } => {
3804                         assert_eq!(*node_id, nodes[1].node.get_our_node_id());
3805                 },
3806                 _ => panic!("Unexpected event"),
3807         }
3808
3809         reconnect_nodes(&nodes[0], &nodes[1], (false, true), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3810
3811         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3812         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3813
3814         confirm_transaction(&nodes[1].block_notifier, &nodes[1].chain_monitor, &tx, tx.version);
3815         let events_2 = nodes[1].node.get_and_clear_pending_msg_events();
3816         assert_eq!(events_2.len(), 2);
3817         let funding_locked = match events_2[0] {
3818                 MessageSendEvent::SendFundingLocked { ref node_id, ref msg } => {
3819                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
3820                         msg.clone()
3821                 },
3822                 _ => panic!("Unexpected event"),
3823         };
3824         let bs_announcement_sigs = match events_2[1] {
3825                 MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } => {
3826                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
3827                         msg.clone()
3828                 },
3829                 _ => panic!("Unexpected event"),
3830         };
3831
3832         reconnect_nodes(&nodes[0], &nodes[1], (true, true), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3833
3834         nodes[0].node.handle_funding_locked(&nodes[1].node.get_our_node_id(), &funding_locked);
3835         nodes[0].node.handle_announcement_signatures(&nodes[1].node.get_our_node_id(), &bs_announcement_sigs);
3836         let events_3 = nodes[0].node.get_and_clear_pending_msg_events();
3837         assert_eq!(events_3.len(), 2);
3838         let as_announcement_sigs = match events_3[0] {
3839                 MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } => {
3840                         assert_eq!(*node_id, nodes[1].node.get_our_node_id());
3841                         msg.clone()
3842                 },
3843                 _ => panic!("Unexpected event"),
3844         };
3845         let (as_announcement, as_update) = match events_3[1] {
3846                 MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } => {
3847                         (msg.clone(), update_msg.clone())
3848                 },
3849                 _ => panic!("Unexpected event"),
3850         };
3851
3852         nodes[1].node.handle_announcement_signatures(&nodes[0].node.get_our_node_id(), &as_announcement_sigs);
3853         let events_4 = nodes[1].node.get_and_clear_pending_msg_events();
3854         assert_eq!(events_4.len(), 1);
3855         let (_, bs_update) = match events_4[0] {
3856                 MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } => {
3857                         (msg.clone(), update_msg.clone())
3858                 },
3859                 _ => panic!("Unexpected event"),
3860         };
3861
3862         nodes[0].net_graph_msg_handler.handle_channel_announcement(&as_announcement).unwrap();
3863         nodes[0].net_graph_msg_handler.handle_channel_update(&bs_update).unwrap();
3864         nodes[0].net_graph_msg_handler.handle_channel_update(&as_update).unwrap();
3865
3866         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3867         let logger = test_utils::TestLogger::new();
3868         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
3869         let (payment_preimage, _) = send_along_route(&nodes[0], route, &[&nodes[1]], 1000000);
3870         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage, 1_000_000);
3871 }
3872
3873 #[test]
3874 fn test_drop_messages_peer_disconnect_dual_htlc() {
3875         // Test that we can handle reconnecting when both sides of a channel have pending
3876         // commitment_updates when we disconnect.
3877         let chanmon_cfgs = create_chanmon_cfgs(2);
3878         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
3879         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
3880         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
3881         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3882         let logger = test_utils::TestLogger::new();
3883
3884         let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
3885
3886         // Now try to send a second payment which will fail to send
3887         let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
3888         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3889         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
3890         nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap();
3891         check_added_monitors!(nodes[0], 1);
3892
3893         let events_1 = nodes[0].node.get_and_clear_pending_msg_events();
3894         assert_eq!(events_1.len(), 1);
3895         match events_1[0] {
3896                 MessageSendEvent::UpdateHTLCs { .. } => {},
3897                 _ => panic!("Unexpected event"),
3898         }
3899
3900         assert!(nodes[1].node.claim_funds(payment_preimage_1, &None, 1_000_000));
3901         check_added_monitors!(nodes[1], 1);
3902
3903         let events_2 = nodes[1].node.get_and_clear_pending_msg_events();
3904         assert_eq!(events_2.len(), 1);
3905         match events_2[0] {
3906                 MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, ref update_fee, ref commitment_signed } } => {
3907                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
3908                         assert!(update_add_htlcs.is_empty());
3909                         assert_eq!(update_fulfill_htlcs.len(), 1);
3910                         assert!(update_fail_htlcs.is_empty());
3911                         assert!(update_fail_malformed_htlcs.is_empty());
3912                         assert!(update_fee.is_none());
3913
3914                         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_htlcs[0]);
3915                         let events_3 = nodes[0].node.get_and_clear_pending_events();
3916                         assert_eq!(events_3.len(), 1);
3917                         match events_3[0] {
3918                                 Event::PaymentSent { ref payment_preimage } => {
3919                                         assert_eq!(*payment_preimage, payment_preimage_1);
3920                                 },
3921                                 _ => panic!("Unexpected event"),
3922                         }
3923
3924                         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), commitment_signed);
3925                         let _ = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
3926                         // No commitment_signed so get_event_msg's assert(len == 1) passes
3927                         check_added_monitors!(nodes[0], 1);
3928                 },
3929                 _ => panic!("Unexpected event"),
3930         }
3931
3932         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3933         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3934
3935         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
3936         let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
3937         assert_eq!(reestablish_1.len(), 1);
3938         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
3939         let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
3940         assert_eq!(reestablish_2.len(), 1);
3941
3942         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
3943         let as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
3944         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
3945         let bs_resp = handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
3946
3947         assert!(as_resp.0.is_none());
3948         assert!(bs_resp.0.is_none());
3949
3950         assert!(bs_resp.1.is_none());
3951         assert!(bs_resp.2.is_none());
3952
3953         assert!(as_resp.3 == RAACommitmentOrder::CommitmentFirst);
3954
3955         assert_eq!(as_resp.2.as_ref().unwrap().update_add_htlcs.len(), 1);
3956         assert!(as_resp.2.as_ref().unwrap().update_fulfill_htlcs.is_empty());
3957         assert!(as_resp.2.as_ref().unwrap().update_fail_htlcs.is_empty());
3958         assert!(as_resp.2.as_ref().unwrap().update_fail_malformed_htlcs.is_empty());
3959         assert!(as_resp.2.as_ref().unwrap().update_fee.is_none());
3960         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &as_resp.2.as_ref().unwrap().update_add_htlcs[0]);
3961         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_resp.2.as_ref().unwrap().commitment_signed);
3962         let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
3963         // No commitment_signed so get_event_msg's assert(len == 1) passes
3964         check_added_monitors!(nodes[1], 1);
3965
3966         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), as_resp.1.as_ref().unwrap());
3967         let bs_second_commitment_signed = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
3968         assert!(bs_second_commitment_signed.update_add_htlcs.is_empty());
3969         assert!(bs_second_commitment_signed.update_fulfill_htlcs.is_empty());
3970         assert!(bs_second_commitment_signed.update_fail_htlcs.is_empty());
3971         assert!(bs_second_commitment_signed.update_fail_malformed_htlcs.is_empty());
3972         assert!(bs_second_commitment_signed.update_fee.is_none());
3973         check_added_monitors!(nodes[1], 1);
3974
3975         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack);
3976         let as_commitment_signed = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
3977         assert!(as_commitment_signed.update_add_htlcs.is_empty());
3978         assert!(as_commitment_signed.update_fulfill_htlcs.is_empty());
3979         assert!(as_commitment_signed.update_fail_htlcs.is_empty());
3980         assert!(as_commitment_signed.update_fail_malformed_htlcs.is_empty());
3981         assert!(as_commitment_signed.update_fee.is_none());
3982         check_added_monitors!(nodes[0], 1);
3983
3984         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_second_commitment_signed.commitment_signed);
3985         let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
3986         // No commitment_signed so get_event_msg's assert(len == 1) passes
3987         check_added_monitors!(nodes[0], 1);
3988
3989         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_commitment_signed.commitment_signed);
3990         let bs_second_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
3991         // No commitment_signed so get_event_msg's assert(len == 1) passes
3992         check_added_monitors!(nodes[1], 1);
3993
3994         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_and_ack);
3995         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
3996         check_added_monitors!(nodes[1], 1);
3997
3998         expect_pending_htlcs_forwardable!(nodes[1]);
3999
4000         let events_5 = nodes[1].node.get_and_clear_pending_events();
4001         assert_eq!(events_5.len(), 1);
4002         match events_5[0] {
4003                 Event::PaymentReceived { ref payment_hash, ref payment_secret, amt: _ } => {
4004                         assert_eq!(payment_hash_2, *payment_hash);
4005                         assert_eq!(*payment_secret, None);
4006                 },
4007                 _ => panic!("Unexpected event"),
4008         }
4009
4010         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_second_revoke_and_ack);
4011         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
4012         check_added_monitors!(nodes[0], 1);
4013
4014         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
4015 }
4016
4017 fn do_test_htlc_timeout(send_partial_mpp: bool) {
4018         // If the user fails to claim/fail an HTLC within the HTLC CLTV timeout we fail it for them
4019         // to avoid our counterparty failing the channel.
4020         let chanmon_cfgs = create_chanmon_cfgs(2);
4021         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4022         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4023         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4024
4025         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4026         let logger = test_utils::TestLogger::new();
4027
4028         let our_payment_hash = if send_partial_mpp {
4029                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
4030                 let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
4031                 let (_, our_payment_hash) = get_payment_preimage_hash!(&nodes[0]);
4032                 let payment_secret = PaymentSecret([0xdb; 32]);
4033                 // Use the utility function send_payment_along_path to send the payment with MPP data which
4034                 // indicates there are more HTLCs coming.
4035                 nodes[0].node.send_payment_along_path(&route.paths[0], &our_payment_hash, &Some(payment_secret), 200000, CHAN_CONFIRM_DEPTH).unwrap();
4036                 check_added_monitors!(nodes[0], 1);
4037                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
4038                 assert_eq!(events.len(), 1);
4039                 // Now do the relevant commitment_signed/RAA dances along the path, noting that the final
4040                 // hop should *not* yet generate any PaymentReceived event(s).
4041                 pass_along_path(&nodes[0], &[&nodes[1]], 100000, our_payment_hash, Some(payment_secret), events.drain(..).next().unwrap(), false);
4042                 our_payment_hash
4043         } else {
4044                 route_payment(&nodes[0], &[&nodes[1]], 100000).1
4045         };
4046
4047         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4048         nodes[0].block_notifier.block_connected_checked(&header, 101, &[], &[]);
4049         nodes[1].block_notifier.block_connected_checked(&header, 101, &[], &[]);
4050         for i in 102..TEST_FINAL_CLTV + 100 + 1 - CLTV_CLAIM_BUFFER - LATENCY_GRACE_PERIOD_BLOCKS {
4051                 header.prev_blockhash = header.bitcoin_hash();
4052                 nodes[0].block_notifier.block_connected_checked(&header, i, &[], &[]);
4053                 nodes[1].block_notifier.block_connected_checked(&header, i, &[], &[]);
4054         }
4055
4056         expect_pending_htlcs_forwardable!(nodes[1]);
4057
4058         check_added_monitors!(nodes[1], 1);
4059         let htlc_timeout_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
4060         assert!(htlc_timeout_updates.update_add_htlcs.is_empty());
4061         assert_eq!(htlc_timeout_updates.update_fail_htlcs.len(), 1);
4062         assert!(htlc_timeout_updates.update_fail_malformed_htlcs.is_empty());
4063         assert!(htlc_timeout_updates.update_fee.is_none());
4064
4065         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &htlc_timeout_updates.update_fail_htlcs[0]);
4066         commitment_signed_dance!(nodes[0], nodes[1], htlc_timeout_updates.commitment_signed, false);
4067         // 100_000 msat as u64, followed by a height of 123 as u32
4068         let mut expected_failure_data = byte_utils::be64_to_array(100_000).to_vec();
4069         expected_failure_data.extend_from_slice(&byte_utils::be32_to_array(123));
4070         expect_payment_failed!(nodes[0], our_payment_hash, true, 0x4000 | 15, &expected_failure_data[..]);
4071 }
4072
4073 #[test]
4074 fn test_htlc_timeout() {
4075         do_test_htlc_timeout(true);
4076         do_test_htlc_timeout(false);
4077 }
4078
4079 fn do_test_holding_cell_htlc_add_timeouts(forwarded_htlc: bool) {
4080         // Tests that HTLCs in the holding cell are timed out after the requisite number of blocks.
4081         let chanmon_cfgs = create_chanmon_cfgs(3);
4082         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
4083         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
4084         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
4085         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4086         create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
4087         let logger = test_utils::TestLogger::new();
4088
4089         // Route a first payment to get the 1 -> 2 channel in awaiting_raa...
4090         let (_, first_payment_hash) = get_payment_preimage_hash!(nodes[0]);
4091         {
4092                 let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
4093                 let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
4094                 nodes[1].node.send_payment(&route, first_payment_hash, &None).unwrap();
4095         }
4096         assert_eq!(nodes[1].node.get_and_clear_pending_msg_events().len(), 1);
4097         check_added_monitors!(nodes[1], 1);
4098
4099         // Now attempt to route a second payment, which should be placed in the holding cell
4100         let (_, second_payment_hash) = get_payment_preimage_hash!(nodes[0]);
4101         if forwarded_htlc {
4102                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
4103                 let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
4104                 nodes[0].node.send_payment(&route, second_payment_hash, &None).unwrap();
4105                 check_added_monitors!(nodes[0], 1);
4106                 let payment_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
4107                 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
4108                 commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
4109                 expect_pending_htlcs_forwardable!(nodes[1]);
4110                 check_added_monitors!(nodes[1], 0);
4111         } else {
4112                 let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
4113                 let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
4114                 nodes[1].node.send_payment(&route, second_payment_hash, &None).unwrap();
4115                 check_added_monitors!(nodes[1], 0);
4116         }
4117
4118         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4119         nodes[1].block_notifier.block_connected_checked(&header, 101, &[], &[]);
4120         for i in 102..TEST_FINAL_CLTV + 100 - CLTV_CLAIM_BUFFER - LATENCY_GRACE_PERIOD_BLOCKS {
4121                 header.prev_blockhash = header.bitcoin_hash();
4122                 nodes[1].block_notifier.block_connected_checked(&header, i, &[], &[]);
4123         }
4124
4125         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4126         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
4127
4128         header.prev_blockhash = header.bitcoin_hash();
4129         nodes[1].block_notifier.block_connected_checked(&header, TEST_FINAL_CLTV + 100 - CLTV_CLAIM_BUFFER - LATENCY_GRACE_PERIOD_BLOCKS, &[], &[]);
4130
4131         if forwarded_htlc {
4132                 expect_pending_htlcs_forwardable!(nodes[1]);
4133                 check_added_monitors!(nodes[1], 1);
4134                 let fail_commit = nodes[1].node.get_and_clear_pending_msg_events();
4135                 assert_eq!(fail_commit.len(), 1);
4136                 match fail_commit[0] {
4137                         MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fail_htlcs, ref commitment_signed, .. }, .. } => {
4138                                 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlcs[0]);
4139                                 commitment_signed_dance!(nodes[0], nodes[1], commitment_signed, true, true);
4140                         },
4141                         _ => unreachable!(),
4142                 }
4143                 expect_payment_failed!(nodes[0], second_payment_hash, false);
4144                 if let &MessageSendEvent::PaymentFailureNetworkUpdate { ref update } = &nodes[0].node.get_and_clear_pending_msg_events()[0] {
4145                         match update {
4146                                 &HTLCFailChannelUpdate::ChannelUpdateMessage { .. } => {},
4147                                 _ => panic!("Unexpected event"),
4148                         }
4149                 } else {
4150                         panic!("Unexpected event");
4151                 }
4152         } else {
4153                 expect_payment_failed!(nodes[1], second_payment_hash, true);
4154         }
4155 }
4156
4157 #[test]
4158 fn test_holding_cell_htlc_add_timeouts() {
4159         do_test_holding_cell_htlc_add_timeouts(false);
4160         do_test_holding_cell_htlc_add_timeouts(true);
4161 }
4162
4163 #[test]
4164 fn test_invalid_channel_announcement() {
4165         //Test BOLT 7 channel_announcement msg requirement for final node, gather data to build customed channel_announcement msgs
4166         let secp_ctx = Secp256k1::new();
4167         let chanmon_cfgs = create_chanmon_cfgs(2);
4168         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4169         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4170         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4171
4172         let chan_announcement = create_chan_between_nodes(&nodes[0], &nodes[1], InitFeatures::known(), InitFeatures::known());
4173
4174         let a_channel_lock = nodes[0].node.channel_state.lock().unwrap();
4175         let b_channel_lock = nodes[1].node.channel_state.lock().unwrap();
4176         let as_chan = a_channel_lock.by_id.get(&chan_announcement.3).unwrap();
4177         let bs_chan = b_channel_lock.by_id.get(&chan_announcement.3).unwrap();
4178
4179         nodes[0].net_graph_msg_handler.handle_htlc_fail_channel_update(&msgs::HTLCFailChannelUpdate::ChannelClosed { short_channel_id : as_chan.get_short_channel_id().unwrap(), is_permanent: false } );
4180
4181         let as_bitcoin_key = as_chan.get_local_keys().inner.local_channel_pubkeys.funding_pubkey;
4182         let bs_bitcoin_key = bs_chan.get_local_keys().inner.local_channel_pubkeys.funding_pubkey;
4183
4184         let as_network_key = nodes[0].node.get_our_node_id();
4185         let bs_network_key = nodes[1].node.get_our_node_id();
4186
4187         let were_node_one = as_bitcoin_key.serialize()[..] < bs_bitcoin_key.serialize()[..];
4188
4189         let mut chan_announcement;
4190
4191         macro_rules! dummy_unsigned_msg {
4192                 () => {
4193                         msgs::UnsignedChannelAnnouncement {
4194                                 features: ChannelFeatures::known(),
4195                                 chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
4196                                 short_channel_id: as_chan.get_short_channel_id().unwrap(),
4197                                 node_id_1: if were_node_one { as_network_key } else { bs_network_key },
4198                                 node_id_2: if were_node_one { bs_network_key } else { as_network_key },
4199                                 bitcoin_key_1: if were_node_one { as_bitcoin_key } else { bs_bitcoin_key },
4200                                 bitcoin_key_2: if were_node_one { bs_bitcoin_key } else { as_bitcoin_key },
4201                                 excess_data: Vec::new(),
4202                         };
4203                 }
4204         }
4205
4206         macro_rules! sign_msg {
4207                 ($unsigned_msg: expr) => {
4208                         let msghash = Message::from_slice(&Sha256dHash::hash(&$unsigned_msg.encode()[..])[..]).unwrap();
4209                         let as_bitcoin_sig = secp_ctx.sign(&msghash, &as_chan.get_local_keys().inner.funding_key);
4210                         let bs_bitcoin_sig = secp_ctx.sign(&msghash, &bs_chan.get_local_keys().inner.funding_key);
4211                         let as_node_sig = secp_ctx.sign(&msghash, &nodes[0].keys_manager.get_node_secret());
4212                         let bs_node_sig = secp_ctx.sign(&msghash, &nodes[1].keys_manager.get_node_secret());
4213                         chan_announcement = msgs::ChannelAnnouncement {
4214                                 node_signature_1 : if were_node_one { as_node_sig } else { bs_node_sig},
4215                                 node_signature_2 : if were_node_one { bs_node_sig } else { as_node_sig},
4216                                 bitcoin_signature_1: if were_node_one { as_bitcoin_sig } else { bs_bitcoin_sig },
4217                                 bitcoin_signature_2 : if were_node_one { bs_bitcoin_sig } else { as_bitcoin_sig },
4218                                 contents: $unsigned_msg
4219                         }
4220                 }
4221         }
4222
4223         let unsigned_msg = dummy_unsigned_msg!();
4224         sign_msg!(unsigned_msg);
4225         assert_eq!(nodes[0].net_graph_msg_handler.handle_channel_announcement(&chan_announcement).unwrap(), true);
4226         let _ = nodes[0].net_graph_msg_handler.handle_htlc_fail_channel_update(&msgs::HTLCFailChannelUpdate::ChannelClosed { short_channel_id : as_chan.get_short_channel_id().unwrap(), is_permanent: false } );
4227
4228         // Configured with Network::Testnet
4229         let mut unsigned_msg = dummy_unsigned_msg!();
4230         unsigned_msg.chain_hash = genesis_block(Network::Bitcoin).header.bitcoin_hash();
4231         sign_msg!(unsigned_msg);
4232         assert!(nodes[0].net_graph_msg_handler.handle_channel_announcement(&chan_announcement).is_err());
4233
4234         let mut unsigned_msg = dummy_unsigned_msg!();
4235         unsigned_msg.chain_hash = BlockHash::hash(&[1,2,3,4,5,6,7,8,9]);
4236         sign_msg!(unsigned_msg);
4237         assert!(nodes[0].net_graph_msg_handler.handle_channel_announcement(&chan_announcement).is_err());
4238 }
4239
4240 #[test]
4241 fn test_no_txn_manager_serialize_deserialize() {
4242         let chanmon_cfgs = create_chanmon_cfgs(2);
4243         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4244         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4245         let logger: test_utils::TestLogger;
4246         let fee_estimator: test_utils::TestFeeEstimator;
4247         let new_chan_monitor: test_utils::TestChannelMonitor;
4248         let keys_manager: test_utils::TestKeysInterface;
4249         let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>;
4250         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4251
4252         let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::known(), InitFeatures::known());
4253
4254         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4255
4256         let nodes_0_serialized = nodes[0].node.encode();
4257         let mut chan_0_monitor_serialized = test_utils::TestVecWriter(Vec::new());
4258         nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter().next().unwrap().1.write_for_disk(&mut chan_0_monitor_serialized).unwrap();
4259
4260         logger = test_utils::TestLogger::new();
4261         fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
4262         new_chan_monitor = test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), &logger, &fee_estimator);
4263         nodes[0].chan_monitor = &new_chan_monitor;
4264         let mut chan_0_monitor_read = &chan_0_monitor_serialized.0[..];
4265         let (_, mut chan_0_monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut chan_0_monitor_read).unwrap();
4266         assert!(chan_0_monitor_read.is_empty());
4267
4268         let mut nodes_0_read = &nodes_0_serialized[..];
4269         let config = UserConfig::default();
4270         keys_manager = test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet);
4271         let (_, nodes_0_deserialized_tmp) = {
4272                 let mut channel_monitors = HashMap::new();
4273                 channel_monitors.insert(chan_0_monitor.get_funding_txo().0, &mut chan_0_monitor);
4274                 <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
4275                         default_config: config,
4276                         keys_manager: &keys_manager,
4277                         fee_estimator: &fee_estimator,
4278                         monitor: nodes[0].chan_monitor,
4279                         tx_broadcaster: nodes[0].tx_broadcaster.clone(),
4280                         logger: &logger,
4281                         channel_monitors: &mut channel_monitors,
4282                 }).unwrap()
4283         };
4284         nodes_0_deserialized = nodes_0_deserialized_tmp;
4285         assert!(nodes_0_read.is_empty());
4286
4287         assert!(nodes[0].chan_monitor.add_monitor(chan_0_monitor.get_funding_txo().0, chan_0_monitor).is_ok());
4288         nodes[0].node = &nodes_0_deserialized;
4289         nodes[0].block_notifier.register_listener(nodes[0].node);
4290         assert_eq!(nodes[0].node.list_channels().len(), 1);
4291         check_added_monitors!(nodes[0], 1);
4292
4293         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
4294         let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
4295         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
4296         let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
4297
4298         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
4299         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4300         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
4301         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
4302
4303         let (funding_locked, _) = create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
4304         let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked);
4305         for node in nodes.iter() {
4306                 assert!(node.net_graph_msg_handler.handle_channel_announcement(&announcement).unwrap());
4307                 node.net_graph_msg_handler.handle_channel_update(&as_update).unwrap();
4308                 node.net_graph_msg_handler.handle_channel_update(&bs_update).unwrap();
4309         }
4310
4311         send_payment(&nodes[0], &[&nodes[1]], 1000000, 1_000_000);
4312 }
4313
4314 #[test]
4315 fn test_manager_serialize_deserialize_events() {
4316         // This test makes sure the events field in ChannelManager survives de/serialization
4317         let chanmon_cfgs = create_chanmon_cfgs(2);
4318         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4319         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4320         let fee_estimator: test_utils::TestFeeEstimator;
4321         let logger: test_utils::TestLogger;
4322         let new_chan_monitor: test_utils::TestChannelMonitor;
4323         let keys_manager: test_utils::TestKeysInterface;
4324         let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>;
4325         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4326
4327         // Start creating a channel, but stop right before broadcasting the event message FundingBroadcastSafe
4328         let channel_value = 100000;
4329         let push_msat = 10001;
4330         let a_flags = InitFeatures::known();
4331         let b_flags = InitFeatures::known();
4332         let node_a = nodes.pop().unwrap();
4333         let node_b = nodes.pop().unwrap();
4334         node_a.node.create_channel(node_b.node.get_our_node_id(), channel_value, push_msat, 42, None).unwrap();
4335         node_b.node.handle_open_channel(&node_a.node.get_our_node_id(), a_flags, &get_event_msg!(node_a, MessageSendEvent::SendOpenChannel, node_b.node.get_our_node_id()));
4336         node_a.node.handle_accept_channel(&node_b.node.get_our_node_id(), b_flags, &get_event_msg!(node_b, MessageSendEvent::SendAcceptChannel, node_a.node.get_our_node_id()));
4337
4338         let (temporary_channel_id, tx, funding_output) = create_funding_transaction(&node_a, channel_value, 42);
4339
4340         node_a.node.funding_transaction_generated(&temporary_channel_id, funding_output);
4341         check_added_monitors!(node_a, 0);
4342
4343         node_b.node.handle_funding_created(&node_a.node.get_our_node_id(), &get_event_msg!(node_a, MessageSendEvent::SendFundingCreated, node_b.node.get_our_node_id()));
4344         {
4345                 let mut added_monitors = node_b.chan_monitor.added_monitors.lock().unwrap();
4346                 assert_eq!(added_monitors.len(), 1);
4347                 assert_eq!(added_monitors[0].0, funding_output);
4348                 added_monitors.clear();
4349         }
4350
4351         node_a.node.handle_funding_signed(&node_b.node.get_our_node_id(), &get_event_msg!(node_b, MessageSendEvent::SendFundingSigned, node_a.node.get_our_node_id()));
4352         {
4353                 let mut added_monitors = node_a.chan_monitor.added_monitors.lock().unwrap();
4354                 assert_eq!(added_monitors.len(), 1);
4355                 assert_eq!(added_monitors[0].0, funding_output);
4356                 added_monitors.clear();
4357         }
4358         // Normally, this is where node_a would check for a FundingBroadcastSafe event, but the test de/serializes first instead
4359
4360         nodes.push(node_a);
4361         nodes.push(node_b);
4362
4363         // Start the de/seriailization process mid-channel creation to check that the channel manager will hold onto events that are serialized
4364         let nodes_0_serialized = nodes[0].node.encode();
4365         let mut chan_0_monitor_serialized = test_utils::TestVecWriter(Vec::new());
4366         nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter().next().unwrap().1.write_for_disk(&mut chan_0_monitor_serialized).unwrap();
4367
4368         fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
4369         logger = test_utils::TestLogger::new();
4370         new_chan_monitor = test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), &logger, &fee_estimator);
4371         nodes[0].chan_monitor = &new_chan_monitor;
4372         let mut chan_0_monitor_read = &chan_0_monitor_serialized.0[..];
4373         let (_, mut chan_0_monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut chan_0_monitor_read).unwrap();
4374         assert!(chan_0_monitor_read.is_empty());
4375
4376         let mut nodes_0_read = &nodes_0_serialized[..];
4377         let config = UserConfig::default();
4378         keys_manager = test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet);
4379         let (_, nodes_0_deserialized_tmp) = {
4380                 let mut channel_monitors = HashMap::new();
4381                 channel_monitors.insert(chan_0_monitor.get_funding_txo().0, &mut chan_0_monitor);
4382                 <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
4383                         default_config: config,
4384                         keys_manager: &keys_manager,
4385                         fee_estimator: &fee_estimator,
4386                         monitor: nodes[0].chan_monitor,
4387                         tx_broadcaster: nodes[0].tx_broadcaster.clone(),
4388                         logger: &logger,
4389                         channel_monitors: &mut channel_monitors,
4390                 }).unwrap()
4391         };
4392         nodes_0_deserialized = nodes_0_deserialized_tmp;
4393         assert!(nodes_0_read.is_empty());
4394
4395         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4396
4397         assert!(nodes[0].chan_monitor.add_monitor(chan_0_monitor.get_funding_txo().0, chan_0_monitor).is_ok());
4398         nodes[0].node = &nodes_0_deserialized;
4399
4400         // After deserializing, make sure the FundingBroadcastSafe event is still held by the channel manager
4401         let events_4 = nodes[0].node.get_and_clear_pending_events();
4402         assert_eq!(events_4.len(), 1);
4403         match events_4[0] {
4404                 Event::FundingBroadcastSafe { ref funding_txo, user_channel_id } => {
4405                         assert_eq!(user_channel_id, 42);
4406                         assert_eq!(*funding_txo, funding_output);
4407                 },
4408                 _ => panic!("Unexpected event"),
4409         };
4410
4411         // Make sure the channel is functioning as though the de/serialization never happened
4412         nodes[0].block_notifier.register_listener(nodes[0].node);
4413         assert_eq!(nodes[0].node.list_channels().len(), 1);
4414         check_added_monitors!(nodes[0], 1);
4415
4416         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
4417         let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
4418         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
4419         let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
4420
4421         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
4422         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4423         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
4424         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
4425
4426         let (funding_locked, _) = create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
4427         let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked);
4428         for node in nodes.iter() {
4429                 assert!(node.net_graph_msg_handler.handle_channel_announcement(&announcement).unwrap());
4430                 node.net_graph_msg_handler.handle_channel_update(&as_update).unwrap();
4431                 node.net_graph_msg_handler.handle_channel_update(&bs_update).unwrap();
4432         }
4433
4434         send_payment(&nodes[0], &[&nodes[1]], 1000000, 1_000_000);
4435 }
4436
4437 #[test]
4438 fn test_simple_manager_serialize_deserialize() {
4439         let chanmon_cfgs = create_chanmon_cfgs(2);
4440         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4441         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4442         let logger: test_utils::TestLogger;
4443         let fee_estimator: test_utils::TestFeeEstimator;
4444         let new_chan_monitor: test_utils::TestChannelMonitor;
4445         let keys_manager: test_utils::TestKeysInterface;
4446         let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>;
4447         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4448         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4449
4450         let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
4451         let (_, our_payment_hash) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
4452
4453         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4454
4455         let nodes_0_serialized = nodes[0].node.encode();
4456         let mut chan_0_monitor_serialized = test_utils::TestVecWriter(Vec::new());
4457         nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter().next().unwrap().1.write_for_disk(&mut chan_0_monitor_serialized).unwrap();
4458
4459         logger = test_utils::TestLogger::new();
4460         fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
4461         new_chan_monitor = test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), &logger, &fee_estimator);
4462         nodes[0].chan_monitor = &new_chan_monitor;
4463         let mut chan_0_monitor_read = &chan_0_monitor_serialized.0[..];
4464         let (_, mut chan_0_monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut chan_0_monitor_read).unwrap();
4465         assert!(chan_0_monitor_read.is_empty());
4466
4467         let mut nodes_0_read = &nodes_0_serialized[..];
4468         keys_manager = test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet);
4469         let (_, nodes_0_deserialized_tmp) = {
4470                 let mut channel_monitors = HashMap::new();
4471                 channel_monitors.insert(chan_0_monitor.get_funding_txo().0, &mut chan_0_monitor);
4472                 <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
4473                         default_config: UserConfig::default(),
4474                         keys_manager: &keys_manager,
4475                         fee_estimator: &fee_estimator,
4476                         monitor: nodes[0].chan_monitor,
4477                         tx_broadcaster: nodes[0].tx_broadcaster.clone(),
4478                         logger: &logger,
4479                         channel_monitors: &mut channel_monitors,
4480                 }).unwrap()
4481         };
4482         nodes_0_deserialized = nodes_0_deserialized_tmp;
4483         assert!(nodes_0_read.is_empty());
4484
4485         assert!(nodes[0].chan_monitor.add_monitor(chan_0_monitor.get_funding_txo().0, chan_0_monitor).is_ok());
4486         nodes[0].node = &nodes_0_deserialized;
4487         check_added_monitors!(nodes[0], 1);
4488
4489         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
4490
4491         fail_payment(&nodes[0], &[&nodes[1]], our_payment_hash);
4492         claim_payment(&nodes[0], &[&nodes[1]], our_payment_preimage, 1_000_000);
4493 }
4494
4495 #[test]
4496 fn test_manager_serialize_deserialize_inconsistent_monitor() {
4497         // Test deserializing a ChannelManager with an out-of-date ChannelMonitor
4498         let chanmon_cfgs = create_chanmon_cfgs(4);
4499         let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
4500         let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
4501         let logger: test_utils::TestLogger;
4502         let fee_estimator: test_utils::TestFeeEstimator;
4503         let new_chan_monitor: test_utils::TestChannelMonitor;
4504         let keys_manager: test_utils::TestKeysInterface;
4505         let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>;
4506         let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
4507         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4508         create_announced_chan_between_nodes(&nodes, 2, 0, InitFeatures::known(), InitFeatures::known());
4509         let (_, _, channel_id, funding_tx) = create_announced_chan_between_nodes(&nodes, 0, 3, InitFeatures::known(), InitFeatures::known());
4510
4511         let mut node_0_stale_monitors_serialized = Vec::new();
4512         for monitor in nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter() {
4513                 let mut writer = test_utils::TestVecWriter(Vec::new());
4514                 monitor.1.write_for_disk(&mut writer).unwrap();
4515                 node_0_stale_monitors_serialized.push(writer.0);
4516         }
4517
4518         let (our_payment_preimage, _) = route_payment(&nodes[2], &[&nodes[0], &nodes[1]], 1000000);
4519
4520         // Serialize the ChannelManager here, but the monitor we keep up-to-date
4521         let nodes_0_serialized = nodes[0].node.encode();
4522
4523         route_payment(&nodes[0], &[&nodes[3]], 1000000);
4524         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4525         nodes[2].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4526         nodes[3].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4527
4528         // Now the ChannelMonitor (which is now out-of-sync with ChannelManager for channel w/
4529         // nodes[3])
4530         let mut node_0_monitors_serialized = Vec::new();
4531         for monitor in nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter() {
4532                 let mut writer = test_utils::TestVecWriter(Vec::new());
4533                 monitor.1.write_for_disk(&mut writer).unwrap();
4534                 node_0_monitors_serialized.push(writer.0);
4535         }
4536
4537         logger = test_utils::TestLogger::new();
4538         fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
4539         new_chan_monitor = test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), &logger, &fee_estimator);
4540         nodes[0].chan_monitor = &new_chan_monitor;
4541
4542         let mut node_0_stale_monitors = Vec::new();
4543         for serialized in node_0_stale_monitors_serialized.iter() {
4544                 let mut read = &serialized[..];
4545                 let (_, monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut read).unwrap();
4546                 assert!(read.is_empty());
4547                 node_0_stale_monitors.push(monitor);
4548         }
4549
4550         let mut node_0_monitors = Vec::new();
4551         for serialized in node_0_monitors_serialized.iter() {
4552                 let mut read = &serialized[..];
4553                 let (_, monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut read).unwrap();
4554                 assert!(read.is_empty());
4555                 node_0_monitors.push(monitor);
4556         }
4557
4558         keys_manager = test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet);
4559
4560         let mut nodes_0_read = &nodes_0_serialized[..];
4561         if let Err(msgs::DecodeError::InvalidValue) =
4562                 <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
4563                 default_config: UserConfig::default(),
4564                 keys_manager: &keys_manager,
4565                 fee_estimator: &fee_estimator,
4566                 monitor: nodes[0].chan_monitor,
4567                 tx_broadcaster: nodes[0].tx_broadcaster.clone(),
4568                 logger: &logger,
4569                 channel_monitors: &mut node_0_stale_monitors.iter_mut().map(|monitor| { (monitor.get_funding_txo().0, monitor) }).collect(),
4570         }) { } else {
4571                 panic!("If the monitor(s) are stale, this indicates a bug and we should get an Err return");
4572         };
4573
4574         let mut nodes_0_read = &nodes_0_serialized[..];
4575         let (_, nodes_0_deserialized_tmp) =
4576                 <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
4577                 default_config: UserConfig::default(),
4578                 keys_manager: &keys_manager,
4579                 fee_estimator: &fee_estimator,
4580                 monitor: nodes[0].chan_monitor,
4581                 tx_broadcaster: nodes[0].tx_broadcaster.clone(),
4582                 logger: &logger,
4583                 channel_monitors: &mut node_0_monitors.iter_mut().map(|monitor| { (monitor.get_funding_txo().0, monitor) }).collect(),
4584         }).unwrap();
4585         nodes_0_deserialized = nodes_0_deserialized_tmp;
4586         assert!(nodes_0_read.is_empty());
4587
4588         { // Channel close should result in a commitment tx and an HTLC tx
4589                 let txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
4590                 assert_eq!(txn.len(), 2);
4591                 assert_eq!(txn[0].input[0].previous_output.txid, funding_tx.txid());
4592                 assert_eq!(txn[1].input[0].previous_output.txid, txn[0].txid());
4593         }
4594
4595         for monitor in node_0_monitors.drain(..) {
4596                 assert!(nodes[0].chan_monitor.add_monitor(monitor.get_funding_txo().0, monitor).is_ok());
4597                 check_added_monitors!(nodes[0], 1);
4598         }
4599         nodes[0].node = &nodes_0_deserialized;
4600
4601         // nodes[1] and nodes[2] have no lost state with nodes[0]...
4602         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
4603         reconnect_nodes(&nodes[0], &nodes[2], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
4604         //... and we can even still claim the payment!
4605         claim_payment(&nodes[2], &[&nodes[0], &nodes[1]], our_payment_preimage, 1_000_000);
4606
4607         nodes[3].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
4608         let reestablish = get_event_msg!(nodes[3], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
4609         nodes[0].node.peer_connected(&nodes[3].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
4610         nodes[0].node.handle_channel_reestablish(&nodes[3].node.get_our_node_id(), &reestablish);
4611         let msg_events = nodes[0].node.get_and_clear_pending_msg_events();
4612         assert_eq!(msg_events.len(), 1);
4613         if let MessageSendEvent::HandleError { ref action, .. } = msg_events[0] {
4614                 match action {
4615                         &ErrorAction::SendErrorMessage { ref msg } => {
4616                                 assert_eq!(msg.channel_id, channel_id);
4617                         },
4618                         _ => panic!("Unexpected event!"),
4619                 }
4620         }
4621 }
4622
4623 macro_rules! check_spendable_outputs {
4624         ($node: expr, $der_idx: expr, $keysinterface: expr, $chan_value: expr) => {
4625                 {
4626                         let events = $node.chan_monitor.simple_monitor.get_and_clear_pending_events();
4627                         let mut txn = Vec::new();
4628                         for event in events {
4629                                 match event {
4630                                         Event::SpendableOutputs { ref outputs } => {
4631                                                 for outp in outputs {
4632                                                         match *outp {
4633                                                                 SpendableOutputDescriptor::StaticOutputRemotePayment { ref outpoint, ref output, ref key_derivation_params } => {
4634                                                                         let input = TxIn {
4635                                                                                 previous_output: outpoint.clone(),
4636                                                                                 script_sig: Script::new(),
4637                                                                                 sequence: 0,
4638                                                                                 witness: Vec::new(),
4639                                                                         };
4640                                                                         let outp = TxOut {
4641                                                                                 script_pubkey: Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(),
4642                                                                                 value: output.value,
4643                                                                         };
4644                                                                         let mut spend_tx = Transaction {
4645                                                                                 version: 2,
4646                                                                                 lock_time: 0,
4647                                                                                 input: vec![input],
4648                                                                                 output: vec![outp],
4649                                                                         };
4650                                                                         let secp_ctx = Secp256k1::new();
4651                                                                         let keys = $keysinterface.derive_channel_keys($chan_value, key_derivation_params.0, key_derivation_params.1);
4652                                                                         let remotepubkey = keys.pubkeys().payment_point;
4653                                                                         let witness_script = Address::p2pkh(&::bitcoin::PublicKey{compressed: true, key: remotepubkey}, Network::Testnet).script_pubkey();
4654                                                                         let sighash = Message::from_slice(&bip143::SighashComponents::new(&spend_tx).sighash_all(&spend_tx.input[0], &witness_script, output.value)[..]).unwrap();
4655                                                                         let remotesig = secp_ctx.sign(&sighash, &keys.inner.payment_key);
4656                                                                         spend_tx.input[0].witness.push(remotesig.serialize_der().to_vec());
4657                                                                         spend_tx.input[0].witness[0].push(SigHashType::All as u8);
4658                                                                         spend_tx.input[0].witness.push(remotepubkey.serialize().to_vec());
4659                                                                         txn.push(spend_tx);
4660                                                                 },
4661                                                                 SpendableOutputDescriptor::DynamicOutputP2WSH { ref outpoint, ref per_commitment_point, ref to_self_delay, ref output, ref key_derivation_params, ref remote_revocation_pubkey } => {
4662                                                                         let input = TxIn {
4663                                                                                 previous_output: outpoint.clone(),
4664                                                                                 script_sig: Script::new(),
4665                                                                                 sequence: *to_self_delay as u32,
4666                                                                                 witness: Vec::new(),
4667                                                                         };
4668                                                                         let outp = TxOut {
4669                                                                                 script_pubkey: Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(),
4670                                                                                 value: output.value,
4671                                                                         };
4672                                                                         let mut spend_tx = Transaction {
4673                                                                                 version: 2,
4674                                                                                 lock_time: 0,
4675                                                                                 input: vec![input],
4676                                                                                 output: vec![outp],
4677                                                                         };
4678                                                                         let secp_ctx = Secp256k1::new();
4679                                                                         let keys = $keysinterface.derive_channel_keys($chan_value, key_derivation_params.0, key_derivation_params.1);
4680                                                                         if let Ok(delayed_payment_key) = chan_utils::derive_private_key(&secp_ctx, &per_commitment_point, &keys.inner.delayed_payment_base_key) {
4681
4682                                                                                 let delayed_payment_pubkey = PublicKey::from_secret_key(&secp_ctx, &delayed_payment_key);
4683                                                                                 let witness_script = chan_utils::get_revokeable_redeemscript(remote_revocation_pubkey, *to_self_delay, &delayed_payment_pubkey);
4684                                                                                 let sighash = Message::from_slice(&bip143::SighashComponents::new(&spend_tx).sighash_all(&spend_tx.input[0], &witness_script, output.value)[..]).unwrap();
4685                                                                                 let local_delayedsig = secp_ctx.sign(&sighash, &delayed_payment_key);
4686                                                                                 spend_tx.input[0].witness.push(local_delayedsig.serialize_der().to_vec());
4687                                                                                 spend_tx.input[0].witness[0].push(SigHashType::All as u8);
4688                                                                                 spend_tx.input[0].witness.push(vec!()); //MINIMALIF
4689                                                                                 spend_tx.input[0].witness.push(witness_script.clone().into_bytes());
4690                                                                         } else { panic!() }
4691                                                                         txn.push(spend_tx);
4692                                                                 },
4693                                                                 SpendableOutputDescriptor::StaticOutput { ref outpoint, ref output } => {
4694                                                                         let secp_ctx = Secp256k1::new();
4695                                                                         let input = TxIn {
4696                                                                                 previous_output: outpoint.clone(),
4697                                                                                 script_sig: Script::new(),
4698                                                                                 sequence: 0,
4699                                                                                 witness: Vec::new(),
4700                                                                         };
4701                                                                         let outp = TxOut {
4702                                                                                 script_pubkey: Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(),
4703                                                                                 value: output.value,
4704                                                                         };
4705                                                                         let mut spend_tx = Transaction {
4706                                                                                 version: 2,
4707                                                                                 lock_time: 0,
4708                                                                                 input: vec![input],
4709                                                                                 output: vec![outp.clone()],
4710                                                                         };
4711                                                                         let secret = {
4712                                                                                 match ExtendedPrivKey::new_master(Network::Testnet, &$node.node_seed) {
4713                                                                                         Ok(master_key) => {
4714                                                                                                 match master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx($der_idx).expect("key space exhausted")) {
4715                                                                                                         Ok(key) => key,
4716                                                                                                         Err(_) => panic!("Your RNG is busted"),
4717                                                                                                 }
4718                                                                                         }
4719                                                                                         Err(_) => panic!("Your rng is busted"),
4720                                                                                 }
4721                                                                         };
4722                                                                         let pubkey = ExtendedPubKey::from_private(&secp_ctx, &secret).public_key;
4723                                                                         let witness_script = Address::p2pkh(&pubkey, Network::Testnet).script_pubkey();
4724                                                                         let sighash = Message::from_slice(&bip143::SighashComponents::new(&spend_tx).sighash_all(&spend_tx.input[0], &witness_script, output.value)[..]).unwrap();
4725                                                                         let sig = secp_ctx.sign(&sighash, &secret.private_key.key);
4726                                                                         spend_tx.input[0].witness.push(sig.serialize_der().to_vec());
4727                                                                         spend_tx.input[0].witness[0].push(SigHashType::All as u8);
4728                                                                         spend_tx.input[0].witness.push(pubkey.key.serialize().to_vec());
4729                                                                         txn.push(spend_tx);
4730                                                                 },
4731                                                         }
4732                                                 }
4733                                         },
4734                                         _ => panic!("Unexpected event"),
4735                                 };
4736                         }
4737                         txn
4738                 }
4739         }
4740 }
4741
4742 #[test]
4743 fn test_claim_sizeable_push_msat() {
4744         // Incidentally test SpendableOutput event generation due to detection of to_local output on commitment tx
4745         let chanmon_cfgs = create_chanmon_cfgs(2);
4746         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4747         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4748         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4749
4750         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 99000000, InitFeatures::known(), InitFeatures::known());
4751         nodes[1].node.force_close_channel(&chan.2);
4752         check_closed_broadcast!(nodes[1], false);
4753         check_added_monitors!(nodes[1], 1);
4754         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
4755         assert_eq!(node_txn.len(), 1);
4756         check_spends!(node_txn[0], chan.3);
4757         assert_eq!(node_txn[0].output.len(), 2); // We can't force trimming of to_remote output as channel_reserve_satoshis block us to do so at channel opening
4758
4759         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4760         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone()] }, 0);
4761         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
4762
4763         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
4764         assert_eq!(spend_txn.len(), 1);
4765         check_spends!(spend_txn[0], node_txn[0]);
4766 }
4767
4768 #[test]
4769 fn test_claim_on_remote_sizeable_push_msat() {
4770         // Same test as previous, just test on remote commitment tx, as per_commitment_point registration changes following you're funder/fundee and
4771         // to_remote output is encumbered by a P2WPKH
4772         let chanmon_cfgs = create_chanmon_cfgs(2);
4773         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4774         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4775         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4776
4777         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 99000000, InitFeatures::known(), InitFeatures::known());
4778         nodes[0].node.force_close_channel(&chan.2);
4779         check_closed_broadcast!(nodes[0], false);
4780         check_added_monitors!(nodes[0], 1);
4781
4782         let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
4783         assert_eq!(node_txn.len(), 1);
4784         check_spends!(node_txn[0], chan.3);
4785         assert_eq!(node_txn[0].output.len(), 2); // We can't force trimming of to_remote output as channel_reserve_satoshis block us to do so at channel opening
4786
4787         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4788         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone()] }, 0);
4789         check_closed_broadcast!(nodes[1], false);
4790         check_added_monitors!(nodes[1], 1);
4791         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
4792
4793         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
4794         assert_eq!(spend_txn.len(), 2);
4795         assert_eq!(spend_txn[0], spend_txn[1]);
4796         check_spends!(spend_txn[0], node_txn[0]);
4797 }
4798
4799 #[test]
4800 fn test_claim_on_remote_revoked_sizeable_push_msat() {
4801         // Same test as previous, just test on remote revoked commitment tx, as per_commitment_point registration changes following you're funder/fundee and
4802         // to_remote output is encumbered by a P2WPKH
4803
4804         let chanmon_cfgs = create_chanmon_cfgs(2);
4805         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4806         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4807         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4808
4809         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 59000000, InitFeatures::known(), InitFeatures::known());
4810         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
4811         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan.2);
4812         assert_eq!(revoked_local_txn[0].input.len(), 1);
4813         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid());
4814
4815         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
4816         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4817         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 0);
4818         check_closed_broadcast!(nodes[1], false);
4819         check_added_monitors!(nodes[1], 1);
4820
4821         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
4822         let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4823         nodes[1].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone()] }, 1);
4824         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
4825
4826         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
4827         assert_eq!(spend_txn.len(), 3);
4828         assert_eq!(spend_txn[0], spend_txn[1]); // to_remote output on revoked remote commitment_tx
4829         check_spends!(spend_txn[0], revoked_local_txn[0]);
4830         check_spends!(spend_txn[2], node_txn[0]);
4831 }
4832
4833 #[test]
4834 fn test_static_spendable_outputs_preimage_tx() {
4835         let chanmon_cfgs = create_chanmon_cfgs(2);
4836         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4837         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4838         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4839
4840         // Create some initial channels
4841         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4842
4843         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
4844
4845         let commitment_tx = get_local_commitment_txn!(nodes[0], chan_1.2);
4846         assert_eq!(commitment_tx[0].input.len(), 1);
4847         assert_eq!(commitment_tx[0].input[0].previous_output.txid, chan_1.3.txid());
4848
4849         // Settle A's commitment tx on B's chain
4850         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4851         assert!(nodes[1].node.claim_funds(payment_preimage, &None, 3_000_000));
4852         check_added_monitors!(nodes[1], 1);
4853         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()] }, 1);
4854         check_added_monitors!(nodes[1], 1);
4855         let events = nodes[1].node.get_and_clear_pending_msg_events();
4856         match events[0] {
4857                 MessageSendEvent::UpdateHTLCs { .. } => {},
4858                 _ => panic!("Unexpected event"),
4859         }
4860         match events[1] {
4861                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
4862                 _ => panic!("Unexepected event"),
4863         }
4864
4865         // Check B's monitor was able to send back output descriptor event for preimage tx on A's commitment tx
4866         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); // ChannelManager : 2 (local commitment tx + HTLC-Success), ChannelMonitor: preimage tx
4867         assert_eq!(node_txn.len(), 3);
4868         check_spends!(node_txn[0], commitment_tx[0]);
4869         assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
4870         check_spends!(node_txn[1], chan_1.3);
4871         check_spends!(node_txn[2], node_txn[1]);
4872
4873         let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4874         nodes[1].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone()] }, 1);
4875         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
4876
4877         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
4878         assert_eq!(spend_txn.len(), 1);
4879         check_spends!(spend_txn[0], node_txn[0]);
4880 }
4881
4882 #[test]
4883 fn test_static_spendable_outputs_timeout_tx() {
4884         let chanmon_cfgs = create_chanmon_cfgs(2);
4885         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4886         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4887         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4888
4889         // Create some initial channels
4890         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4891
4892         // Rebalance the network a bit by relaying one payment through all the channels ...
4893         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
4894
4895         let (_, our_payment_hash) = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3_000_000);
4896
4897         let commitment_tx = get_local_commitment_txn!(nodes[0], chan_1.2);
4898         assert_eq!(commitment_tx[0].input.len(), 1);
4899         assert_eq!(commitment_tx[0].input[0].previous_output.txid, chan_1.3.txid());
4900
4901         // Settle A's commitment tx on B' chain
4902         let header = BlockHeader { version: 0x2000_0000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
4903         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()] }, 0);
4904         check_added_monitors!(nodes[1], 1);
4905         let events = nodes[1].node.get_and_clear_pending_msg_events();
4906         match events[0] {
4907                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
4908                 _ => panic!("Unexpected event"),
4909         }
4910
4911         // Check B's monitor was able to send back output descriptor event for timeout tx on A's commitment tx
4912         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
4913         assert_eq!(node_txn.len(), 3); // ChannelManager : 2 (local commitent tx + HTLC-timeout), ChannelMonitor: timeout tx
4914         check_spends!(node_txn[0],  commitment_tx[0].clone());
4915         assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
4916         check_spends!(node_txn[1], chan_1.3.clone());
4917         check_spends!(node_txn[2], node_txn[1]);
4918
4919         let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4920         nodes[1].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone()] }, 1);
4921         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
4922         expect_payment_failed!(nodes[1], our_payment_hash, true);
4923
4924         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
4925         assert_eq!(spend_txn.len(), 3); // SpendableOutput: remote_commitment_tx.to_remote (*2), timeout_tx.output (*1)
4926         check_spends!(spend_txn[2], node_txn[0].clone());
4927 }
4928
4929 #[test]
4930 fn test_static_spendable_outputs_justice_tx_revoked_commitment_tx() {
4931         let chanmon_cfgs = create_chanmon_cfgs(2);
4932         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4933         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4934         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4935
4936         // Create some initial channels
4937         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4938
4939         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
4940         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
4941         assert_eq!(revoked_local_txn[0].input.len(), 1);
4942         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
4943
4944         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
4945
4946         let  header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4947         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 0);
4948         check_closed_broadcast!(nodes[1], false);
4949         check_added_monitors!(nodes[1], 1);
4950
4951         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
4952         assert_eq!(node_txn.len(), 2);
4953         assert_eq!(node_txn[0].input.len(), 2);
4954         check_spends!(node_txn[0], revoked_local_txn[0]);
4955
4956         let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4957         nodes[1].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone()] }, 1);
4958         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
4959
4960         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
4961         assert_eq!(spend_txn.len(), 1);
4962         check_spends!(spend_txn[0], node_txn[0]);
4963 }
4964
4965 #[test]
4966 fn test_static_spendable_outputs_justice_tx_revoked_htlc_timeout_tx() {
4967         let chanmon_cfgs = create_chanmon_cfgs(2);
4968         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4969         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4970         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4971
4972         // Create some initial channels
4973         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4974
4975         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
4976         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
4977         assert_eq!(revoked_local_txn[0].input.len(), 1);
4978         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
4979
4980         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
4981
4982         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4983         // A will generate HTLC-Timeout from revoked commitment tx
4984         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
4985         check_closed_broadcast!(nodes[0], false);
4986         check_added_monitors!(nodes[0], 1);
4987
4988         let revoked_htlc_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
4989         assert_eq!(revoked_htlc_txn.len(), 2);
4990         assert_eq!(revoked_htlc_txn[0].input.len(), 1);
4991         assert_eq!(revoked_htlc_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
4992         check_spends!(revoked_htlc_txn[0], revoked_local_txn[0]);
4993         check_spends!(revoked_htlc_txn[1], chan_1.3);
4994
4995         // B will generate justice tx from A's revoked commitment/HTLC tx
4996         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone(), revoked_htlc_txn[0].clone()] }, 0);
4997         check_closed_broadcast!(nodes[1], false);
4998         check_added_monitors!(nodes[1], 1);
4999
5000         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5001         assert_eq!(node_txn.len(), 4); // ChannelMonitor: justice tx on revoked commitment, justice tx on revoked HTLC-timeout, adjusted justice tx, ChannelManager: local commitment tx
5002         assert_eq!(node_txn[0].input.len(), 2);
5003         check_spends!(node_txn[0], revoked_local_txn[0]);
5004         check_spends!(node_txn[1], chan_1.3);
5005         assert_eq!(node_txn[2].input.len(), 1);
5006         check_spends!(node_txn[2], revoked_htlc_txn[0]);
5007         assert_eq!(node_txn[3].input.len(), 1);
5008         check_spends!(node_txn[3], revoked_local_txn[0]);
5009
5010         let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5011         nodes[1].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone(), node_txn[2].clone()] }, 1);
5012         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
5013
5014         // Check B's ChannelMonitor was able to generate the right spendable output descriptor
5015         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
5016         assert_eq!(spend_txn.len(), 2);
5017         check_spends!(spend_txn[0], node_txn[0]);
5018         check_spends!(spend_txn[1], node_txn[2]);
5019 }
5020
5021 #[test]
5022 fn test_static_spendable_outputs_justice_tx_revoked_htlc_success_tx() {
5023         let chanmon_cfgs = create_chanmon_cfgs(2);
5024         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
5025         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
5026         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
5027
5028         // Create some initial channels
5029         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5030
5031         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
5032         let revoked_local_txn = get_local_commitment_txn!(nodes[1], chan_1.2);
5033         assert_eq!(revoked_local_txn[0].input.len(), 1);
5034         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
5035
5036         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
5037
5038         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5039         // B will generate HTLC-Success from revoked commitment tx
5040         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
5041         check_closed_broadcast!(nodes[1], false);
5042         check_added_monitors!(nodes[1], 1);
5043         let revoked_htlc_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5044
5045         assert_eq!(revoked_htlc_txn.len(), 2);
5046         assert_eq!(revoked_htlc_txn[0].input.len(), 1);
5047         assert_eq!(revoked_htlc_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5048         check_spends!(revoked_htlc_txn[0], revoked_local_txn[0]);
5049
5050         // A will generate justice tx from B's revoked commitment/HTLC tx
5051         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone(), revoked_htlc_txn[0].clone()] }, 1);
5052         check_closed_broadcast!(nodes[0], false);
5053         check_added_monitors!(nodes[0], 1);
5054
5055         let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
5056         assert_eq!(node_txn.len(), 3); // ChannelMonitor: justice tx on revoked commitment, justice tx on revoked HTLC-success, ChannelManager: local commitment tx
5057         assert_eq!(node_txn[2].input.len(), 1);
5058         check_spends!(node_txn[2], revoked_htlc_txn[0]);
5059
5060         let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5061         nodes[0].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone(), node_txn[2].clone()] }, 1);
5062         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
5063
5064         // Check A's ChannelMonitor was able to generate the right spendable output descriptor
5065         let spend_txn = check_spendable_outputs!(nodes[0], 1, node_cfgs[0].keys_manager, 100000);
5066         assert_eq!(spend_txn.len(), 5); // Duplicated SpendableOutput due to block rescan after revoked htlc output tracking
5067         assert_eq!(spend_txn[0], spend_txn[1]);
5068         assert_eq!(spend_txn[0], spend_txn[2]);
5069         check_spends!(spend_txn[0], revoked_local_txn[0]); // spending to_remote output from revoked local tx
5070         check_spends!(spend_txn[3], node_txn[0]); // spending justice tx output from revoked local tx htlc received output
5071         check_spends!(spend_txn[4], node_txn[2]); // spending justice tx output on htlc success tx
5072 }
5073
5074 #[test]
5075 fn test_onchain_to_onchain_claim() {
5076         // Test that in case of channel closure, we detect the state of output thanks to
5077         // ChainWatchInterface and claim HTLC on downstream peer's remote commitment tx.
5078         // First, have C claim an HTLC against its own latest commitment transaction.
5079         // Then, broadcast these to B, which should update the monitor downstream on the A<->B
5080         // channel.
5081         // Finally, check that B will claim the HTLC output if A's latest commitment transaction
5082         // gets broadcast.
5083
5084         let chanmon_cfgs = create_chanmon_cfgs(3);
5085         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
5086         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
5087         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
5088
5089         // Create some initial channels
5090         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5091         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
5092
5093         // Rebalance the network a bit by relaying one payment through all the channels ...
5094         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
5095         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
5096
5097         let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
5098         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
5099         let commitment_tx = get_local_commitment_txn!(nodes[2], chan_2.2);
5100         check_spends!(commitment_tx[0], chan_2.3);
5101         nodes[2].node.claim_funds(payment_preimage, &None, 3_000_000);
5102         check_added_monitors!(nodes[2], 1);
5103         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
5104         assert!(updates.update_add_htlcs.is_empty());
5105         assert!(updates.update_fail_htlcs.is_empty());
5106         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
5107         assert!(updates.update_fail_malformed_htlcs.is_empty());
5108
5109         nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
5110         check_closed_broadcast!(nodes[2], false);
5111         check_added_monitors!(nodes[2], 1);
5112
5113         let c_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 2 (commitment tx, HTLC-Success tx), ChannelMonitor : 1 (HTLC-Success tx)
5114         assert_eq!(c_txn.len(), 3);
5115         assert_eq!(c_txn[0], c_txn[2]);
5116         assert_eq!(commitment_tx[0], c_txn[1]);
5117         check_spends!(c_txn[1], chan_2.3);
5118         check_spends!(c_txn[2], c_txn[1]);
5119         assert_eq!(c_txn[1].input[0].witness.clone().last().unwrap().len(), 71);
5120         assert_eq!(c_txn[2].input[0].witness.clone().last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5121         assert!(c_txn[0].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
5122         assert_eq!(c_txn[0].lock_time, 0); // Success tx
5123
5124         // So we broadcast C's commitment tx and HTLC-Success on B's chain, we should successfully be able to extract preimage and update downstream monitor
5125         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![c_txn[1].clone(), c_txn[2].clone()]}, 1);
5126         {
5127                 let mut b_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5128                 // ChannelMonitor: claim tx, ChannelManager: local commitment tx + HTLC-timeout tx
5129                 assert_eq!(b_txn.len(), 3);
5130                 check_spends!(b_txn[1], chan_2.3); // B local commitment tx, issued by ChannelManager
5131                 check_spends!(b_txn[2], b_txn[1]); // HTLC-Timeout on B local commitment tx, issued by ChannelManager
5132                 assert_eq!(b_txn[2].input[0].witness.clone().last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
5133                 assert!(b_txn[2].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
5134                 assert_ne!(b_txn[2].lock_time, 0); // Timeout tx
5135                 check_spends!(b_txn[0], c_txn[1]); // timeout tx on C remote commitment tx, issued by ChannelMonitor, * 2 due to block rescan
5136                 assert_eq!(b_txn[0].input[0].witness.clone().last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5137                 assert!(b_txn[0].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
5138                 assert_ne!(b_txn[2].lock_time, 0); // Timeout tx
5139                 b_txn.clear();
5140         }
5141         check_added_monitors!(nodes[1], 1);
5142         let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
5143         check_added_monitors!(nodes[1], 1);
5144         match msg_events[0] {
5145                 MessageSendEvent::BroadcastChannelUpdate {  .. } => {},
5146                 _ => panic!("Unexpected event"),
5147         }
5148         match msg_events[1] {
5149                 MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, .. } } => {
5150                         assert!(update_add_htlcs.is_empty());
5151                         assert!(update_fail_htlcs.is_empty());
5152                         assert_eq!(update_fulfill_htlcs.len(), 1);
5153                         assert!(update_fail_malformed_htlcs.is_empty());
5154                         assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
5155                 },
5156                 _ => panic!("Unexpected event"),
5157         };
5158         // Broadcast A's commitment tx on B's chain to see if we are able to claim inbound HTLC with our HTLC-Success tx
5159         let commitment_tx = get_local_commitment_txn!(nodes[0], chan_1.2);
5160         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
5161         let b_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5162         // ChannelMonitor: HTLC-Success tx, ChannelManager: local commitment tx + HTLC-Success tx
5163         assert_eq!(b_txn.len(), 3);
5164         check_spends!(b_txn[1], chan_1.3);
5165         check_spends!(b_txn[2], b_txn[1]);
5166         check_spends!(b_txn[0], commitment_tx[0]);
5167         assert_eq!(b_txn[0].input[0].witness.clone().last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
5168         assert!(b_txn[0].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
5169         assert_eq!(b_txn[0].lock_time, 0); // Success tx
5170
5171         check_closed_broadcast!(nodes[1], false);
5172         check_added_monitors!(nodes[1], 1);
5173 }
5174
5175 #[test]
5176 fn test_duplicate_payment_hash_one_failure_one_success() {
5177         // Topology : A --> B --> C
5178         // We route 2 payments with same hash between B and C, one will be timeout, the other successfully claim
5179         let chanmon_cfgs = create_chanmon_cfgs(3);
5180         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
5181         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
5182         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
5183
5184         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5185         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
5186
5187         let (our_payment_preimage, duplicate_payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 900000);
5188         *nodes[0].network_payment_count.borrow_mut() -= 1;
5189         assert_eq!(route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 900000).1, duplicate_payment_hash);
5190
5191         let commitment_txn = get_local_commitment_txn!(nodes[2], chan_2.2);
5192         assert_eq!(commitment_txn[0].input.len(), 1);
5193         check_spends!(commitment_txn[0], chan_2.3);
5194
5195         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5196         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![commitment_txn[0].clone()] }, 1);
5197         check_closed_broadcast!(nodes[1], false);
5198         check_added_monitors!(nodes[1], 1);
5199
5200         let htlc_timeout_tx;
5201         { // Extract one of the two HTLC-Timeout transaction
5202                 let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5203                 // ChannelMonitor: timeout tx * 2, ChannelManager: local commitment tx + HTLC-timeout * 2
5204                 assert_eq!(node_txn.len(), 5);
5205                 check_spends!(node_txn[0], commitment_txn[0]);
5206                 assert_eq!(node_txn[0].input.len(), 1);
5207                 check_spends!(node_txn[1], commitment_txn[0]);
5208                 assert_eq!(node_txn[1].input.len(), 1);
5209                 assert_ne!(node_txn[0].input[0], node_txn[1].input[0]);
5210                 assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5211                 assert_eq!(node_txn[1].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5212                 check_spends!(node_txn[2], chan_2.3);
5213                 check_spends!(node_txn[3], node_txn[2]);
5214                 check_spends!(node_txn[4], node_txn[2]);
5215                 htlc_timeout_tx = node_txn[1].clone();
5216         }
5217
5218         nodes[2].node.claim_funds(our_payment_preimage, &None, 900_000);
5219         nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![commitment_txn[0].clone()] }, 1);
5220         check_added_monitors!(nodes[2], 3);
5221         let events = nodes[2].node.get_and_clear_pending_msg_events();
5222         match events[0] {
5223                 MessageSendEvent::UpdateHTLCs { .. } => {},
5224                 _ => panic!("Unexpected event"),
5225         }
5226         match events[1] {
5227                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5228                 _ => panic!("Unexepected event"),
5229         }
5230         let htlc_success_txn: Vec<_> = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
5231         assert_eq!(htlc_success_txn.len(), 5); // ChannelMonitor: HTLC-Success txn (*2 due to 2-HTLC outputs), ChannelManager: local commitment tx + HTLC-Success txn (*2 due to 2-HTLC outputs)
5232         check_spends!(htlc_success_txn[2], chan_2.3);
5233         check_spends!(htlc_success_txn[3], htlc_success_txn[2]);
5234         check_spends!(htlc_success_txn[4], htlc_success_txn[2]);
5235         assert_eq!(htlc_success_txn[0], htlc_success_txn[3]);
5236         assert_eq!(htlc_success_txn[0].input.len(), 1);
5237         assert_eq!(htlc_success_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5238         assert_eq!(htlc_success_txn[1], htlc_success_txn[4]);
5239         assert_eq!(htlc_success_txn[1].input.len(), 1);
5240         assert_eq!(htlc_success_txn[1].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5241         assert_ne!(htlc_success_txn[0].input[0], htlc_success_txn[1].input[0]);
5242         check_spends!(htlc_success_txn[0], commitment_txn[0]);
5243         check_spends!(htlc_success_txn[1], commitment_txn[0]);
5244
5245         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![htlc_timeout_tx] }, 200);
5246         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 200, true, header.bitcoin_hash());
5247         expect_pending_htlcs_forwardable!(nodes[1]);
5248         let htlc_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5249         assert!(htlc_updates.update_add_htlcs.is_empty());
5250         assert_eq!(htlc_updates.update_fail_htlcs.len(), 1);
5251         assert_eq!(htlc_updates.update_fail_htlcs[0].htlc_id, 1);
5252         assert!(htlc_updates.update_fulfill_htlcs.is_empty());
5253         assert!(htlc_updates.update_fail_malformed_htlcs.is_empty());
5254         check_added_monitors!(nodes[1], 1);
5255
5256         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &htlc_updates.update_fail_htlcs[0]);
5257         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
5258         {
5259                 commitment_signed_dance!(nodes[0], nodes[1], &htlc_updates.commitment_signed, false, true);
5260                 let events = nodes[0].node.get_and_clear_pending_msg_events();
5261                 assert_eq!(events.len(), 1);
5262                 match events[0] {
5263                         MessageSendEvent::PaymentFailureNetworkUpdate { update: msgs::HTLCFailChannelUpdate::ChannelClosed { .. }  } => {
5264                         },
5265                         _ => { panic!("Unexpected event"); }
5266                 }
5267         }
5268         expect_payment_failed!(nodes[0], duplicate_payment_hash, false);
5269
5270         // Solve 2nd HTLC by broadcasting on B's chain HTLC-Success Tx from C
5271         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![htlc_success_txn[0].clone()] }, 200);
5272         let updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5273         assert!(updates.update_add_htlcs.is_empty());
5274         assert!(updates.update_fail_htlcs.is_empty());
5275         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
5276         assert_eq!(updates.update_fulfill_htlcs[0].htlc_id, 0);
5277         assert!(updates.update_fail_malformed_htlcs.is_empty());
5278         check_added_monitors!(nodes[1], 1);
5279
5280         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
5281         commitment_signed_dance!(nodes[0], nodes[1], &updates.commitment_signed, false);
5282
5283         let events = nodes[0].node.get_and_clear_pending_events();
5284         match events[0] {
5285                 Event::PaymentSent { ref payment_preimage } => {
5286                         assert_eq!(*payment_preimage, our_payment_preimage);
5287                 }
5288                 _ => panic!("Unexpected event"),
5289         }
5290 }
5291
5292 #[test]
5293 fn test_dynamic_spendable_outputs_local_htlc_success_tx() {
5294         let chanmon_cfgs = create_chanmon_cfgs(2);
5295         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
5296         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
5297         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
5298
5299         // Create some initial channels
5300         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5301
5302         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9000000).0;
5303         let local_txn = get_local_commitment_txn!(nodes[1], chan_1.2);
5304         assert_eq!(local_txn[0].input.len(), 1);
5305         check_spends!(local_txn[0], chan_1.3);
5306
5307         // Give B knowledge of preimage to be able to generate a local HTLC-Success Tx
5308         nodes[1].node.claim_funds(payment_preimage, &None, 9_000_000);
5309         check_added_monitors!(nodes[1], 1);
5310         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5311         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![local_txn[0].clone()] }, 1);
5312         check_added_monitors!(nodes[1], 1);
5313         let events = nodes[1].node.get_and_clear_pending_msg_events();
5314         match events[0] {
5315                 MessageSendEvent::UpdateHTLCs { .. } => {},
5316                 _ => panic!("Unexpected event"),
5317         }
5318         match events[1] {
5319                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5320                 _ => panic!("Unexepected event"),
5321         }
5322         let node_txn = {
5323                 let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5324                 assert_eq!(node_txn[0].input.len(), 1);
5325                 assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5326                 check_spends!(node_txn[0], local_txn[0]);
5327                 vec![node_txn[0].clone(), node_txn[2].clone()]
5328         };
5329
5330         let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5331         nodes[1].block_notifier.block_connected(&Block { header: header_201, txdata: node_txn.clone() }, 201);
5332         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 201, true, header_201.bitcoin_hash());
5333
5334         // Verify that B is able to spend its own HTLC-Success tx thanks to spendable output event given back by its ChannelMonitor
5335         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
5336         assert_eq!(spend_txn.len(), 2);
5337         check_spends!(spend_txn[0], node_txn[0]);
5338         check_spends!(spend_txn[1], node_txn[1]);
5339 }
5340
5341 fn do_test_fail_backwards_unrevoked_remote_announce(deliver_last_raa: bool, announce_latest: bool) {
5342         // Test that we fail backwards the full set of HTLCs we need to when remote broadcasts an
5343         // unrevoked commitment transaction.
5344         // This includes HTLCs which were below the dust threshold as well as HTLCs which were awaiting
5345         // a remote RAA before they could be failed backwards (and combinations thereof).
5346         // We also test duplicate-hash HTLCs by adding two nodes on each side of the target nodes which
5347         // use the same payment hashes.
5348         // Thus, we use a six-node network:
5349         //
5350         // A \         / E
5351         //    - C - D -
5352         // B /         \ F
5353         // And test where C fails back to A/B when D announces its latest commitment transaction
5354         let chanmon_cfgs = create_chanmon_cfgs(6);
5355         let node_cfgs = create_node_cfgs(6, &chanmon_cfgs);
5356         let node_chanmgrs = create_node_chanmgrs(6, &node_cfgs, &[None, None, None, None, None, None]);
5357         let nodes = create_network(6, &node_cfgs, &node_chanmgrs);
5358         let logger = test_utils::TestLogger::new();
5359
5360         create_announced_chan_between_nodes(&nodes, 0, 2, InitFeatures::known(), InitFeatures::known());
5361         create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
5362         let chan = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
5363         create_announced_chan_between_nodes(&nodes, 3, 4, InitFeatures::known(), InitFeatures::known());
5364         create_announced_chan_between_nodes(&nodes, 3, 5, InitFeatures::known(), InitFeatures::known());
5365
5366         // Rebalance and check output sanity...
5367         send_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 500000, 500_000);
5368         send_payment(&nodes[1], &[&nodes[2], &nodes[3], &nodes[5]], 500000, 500_000);
5369         assert_eq!(get_local_commitment_txn!(nodes[3], chan.2)[0].output.len(), 2);
5370
5371         let ds_dust_limit = nodes[3].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
5372         // 0th HTLC:
5373         let (_, payment_hash_1) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], ds_dust_limit*1000); // not added < dust limit + HTLC tx fee
5374         // 1st HTLC:
5375         let (_, payment_hash_2) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], ds_dust_limit*1000); // not added < dust limit + HTLC tx fee
5376         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
5377         let our_node_id = &nodes[1].node.get_our_node_id();
5378         let route = get_route(our_node_id, &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[5].node.get_our_node_id(), None, &Vec::new(), ds_dust_limit*1000, TEST_FINAL_CLTV, &logger).unwrap();
5379         // 2nd HTLC:
5380         send_along_route_with_hash(&nodes[1], route.clone(), &[&nodes[2], &nodes[3], &nodes[5]], ds_dust_limit*1000, payment_hash_1); // not added < dust limit + HTLC tx fee
5381         // 3rd HTLC:
5382         send_along_route_with_hash(&nodes[1], route, &[&nodes[2], &nodes[3], &nodes[5]], ds_dust_limit*1000, payment_hash_2); // not added < dust limit + HTLC tx fee
5383         // 4th HTLC:
5384         let (_, payment_hash_3) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 1000000);
5385         // 5th HTLC:
5386         let (_, payment_hash_4) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 1000000);
5387         let route = get_route(our_node_id, &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[5].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
5388         // 6th HTLC:
5389         send_along_route_with_hash(&nodes[1], route.clone(), &[&nodes[2], &nodes[3], &nodes[5]], 1000000, payment_hash_3);
5390         // 7th HTLC:
5391         send_along_route_with_hash(&nodes[1], route, &[&nodes[2], &nodes[3], &nodes[5]], 1000000, payment_hash_4);
5392
5393         // 8th HTLC:
5394         let (_, payment_hash_5) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 1000000);
5395         // 9th HTLC:
5396         let route = get_route(our_node_id, &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[5].node.get_our_node_id(), None, &Vec::new(), ds_dust_limit*1000, TEST_FINAL_CLTV, &logger).unwrap();
5397         send_along_route_with_hash(&nodes[1], route, &[&nodes[2], &nodes[3], &nodes[5]], ds_dust_limit*1000, payment_hash_5); // not added < dust limit + HTLC tx fee
5398
5399         // 10th HTLC:
5400         let (_, payment_hash_6) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], ds_dust_limit*1000); // not added < dust limit + HTLC tx fee
5401         // 11th HTLC:
5402         let route = get_route(our_node_id, &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[5].node.get_our_node_id(), None, &Vec::new(), 1000000, TEST_FINAL_CLTV, &logger).unwrap();
5403         send_along_route_with_hash(&nodes[1], route, &[&nodes[2], &nodes[3], &nodes[5]], 1000000, payment_hash_6);
5404
5405         // Double-check that six of the new HTLC were added
5406         // We now have six HTLCs pending over the dust limit and six HTLCs under the dust limit (ie,
5407         // with to_local and to_remote outputs, 8 outputs and 6 HTLCs not included).
5408         assert_eq!(get_local_commitment_txn!(nodes[3], chan.2).len(), 1);
5409         assert_eq!(get_local_commitment_txn!(nodes[3], chan.2)[0].output.len(), 8);
5410
5411         // Now fail back three of the over-dust-limit and three of the under-dust-limit payments in one go.
5412         // Fail 0th below-dust, 4th above-dust, 8th above-dust, 10th below-dust HTLCs
5413         assert!(nodes[4].node.fail_htlc_backwards(&payment_hash_1, &None));
5414         assert!(nodes[4].node.fail_htlc_backwards(&payment_hash_3, &None));
5415         assert!(nodes[4].node.fail_htlc_backwards(&payment_hash_5, &None));
5416         assert!(nodes[4].node.fail_htlc_backwards(&payment_hash_6, &None));
5417         check_added_monitors!(nodes[4], 0);
5418         expect_pending_htlcs_forwardable!(nodes[4]);
5419         check_added_monitors!(nodes[4], 1);
5420
5421         let four_removes = get_htlc_update_msgs!(nodes[4], nodes[3].node.get_our_node_id());
5422         nodes[3].node.handle_update_fail_htlc(&nodes[4].node.get_our_node_id(), &four_removes.update_fail_htlcs[0]);
5423         nodes[3].node.handle_update_fail_htlc(&nodes[4].node.get_our_node_id(), &four_removes.update_fail_htlcs[1]);
5424         nodes[3].node.handle_update_fail_htlc(&nodes[4].node.get_our_node_id(), &four_removes.update_fail_htlcs[2]);
5425         nodes[3].node.handle_update_fail_htlc(&nodes[4].node.get_our_node_id(), &four_removes.update_fail_htlcs[3]);
5426         commitment_signed_dance!(nodes[3], nodes[4], four_removes.commitment_signed, false);
5427
5428         // Fail 3rd below-dust and 7th above-dust HTLCs
5429         assert!(nodes[5].node.fail_htlc_backwards(&payment_hash_2, &None));
5430         assert!(nodes[5].node.fail_htlc_backwards(&payment_hash_4, &None));
5431         check_added_monitors!(nodes[5], 0);
5432         expect_pending_htlcs_forwardable!(nodes[5]);
5433         check_added_monitors!(nodes[5], 1);
5434
5435         let two_removes = get_htlc_update_msgs!(nodes[5], nodes[3].node.get_our_node_id());
5436         nodes[3].node.handle_update_fail_htlc(&nodes[5].node.get_our_node_id(), &two_removes.update_fail_htlcs[0]);
5437         nodes[3].node.handle_update_fail_htlc(&nodes[5].node.get_our_node_id(), &two_removes.update_fail_htlcs[1]);
5438         commitment_signed_dance!(nodes[3], nodes[5], two_removes.commitment_signed, false);
5439
5440         let ds_prev_commitment_tx = get_local_commitment_txn!(nodes[3], chan.2);
5441
5442         expect_pending_htlcs_forwardable!(nodes[3]);
5443         check_added_monitors!(nodes[3], 1);
5444         let six_removes = get_htlc_update_msgs!(nodes[3], nodes[2].node.get_our_node_id());
5445         nodes[2].node.handle_update_fail_htlc(&nodes[3].node.get_our_node_id(), &six_removes.update_fail_htlcs[0]);
5446         nodes[2].node.handle_update_fail_htlc(&nodes[3].node.get_our_node_id(), &six_removes.update_fail_htlcs[1]);
5447         nodes[2].node.handle_update_fail_htlc(&nodes[3].node.get_our_node_id(), &six_removes.update_fail_htlcs[2]);
5448         nodes[2].node.handle_update_fail_htlc(&nodes[3].node.get_our_node_id(), &six_removes.update_fail_htlcs[3]);
5449         nodes[2].node.handle_update_fail_htlc(&nodes[3].node.get_our_node_id(), &six_removes.update_fail_htlcs[4]);
5450         nodes[2].node.handle_update_fail_htlc(&nodes[3].node.get_our_node_id(), &six_removes.update_fail_htlcs[5]);
5451         if deliver_last_raa {
5452                 commitment_signed_dance!(nodes[2], nodes[3], six_removes.commitment_signed, false);
5453         } else {
5454                 let _cs_last_raa = commitment_signed_dance!(nodes[2], nodes[3], six_removes.commitment_signed, false, true, false, true);
5455         }
5456
5457         // D's latest commitment transaction now contains 1st + 2nd + 9th HTLCs (implicitly, they're
5458         // below the dust limit) and the 5th + 6th + 11th HTLCs. It has failed back the 0th, 3rd, 4th,
5459         // 7th, 8th, and 10th, but as we haven't yet delivered the final RAA to C, the fails haven't
5460         // propagated back to A/B yet (and D has two unrevoked commitment transactions).
5461         //
5462         // We now broadcast the latest commitment transaction, which *should* result in failures for
5463         // the 0th, 1st, 2nd, 3rd, 4th, 7th, 8th, 9th, and 10th HTLCs, ie all the below-dust HTLCs and
5464         // the non-broadcast above-dust HTLCs.
5465         //
5466         // Alternatively, we may broadcast the previous commitment transaction, which should only
5467         // result in failures for the below-dust HTLCs, ie the 0th, 1st, 2nd, 3rd, 9th, and 10th HTLCs.
5468         let ds_last_commitment_tx = get_local_commitment_txn!(nodes[3], chan.2);
5469
5470         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5471         if announce_latest {
5472                 nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![ds_last_commitment_tx[0].clone()]}, 1);
5473         } else {
5474                 nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![ds_prev_commitment_tx[0].clone()]}, 1);
5475         }
5476         connect_blocks(&nodes[2].block_notifier, ANTI_REORG_DELAY - 1, 1, true,  header.bitcoin_hash());
5477         check_closed_broadcast!(nodes[2], false);
5478         expect_pending_htlcs_forwardable!(nodes[2]);
5479         check_added_monitors!(nodes[2], 3);
5480
5481         let cs_msgs = nodes[2].node.get_and_clear_pending_msg_events();
5482         assert_eq!(cs_msgs.len(), 2);
5483         let mut a_done = false;
5484         for msg in cs_msgs {
5485                 match msg {
5486                         MessageSendEvent::UpdateHTLCs { ref node_id, ref updates } => {
5487                                 // Both under-dust HTLCs and the one above-dust HTLC that we had already failed
5488                                 // should be failed-backwards here.
5489                                 let target = if *node_id == nodes[0].node.get_our_node_id() {
5490                                         // If announce_latest, expect 0th, 1st, 4th, 8th, 10th HTLCs, else only 0th, 1st, 10th below-dust HTLCs
5491                                         for htlc in &updates.update_fail_htlcs {
5492                                                 assert!(htlc.htlc_id == 1 || htlc.htlc_id == 2 || htlc.htlc_id == 6 || if announce_latest { htlc.htlc_id == 3 || htlc.htlc_id == 5 } else { false });
5493                                         }
5494                                         assert_eq!(updates.update_fail_htlcs.len(), if announce_latest { 5 } else { 3 });
5495                                         assert!(!a_done);
5496                                         a_done = true;
5497                                         &nodes[0]
5498                                 } else {
5499                                         // If announce_latest, expect 2nd, 3rd, 7th, 9th HTLCs, else only 2nd, 3rd, 9th below-dust HTLCs
5500                                         for htlc in &updates.update_fail_htlcs {
5501                                                 assert!(htlc.htlc_id == 1 || htlc.htlc_id == 2 || htlc.htlc_id == 5 || if announce_latest { htlc.htlc_id == 4 } else { false });
5502                                         }
5503                                         assert_eq!(*node_id, nodes[1].node.get_our_node_id());
5504                                         assert_eq!(updates.update_fail_htlcs.len(), if announce_latest { 4 } else { 3 });
5505                                         &nodes[1]
5506                                 };
5507                                 target.node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
5508                                 target.node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[1]);
5509                                 target.node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[2]);
5510                                 if announce_latest {
5511                                         target.node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[3]);
5512                                         if *node_id == nodes[0].node.get_our_node_id() {
5513                                                 target.node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[4]);
5514                                         }
5515                                 }
5516                                 commitment_signed_dance!(target, nodes[2], updates.commitment_signed, false, true);
5517                         },
5518                         _ => panic!("Unexpected event"),
5519                 }
5520         }
5521
5522         let as_events = nodes[0].node.get_and_clear_pending_events();
5523         assert_eq!(as_events.len(), if announce_latest { 5 } else { 3 });
5524         let mut as_failds = HashSet::new();
5525         for event in as_events.iter() {
5526                 if let &Event::PaymentFailed { ref payment_hash, ref rejected_by_dest, .. } = event {
5527                         assert!(as_failds.insert(*payment_hash));
5528                         if *payment_hash != payment_hash_2 {
5529                                 assert_eq!(*rejected_by_dest, deliver_last_raa);
5530                         } else {
5531                                 assert!(!rejected_by_dest);
5532                         }
5533                 } else { panic!("Unexpected event"); }
5534         }
5535         assert!(as_failds.contains(&payment_hash_1));
5536         assert!(as_failds.contains(&payment_hash_2));
5537         if announce_latest {
5538                 assert!(as_failds.contains(&payment_hash_3));
5539                 assert!(as_failds.contains(&payment_hash_5));
5540         }
5541         assert!(as_failds.contains(&payment_hash_6));
5542
5543         let bs_events = nodes[1].node.get_and_clear_pending_events();
5544         assert_eq!(bs_events.len(), if announce_latest { 4 } else { 3 });
5545         let mut bs_failds = HashSet::new();
5546         for event in bs_events.iter() {
5547                 if let &Event::PaymentFailed { ref payment_hash, ref rejected_by_dest, .. } = event {
5548                         assert!(bs_failds.insert(*payment_hash));
5549                         if *payment_hash != payment_hash_1 && *payment_hash != payment_hash_5 {
5550                                 assert_eq!(*rejected_by_dest, deliver_last_raa);
5551                         } else {
5552                                 assert!(!rejected_by_dest);
5553                         }
5554                 } else { panic!("Unexpected event"); }
5555         }
5556         assert!(bs_failds.contains(&payment_hash_1));
5557         assert!(bs_failds.contains(&payment_hash_2));
5558         if announce_latest {
5559                 assert!(bs_failds.contains(&payment_hash_4));
5560         }
5561         assert!(bs_failds.contains(&payment_hash_5));
5562
5563         // For each HTLC which was not failed-back by normal process (ie deliver_last_raa), we should
5564         // get a PaymentFailureNetworkUpdate. A should have gotten 4 HTLCs which were failed-back due
5565         // to unknown-preimage-etc, B should have gotten 2. Thus, in the
5566         // announce_latest && deliver_last_raa case, we should have 5-4=1 and 4-2=2
5567         // PaymentFailureNetworkUpdates.
5568         let as_msg_events = nodes[0].node.get_and_clear_pending_msg_events();
5569         assert_eq!(as_msg_events.len(), if deliver_last_raa { 1 } else if !announce_latest { 3 } else { 5 });
5570         let bs_msg_events = nodes[1].node.get_and_clear_pending_msg_events();
5571         assert_eq!(bs_msg_events.len(), if deliver_last_raa { 2 } else if !announce_latest { 3 } else { 4 });
5572         for event in as_msg_events.iter().chain(bs_msg_events.iter()) {
5573                 match event {
5574                         &MessageSendEvent::PaymentFailureNetworkUpdate { .. } => {},
5575                         _ => panic!("Unexpected event"),
5576                 }
5577         }
5578 }
5579
5580 #[test]
5581 fn test_fail_backwards_latest_remote_announce_a() {
5582         do_test_fail_backwards_unrevoked_remote_announce(false, true);
5583 }
5584
5585 #[test]
5586 fn test_fail_backwards_latest_remote_announce_b() {
5587         do_test_fail_backwards_unrevoked_remote_announce(true, true);
5588 }
5589
5590 #[test]
5591 fn test_fail_backwards_previous_remote_announce() {
5592         do_test_fail_backwards_unrevoked_remote_announce(false, false);
5593         // Note that true, true doesn't make sense as it implies we announce a revoked state, which is
5594         // tested for in test_commitment_revoked_fail_backward_exhaustive()
5595 }
5596
5597 #[test]
5598 fn test_dynamic_spendable_outputs_local_htlc_timeout_tx() {
5599         let chanmon_cfgs = create_chanmon_cfgs(2);
5600         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
5601         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
5602         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
5603
5604         // Create some initial channels
5605         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5606
5607         let (_, our_payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9000000);
5608         let local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
5609         assert_eq!(local_txn[0].input.len(), 1);
5610         check_spends!(local_txn[0], chan_1.3);
5611
5612         // Timeout HTLC on A's chain and so it can generate a HTLC-Timeout tx
5613         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5614         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![local_txn[0].clone()] }, 200);
5615         check_closed_broadcast!(nodes[0], false);
5616         check_added_monitors!(nodes[0], 1);
5617
5618         let htlc_timeout = {
5619                 let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
5620                 assert_eq!(node_txn[0].input.len(), 1);
5621                 assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
5622                 check_spends!(node_txn[0], local_txn[0]);
5623                 node_txn[0].clone()
5624         };
5625
5626         let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5627         nodes[0].block_notifier.block_connected(&Block { header: header_201, txdata: vec![htlc_timeout.clone()] }, 201);
5628         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 201, true, header_201.bitcoin_hash());
5629         expect_payment_failed!(nodes[0], our_payment_hash, true);
5630
5631         // Verify that A is able to spend its own HTLC-Timeout tx thanks to spendable output event given back by its ChannelMonitor
5632         let spend_txn = check_spendable_outputs!(nodes[0], 1, node_cfgs[0].keys_manager, 100000);
5633         assert_eq!(spend_txn.len(), 3);
5634         assert_eq!(spend_txn[0], spend_txn[1]);
5635         check_spends!(spend_txn[0], local_txn[0]);
5636         check_spends!(spend_txn[2], htlc_timeout);
5637 }
5638
5639 #[test]
5640 fn test_key_derivation_params() {
5641         // This test is a copy of test_dynamic_spendable_outputs_local_htlc_timeout_tx, with
5642         // a key manager rotation to test that key_derivation_params returned in DynamicOutputP2WSH
5643         // let us re-derive the channel key set to then derive a delayed_payment_key.
5644
5645         let chanmon_cfgs = create_chanmon_cfgs(3);
5646
5647         // We manually create the node configuration to backup the seed.
5648         let seed = [42; 32];
5649         let keys_manager = test_utils::TestKeysInterface::new(&seed, Network::Testnet);
5650         let chan_monitor = test_utils::TestChannelMonitor::new(&chanmon_cfgs[0].chain_monitor, &chanmon_cfgs[0].tx_broadcaster, &chanmon_cfgs[0].logger, &chanmon_cfgs[0].fee_estimator);
5651         let node = NodeCfg { chain_monitor: &chanmon_cfgs[0].chain_monitor, logger: &chanmon_cfgs[0].logger, tx_broadcaster: &chanmon_cfgs[0].tx_broadcaster, fee_estimator: &chanmon_cfgs[0].fee_estimator, chan_monitor, keys_manager, node_seed: seed };
5652         let mut node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
5653         node_cfgs.remove(0);
5654         node_cfgs.insert(0, node);
5655
5656         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
5657         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
5658
5659         // Create some initial channels
5660         // Create a dummy channel to advance index by one and thus test re-derivation correctness
5661         // for node 0
5662         let chan_0 = create_announced_chan_between_nodes(&nodes, 0, 2, InitFeatures::known(), InitFeatures::known());
5663         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5664         assert_ne!(chan_0.3.output[0].script_pubkey, chan_1.3.output[0].script_pubkey);
5665
5666         let (_, our_payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9000000);
5667         let local_txn_0 = get_local_commitment_txn!(nodes[0], chan_0.2);
5668         let local_txn_1 = get_local_commitment_txn!(nodes[0], chan_1.2);
5669         assert_eq!(local_txn_1[0].input.len(), 1);
5670         check_spends!(local_txn_1[0], chan_1.3);
5671
5672         // We check funding pubkey are unique
5673         let (from_0_funding_key_0, from_0_funding_key_1) = (PublicKey::from_slice(&local_txn_0[0].input[0].witness[3][2..35]), PublicKey::from_slice(&local_txn_0[0].input[0].witness[3][36..69]));
5674         let (from_1_funding_key_0, from_1_funding_key_1) = (PublicKey::from_slice(&local_txn_1[0].input[0].witness[3][2..35]), PublicKey::from_slice(&local_txn_1[0].input[0].witness[3][36..69]));
5675         if from_0_funding_key_0 == from_1_funding_key_0
5676             || from_0_funding_key_0 == from_1_funding_key_1
5677             || from_0_funding_key_1 == from_1_funding_key_0
5678             || from_0_funding_key_1 == from_1_funding_key_1 {
5679                 panic!("Funding pubkeys aren't unique");
5680         }
5681
5682         // Timeout HTLC on A's chain and so it can generate a HTLC-Timeout tx
5683         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5684         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![local_txn_1[0].clone()] }, 200);
5685         check_closed_broadcast!(nodes[0], false);
5686         check_added_monitors!(nodes[0], 1);
5687
5688         let htlc_timeout = {
5689                 let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
5690                 assert_eq!(node_txn[0].input.len(), 1);
5691                 assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
5692                 check_spends!(node_txn[0], local_txn_1[0]);
5693                 node_txn[0].clone()
5694         };
5695
5696         let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5697         nodes[0].block_notifier.block_connected(&Block { header: header_201, txdata: vec![htlc_timeout.clone()] }, 201);
5698         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 201, true, header_201.bitcoin_hash());
5699         expect_payment_failed!(nodes[0], our_payment_hash, true);
5700
5701         // Verify that A is able to spend its own HTLC-Timeout tx thanks to spendable output event given back by its ChannelMonitor
5702         let new_keys_manager = test_utils::TestKeysInterface::new(&seed, Network::Testnet);
5703         let spend_txn = check_spendable_outputs!(nodes[0], 1, new_keys_manager, 100000);
5704         assert_eq!(spend_txn.len(), 3);
5705         assert_eq!(spend_txn[0], spend_txn[1]);
5706         check_spends!(spend_txn[0], local_txn_1[0]);
5707         check_spends!(spend_txn[2], htlc_timeout);
5708 }
5709
5710 #[test]
5711 fn test_static_output_closing_tx() {
5712         let chanmon_cfgs = create_chanmon_cfgs(2);
5713         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
5714         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
5715         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
5716
5717         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5718
5719         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
5720         let closing_tx = close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true).2;
5721
5722         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5723         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![closing_tx.clone()] }, 0);
5724         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 0, true, header.bitcoin_hash());
5725
5726         let spend_txn = check_spendable_outputs!(nodes[0], 2, node_cfgs[0].keys_manager, 100000);
5727         assert_eq!(spend_txn.len(), 1);
5728         check_spends!(spend_txn[0], closing_tx);
5729
5730         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![closing_tx.clone()] }, 0);
5731         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 0, true, header.bitcoin_hash());
5732
5733         let spend_txn = check_spendable_outputs!(nodes[1], 2, node_cfgs[1].keys_manager, 100000);
5734         assert_eq!(spend_txn.len(), 1);
5735         check_spends!(spend_txn[0], closing_tx);
5736 }
5737
5738 fn do_htlc_claim_local_commitment_only(use_dust: bool) {
5739         let chanmon_cfgs = create_chanmon_cfgs(2);
5740         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
5741         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
5742         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
5743         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5744
5745         let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1]], if use_dust { 50000 } else { 3000000 });
5746
5747         // Claim the payment, but don't deliver A's commitment_signed, resulting in the HTLC only being
5748         // present in B's local commitment transaction, but none of A's commitment transactions.
5749         assert!(nodes[1].node.claim_funds(our_payment_preimage, &None, if use_dust { 50_000 } else { 3_000_000 }));
5750         check_added_monitors!(nodes[1], 1);
5751
5752         let bs_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5753         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &bs_updates.update_fulfill_htlcs[0]);
5754         let events = nodes[0].node.get_and_clear_pending_events();
5755         assert_eq!(events.len(), 1);
5756         match events[0] {
5757                 Event::PaymentSent { payment_preimage } => {
5758                         assert_eq!(payment_preimage, our_payment_preimage);
5759                 },
5760                 _ => panic!("Unexpected event"),
5761         }
5762
5763         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_updates.commitment_signed);
5764         check_added_monitors!(nodes[0], 1);
5765         let as_updates = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
5766         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_updates.0);
5767         check_added_monitors!(nodes[1], 1);
5768
5769         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5770         for i in 1..TEST_FINAL_CLTV - CLTV_CLAIM_BUFFER + CHAN_CONFIRM_DEPTH + 1 {
5771                 nodes[1].block_notifier.block_connected_checked(&header, i, &Vec::new(), &Vec::new());
5772                 header.prev_blockhash = header.bitcoin_hash();
5773         }
5774         test_txn_broadcast(&nodes[1], &chan, None, if use_dust { HTLCType::NONE } else { HTLCType::SUCCESS });
5775         check_closed_broadcast!(nodes[1], false);
5776         check_added_monitors!(nodes[1], 1);
5777 }
5778
5779 fn do_htlc_claim_current_remote_commitment_only(use_dust: bool) {
5780         let chanmon_cfgs = create_chanmon_cfgs(2);
5781         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
5782         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
5783         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
5784         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5785         let logger = test_utils::TestLogger::new();
5786
5787         let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
5788         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
5789         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &Vec::new(), if use_dust { 50000 } else { 3000000 }, TEST_FINAL_CLTV, &logger).unwrap();
5790         nodes[0].node.send_payment(&route, payment_hash, &None).unwrap();
5791         check_added_monitors!(nodes[0], 1);
5792
5793         let _as_update = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
5794
5795         // As far as A is concerned, the HTLC is now present only in the latest remote commitment
5796         // transaction, however it is not in A's latest local commitment, so we can just broadcast that
5797         // to "time out" the HTLC.
5798
5799         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5800
5801         for i in 1..TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + CHAN_CONFIRM_DEPTH + 1 {
5802                 nodes[0].block_notifier.block_connected(&Block { header, txdata: Vec::new()}, i);
5803                 header.prev_blockhash = header.bitcoin_hash();
5804         }
5805         test_txn_broadcast(&nodes[0], &chan, None, HTLCType::NONE);
5806         check_closed_broadcast!(nodes[0], false);
5807         check_added_monitors!(nodes[0], 1);
5808 }
5809
5810 fn do_htlc_claim_previous_remote_commitment_only(use_dust: bool, check_revoke_no_close: bool) {
5811         let chanmon_cfgs = create_chanmon_cfgs(3);
5812         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
5813         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
5814         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
5815         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5816
5817         // Fail the payment, but don't deliver A's final RAA, resulting in the HTLC only being present
5818         // in B's previous (unrevoked) commitment transaction, but none of A's commitment transactions.
5819         // Also optionally test that we *don't* fail the channel in case the commitment transaction was
5820         // actually revoked.
5821         let htlc_value = if use_dust { 50000 } else { 3000000 };
5822         let (_, our_payment_hash) = route_payment(&nodes[0], &[&nodes[1]], htlc_value);
5823         assert!(nodes[1].node.fail_htlc_backwards(&our_payment_hash, &None));
5824         expect_pending_htlcs_forwardable!(nodes[1]);
5825         check_added_monitors!(nodes[1], 1);
5826
5827         let bs_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5828         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &bs_updates.update_fail_htlcs[0]);
5829         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_updates.commitment_signed);
5830         check_added_monitors!(nodes[0], 1);
5831         let as_updates = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
5832         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_updates.0);
5833         check_added_monitors!(nodes[1], 1);
5834         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_updates.1);
5835         check_added_monitors!(nodes[1], 1);
5836         let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
5837
5838         if check_revoke_no_close {
5839                 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack);
5840                 check_added_monitors!(nodes[0], 1);
5841         }
5842
5843         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5844         for i in 1..TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + CHAN_CONFIRM_DEPTH + 1 {
5845                 nodes[0].block_notifier.block_connected_checked(&header, i, &Vec::new(), &Vec::new());
5846                 header.prev_blockhash = header.bitcoin_hash();
5847         }
5848         if !check_revoke_no_close {
5849                 test_txn_broadcast(&nodes[0], &chan, None, HTLCType::NONE);
5850                 check_closed_broadcast!(nodes[0], false);
5851                 check_added_monitors!(nodes[0], 1);
5852         } else {
5853                 expect_payment_failed!(nodes[0], our_payment_hash, true);
5854         }
5855 }
5856
5857 // Test that we close channels on-chain when broadcastable HTLCs reach their timeout window.
5858 // There are only a few cases to test here:
5859 //  * its not really normative behavior, but we test that below-dust HTLCs "included" in
5860 //    broadcastable commitment transactions result in channel closure,
5861 //  * its included in an unrevoked-but-previous remote commitment transaction,
5862 //  * its included in the latest remote or local commitment transactions.
5863 // We test each of the three possible commitment transactions individually and use both dust and
5864 // non-dust HTLCs.
5865 // Note that we don't bother testing both outbound and inbound HTLC failures for each case, and we
5866 // assume they are handled the same across all six cases, as both outbound and inbound failures are
5867 // tested for at least one of the cases in other tests.
5868 #[test]
5869 fn htlc_claim_single_commitment_only_a() {
5870         do_htlc_claim_local_commitment_only(true);
5871         do_htlc_claim_local_commitment_only(false);
5872
5873         do_htlc_claim_current_remote_commitment_only(true);
5874         do_htlc_claim_current_remote_commitment_only(false);
5875 }
5876
5877 #[test]
5878 fn htlc_claim_single_commitment_only_b() {
5879         do_htlc_claim_previous_remote_commitment_only(true, false);
5880         do_htlc_claim_previous_remote_commitment_only(false, false);
5881         do_htlc_claim_previous_remote_commitment_only(true, true);
5882         do_htlc_claim_previous_remote_commitment_only(false, true);
5883 }
5884
5885 fn run_onion_failure_test<F1,F2>(_name: &str, test_case: u8, nodes: &Vec<Node>, route: &Route, payment_hash: &PaymentHash, callback_msg: F1, callback_node: F2, expected_retryable: bool, expected_error_code: Option<u16>, expected_channel_update: Option<HTLCFailChannelUpdate>)
5886         where F1: for <'a> FnMut(&'a mut msgs::UpdateAddHTLC),
5887                                 F2: FnMut(),
5888 {
5889         run_onion_failure_test_with_fail_intercept(_name, test_case, nodes, route, payment_hash, callback_msg, |_|{}, callback_node, expected_retryable, expected_error_code, expected_channel_update);
5890 }
5891
5892 // test_case
5893 // 0: node1 fails backward
5894 // 1: final node fails backward
5895 // 2: payment completed but the user rejects the payment
5896 // 3: final node fails backward (but tamper onion payloads from node0)
5897 // 100: trigger error in the intermediate node and tamper returning fail_htlc
5898 // 200: trigger error in the final node and tamper returning fail_htlc
5899 fn run_onion_failure_test_with_fail_intercept<F1,F2,F3>(_name: &str, test_case: u8, nodes: &Vec<Node>, route: &Route, payment_hash: &PaymentHash, mut callback_msg: F1, mut callback_fail: F2, mut callback_node: F3, expected_retryable: bool, expected_error_code: Option<u16>, expected_channel_update: Option<HTLCFailChannelUpdate>)
5900         where F1: for <'a> FnMut(&'a mut msgs::UpdateAddHTLC),
5901                                 F2: for <'a> FnMut(&'a mut msgs::UpdateFailHTLC),
5902                                 F3: FnMut(),
5903 {
5904
5905         // reset block height
5906         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5907         for ix in 0..nodes.len() {
5908                 nodes[ix].block_notifier.block_connected_checked(&header, 1, &[], &[]);
5909         }
5910
5911         macro_rules! expect_event {
5912                 ($node: expr, $event_type: path) => {{
5913                         let events = $node.node.get_and_clear_pending_events();
5914                         assert_eq!(events.len(), 1);
5915                         match events[0] {
5916                                 $event_type { .. } => {},
5917                                 _ => panic!("Unexpected event"),
5918                         }
5919                 }}
5920         }
5921
5922         macro_rules! expect_htlc_forward {
5923                 ($node: expr) => {{
5924                         expect_event!($node, Event::PendingHTLCsForwardable);
5925                         $node.node.process_pending_htlc_forwards();
5926                 }}
5927         }
5928
5929         // 0 ~~> 2 send payment
5930         nodes[0].node.send_payment(&route, payment_hash.clone(), &None).unwrap();
5931         check_added_monitors!(nodes[0], 1);
5932         let update_0 = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
5933         // temper update_add (0 => 1)
5934         let mut update_add_0 = update_0.update_add_htlcs[0].clone();
5935         if test_case == 0 || test_case == 3 || test_case == 100 {
5936                 callback_msg(&mut update_add_0);
5937                 callback_node();
5938         }
5939         // 0 => 1 update_add & CS
5940         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &update_add_0);
5941         commitment_signed_dance!(nodes[1], nodes[0], &update_0.commitment_signed, false, true);
5942
5943         let update_1_0 = match test_case {
5944                 0|100 => { // intermediate node failure; fail backward to 0
5945                         let update_1_0 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5946                         assert!(update_1_0.update_fail_htlcs.len()+update_1_0.update_fail_malformed_htlcs.len()==1 && (update_1_0.update_fail_htlcs.len()==1 || update_1_0.update_fail_malformed_htlcs.len()==1));
5947                         update_1_0
5948                 },
5949                 1|2|3|200 => { // final node failure; forwarding to 2
5950                         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
5951                         // forwarding on 1
5952                         if test_case != 200 {
5953                                 callback_node();
5954                         }
5955                         expect_htlc_forward!(&nodes[1]);
5956
5957                         let update_1 = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
5958                         check_added_monitors!(&nodes[1], 1);
5959                         assert_eq!(update_1.update_add_htlcs.len(), 1);
5960                         // tamper update_add (1 => 2)
5961                         let mut update_add_1 = update_1.update_add_htlcs[0].clone();
5962                         if test_case != 3 && test_case != 200 {
5963                                 callback_msg(&mut update_add_1);
5964                         }
5965
5966                         // 1 => 2
5967                         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &update_add_1);
5968                         commitment_signed_dance!(nodes[2], nodes[1], update_1.commitment_signed, false, true);
5969
5970                         if test_case == 2 || test_case == 200 {
5971                                 expect_htlc_forward!(&nodes[2]);
5972                                 expect_event!(&nodes[2], Event::PaymentReceived);
5973                                 callback_node();
5974                                 expect_pending_htlcs_forwardable!(nodes[2]);
5975                         }
5976
5977                         let update_2_1 = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
5978                         if test_case == 2 || test_case == 200 {
5979                                 check_added_monitors!(&nodes[2], 1);
5980                         }
5981                         assert!(update_2_1.update_fail_htlcs.len() == 1);
5982
5983                         let mut fail_msg = update_2_1.update_fail_htlcs[0].clone();
5984                         if test_case == 200 {
5985                                 callback_fail(&mut fail_msg);
5986                         }
5987
5988                         // 2 => 1
5989                         nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &fail_msg);
5990                         commitment_signed_dance!(nodes[1], nodes[2], update_2_1.commitment_signed, true);
5991
5992                         // backward fail on 1
5993                         let update_1_0 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5994                         assert!(update_1_0.update_fail_htlcs.len() == 1);
5995                         update_1_0
5996                 },
5997                 _ => unreachable!(),
5998         };
5999
6000         // 1 => 0 commitment_signed_dance
6001         if update_1_0.update_fail_htlcs.len() > 0 {
6002                 let mut fail_msg = update_1_0.update_fail_htlcs[0].clone();
6003                 if test_case == 100 {
6004                         callback_fail(&mut fail_msg);
6005                 }
6006                 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &fail_msg);
6007         } else {
6008                 nodes[0].node.handle_update_fail_malformed_htlc(&nodes[1].node.get_our_node_id(), &update_1_0.update_fail_malformed_htlcs[0]);
6009         };
6010
6011         commitment_signed_dance!(nodes[0], nodes[1], update_1_0.commitment_signed, false, true);
6012
6013         let events = nodes[0].node.get_and_clear_pending_events();
6014         assert_eq!(events.len(), 1);
6015         if let &Event::PaymentFailed { payment_hash:_, ref rejected_by_dest, ref error_code, error_data: _ } = &events[0] {
6016                 assert_eq!(*rejected_by_dest, !expected_retryable);
6017                 assert_eq!(*error_code, expected_error_code);
6018         } else {
6019                 panic!("Uexpected event");
6020         }
6021
6022         let events = nodes[0].node.get_and_clear_pending_msg_events();
6023         if expected_channel_update.is_some() {
6024                 assert_eq!(events.len(), 1);
6025                 match events[0] {
6026                         MessageSendEvent::PaymentFailureNetworkUpdate { ref update } => {
6027                                 match update {
6028                                         &HTLCFailChannelUpdate::ChannelUpdateMessage { .. } => {
6029                                                 if let HTLCFailChannelUpdate::ChannelUpdateMessage { .. } = expected_channel_update.unwrap() {} else {
6030                                                         panic!("channel_update not found!");
6031                                                 }
6032                                         },
6033                                         &HTLCFailChannelUpdate::ChannelClosed { ref short_channel_id, ref is_permanent } => {
6034                                                 if let HTLCFailChannelUpdate::ChannelClosed { short_channel_id: ref expected_short_channel_id, is_permanent: ref expected_is_permanent } = expected_channel_update.unwrap() {
6035                                                         assert!(*short_channel_id == *expected_short_channel_id);
6036                                                         assert!(*is_permanent == *expected_is_permanent);
6037                                                 } else {
6038                                                         panic!("Unexpected message event");
6039                                                 }
6040                                         },
6041                                         &HTLCFailChannelUpdate::NodeFailure { ref node_id, ref is_permanent } => {
6042                                                 if let HTLCFailChannelUpdate::NodeFailure { node_id: ref expected_node_id, is_permanent: ref expected_is_permanent } = expected_channel_update.unwrap() {
6043                                                         assert!(*node_id == *expected_node_id);
6044                                                         assert!(*is_permanent == *expected_is_permanent);
6045                                                 } else {
6046                                                         panic!("Unexpected message event");
6047                                                 }
6048                                         },
6049                                 }
6050                         },
6051                         _ => panic!("Unexpected message event"),
6052                 }
6053         } else {
6054                 assert_eq!(events.len(), 0);
6055         }
6056 }
6057
6058 impl msgs::ChannelUpdate {
6059         fn dummy() -> msgs::ChannelUpdate {
6060                 use bitcoin::secp256k1::ffi::Signature as FFISignature;
6061                 use bitcoin::secp256k1::Signature;
6062                 msgs::ChannelUpdate {
6063                         signature: Signature::from(FFISignature::new()),
6064                         contents: msgs::UnsignedChannelUpdate {
6065                                 chain_hash: BlockHash::hash(&vec![0u8][..]),
6066                                 short_channel_id: 0,
6067                                 timestamp: 0,
6068                                 flags: 0,
6069                                 cltv_expiry_delta: 0,
6070                                 htlc_minimum_msat: 0,
6071                                 htlc_maximum_msat: OptionalField::Absent,
6072                                 fee_base_msat: 0,
6073                                 fee_proportional_millionths: 0,
6074                                 excess_data: vec![],
6075                         }
6076                 }
6077         }
6078 }
6079
6080 struct BogusOnionHopData {
6081         data: Vec<u8>
6082 }
6083 impl BogusOnionHopData {
6084         fn new(orig: msgs::OnionHopData) -> Self {
6085                 Self { data: orig.encode() }
6086         }
6087 }
6088 impl Writeable for BogusOnionHopData {
6089         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
6090                 writer.write_all(&self.data[..])
6091         }
6092 }
6093
6094 #[test]
6095 fn test_onion_failure() {
6096         use ln::msgs::ChannelUpdate;
6097         use ln::channelmanager::CLTV_FAR_FAR_AWAY;
6098         use bitcoin::secp256k1;
6099
6100         const BADONION: u16 = 0x8000;
6101         const PERM: u16 = 0x4000;
6102         const NODE: u16 = 0x2000;
6103         const UPDATE: u16 = 0x1000;
6104
6105         let chanmon_cfgs = create_chanmon_cfgs(3);
6106         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
6107         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
6108         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
6109         for node in nodes.iter() {
6110                 *node.keys_manager.override_session_priv.lock().unwrap() = Some(SecretKey::from_slice(&[3; 32]).unwrap());
6111         }
6112         let channels = [create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()), create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known())];
6113         let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
6114         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6115         let logger = test_utils::TestLogger::new();
6116         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, &Vec::new(), 40000, TEST_FINAL_CLTV, &logger).unwrap();
6117         // positve case
6118         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 40000, 40_000);
6119
6120         // intermediate node failure
6121         run_onion_failure_test("invalid_realm", 0, &nodes, &route, &payment_hash, |msg| {
6122                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6123                 let cur_height = nodes[0].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
6124                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6125                 let (mut onion_payloads, _htlc_msat, _htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 40000, &None, cur_height).unwrap();
6126                 let mut new_payloads = Vec::new();
6127                 for payload in onion_payloads.drain(..) {
6128                         new_payloads.push(BogusOnionHopData::new(payload));
6129                 }
6130                 // break the first (non-final) hop payload by swapping the realm (0) byte for a byte
6131                 // describing a length-1 TLV payload, which is obviously bogus.
6132                 new_payloads[0].data[0] = 1;
6133                 msg.onion_routing_packet = onion_utils::construct_onion_packet_bogus_hopdata(new_payloads, onion_keys, [0; 32], &payment_hash);
6134         }, ||{}, true, Some(PERM|22), Some(msgs::HTLCFailChannelUpdate::ChannelClosed{short_channel_id: channels[1].0.contents.short_channel_id, is_permanent: true}));//XXX incremented channels idx here
6135
6136         // final node failure
6137         run_onion_failure_test("invalid_realm", 3, &nodes, &route, &payment_hash, |msg| {
6138                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6139                 let cur_height = nodes[0].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
6140                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6141                 let (mut onion_payloads, _htlc_msat, _htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 40000, &None, cur_height).unwrap();
6142                 let mut new_payloads = Vec::new();
6143                 for payload in onion_payloads.drain(..) {
6144                         new_payloads.push(BogusOnionHopData::new(payload));
6145                 }
6146                 // break the last-hop payload by swapping the realm (0) byte for a byte describing a
6147                 // length-1 TLV payload, which is obviously bogus.
6148                 new_payloads[1].data[0] = 1;
6149                 msg.onion_routing_packet = onion_utils::construct_onion_packet_bogus_hopdata(new_payloads, onion_keys, [0; 32], &payment_hash);
6150         }, ||{}, false, Some(PERM|22), Some(msgs::HTLCFailChannelUpdate::ChannelClosed{short_channel_id: channels[1].0.contents.short_channel_id, is_permanent: true}));
6151
6152         // the following three with run_onion_failure_test_with_fail_intercept() test only the origin node
6153         // receiving simulated fail messages
6154         // intermediate node failure
6155         run_onion_failure_test_with_fail_intercept("temporary_node_failure", 100, &nodes, &route, &payment_hash, |msg| {
6156                 // trigger error
6157                 msg.amount_msat -= 1;
6158         }, |msg| {
6159                 // and tamper returning error message
6160                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6161                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6162                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], NODE|2, &[0;0]);
6163         }, ||{}, true, Some(NODE|2), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.paths[0][0].pubkey, is_permanent: false}));
6164
6165         // final node failure
6166         run_onion_failure_test_with_fail_intercept("temporary_node_failure", 200, &nodes, &route, &payment_hash, |_msg| {}, |msg| {
6167                 // and tamper returning error message
6168                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6169                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6170                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[1].shared_secret[..], NODE|2, &[0;0]);
6171         }, ||{
6172                 nodes[2].node.fail_htlc_backwards(&payment_hash, &None);
6173         }, true, Some(NODE|2), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.paths[0][1].pubkey, is_permanent: false}));
6174
6175         // intermediate node failure
6176         run_onion_failure_test_with_fail_intercept("permanent_node_failure", 100, &nodes, &route, &payment_hash, |msg| {
6177                 msg.amount_msat -= 1;
6178         }, |msg| {
6179                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6180                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6181                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], PERM|NODE|2, &[0;0]);
6182         }, ||{}, true, Some(PERM|NODE|2), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.paths[0][0].pubkey, is_permanent: true}));
6183
6184         // final node failure
6185         run_onion_failure_test_with_fail_intercept("permanent_node_failure", 200, &nodes, &route, &payment_hash, |_msg| {}, |msg| {
6186                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6187                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6188                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[1].shared_secret[..], PERM|NODE|2, &[0;0]);
6189         }, ||{
6190                 nodes[2].node.fail_htlc_backwards(&payment_hash, &None);
6191         }, false, Some(PERM|NODE|2), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.paths[0][1].pubkey, is_permanent: true}));
6192
6193         // intermediate node failure
6194         run_onion_failure_test_with_fail_intercept("required_node_feature_missing", 100, &nodes, &route, &payment_hash, |msg| {
6195                 msg.amount_msat -= 1;
6196         }, |msg| {
6197                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6198                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6199                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], PERM|NODE|3, &[0;0]);
6200         }, ||{
6201                 nodes[2].node.fail_htlc_backwards(&payment_hash, &None);
6202         }, true, Some(PERM|NODE|3), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.paths[0][0].pubkey, is_permanent: true}));
6203
6204         // final node failure
6205         run_onion_failure_test_with_fail_intercept("required_node_feature_missing", 200, &nodes, &route, &payment_hash, |_msg| {}, |msg| {
6206                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6207                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6208                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[1].shared_secret[..], PERM|NODE|3, &[0;0]);
6209         }, ||{
6210                 nodes[2].node.fail_htlc_backwards(&payment_hash, &None);
6211         }, false, Some(PERM|NODE|3), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.paths[0][1].pubkey, is_permanent: true}));
6212
6213         run_onion_failure_test("invalid_onion_version", 0, &nodes, &route, &payment_hash, |msg| { msg.onion_routing_packet.version = 1; }, ||{}, true,
6214                 Some(BADONION|PERM|4), None);
6215
6216         run_onion_failure_test("invalid_onion_hmac", 0, &nodes, &route, &payment_hash, |msg| { msg.onion_routing_packet.hmac = [3; 32]; }, ||{}, true,
6217                 Some(BADONION|PERM|5), None);
6218
6219         run_onion_failure_test("invalid_onion_key", 0, &nodes, &route, &payment_hash, |msg| { msg.onion_routing_packet.public_key = Err(secp256k1::Error::InvalidPublicKey);}, ||{}, true,
6220                 Some(BADONION|PERM|6), None);
6221
6222         run_onion_failure_test_with_fail_intercept("temporary_channel_failure", 100, &nodes, &route, &payment_hash, |msg| {
6223                 msg.amount_msat -= 1;
6224         }, |msg| {
6225                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6226                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6227                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], UPDATE|7, &ChannelUpdate::dummy().encode_with_len()[..]);
6228         }, ||{}, true, Some(UPDATE|7), Some(msgs::HTLCFailChannelUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy()}));
6229
6230         run_onion_failure_test_with_fail_intercept("permanent_channel_failure", 100, &nodes, &route, &payment_hash, |msg| {
6231                 msg.amount_msat -= 1;
6232         }, |msg| {
6233                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6234                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6235                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], PERM|8, &[0;0]);
6236                 // short_channel_id from the processing node
6237         }, ||{}, true, Some(PERM|8), Some(msgs::HTLCFailChannelUpdate::ChannelClosed{short_channel_id: channels[1].0.contents.short_channel_id, is_permanent: true}));
6238
6239         run_onion_failure_test_with_fail_intercept("required_channel_feature_missing", 100, &nodes, &route, &payment_hash, |msg| {
6240                 msg.amount_msat -= 1;
6241         }, |msg| {
6242                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6243                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6244                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], PERM|9, &[0;0]);
6245                 // short_channel_id from the processing node
6246         }, ||{}, true, Some(PERM|9), Some(msgs::HTLCFailChannelUpdate::ChannelClosed{short_channel_id: channels[1].0.contents.short_channel_id, is_permanent: true}));
6247
6248         let mut bogus_route = route.clone();
6249         bogus_route.paths[0][1].short_channel_id -= 1;
6250         run_onion_failure_test("unknown_next_peer", 0, &nodes, &bogus_route, &payment_hash, |_| {}, ||{}, true, Some(PERM|10),
6251           Some(msgs::HTLCFailChannelUpdate::ChannelClosed{short_channel_id: bogus_route.paths[0][1].short_channel_id, is_permanent:true}));
6252
6253         let amt_to_forward = nodes[1].node.channel_state.lock().unwrap().by_id.get(&channels[1].2).unwrap().get_their_htlc_minimum_msat() - 1;
6254         let mut bogus_route = route.clone();
6255         let route_len = bogus_route.paths[0].len();
6256         bogus_route.paths[0][route_len-1].fee_msat = amt_to_forward;
6257         run_onion_failure_test("amount_below_minimum", 0, &nodes, &bogus_route, &payment_hash, |_| {}, ||{}, true, Some(UPDATE|11), Some(msgs::HTLCFailChannelUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy()}));
6258
6259         //TODO: with new config API, we will be able to generate both valid and
6260         //invalid channel_update cases.
6261         run_onion_failure_test("fee_insufficient", 0, &nodes, &route, &payment_hash, |msg| {
6262                 msg.amount_msat -= 1;
6263         }, || {}, true, Some(UPDATE|12), Some(msgs::HTLCFailChannelUpdate::ChannelClosed { short_channel_id: channels[0].0.contents.short_channel_id, is_permanent: true}));
6264
6265         run_onion_failure_test("incorrect_cltv_expiry", 0, &nodes, &route, &payment_hash, |msg| {
6266                 // need to violate: cltv_expiry - cltv_expiry_delta >= outgoing_cltv_value
6267                 msg.cltv_expiry -= 1;
6268         }, || {}, true, Some(UPDATE|13), Some(msgs::HTLCFailChannelUpdate::ChannelClosed { short_channel_id: channels[0].0.contents.short_channel_id, is_permanent: true}));
6269
6270         run_onion_failure_test("expiry_too_soon", 0, &nodes, &route, &payment_hash, |msg| {
6271                 let height = msg.cltv_expiry - CLTV_CLAIM_BUFFER - LATENCY_GRACE_PERIOD_BLOCKS + 1;
6272                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
6273
6274                 nodes[1].block_notifier.block_connected_checked(&header, height, &[], &[]);
6275         }, ||{}, true, Some(UPDATE|14), Some(msgs::HTLCFailChannelUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy()}));
6276
6277         run_onion_failure_test("unknown_payment_hash", 2, &nodes, &route, &payment_hash, |_| {}, || {
6278                 nodes[2].node.fail_htlc_backwards(&payment_hash, &None);
6279         }, false, Some(PERM|15), None);
6280
6281         run_onion_failure_test("final_expiry_too_soon", 1, &nodes, &route, &payment_hash, |msg| {
6282                 let height = msg.cltv_expiry - CLTV_CLAIM_BUFFER - LATENCY_GRACE_PERIOD_BLOCKS + 1;
6283                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
6284
6285                 nodes[2].block_notifier.block_connected_checked(&header, height, &[], &[]);
6286         }, || {}, true, Some(17), None);
6287
6288         run_onion_failure_test("final_incorrect_cltv_expiry", 1, &nodes, &route, &payment_hash, |_| {}, || {
6289                 for (_, pending_forwards) in nodes[1].node.channel_state.lock().unwrap().forward_htlcs.iter_mut() {
6290                         for f in pending_forwards.iter_mut() {
6291                                 match f {
6292                                         &mut HTLCForwardInfo::AddHTLC { ref mut forward_info, .. } =>
6293                                                 forward_info.outgoing_cltv_value += 1,
6294                                         _ => {},
6295                                 }
6296                         }
6297                 }
6298         }, true, Some(18), None);
6299
6300         run_onion_failure_test("final_incorrect_htlc_amount", 1, &nodes, &route, &payment_hash, |_| {}, || {
6301                 // violate amt_to_forward > msg.amount_msat
6302                 for (_, pending_forwards) in nodes[1].node.channel_state.lock().unwrap().forward_htlcs.iter_mut() {
6303                         for f in pending_forwards.iter_mut() {
6304                                 match f {
6305                                         &mut HTLCForwardInfo::AddHTLC { ref mut forward_info, .. } =>
6306                                                 forward_info.amt_to_forward -= 1,
6307                                         _ => {},
6308                                 }
6309                         }
6310                 }
6311         }, true, Some(19), None);
6312
6313         run_onion_failure_test("channel_disabled", 0, &nodes, &route, &payment_hash, |_| {}, || {
6314                 // disconnect event to the channel between nodes[1] ~ nodes[2]
6315                 nodes[1].node.peer_disconnected(&nodes[2].node.get_our_node_id(), false);
6316                 nodes[2].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
6317         }, true, Some(UPDATE|20), Some(msgs::HTLCFailChannelUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy()}));
6318         reconnect_nodes(&nodes[1], &nodes[2], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
6319
6320         run_onion_failure_test("expiry_too_far", 0, &nodes, &route, &payment_hash, |msg| {
6321                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6322                 let mut route = route.clone();
6323                 let height = 1;
6324                 route.paths[0][1].cltv_expiry_delta += CLTV_FAR_FAR_AWAY + route.paths[0][0].cltv_expiry_delta + 1;
6325                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6326                 let (onion_payloads, _, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 40000, &None, height).unwrap();
6327                 let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash);
6328                 msg.cltv_expiry = htlc_cltv;
6329                 msg.onion_routing_packet = onion_packet;
6330         }, ||{}, true, Some(21), None);
6331 }
6332
6333 #[test]
6334 #[should_panic]
6335 fn bolt2_open_channel_sending_node_checks_part1() { //This test needs to be on its own as we are catching a panic
6336         let chanmon_cfgs = create_chanmon_cfgs(2);
6337         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6338         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6339         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6340         //Force duplicate channel ids
6341         for node in nodes.iter() {
6342                 *node.keys_manager.override_channel_id_priv.lock().unwrap() = Some([0; 32]);
6343         }
6344
6345         // BOLT #2 spec: Sending node must ensure temporary_channel_id is unique from any other channel ID with the same peer.
6346         let channel_value_satoshis=10000;
6347         let push_msat=10001;
6348         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_satoshis, push_msat, 42, None).unwrap();
6349         let node0_to_1_send_open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
6350         nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &node0_to_1_send_open_channel);
6351
6352         //Create a second channel with a channel_id collision
6353         assert!(nodes[0].node.create_channel(nodes[0].node.get_our_node_id(), channel_value_satoshis, push_msat, 42, None).is_err());
6354 }
6355
6356 #[test]
6357 fn bolt2_open_channel_sending_node_checks_part2() {
6358         let chanmon_cfgs = create_chanmon_cfgs(2);
6359         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6360         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6361         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6362
6363         // BOLT #2 spec: Sending node must set funding_satoshis to less than 2^24 satoshis
6364         let channel_value_satoshis=2^24;
6365         let push_msat=10001;
6366         assert!(nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_satoshis, push_msat, 42, None).is_err());
6367
6368         // BOLT #2 spec: Sending node must set push_msat to equal or less than 1000 * funding_satoshis
6369         let channel_value_satoshis=10000;
6370         // Test when push_msat is equal to 1000 * funding_satoshis.
6371         let push_msat=1000*channel_value_satoshis+1;
6372         assert!(nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_satoshis, push_msat, 42, None).is_err());
6373
6374         // BOLT #2 spec: Sending node must set set channel_reserve_satoshis greater than or equal to dust_limit_satoshis
6375         let channel_value_satoshis=10000;
6376         let push_msat=10001;
6377         assert!(nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_satoshis, push_msat, 42, None).is_ok()); //Create a valid channel
6378         let node0_to_1_send_open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
6379         assert!(node0_to_1_send_open_channel.channel_reserve_satoshis>=node0_to_1_send_open_channel.dust_limit_satoshis);
6380
6381         // BOLT #2 spec: Sending node must set undefined bits in channel_flags to 0
6382         // Only the least-significant bit of channel_flags is currently defined resulting in channel_flags only having one of two possible states 0 or 1
6383         assert!(node0_to_1_send_open_channel.channel_flags<=1);
6384
6385         // BOLT #2 spec: Sending node should set to_self_delay sufficient to ensure the sender can irreversibly spend a commitment transaction output, in case of misbehaviour by the receiver.
6386         assert!(BREAKDOWN_TIMEOUT>0);
6387         assert!(node0_to_1_send_open_channel.to_self_delay==BREAKDOWN_TIMEOUT);
6388
6389         // BOLT #2 spec: Sending node must ensure the chain_hash value identifies the chain it wishes to open the channel within.
6390         let chain_hash=genesis_block(Network::Testnet).header.bitcoin_hash();
6391         assert_eq!(node0_to_1_send_open_channel.chain_hash,chain_hash);
6392
6393         // BOLT #2 spec: Sending node must set funding_pubkey, revocation_basepoint, htlc_basepoint, payment_basepoint, and delayed_payment_basepoint to valid DER-encoded, compressed, secp256k1 pubkeys.
6394         assert!(PublicKey::from_slice(&node0_to_1_send_open_channel.funding_pubkey.serialize()).is_ok());
6395         assert!(PublicKey::from_slice(&node0_to_1_send_open_channel.revocation_basepoint.serialize()).is_ok());
6396         assert!(PublicKey::from_slice(&node0_to_1_send_open_channel.htlc_basepoint.serialize()).is_ok());
6397         assert!(PublicKey::from_slice(&node0_to_1_send_open_channel.payment_point.serialize()).is_ok());
6398         assert!(PublicKey::from_slice(&node0_to_1_send_open_channel.delayed_payment_basepoint.serialize()).is_ok());
6399 }
6400
6401 // Test that if we fail to send an HTLC that is being freed from the holding cell, and the HTLC
6402 // originated from our node, its failure is surfaced to the user. We trigger this failure to
6403 // free the HTLC by increasing our fee while the HTLC is in the holding cell such that the HTLC
6404 // is no longer affordable once it's freed.
6405 #[test]
6406 fn test_fail_holding_cell_htlc_upon_free() {
6407         let chanmon_cfgs = create_chanmon_cfgs(2);
6408         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6409         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6410         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6411         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6412         let logger = test_utils::TestLogger::new();
6413
6414         // First nodes[0] generates an update_fee, setting the channel's
6415         // pending_update_fee.
6416         nodes[0].node.update_fee(chan.2, get_feerate!(nodes[0], chan.2) + 20).unwrap();
6417         check_added_monitors!(nodes[0], 1);
6418
6419         let events = nodes[0].node.get_and_clear_pending_msg_events();
6420         assert_eq!(events.len(), 1);
6421         let (update_msg, commitment_signed) = match events[0] {
6422                 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fee, ref commitment_signed, .. }, .. } => {
6423                         (update_fee.as_ref(), commitment_signed)
6424                 },
6425                 _ => panic!("Unexpected event"),
6426         };
6427
6428         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
6429
6430         let mut chan_stat = get_channel_value_stat!(nodes[0], chan.2);
6431         let channel_reserve = chan_stat.channel_reserve_msat;
6432         let feerate = get_feerate!(nodes[0], chan.2);
6433
6434         // 2* and +1 HTLCs on the commit tx fee calculation for the fee spike reserve.
6435         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6436         let max_can_send = 5000000 - channel_reserve - 2*commit_tx_fee_msat(feerate, 1 + 1);
6437         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6438         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], max_can_send, TEST_FINAL_CLTV, &logger).unwrap();
6439
6440         // Send a payment which passes reserve checks but gets stuck in the holding cell.
6441         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6442         chan_stat = get_channel_value_stat!(nodes[0], chan.2);
6443         assert_eq!(chan_stat.holding_cell_outbound_amount_msat, max_can_send);
6444
6445         // Flush the pending fee update.
6446         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed);
6447         let (as_revoke_and_ack, _) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
6448         check_added_monitors!(nodes[1], 1);
6449         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_revoke_and_ack);
6450         check_added_monitors!(nodes[0], 1);
6451
6452         // Upon receipt of the RAA, there will be an attempt to resend the holding cell
6453         // HTLC, but now that the fee has been raised the payment will now fail, causing
6454         // us to surface its failure to the user.
6455         chan_stat = get_channel_value_stat!(nodes[0], chan.2);
6456         assert_eq!(chan_stat.holding_cell_outbound_amount_msat, 0);
6457         nodes[0].logger.assert_log("lightning::ln::channel".to_string(), "Freeing holding cell with 1 HTLC updates".to_string(), 1);
6458         let failure_log = format!("Failed to send HTLC with payment_hash {} due to Cannot send value that would put us under local channel reserve value ({})", log_bytes!(our_payment_hash.0), chan_stat.channel_reserve_msat);
6459         nodes[0].logger.assert_log("lightning::ln::channel".to_string(), failure_log.to_string(), 1);
6460
6461         // Check that the payment failed to be sent out.
6462         let events = nodes[0].node.get_and_clear_pending_events();
6463         assert_eq!(events.len(), 1);
6464         match &events[0] {
6465                 &Event::PaymentFailed { ref payment_hash, ref rejected_by_dest, ref error_code, ref error_data } => {
6466                         assert_eq!(our_payment_hash.clone(), *payment_hash);
6467                         assert_eq!(*rejected_by_dest, false);
6468                         assert_eq!(*error_code, None);
6469                         assert_eq!(*error_data, None);
6470                 },
6471                 _ => panic!("Unexpected event"),
6472         }
6473 }
6474
6475 // Test that if multiple HTLCs are released from the holding cell and one is
6476 // valid but the other is no longer valid upon release, the valid HTLC can be
6477 // successfully completed while the other one fails as expected.
6478 #[test]
6479 fn test_free_and_fail_holding_cell_htlcs() {
6480         let chanmon_cfgs = create_chanmon_cfgs(2);
6481         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6482         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6483         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6484         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6485         let logger = test_utils::TestLogger::new();
6486
6487         // First nodes[0] generates an update_fee, setting the channel's
6488         // pending_update_fee.
6489         nodes[0].node.update_fee(chan.2, get_feerate!(nodes[0], chan.2) + 200).unwrap();
6490         check_added_monitors!(nodes[0], 1);
6491
6492         let events = nodes[0].node.get_and_clear_pending_msg_events();
6493         assert_eq!(events.len(), 1);
6494         let (update_msg, commitment_signed) = match events[0] {
6495                 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fee, ref commitment_signed, .. }, .. } => {
6496                         (update_fee.as_ref(), commitment_signed)
6497                 },
6498                 _ => panic!("Unexpected event"),
6499         };
6500
6501         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
6502
6503         let mut chan_stat = get_channel_value_stat!(nodes[0], chan.2);
6504         let channel_reserve = chan_stat.channel_reserve_msat;
6505         let feerate = get_feerate!(nodes[0], chan.2);
6506
6507         // 2* and +1 HTLCs on the commit tx fee calculation for the fee spike reserve.
6508         let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
6509         let amt_1 = 20000;
6510         let (_, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
6511         let amt_2 = 5000000 - channel_reserve - 2*commit_tx_fee_msat(feerate, 2 + 1) - amt_1;
6512         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6513         let route_1 = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], amt_1, TEST_FINAL_CLTV, &logger).unwrap();
6514         let route_2 = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], amt_2, TEST_FINAL_CLTV, &logger).unwrap();
6515
6516         // Send 2 payments which pass reserve checks but get stuck in the holding cell.
6517         nodes[0].node.send_payment(&route_1, payment_hash_1, &None).unwrap();
6518         chan_stat = get_channel_value_stat!(nodes[0], chan.2);
6519         assert_eq!(chan_stat.holding_cell_outbound_amount_msat, amt_1);
6520         nodes[0].node.send_payment(&route_2, payment_hash_2, &None).unwrap();
6521         chan_stat = get_channel_value_stat!(nodes[0], chan.2);
6522         assert_eq!(chan_stat.holding_cell_outbound_amount_msat, amt_1 + amt_2);
6523
6524         // Flush the pending fee update.
6525         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed);
6526         let (revoke_and_ack, commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
6527         check_added_monitors!(nodes[1], 1);
6528         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke_and_ack);
6529         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_signed);
6530         check_added_monitors!(nodes[0], 2);
6531
6532         // Upon receipt of the RAA, there will be an attempt to resend the holding cell HTLCs,
6533         // but now that the fee has been raised the second payment will now fail, causing us
6534         // to surface its failure to the user. The first payment should succeed.
6535         chan_stat = get_channel_value_stat!(nodes[0], chan.2);
6536         assert_eq!(chan_stat.holding_cell_outbound_amount_msat, 0);
6537         nodes[0].logger.assert_log("lightning::ln::channel".to_string(), "Freeing holding cell with 2 HTLC updates".to_string(), 1);
6538         let failure_log = format!("Failed to send HTLC with payment_hash {} due to Cannot send value that would put us under local channel reserve value ({})", log_bytes!(payment_hash_2.0), chan_stat.channel_reserve_msat);
6539         nodes[0].logger.assert_log("lightning::ln::channel".to_string(), failure_log.to_string(), 1);
6540
6541         // Check that the second payment failed to be sent out.
6542         let events = nodes[0].node.get_and_clear_pending_events();
6543         assert_eq!(events.len(), 1);
6544         match &events[0] {
6545                 &Event::PaymentFailed { ref payment_hash, ref rejected_by_dest, ref error_code, ref error_data } => {
6546                         assert_eq!(payment_hash_2.clone(), *payment_hash);
6547                         assert_eq!(*rejected_by_dest, false);
6548                         assert_eq!(*error_code, None);
6549                         assert_eq!(*error_data, None);
6550                 },
6551                 _ => panic!("Unexpected event"),
6552         }
6553
6554         // Complete the first payment and the RAA from the fee update.
6555         let (payment_event, send_raa_event) = {
6556                 let mut msgs = nodes[0].node.get_and_clear_pending_msg_events();
6557                 assert_eq!(msgs.len(), 2);
6558                 (SendEvent::from_event(msgs.remove(0)), msgs.remove(0))
6559         };
6560         let raa = match send_raa_event {
6561                 MessageSendEvent::SendRevokeAndACK { msg, .. } => msg,
6562                 _ => panic!("Unexpected event"),
6563         };
6564         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &raa);
6565         check_added_monitors!(nodes[1], 1);
6566         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
6567         commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
6568         let events = nodes[1].node.get_and_clear_pending_events();
6569         assert_eq!(events.len(), 1);
6570         match events[0] {
6571                 Event::PendingHTLCsForwardable { .. } => {},
6572                 _ => panic!("Unexpected event"),
6573         }
6574         nodes[1].node.process_pending_htlc_forwards();
6575         let events = nodes[1].node.get_and_clear_pending_events();
6576         assert_eq!(events.len(), 1);
6577         match events[0] {
6578                 Event::PaymentReceived { .. } => {},
6579                 _ => panic!("Unexpected event"),
6580         }
6581         nodes[1].node.claim_funds(payment_preimage_1, &None, amt_1);
6582         check_added_monitors!(nodes[1], 1);
6583         let update_msgs = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
6584         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_msgs.update_fulfill_htlcs[0]);
6585         commitment_signed_dance!(nodes[0], nodes[1], update_msgs.commitment_signed, false, true);
6586         let events = nodes[0].node.get_and_clear_pending_events();
6587         assert_eq!(events.len(), 1);
6588         match events[0] {
6589                 Event::PaymentSent { ref payment_preimage } => {
6590                         assert_eq!(*payment_preimage, payment_preimage_1);
6591                 }
6592                 _ => panic!("Unexpected event"),
6593         }
6594 }
6595
6596 // Test that if we fail to forward an HTLC that is being freed from the holding cell that the
6597 // HTLC is failed backwards. We trigger this failure to forward the freed HTLC by increasing
6598 // our fee while the HTLC is in the holding cell such that the HTLC is no longer affordable
6599 // once it's freed.
6600 #[test]
6601 fn test_fail_holding_cell_htlc_upon_free_multihop() {
6602         let chanmon_cfgs = create_chanmon_cfgs(3);
6603         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
6604         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
6605         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
6606         let chan_0_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6607         let chan_1_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6608         let logger = test_utils::TestLogger::new();
6609
6610         // First nodes[1] generates an update_fee, setting the channel's
6611         // pending_update_fee.
6612         nodes[1].node.update_fee(chan_1_2.2, get_feerate!(nodes[1], chan_1_2.2) + 20).unwrap();
6613         check_added_monitors!(nodes[1], 1);
6614
6615         let events = nodes[1].node.get_and_clear_pending_msg_events();
6616         assert_eq!(events.len(), 1);
6617         let (update_msg, commitment_signed) = match events[0] {
6618                 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fee, ref commitment_signed, .. }, .. } => {
6619                         (update_fee.as_ref(), commitment_signed)
6620                 },
6621                 _ => panic!("Unexpected event"),
6622         };
6623
6624         nodes[2].node.handle_update_fee(&nodes[1].node.get_our_node_id(), update_msg.unwrap());
6625
6626         let mut chan_stat = get_channel_value_stat!(nodes[0], chan_0_1.2);
6627         let channel_reserve = chan_stat.channel_reserve_msat;
6628         let feerate = get_feerate!(nodes[0], chan_0_1.2);
6629
6630         // Send a payment which passes reserve checks but gets stuck in the holding cell.
6631         let feemsat = 239;
6632         let total_routing_fee_msat = (nodes.len() - 2) as u64 * feemsat;
6633         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6634         let max_can_send = 5000000 - channel_reserve - 2*commit_tx_fee_msat(feerate, 1 + 1) - total_routing_fee_msat;
6635         let payment_event = {
6636                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6637                 let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, &[], max_can_send, TEST_FINAL_CLTV, &logger).unwrap();
6638                 nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6639                 check_added_monitors!(nodes[0], 1);
6640
6641                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
6642                 assert_eq!(events.len(), 1);
6643
6644                 SendEvent::from_event(events.remove(0))
6645         };
6646         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
6647         check_added_monitors!(nodes[1], 0);
6648         commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
6649         expect_pending_htlcs_forwardable!(nodes[1]);
6650
6651         chan_stat = get_channel_value_stat!(nodes[1], chan_1_2.2);
6652         assert_eq!(chan_stat.holding_cell_outbound_amount_msat, max_can_send);
6653
6654         // Flush the pending fee update.
6655         nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), commitment_signed);
6656         let (raa, commitment_signed) = get_revoke_commit_msgs!(nodes[2], nodes[1].node.get_our_node_id());
6657         check_added_monitors!(nodes[2], 1);
6658         nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &raa);
6659         nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &commitment_signed);
6660         check_added_monitors!(nodes[1], 2);
6661
6662         // A final RAA message is generated to finalize the fee update.
6663         let events = nodes[1].node.get_and_clear_pending_msg_events();
6664         assert_eq!(events.len(), 1);
6665
6666         let raa_msg = match &events[0] {
6667                 &MessageSendEvent::SendRevokeAndACK { ref msg, .. } => {
6668                         msg.clone()
6669                 },
6670                 _ => panic!("Unexpected event"),
6671         };
6672
6673         nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &raa_msg);
6674         check_added_monitors!(nodes[2], 1);
6675         assert!(nodes[2].node.get_and_clear_pending_msg_events().is_empty());
6676
6677         // nodes[1]'s ChannelManager will now signal that we have HTLC forwards to process.
6678         let process_htlc_forwards_event = nodes[1].node.get_and_clear_pending_events();
6679         assert_eq!(process_htlc_forwards_event.len(), 1);
6680         match &process_htlc_forwards_event[0] {
6681                 &Event::PendingHTLCsForwardable { .. } => {},
6682                 _ => panic!("Unexpected event"),
6683         }
6684
6685         // In response, we call ChannelManager's process_pending_htlc_forwards
6686         nodes[1].node.process_pending_htlc_forwards();
6687         check_added_monitors!(nodes[1], 1);
6688
6689         // This causes the HTLC to be failed backwards.
6690         let fail_event = nodes[1].node.get_and_clear_pending_msg_events();
6691         assert_eq!(fail_event.len(), 1);
6692         let (fail_msg, commitment_signed) = match &fail_event[0] {
6693                 &MessageSendEvent::UpdateHTLCs { ref updates, .. } => {
6694                         assert_eq!(updates.update_add_htlcs.len(), 0);
6695                         assert_eq!(updates.update_fulfill_htlcs.len(), 0);
6696                         assert_eq!(updates.update_fail_malformed_htlcs.len(), 0);
6697                         assert_eq!(updates.update_fail_htlcs.len(), 1);
6698                         (updates.update_fail_htlcs[0].clone(), updates.commitment_signed.clone())
6699                 },
6700                 _ => panic!("Unexpected event"),
6701         };
6702
6703         // Pass the failure messages back to nodes[0].
6704         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &fail_msg);
6705         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_signed);
6706
6707         // Complete the HTLC failure+removal process.
6708         let (raa, commitment_signed) = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6709         check_added_monitors!(nodes[0], 1);
6710         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &raa);
6711         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &commitment_signed);
6712         check_added_monitors!(nodes[1], 2);
6713         let final_raa_event = nodes[1].node.get_and_clear_pending_msg_events();
6714         assert_eq!(final_raa_event.len(), 1);
6715         let raa = match &final_raa_event[0] {
6716                 &MessageSendEvent::SendRevokeAndACK { ref msg, .. } => msg.clone(),
6717                 _ => panic!("Unexpected event"),
6718         };
6719         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &raa);
6720         let fail_msg_event = nodes[0].node.get_and_clear_pending_msg_events();
6721         assert_eq!(fail_msg_event.len(), 1);
6722         match &fail_msg_event[0] {
6723                 &MessageSendEvent::PaymentFailureNetworkUpdate { .. } => {},
6724                 _ => panic!("Unexpected event"),
6725         }
6726         let failure_event = nodes[0].node.get_and_clear_pending_events();
6727         assert_eq!(failure_event.len(), 1);
6728         match &failure_event[0] {
6729                 &Event::PaymentFailed { rejected_by_dest, .. } => {
6730                         assert!(!rejected_by_dest);
6731                 },
6732                 _ => panic!("Unexpected event"),
6733         }
6734         check_added_monitors!(nodes[0], 1);
6735 }
6736
6737 // BOLT 2 Requirements for the Sender when constructing and sending an update_add_htlc message.
6738 // BOLT 2 Requirement: MUST NOT offer amount_msat it cannot pay for in the remote commitment transaction at the current feerate_per_kw (see "Updating Fees") while maintaining its channel reserve.
6739 //TODO: I don't believe this is explicitly enforced when sending an HTLC but as the Fee aspect of the BOLT specs is in flux leaving this as a TODO.
6740
6741 #[test]
6742 fn test_update_add_htlc_bolt2_sender_value_below_minimum_msat() {
6743         //BOLT2 Requirement: MUST NOT offer amount_msat below the receiving node's htlc_minimum_msat (same validation check catches both of these)
6744         let chanmon_cfgs = create_chanmon_cfgs(2);
6745         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6746         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6747         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6748         let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6749
6750         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6751         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6752         let logger = test_utils::TestLogger::new();
6753         let mut route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
6754         route.paths[0][0].fee_msat = 100;
6755
6756         unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
6757                 assert!(regex::Regex::new(r"Cannot send less than their minimum HTLC value \(\d+\)").unwrap().is_match(err)));
6758         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
6759         nodes[0].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot send less than their minimum HTLC value".to_string(), 1);
6760 }
6761
6762 #[test]
6763 fn test_update_add_htlc_bolt2_sender_zero_value_msat() {
6764         //BOLT2 Requirement: MUST offer amount_msat greater than 0.
6765         let chanmon_cfgs = create_chanmon_cfgs(2);
6766         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6767         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6768         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6769         let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6770         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6771
6772         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6773         let logger = test_utils::TestLogger::new();
6774         let mut route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
6775         route.paths[0][0].fee_msat = 0;
6776         unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
6777                 assert_eq!(err, "Cannot send 0-msat HTLC"));
6778
6779         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
6780         nodes[0].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot send 0-msat HTLC".to_string(), 1);
6781 }
6782
6783 #[test]
6784 fn test_update_add_htlc_bolt2_receiver_zero_value_msat() {
6785         //BOLT2 Requirement: MUST offer amount_msat greater than 0.
6786         let chanmon_cfgs = create_chanmon_cfgs(2);
6787         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6788         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6789         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6790         let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6791
6792         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6793         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6794         let logger = test_utils::TestLogger::new();
6795         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
6796         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6797         check_added_monitors!(nodes[0], 1);
6798         let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6799         updates.update_add_htlcs[0].amount_msat = 0;
6800
6801         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6802         nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Remote side tried to send a 0-msat HTLC".to_string(), 1);
6803         check_closed_broadcast!(nodes[1], true).unwrap();
6804         check_added_monitors!(nodes[1], 1);
6805 }
6806
6807 #[test]
6808 fn test_update_add_htlc_bolt2_sender_cltv_expiry_too_high() {
6809         //BOLT 2 Requirement: MUST set cltv_expiry less than 500000000.
6810         //It is enforced when constructing a route.
6811         let chanmon_cfgs = create_chanmon_cfgs(2);
6812         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6813         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6814         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6815         let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 0, InitFeatures::known(), InitFeatures::known());
6816         let logger = test_utils::TestLogger::new();
6817
6818         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6819
6820         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6821         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], 100000000, 500000001, &logger).unwrap();
6822         unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::RouteError { ref err },
6823                 assert_eq!(err, &"Channel CLTV overflowed?"));
6824 }
6825
6826 #[test]
6827 fn test_update_add_htlc_bolt2_sender_exceed_max_htlc_num_and_htlc_id_increment() {
6828         //BOLT 2 Requirement: if result would be offering more than the remote's max_accepted_htlcs HTLCs, in the remote commitment transaction: MUST NOT add an HTLC.
6829         //BOLT 2 Requirement: for the first HTLC it offers MUST set id to 0.
6830         //BOLT 2 Requirement: MUST increase the value of id by 1 for each successive offer.
6831         let chanmon_cfgs = create_chanmon_cfgs(2);
6832         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6833         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6834         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6835         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 0, InitFeatures::known(), InitFeatures::known());
6836         let max_accepted_htlcs = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().their_max_accepted_htlcs as u64;
6837
6838         let logger = test_utils::TestLogger::new();
6839         for i in 0..max_accepted_htlcs {
6840                 let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6841                 let payment_event = {
6842                         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6843                         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
6844                         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6845                         check_added_monitors!(nodes[0], 1);
6846
6847                         let mut events = nodes[0].node.get_and_clear_pending_msg_events();
6848                         assert_eq!(events.len(), 1);
6849                         if let MessageSendEvent::UpdateHTLCs { node_id: _, updates: msgs::CommitmentUpdate{ update_add_htlcs: ref htlcs, .. }, } = events[0] {
6850                                 assert_eq!(htlcs[0].htlc_id, i);
6851                         } else {
6852                                 assert!(false);
6853                         }
6854                         SendEvent::from_event(events.remove(0))
6855                 };
6856                 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
6857                 check_added_monitors!(nodes[1], 0);
6858                 commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
6859
6860                 expect_pending_htlcs_forwardable!(nodes[1]);
6861                 expect_payment_received!(nodes[1], our_payment_hash, 100000);
6862         }
6863         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6864         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6865         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
6866         unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
6867                 assert!(regex::Regex::new(r"Cannot push more than their max accepted HTLCs \(\d+\)").unwrap().is_match(err)));
6868
6869         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
6870         nodes[0].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot push more than their max accepted HTLCs".to_string(), 1);
6871 }
6872
6873 #[test]
6874 fn test_update_add_htlc_bolt2_sender_exceed_max_htlc_value_in_flight() {
6875         //BOLT 2 Requirement: if the sum of total offered HTLCs would exceed the remote's max_htlc_value_in_flight_msat: MUST NOT add an HTLC.
6876         let chanmon_cfgs = create_chanmon_cfgs(2);
6877         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6878         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6879         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6880         let channel_value = 100000;
6881         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, channel_value, 0, InitFeatures::known(), InitFeatures::known());
6882         let max_in_flight = get_channel_value_stat!(nodes[0], chan.2).their_max_htlc_value_in_flight_msat;
6883
6884         send_payment(&nodes[0], &vec!(&nodes[1])[..], max_in_flight, max_in_flight);
6885
6886         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6887         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6888         let logger = test_utils::TestLogger::new();
6889         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], max_in_flight+1, TEST_FINAL_CLTV, &logger).unwrap();
6890         unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
6891                 assert!(regex::Regex::new(r"Cannot send value that would put us over the max HTLC value in flight our peer will accept \(\d+\)").unwrap().is_match(err)));
6892
6893         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
6894         nodes[0].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot send value that would put us over the max HTLC value in flight our peer will accept".to_string(), 1);
6895
6896         send_payment(&nodes[0], &[&nodes[1]], max_in_flight, max_in_flight);
6897 }
6898
6899 // BOLT 2 Requirements for the Receiver when handling an update_add_htlc message.
6900 #[test]
6901 fn test_update_add_htlc_bolt2_receiver_check_amount_received_more_than_min() {
6902         //BOLT2 Requirement: receiving an amount_msat equal to 0, OR less than its own htlc_minimum_msat -> SHOULD fail the channel.
6903         let chanmon_cfgs = create_chanmon_cfgs(2);
6904         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6905         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6906         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6907         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6908         let htlc_minimum_msat: u64;
6909         {
6910                 let chan_lock = nodes[0].node.channel_state.lock().unwrap();
6911                 let channel = chan_lock.by_id.get(&chan.2).unwrap();
6912                 htlc_minimum_msat = channel.get_our_htlc_minimum_msat();
6913         }
6914
6915         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6916         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6917         let logger = test_utils::TestLogger::new();
6918         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], htlc_minimum_msat, TEST_FINAL_CLTV, &logger).unwrap();
6919         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6920         check_added_monitors!(nodes[0], 1);
6921         let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6922         updates.update_add_htlcs[0].amount_msat = htlc_minimum_msat-1;
6923         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6924         assert!(nodes[1].node.list_channels().is_empty());
6925         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
6926         assert!(regex::Regex::new(r"Remote side tried to send less than our minimum HTLC value\. Lower limit: \(\d+\)\. Actual: \(\d+\)").unwrap().is_match(err_msg.data.as_str()));
6927         check_added_monitors!(nodes[1], 1);
6928 }
6929
6930 #[test]
6931 fn test_update_add_htlc_bolt2_receiver_sender_can_afford_amount_sent() {
6932         //BOLT2 Requirement: receiving an amount_msat that the sending node cannot afford at the current feerate_per_kw (while maintaining its channel reserve): SHOULD fail the channel
6933         let chanmon_cfgs = create_chanmon_cfgs(2);
6934         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6935         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6936         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6937         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6938         let logger = test_utils::TestLogger::new();
6939
6940         let chan_stat = get_channel_value_stat!(nodes[0], chan.2);
6941         let channel_reserve = chan_stat.channel_reserve_msat;
6942         let feerate = get_feerate!(nodes[0], chan.2);
6943         // The 2* and +1 are for the fee spike reserve.
6944         let commit_tx_fee_outbound = 2 * commit_tx_fee_msat(feerate, 1 + 1);
6945
6946         let max_can_send = 5000000 - channel_reserve - commit_tx_fee_outbound;
6947         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6948         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6949         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], max_can_send, TEST_FINAL_CLTV, &logger).unwrap();
6950         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6951         check_added_monitors!(nodes[0], 1);
6952         let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6953
6954         // Even though channel-initiator senders are required to respect the fee_spike_reserve,
6955         // at this time channel-initiatee receivers are not required to enforce that senders
6956         // respect the fee_spike_reserve.
6957         updates.update_add_htlcs[0].amount_msat = max_can_send + commit_tx_fee_outbound + 1;
6958         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6959
6960         assert!(nodes[1].node.list_channels().is_empty());
6961         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
6962         assert_eq!(err_msg.data, "Remote HTLC add would put them under remote reserve value");
6963         check_added_monitors!(nodes[1], 1);
6964 }
6965
6966 #[test]
6967 fn test_update_add_htlc_bolt2_receiver_check_max_htlc_limit() {
6968         //BOLT 2 Requirement: if a sending node adds more than its max_accepted_htlcs HTLCs to its local commitment transaction: SHOULD fail the channel
6969         //BOLT 2 Requirement: MUST allow multiple HTLCs with the same payment_hash.
6970         let chanmon_cfgs = create_chanmon_cfgs(2);
6971         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6972         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6973         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6974         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6975         let logger = test_utils::TestLogger::new();
6976
6977         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6978         let session_priv = SecretKey::from_slice(&[42; 32]).unwrap();
6979
6980         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6981         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], 3999999, TEST_FINAL_CLTV, &logger).unwrap();
6982
6983         let cur_height = nodes[0].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
6984         let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::signing_only(), &route.paths[0], &session_priv).unwrap();
6985         let (onion_payloads, _htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 3999999, &None, cur_height).unwrap();
6986         let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &our_payment_hash);
6987
6988         let mut msg = msgs::UpdateAddHTLC {
6989                 channel_id: chan.2,
6990                 htlc_id: 0,
6991                 amount_msat: 1000,
6992                 payment_hash: our_payment_hash,
6993                 cltv_expiry: htlc_cltv,
6994                 onion_routing_packet: onion_packet.clone(),
6995         };
6996
6997         for i in 0..super::channel::OUR_MAX_HTLCS {
6998                 msg.htlc_id = i as u64;
6999                 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &msg);
7000         }
7001         msg.htlc_id = (super::channel::OUR_MAX_HTLCS) as u64;
7002         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &msg);
7003
7004         assert!(nodes[1].node.list_channels().is_empty());
7005         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
7006         assert!(regex::Regex::new(r"Remote tried to push more than our max accepted HTLCs \(\d+\)").unwrap().is_match(err_msg.data.as_str()));
7007         check_added_monitors!(nodes[1], 1);
7008 }
7009
7010 #[test]
7011 fn test_update_add_htlc_bolt2_receiver_check_max_in_flight_msat() {
7012         //OR adds more than its max_htlc_value_in_flight_msat worth of offered HTLCs to its local commitment transaction: SHOULD fail the channel
7013         let chanmon_cfgs = create_chanmon_cfgs(2);
7014         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7015         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7016         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7017         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
7018         let logger = test_utils::TestLogger::new();
7019
7020         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
7021         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
7022         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
7023         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
7024         check_added_monitors!(nodes[0], 1);
7025         let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
7026         updates.update_add_htlcs[0].amount_msat = get_channel_value_stat!(nodes[1], chan.2).their_max_htlc_value_in_flight_msat + 1;
7027         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
7028
7029         assert!(nodes[1].node.list_channels().is_empty());
7030         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
7031         assert!(regex::Regex::new("Remote HTLC add would put them over our max HTLC value").unwrap().is_match(err_msg.data.as_str()));
7032         check_added_monitors!(nodes[1], 1);
7033 }
7034
7035 #[test]
7036 fn test_update_add_htlc_bolt2_receiver_check_cltv_expiry() {
7037         //BOLT2 Requirement: if sending node sets cltv_expiry to greater or equal to 500000000: SHOULD fail the channel.
7038         let chanmon_cfgs = create_chanmon_cfgs(2);
7039         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7040         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7041         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7042         let logger = test_utils::TestLogger::new();
7043
7044         create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
7045         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
7046         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
7047         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
7048         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
7049         check_added_monitors!(nodes[0], 1);
7050         let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
7051         updates.update_add_htlcs[0].cltv_expiry = 500000000;
7052         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
7053
7054         assert!(nodes[1].node.list_channels().is_empty());
7055         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
7056         assert_eq!(err_msg.data,"Remote provided CLTV expiry in seconds instead of block height");
7057         check_added_monitors!(nodes[1], 1);
7058 }
7059
7060 #[test]
7061 fn test_update_add_htlc_bolt2_receiver_check_repeated_id_ignore() {
7062         //BOLT 2 requirement: if the sender did not previously acknowledge the commitment of that HTLC: MUST ignore a repeated id value after a reconnection.
7063         // We test this by first testing that that repeated HTLCs pass commitment signature checks
7064         // after disconnect and that non-sequential htlc_ids result in a channel failure.
7065         let chanmon_cfgs = create_chanmon_cfgs(2);
7066         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7067         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7068         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7069         let logger = test_utils::TestLogger::new();
7070
7071         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
7072         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
7073         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
7074         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
7075         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
7076         check_added_monitors!(nodes[0], 1);
7077         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
7078         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
7079
7080         //Disconnect and Reconnect
7081         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
7082         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
7083         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
7084         let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
7085         assert_eq!(reestablish_1.len(), 1);
7086         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
7087         let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
7088         assert_eq!(reestablish_2.len(), 1);
7089         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
7090         handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
7091         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
7092         handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
7093
7094         //Resend HTLC
7095         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
7096         assert_eq!(updates.commitment_signed.htlc_signatures.len(), 1);
7097         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &updates.commitment_signed);
7098         check_added_monitors!(nodes[1], 1);
7099         let _bs_responses = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
7100
7101         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
7102
7103         assert!(nodes[1].node.list_channels().is_empty());
7104         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
7105         assert!(regex::Regex::new(r"Remote skipped HTLC ID \(skipped ID: \d+\)").unwrap().is_match(err_msg.data.as_str()));
7106         check_added_monitors!(nodes[1], 1);
7107 }
7108
7109 #[test]
7110 fn test_update_fulfill_htlc_bolt2_update_fulfill_htlc_before_commitment() {
7111         //BOLT 2 Requirement: until the corresponding HTLC is irrevocably committed in both sides' commitment transactions:     MUST NOT send an update_fulfill_htlc, update_fail_htlc, or update_fail_malformed_htlc.
7112
7113         let chanmon_cfgs = create_chanmon_cfgs(2);
7114         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7115         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7116         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7117         let logger = test_utils::TestLogger::new();
7118         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
7119         let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
7120         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
7121         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
7122         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
7123
7124         check_added_monitors!(nodes[0], 1);
7125         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
7126         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
7127
7128         let update_msg = msgs::UpdateFulfillHTLC{
7129                 channel_id: chan.2,
7130                 htlc_id: 0,
7131                 payment_preimage: our_payment_preimage,
7132         };
7133
7134         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_msg);
7135
7136         assert!(nodes[0].node.list_channels().is_empty());
7137         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
7138         assert!(regex::Regex::new(r"Remote tried to fulfill/fail HTLC \(\d+\) before it had been committed").unwrap().is_match(err_msg.data.as_str()));
7139         check_added_monitors!(nodes[0], 1);
7140 }
7141
7142 #[test]
7143 fn test_update_fulfill_htlc_bolt2_update_fail_htlc_before_commitment() {
7144         //BOLT 2 Requirement: until the corresponding HTLC is irrevocably committed in both sides' commitment transactions:     MUST NOT send an update_fulfill_htlc, update_fail_htlc, or update_fail_malformed_htlc.
7145
7146         let chanmon_cfgs = create_chanmon_cfgs(2);
7147         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7148         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7149         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7150         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
7151         let logger = test_utils::TestLogger::new();
7152
7153         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
7154         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
7155         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
7156         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
7157         check_added_monitors!(nodes[0], 1);
7158         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
7159         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
7160
7161         let update_msg = msgs::UpdateFailHTLC{
7162                 channel_id: chan.2,
7163                 htlc_id: 0,
7164                 reason: msgs::OnionErrorPacket { data: Vec::new()},
7165         };
7166
7167         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_msg);
7168
7169         assert!(nodes[0].node.list_channels().is_empty());
7170         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
7171         assert!(regex::Regex::new(r"Remote tried to fulfill/fail HTLC \(\d+\) before it had been committed").unwrap().is_match(err_msg.data.as_str()));
7172         check_added_monitors!(nodes[0], 1);
7173 }
7174
7175 #[test]
7176 fn test_update_fulfill_htlc_bolt2_update_fail_malformed_htlc_before_commitment() {
7177         //BOLT 2 Requirement: until the corresponding HTLC is irrevocably committed in both sides' commitment transactions:     MUST NOT send an update_fulfill_htlc, update_fail_htlc, or update_fail_malformed_htlc.
7178
7179         let chanmon_cfgs = create_chanmon_cfgs(2);
7180         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7181         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7182         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7183         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
7184         let logger = test_utils::TestLogger::new();
7185
7186         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
7187         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
7188         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
7189         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
7190         check_added_monitors!(nodes[0], 1);
7191         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
7192         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
7193
7194         let update_msg = msgs::UpdateFailMalformedHTLC{
7195                 channel_id: chan.2,
7196                 htlc_id: 0,
7197                 sha256_of_onion: [1; 32],
7198                 failure_code: 0x8000,
7199         };
7200
7201         nodes[0].node.handle_update_fail_malformed_htlc(&nodes[1].node.get_our_node_id(), &update_msg);
7202
7203         assert!(nodes[0].node.list_channels().is_empty());
7204         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
7205         assert!(regex::Regex::new(r"Remote tried to fulfill/fail HTLC \(\d+\) before it had been committed").unwrap().is_match(err_msg.data.as_str()));
7206         check_added_monitors!(nodes[0], 1);
7207 }
7208
7209 #[test]
7210 fn test_update_fulfill_htlc_bolt2_incorrect_htlc_id() {
7211         //BOLT 2 Requirement: A receiving node: if the id does not correspond to an HTLC in its current commitment transaction MUST fail the channel.
7212
7213         let chanmon_cfgs = create_chanmon_cfgs(2);
7214         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7215         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7216         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7217         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
7218
7219         let our_payment_preimage = route_payment(&nodes[0], &[&nodes[1]], 100000).0;
7220
7221         nodes[1].node.claim_funds(our_payment_preimage, &None, 100_000);
7222         check_added_monitors!(nodes[1], 1);
7223
7224         let events = nodes[1].node.get_and_clear_pending_msg_events();
7225         assert_eq!(events.len(), 1);
7226         let mut update_fulfill_msg: msgs::UpdateFulfillHTLC = {
7227                 match events[0] {
7228                         MessageSendEvent::UpdateHTLCs { node_id: _ , updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, ref update_fee, .. } } => {
7229                                 assert!(update_add_htlcs.is_empty());
7230                                 assert_eq!(update_fulfill_htlcs.len(), 1);
7231                                 assert!(update_fail_htlcs.is_empty());
7232                                 assert!(update_fail_malformed_htlcs.is_empty());
7233                                 assert!(update_fee.is_none());
7234                                 update_fulfill_htlcs[0].clone()
7235                         },
7236                         _ => panic!("Unexpected event"),
7237                 }
7238         };
7239
7240         update_fulfill_msg.htlc_id = 1;
7241
7242         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_msg);
7243
7244         assert!(nodes[0].node.list_channels().is_empty());
7245         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
7246         assert_eq!(err_msg.data, "Remote tried to fulfill/fail an HTLC we couldn't find");
7247         check_added_monitors!(nodes[0], 1);
7248 }
7249
7250 #[test]
7251 fn test_update_fulfill_htlc_bolt2_wrong_preimage() {
7252         //BOLT 2 Requirement: A receiving node: if the payment_preimage value in update_fulfill_htlc doesn't SHA256 hash to the corresponding HTLC payment_hash MUST fail the channel.
7253
7254         let chanmon_cfgs = create_chanmon_cfgs(2);
7255         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7256         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7257         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7258         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
7259
7260         let our_payment_preimage = route_payment(&nodes[0], &[&nodes[1]], 100000).0;
7261
7262         nodes[1].node.claim_funds(our_payment_preimage, &None, 100_000);
7263         check_added_monitors!(nodes[1], 1);
7264
7265         let events = nodes[1].node.get_and_clear_pending_msg_events();
7266         assert_eq!(events.len(), 1);
7267         let mut update_fulfill_msg: msgs::UpdateFulfillHTLC = {
7268                 match events[0] {
7269                         MessageSendEvent::UpdateHTLCs { node_id: _ , updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, ref update_fee, .. } } => {
7270                                 assert!(update_add_htlcs.is_empty());
7271                                 assert_eq!(update_fulfill_htlcs.len(), 1);
7272                                 assert!(update_fail_htlcs.is_empty());
7273                                 assert!(update_fail_malformed_htlcs.is_empty());
7274                                 assert!(update_fee.is_none());
7275                                 update_fulfill_htlcs[0].clone()
7276                         },
7277                         _ => panic!("Unexpected event"),
7278                 }
7279         };
7280
7281         update_fulfill_msg.payment_preimage = PaymentPreimage([1; 32]);
7282
7283         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_msg);
7284
7285         assert!(nodes[0].node.list_channels().is_empty());
7286         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
7287         assert!(regex::Regex::new(r"Remote tried to fulfill HTLC \(\d+\) with an incorrect preimage").unwrap().is_match(err_msg.data.as_str()));
7288         check_added_monitors!(nodes[0], 1);
7289 }
7290
7291 #[test]
7292 fn test_update_fulfill_htlc_bolt2_missing_badonion_bit_for_malformed_htlc_message() {
7293         //BOLT 2 Requirement: A receiving node: if the BADONION bit in failure_code is not set for update_fail_malformed_htlc MUST fail the channel.
7294
7295         let chanmon_cfgs = create_chanmon_cfgs(2);
7296         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7297         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7298         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7299         create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
7300         let logger = test_utils::TestLogger::new();
7301
7302         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
7303         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
7304         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[1].node.get_our_node_id(), None, &[], 1000000, TEST_FINAL_CLTV, &logger).unwrap();
7305         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
7306         check_added_monitors!(nodes[0], 1);
7307
7308         let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
7309         updates.update_add_htlcs[0].onion_routing_packet.version = 1; //Produce a malformed HTLC message
7310
7311         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
7312         check_added_monitors!(nodes[1], 0);
7313         commitment_signed_dance!(nodes[1], nodes[0], updates.commitment_signed, false, true);
7314
7315         let events = nodes[1].node.get_and_clear_pending_msg_events();
7316
7317         let mut update_msg: msgs::UpdateFailMalformedHTLC = {
7318                 match events[0] {
7319                         MessageSendEvent::UpdateHTLCs { node_id: _ , updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, ref update_fee, .. } } => {
7320                                 assert!(update_add_htlcs.is_empty());
7321                                 assert!(update_fulfill_htlcs.is_empty());
7322                                 assert!(update_fail_htlcs.is_empty());
7323                                 assert_eq!(update_fail_malformed_htlcs.len(), 1);
7324                                 assert!(update_fee.is_none());
7325                                 update_fail_malformed_htlcs[0].clone()
7326                         },
7327                         _ => panic!("Unexpected event"),
7328                 }
7329         };
7330         update_msg.failure_code &= !0x8000;
7331         nodes[0].node.handle_update_fail_malformed_htlc(&nodes[1].node.get_our_node_id(), &update_msg);
7332
7333         assert!(nodes[0].node.list_channels().is_empty());
7334         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
7335         assert_eq!(err_msg.data, "Got update_fail_malformed_htlc with BADONION not set");
7336         check_added_monitors!(nodes[0], 1);
7337 }
7338
7339 #[test]
7340 fn test_update_fulfill_htlc_bolt2_after_malformed_htlc_message_must_forward_update_fail_htlc() {
7341         //BOLT 2 Requirement: a receiving node which has an outgoing HTLC canceled by update_fail_malformed_htlc:
7342         //    * MUST return an error in the update_fail_htlc sent to the link which originally sent the HTLC, using the failure_code given and setting the data to sha256_of_onion.
7343
7344         let chanmon_cfgs = create_chanmon_cfgs(3);
7345         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
7346         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
7347         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
7348         create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
7349         create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
7350         let logger = test_utils::TestLogger::new();
7351
7352         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
7353
7354         //First hop
7355         let mut payment_event = {
7356                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
7357                 let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, &Vec::new(), 100000, TEST_FINAL_CLTV, &logger).unwrap();
7358                 nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
7359                 check_added_monitors!(nodes[0], 1);
7360                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
7361                 assert_eq!(events.len(), 1);
7362                 SendEvent::from_event(events.remove(0))
7363         };
7364         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
7365         check_added_monitors!(nodes[1], 0);
7366         commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
7367         expect_pending_htlcs_forwardable!(nodes[1]);
7368         let mut events_2 = nodes[1].node.get_and_clear_pending_msg_events();
7369         assert_eq!(events_2.len(), 1);
7370         check_added_monitors!(nodes[1], 1);
7371         payment_event = SendEvent::from_event(events_2.remove(0));
7372         assert_eq!(payment_event.msgs.len(), 1);
7373
7374         //Second Hop
7375         payment_event.msgs[0].onion_routing_packet.version = 1; //Produce a malformed HTLC message
7376         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
7377         check_added_monitors!(nodes[2], 0);
7378         commitment_signed_dance!(nodes[2], nodes[1], payment_event.commitment_msg, false, true);
7379
7380         let events_3 = nodes[2].node.get_and_clear_pending_msg_events();
7381         assert_eq!(events_3.len(), 1);
7382         let update_msg : (msgs::UpdateFailMalformedHTLC, msgs::CommitmentSigned) = {
7383                 match events_3[0] {
7384                         MessageSendEvent::UpdateHTLCs { node_id: _ , updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, ref update_fee, ref commitment_signed } } => {
7385                                 assert!(update_add_htlcs.is_empty());
7386                                 assert!(update_fulfill_htlcs.is_empty());
7387                                 assert!(update_fail_htlcs.is_empty());
7388                                 assert_eq!(update_fail_malformed_htlcs.len(), 1);
7389                                 assert!(update_fee.is_none());
7390                                 (update_fail_malformed_htlcs[0].clone(), commitment_signed.clone())
7391                         },
7392                         _ => panic!("Unexpected event"),
7393                 }
7394         };
7395
7396         nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), &update_msg.0);
7397
7398         check_added_monitors!(nodes[1], 0);
7399         commitment_signed_dance!(nodes[1], nodes[2], update_msg.1, false, true);
7400         expect_pending_htlcs_forwardable!(nodes[1]);
7401         let events_4 = nodes[1].node.get_and_clear_pending_msg_events();
7402         assert_eq!(events_4.len(), 1);
7403
7404         //Confirm that handlinge the update_malformed_htlc message produces an update_fail_htlc message to be forwarded back along the route
7405         match events_4[0] {
7406                 MessageSendEvent::UpdateHTLCs { node_id: _ , updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, ref update_fee, .. } } => {
7407                         assert!(update_add_htlcs.is_empty());
7408                         assert!(update_fulfill_htlcs.is_empty());
7409                         assert_eq!(update_fail_htlcs.len(), 1);
7410                         assert!(update_fail_malformed_htlcs.is_empty());
7411                         assert!(update_fee.is_none());
7412                 },
7413                 _ => panic!("Unexpected event"),
7414         };
7415
7416         check_added_monitors!(nodes[1], 1);
7417 }
7418
7419 fn do_test_failure_delay_dust_htlc_local_commitment(announce_latest: bool) {
7420         // Dust-HTLC failure updates must be delayed until failure-trigger tx (in this case local commitment) reach ANTI_REORG_DELAY
7421         // We can have at most two valid local commitment tx, so both cases must be covered, and both txs must be checked to get them all as
7422         // HTLC could have been removed from lastest local commitment tx but still valid until we get remote RAA
7423
7424         let chanmon_cfgs = create_chanmon_cfgs(2);
7425         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7426         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7427         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7428         let chan =create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
7429
7430         let bs_dust_limit = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
7431
7432         // We route 2 dust-HTLCs between A and B
7433         let (_, payment_hash_1) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
7434         let (_, payment_hash_2) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
7435         route_payment(&nodes[0], &[&nodes[1]], 1000000);
7436
7437         // Cache one local commitment tx as previous
7438         let as_prev_commitment_tx = get_local_commitment_txn!(nodes[0], chan.2);
7439
7440         // Fail one HTLC to prune it in the will-be-latest-local commitment tx
7441         assert!(nodes[1].node.fail_htlc_backwards(&payment_hash_2, &None));
7442         check_added_monitors!(nodes[1], 0);
7443         expect_pending_htlcs_forwardable!(nodes[1]);
7444         check_added_monitors!(nodes[1], 1);
7445
7446         let remove = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
7447         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &remove.update_fail_htlcs[0]);
7448         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &remove.commitment_signed);
7449         check_added_monitors!(nodes[0], 1);
7450
7451         // Cache one local commitment tx as lastest
7452         let as_last_commitment_tx = get_local_commitment_txn!(nodes[0], chan.2);
7453
7454         let events = nodes[0].node.get_and_clear_pending_msg_events();
7455         match events[0] {
7456                 MessageSendEvent::SendRevokeAndACK { node_id, .. } => {
7457                         assert_eq!(node_id, nodes[1].node.get_our_node_id());
7458                 },
7459                 _ => panic!("Unexpected event"),
7460         }
7461         match events[1] {
7462                 MessageSendEvent::UpdateHTLCs { node_id, .. } => {
7463                         assert_eq!(node_id, nodes[1].node.get_our_node_id());
7464                 },
7465                 _ => panic!("Unexpected event"),
7466         }
7467
7468         assert_ne!(as_prev_commitment_tx, as_last_commitment_tx);
7469         // Fail the 2 dust-HTLCs, move their failure in maturation buffer (htlc_updated_waiting_threshold_conf)
7470         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7471
7472         if announce_latest {
7473                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![as_last_commitment_tx[0].clone()]}, 1);
7474         } else {
7475                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![as_prev_commitment_tx[0].clone()]}, 1);
7476         }
7477
7478         check_closed_broadcast!(nodes[0], false);
7479         check_added_monitors!(nodes[0], 1);
7480
7481         assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
7482         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 1, true,  header.bitcoin_hash());
7483         let events = nodes[0].node.get_and_clear_pending_events();
7484         // Only 2 PaymentFailed events should show up, over-dust HTLC has to be failed by timeout tx
7485         assert_eq!(events.len(), 2);
7486         let mut first_failed = false;
7487         for event in events {
7488                 match event {
7489                         Event::PaymentFailed { payment_hash, .. } => {
7490                                 if payment_hash == payment_hash_1 {
7491                                         assert!(!first_failed);
7492                                         first_failed = true;
7493                                 } else {
7494                                         assert_eq!(payment_hash, payment_hash_2);
7495                                 }
7496                         }
7497                         _ => panic!("Unexpected event"),
7498                 }
7499         }
7500 }
7501
7502 #[test]
7503 fn test_failure_delay_dust_htlc_local_commitment() {
7504         do_test_failure_delay_dust_htlc_local_commitment(true);
7505         do_test_failure_delay_dust_htlc_local_commitment(false);
7506 }
7507
7508 #[test]
7509 fn test_no_failure_dust_htlc_local_commitment() {
7510         // Transaction filters for failing back dust htlc based on local commitment txn infos has been
7511         // prone to error, we test here that a dummy transaction don't fail them.
7512
7513         let chanmon_cfgs = create_chanmon_cfgs(2);
7514         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7515         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7516         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7517         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
7518
7519         // Rebalance a bit
7520         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
7521
7522         let as_dust_limit = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
7523         let bs_dust_limit = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
7524
7525         // We route 2 dust-HTLCs between A and B
7526         let (preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
7527         let (preimage_2, _) = route_payment(&nodes[1], &[&nodes[0]], as_dust_limit*1000);
7528
7529         // Build a dummy invalid transaction trying to spend a commitment tx
7530         let input = TxIn {
7531                 previous_output: BitcoinOutPoint { txid: chan.3.txid(), vout: 0 },
7532                 script_sig: Script::new(),
7533                 sequence: 0,
7534                 witness: Vec::new(),
7535         };
7536
7537         let outp = TxOut {
7538                 script_pubkey: Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(),
7539                 value: 10000,
7540         };
7541
7542         let dummy_tx = Transaction {
7543                 version: 2,
7544                 lock_time: 0,
7545                 input: vec![input],
7546                 output: vec![outp]
7547         };
7548
7549         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7550         nodes[0].chan_monitor.simple_monitor.block_connected(&header, 1, &[&dummy_tx], &[1;1]);
7551         assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
7552         assert_eq!(nodes[0].node.get_and_clear_pending_msg_events().len(), 0);
7553         // We broadcast a few more block to check everything is all right
7554         connect_blocks(&nodes[0].block_notifier, 20, 1, true,  header.bitcoin_hash());
7555         assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
7556         assert_eq!(nodes[0].node.get_and_clear_pending_msg_events().len(), 0);
7557
7558         claim_payment(&nodes[0], &vec!(&nodes[1])[..], preimage_1, bs_dust_limit*1000);
7559         claim_payment(&nodes[1], &vec!(&nodes[0])[..], preimage_2, as_dust_limit*1000);
7560 }
7561
7562 fn do_test_sweep_outbound_htlc_failure_update(revoked: bool, local: bool) {
7563         // Outbound HTLC-failure updates must be cancelled if we get a reorg before we reach ANTI_REORG_DELAY.
7564         // Broadcast of revoked remote commitment tx, trigger failure-update of dust/non-dust HTLCs
7565         // Broadcast of remote commitment tx, trigger failure-update of dust-HTLCs
7566         // Broadcast of timeout tx on remote commitment tx, trigger failure-udate of non-dust HTLCs
7567         // Broadcast of local commitment tx, trigger failure-update of dust-HTLCs
7568         // Broadcast of HTLC-timeout tx on local commitment tx, trigger failure-update of non-dust HTLCs
7569
7570         let chanmon_cfgs = create_chanmon_cfgs(3);
7571         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
7572         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
7573         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
7574         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
7575
7576         let bs_dust_limit = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
7577
7578         let (_payment_preimage_1, dust_hash) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
7579         let (_payment_preimage_2, non_dust_hash) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
7580
7581         let as_commitment_tx = get_local_commitment_txn!(nodes[0], chan.2);
7582         let bs_commitment_tx = get_local_commitment_txn!(nodes[1], chan.2);
7583
7584         // We revoked bs_commitment_tx
7585         if revoked {
7586                 let (payment_preimage_3, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
7587                 claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3, 1_000_000);
7588         }
7589
7590         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7591         let mut timeout_tx = Vec::new();
7592         if local {
7593                 // We fail dust-HTLC 1 by broadcast of local commitment tx
7594                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![as_commitment_tx[0].clone()]}, 1);
7595                 check_closed_broadcast!(nodes[0], false);
7596                 check_added_monitors!(nodes[0], 1);
7597                 assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
7598                 timeout_tx.push(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap()[0].clone());
7599                 let parent_hash  = connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 2, true, header.bitcoin_hash());
7600                 expect_payment_failed!(nodes[0], dust_hash, true);
7601                 assert_eq!(timeout_tx[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
7602                 // We fail non-dust-HTLC 2 by broadcast of local HTLC-timeout tx on local commitment tx
7603                 let header_2 = BlockHeader { version: 0x20000000, prev_blockhash: parent_hash, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7604                 assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
7605                 nodes[0].block_notifier.block_connected(&Block { header: header_2, txdata: vec![timeout_tx[0].clone()]}, 7);
7606                 let header_3 = BlockHeader { version: 0x20000000, prev_blockhash: header_2.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7607                 connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 8, true, header_3.bitcoin_hash());
7608                 expect_payment_failed!(nodes[0], non_dust_hash, true);
7609         } else {
7610                 // We fail dust-HTLC 1 by broadcast of remote commitment tx. If revoked, fail also non-dust HTLC
7611                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![bs_commitment_tx[0].clone()]}, 1);
7612                 check_closed_broadcast!(nodes[0], false);
7613                 check_added_monitors!(nodes[0], 1);
7614                 assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
7615                 timeout_tx.push(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap()[0].clone());
7616                 let parent_hash  = connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 2, true, header.bitcoin_hash());
7617                 let header_2 = BlockHeader { version: 0x20000000, prev_blockhash: parent_hash, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7618                 if !revoked {
7619                         expect_payment_failed!(nodes[0], dust_hash, true);
7620                         assert_eq!(timeout_tx[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
7621                         // We fail non-dust-HTLC 2 by broadcast of local timeout tx on remote commitment tx
7622                         nodes[0].block_notifier.block_connected(&Block { header: header_2, txdata: vec![timeout_tx[0].clone()]}, 7);
7623                         assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
7624                         let header_3 = BlockHeader { version: 0x20000000, prev_blockhash: header_2.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7625                         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 8, true, header_3.bitcoin_hash());
7626                         expect_payment_failed!(nodes[0], non_dust_hash, true);
7627                 } else {
7628                         // If revoked, both dust & non-dust HTLCs should have been failed after ANTI_REORG_DELAY confs of revoked
7629                         // commitment tx
7630                         let events = nodes[0].node.get_and_clear_pending_events();
7631                         assert_eq!(events.len(), 2);
7632                         let first;
7633                         match events[0] {
7634                                 Event::PaymentFailed { payment_hash, .. } => {
7635                                         if payment_hash == dust_hash { first = true; }
7636                                         else { first = false; }
7637                                 },
7638                                 _ => panic!("Unexpected event"),
7639                         }
7640                         match events[1] {
7641                                 Event::PaymentFailed { payment_hash, .. } => {
7642                                         if first { assert_eq!(payment_hash, non_dust_hash); }
7643                                         else { assert_eq!(payment_hash, dust_hash); }
7644                                 },
7645                                 _ => panic!("Unexpected event"),
7646                         }
7647                 }
7648         }
7649 }
7650
7651 #[test]
7652 fn test_sweep_outbound_htlc_failure_update() {
7653         do_test_sweep_outbound_htlc_failure_update(false, true);
7654         do_test_sweep_outbound_htlc_failure_update(false, false);
7655         do_test_sweep_outbound_htlc_failure_update(true, false);
7656 }
7657
7658 #[test]
7659 fn test_upfront_shutdown_script() {
7660         // BOLT 2 : Option upfront shutdown script, if peer commit its closing_script at channel opening
7661         // enforce it at shutdown message
7662
7663         let mut config = UserConfig::default();
7664         config.channel_options.announced_channel = true;
7665         config.peer_channel_config_limits.force_announced_channel_preference = false;
7666         config.channel_options.commit_upfront_shutdown_pubkey = false;
7667         let user_cfgs = [None, Some(config), None];
7668         let chanmon_cfgs = create_chanmon_cfgs(3);
7669         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
7670         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
7671         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
7672
7673         // We test that in case of peer committing upfront to a script, if it changes at closing, we refuse to sign
7674         let flags = InitFeatures::known();
7675         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1000000, 1000000, flags.clone(), flags.clone());
7676         nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
7677         let mut node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id());
7678         node_0_shutdown.scriptpubkey = Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script().to_p2sh();
7679         // Test we enforce upfront_scriptpbukey if by providing a diffrent one at closing that  we disconnect peer
7680         nodes[2].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
7681     assert!(regex::Regex::new(r"Got shutdown request with a scriptpubkey \([A-Fa-f0-9]+\) which did not match their previous scriptpubkey.").unwrap().is_match(check_closed_broadcast!(nodes[2], true).unwrap().data.as_str()));
7682         check_added_monitors!(nodes[2], 1);
7683
7684         // We test that in case of peer committing upfront to a script, if it doesn't change at closing, we sign
7685         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1000000, 1000000, flags.clone(), flags.clone());
7686         nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
7687         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id());
7688         // We test that in case of peer committing upfront to a script, if it oesn't change at closing, we sign
7689         nodes[2].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
7690         let events = nodes[2].node.get_and_clear_pending_msg_events();
7691         assert_eq!(events.len(), 1);
7692         match events[0] {
7693                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[0].node.get_our_node_id()) }
7694                 _ => panic!("Unexpected event"),
7695         }
7696
7697         // We test that if case of peer non-signaling we don't enforce committed script at channel opening
7698         let flags_no = InitFeatures::known().clear_upfront_shutdown_script();
7699         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, flags_no, flags.clone());
7700         nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
7701         let mut node_1_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
7702         node_1_shutdown.scriptpubkey = Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script().to_p2sh();
7703         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_1_shutdown);
7704         let events = nodes[1].node.get_and_clear_pending_msg_events();
7705         assert_eq!(events.len(), 1);
7706         match events[0] {
7707                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[0].node.get_our_node_id()) }
7708                 _ => panic!("Unexpected event"),
7709         }
7710
7711         // We test that if user opt-out, we provide a zero-length script at channel opening and we are able to close
7712         // channel smoothly, opt-out is from channel initiator here
7713         let chan = create_announced_chan_between_nodes_with_value(&nodes, 1, 0, 1000000, 1000000, flags.clone(), flags.clone());
7714         nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
7715         let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
7716         node_0_shutdown.scriptpubkey = Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script().to_p2sh();
7717         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_0_shutdown);
7718         let events = nodes[0].node.get_and_clear_pending_msg_events();
7719         assert_eq!(events.len(), 1);
7720         match events[0] {
7721                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
7722                 _ => panic!("Unexpected event"),
7723         }
7724
7725         //// We test that if user opt-out, we provide a zero-length script at channel opening and we are able to close
7726         //// channel smoothly
7727         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, flags.clone(), flags.clone());
7728         nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
7729         let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
7730         node_0_shutdown.scriptpubkey = Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script().to_p2sh();
7731         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_0_shutdown);
7732         let events = nodes[0].node.get_and_clear_pending_msg_events();
7733         assert_eq!(events.len(), 2);
7734         match events[0] {
7735                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
7736                 _ => panic!("Unexpected event"),
7737         }
7738         match events[1] {
7739                 MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
7740                 _ => panic!("Unexpected event"),
7741         }
7742 }
7743
7744 #[test]
7745 fn test_user_configurable_csv_delay() {
7746         // We test our channel constructors yield errors when we pass them absurd csv delay
7747
7748         let mut low_our_to_self_config = UserConfig::default();
7749         low_our_to_self_config.own_channel_config.our_to_self_delay = 6;
7750         let mut high_their_to_self_config = UserConfig::default();
7751         high_their_to_self_config.peer_channel_config_limits.their_to_self_delay = 100;
7752         let user_cfgs = [Some(high_their_to_self_config.clone()), None];
7753         let chanmon_cfgs = create_chanmon_cfgs(2);
7754         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7755         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &user_cfgs);
7756         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7757
7758         // We test config.our_to_self > BREAKDOWN_TIMEOUT is enforced in Channel::new_outbound()
7759         let keys_manager: Arc<KeysInterface<ChanKeySigner = EnforcingChannelKeys>> = Arc::new(test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet));
7760         if let Err(error) = Channel::new_outbound(&&test_utils::TestFeeEstimator { sat_per_kw: 253 }, &keys_manager, nodes[1].node.get_our_node_id(), 1000000, 1000000, 0, &low_our_to_self_config) {
7761                 match error {
7762                         APIError::APIMisuseError { err } => { assert!(regex::Regex::new(r"Configured with an unreasonable our_to_self_delay \(\d+\) putting user funds at risks").unwrap().is_match(err.as_str())); },
7763                         _ => panic!("Unexpected event"),
7764                 }
7765         } else { assert!(false) }
7766
7767         // We test config.our_to_self > BREAKDOWN_TIMEOUT is enforced in Channel::new_from_req()
7768         nodes[1].node.create_channel(nodes[0].node.get_our_node_id(), 1000000, 1000000, 42, None).unwrap();
7769         let mut open_channel = get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, nodes[0].node.get_our_node_id());
7770         open_channel.to_self_delay = 200;
7771         if let Err(error) = Channel::new_from_req(&&test_utils::TestFeeEstimator { sat_per_kw: 253 }, &keys_manager, nodes[1].node.get_our_node_id(), InitFeatures::known(), &open_channel, 0, &low_our_to_self_config) {
7772                 match error {
7773                         ChannelError::Close(err) => { assert!(regex::Regex::new(r"Configured with an unreasonable our_to_self_delay \(\d+\) putting user funds at risks").unwrap().is_match(err.as_str()));  },
7774                         _ => panic!("Unexpected event"),
7775                 }
7776         } else { assert!(false); }
7777
7778         // We test msg.to_self_delay <= config.their_to_self_delay is enforced in Chanel::accept_channel()
7779         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 1000000, 1000000, 42, None).unwrap();
7780         nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id()));
7781         let mut accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
7782         accept_channel.to_self_delay = 200;
7783         nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), InitFeatures::known(), &accept_channel);
7784         if let MessageSendEvent::HandleError { ref action, .. } = nodes[0].node.get_and_clear_pending_msg_events()[0] {
7785                 match action {
7786                         &ErrorAction::SendErrorMessage { ref msg } => {
7787                                 assert!(regex::Regex::new(r"They wanted our payments to be delayed by a needlessly long period\. Upper limit: \d+\. Actual: \d+").unwrap().is_match(msg.data.as_str()));
7788                         },
7789                         _ => { assert!(false); }
7790                 }
7791         } else { assert!(false); }
7792
7793         // We test msg.to_self_delay <= config.their_to_self_delay is enforced in Channel::new_from_req()
7794         nodes[1].node.create_channel(nodes[0].node.get_our_node_id(), 1000000, 1000000, 42, None).unwrap();
7795         let mut open_channel = get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, nodes[0].node.get_our_node_id());
7796         open_channel.to_self_delay = 200;
7797         if let Err(error) = Channel::new_from_req(&&test_utils::TestFeeEstimator { sat_per_kw: 253 }, &keys_manager, nodes[1].node.get_our_node_id(), InitFeatures::known(), &open_channel, 0, &high_their_to_self_config) {
7798                 match error {
7799                         ChannelError::Close(err) => { assert!(regex::Regex::new(r"They wanted our payments to be delayed by a needlessly long period\. Upper limit: \d+\. Actual: \d+").unwrap().is_match(err.as_str())); },
7800                         _ => panic!("Unexpected event"),
7801                 }
7802         } else { assert!(false); }
7803 }
7804
7805 #[test]
7806 fn test_data_loss_protect() {
7807         // We want to be sure that :
7808         // * we don't broadcast our Local Commitment Tx in case of fallen behind
7809         // * we close channel in case of detecting other being fallen behind
7810         // * we are able to claim our own outputs thanks to to_remote being static
7811         let keys_manager;
7812         let logger;
7813         let fee_estimator;
7814         let tx_broadcaster;
7815         let chain_monitor;
7816         let monitor;
7817         let node_state_0;
7818         let chanmon_cfgs = create_chanmon_cfgs(2);
7819         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7820         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7821         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7822
7823         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
7824
7825         // Cache node A state before any channel update
7826         let previous_node_state = nodes[0].node.encode();
7827         let mut previous_chan_monitor_state = test_utils::TestVecWriter(Vec::new());
7828         nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter().next().unwrap().1.write_for_disk(&mut previous_chan_monitor_state).unwrap();
7829
7830         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
7831         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
7832
7833         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
7834         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
7835
7836         // Restore node A from previous state
7837         logger = test_utils::TestLogger::with_id(format!("node {}", 0));
7838         let mut chan_monitor = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut ::std::io::Cursor::new(previous_chan_monitor_state.0)).unwrap().1;
7839         chain_monitor = ChainWatchInterfaceUtil::new(Network::Testnet);
7840         tx_broadcaster = test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new())};
7841         fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
7842         keys_manager = test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet);
7843         monitor = test_utils::TestChannelMonitor::new(&chain_monitor, &tx_broadcaster, &logger, &fee_estimator);
7844         node_state_0 = {
7845                 let mut channel_monitors = HashMap::new();
7846                 channel_monitors.insert(OutPoint { txid: chan.3.txid(), index: 0 }, &mut chan_monitor);
7847                 <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut ::std::io::Cursor::new(previous_node_state), ChannelManagerReadArgs {
7848                         keys_manager: &keys_manager,
7849                         fee_estimator: &fee_estimator,
7850                         monitor: &monitor,
7851                         logger: &logger,
7852                         tx_broadcaster: &tx_broadcaster,
7853                         default_config: UserConfig::default(),
7854                         channel_monitors: &mut channel_monitors,
7855                 }).unwrap().1
7856         };
7857         nodes[0].node = &node_state_0;
7858         assert!(monitor.add_monitor(OutPoint { txid: chan.3.txid(), index: 0 }, chan_monitor).is_ok());
7859         nodes[0].chan_monitor = &monitor;
7860         nodes[0].chain_monitor = &chain_monitor;
7861
7862         nodes[0].block_notifier = BlockNotifier::new(&nodes[0].chain_monitor);
7863         nodes[0].block_notifier.register_listener(&nodes[0].chan_monitor.simple_monitor);
7864         nodes[0].block_notifier.register_listener(nodes[0].node);
7865
7866         check_added_monitors!(nodes[0], 1);
7867
7868         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
7869         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
7870
7871         let reestablish_0 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
7872
7873         // Check we don't broadcast any transactions following learning of per_commitment_point from B
7874         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_0[0]);
7875         check_added_monitors!(nodes[0], 1);
7876
7877         {
7878                 let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
7879                 assert_eq!(node_txn.len(), 0);
7880         }
7881
7882         let mut reestablish_1 = Vec::with_capacity(1);
7883         for msg in nodes[0].node.get_and_clear_pending_msg_events() {
7884                 if let MessageSendEvent::SendChannelReestablish { ref node_id, ref msg } = msg {
7885                         assert_eq!(*node_id, nodes[1].node.get_our_node_id());
7886                         reestablish_1.push(msg.clone());
7887                 } else if let MessageSendEvent::BroadcastChannelUpdate { .. } = msg {
7888                 } else if let MessageSendEvent::HandleError { ref action, .. } = msg {
7889                         match action {
7890                                 &ErrorAction::SendErrorMessage { ref msg } => {
7891                                         assert_eq!(msg.data, "We have fallen behind - we have received proof that if we broadcast remote is going to claim our funds - we can't do any automated broadcasting");
7892                                 },
7893                                 _ => panic!("Unexpected event!"),
7894                         }
7895                 } else {
7896                         panic!("Unexpected event")
7897                 }
7898         }
7899
7900         // Check we close channel detecting A is fallen-behind
7901         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
7902         assert_eq!(check_closed_broadcast!(nodes[1], true).unwrap().data, "Peer attempted to reestablish channel with a very old local commitment transaction");
7903         check_added_monitors!(nodes[1], 1);
7904
7905
7906         // Check A is able to claim to_remote output
7907         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
7908         assert_eq!(node_txn.len(), 1);
7909         check_spends!(node_txn[0], chan.3);
7910         assert_eq!(node_txn[0].output.len(), 2);
7911         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
7912         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone()]}, 0);
7913         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 0, true, header.bitcoin_hash());
7914         let spend_txn = check_spendable_outputs!(nodes[0], 1, node_cfgs[0].keys_manager, 100000);
7915         assert_eq!(spend_txn.len(), 1);
7916         check_spends!(spend_txn[0], node_txn[0]);
7917 }
7918
7919 #[test]
7920 fn test_check_htlc_underpaying() {
7921         // Send payment through A -> B but A is maliciously
7922         // sending a probe payment (i.e less than expected value0
7923         // to B, B should refuse payment.
7924
7925         let chanmon_cfgs = create_chanmon_cfgs(2);
7926         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7927         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7928         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7929
7930         // Create some initial channels
7931         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
7932
7933         let (payment_preimage, payment_hash) = route_payment(&nodes[0], &[&nodes[1]], 10_000);
7934
7935         // Node 3 is expecting payment of 100_000 but receive 10_000,
7936         // fail htlc like we didn't know the preimage.
7937         nodes[1].node.claim_funds(payment_preimage, &None, 100_000);
7938         nodes[1].node.process_pending_htlc_forwards();
7939
7940         let events = nodes[1].node.get_and_clear_pending_msg_events();
7941         assert_eq!(events.len(), 1);
7942         let (update_fail_htlc, commitment_signed) = match events[0] {
7943                 MessageSendEvent::UpdateHTLCs { node_id: _ , updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fulfill_htlcs, ref update_fail_htlcs, ref update_fail_malformed_htlcs, ref update_fee, ref commitment_signed } } => {
7944                         assert!(update_add_htlcs.is_empty());
7945                         assert!(update_fulfill_htlcs.is_empty());
7946                         assert_eq!(update_fail_htlcs.len(), 1);
7947                         assert!(update_fail_malformed_htlcs.is_empty());
7948                         assert!(update_fee.is_none());
7949                         (update_fail_htlcs[0].clone(), commitment_signed)
7950                 },
7951                 _ => panic!("Unexpected event"),
7952         };
7953         check_added_monitors!(nodes[1], 1);
7954
7955         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlc);
7956         commitment_signed_dance!(nodes[0], nodes[1], commitment_signed, false, true);
7957
7958         // 10_000 msat as u64, followed by a height of 99 as u32
7959         let mut expected_failure_data = byte_utils::be64_to_array(10_000).to_vec();
7960         expected_failure_data.extend_from_slice(&byte_utils::be32_to_array(99));
7961         expect_payment_failed!(nodes[0], payment_hash, true, 0x4000|15, &expected_failure_data[..]);
7962         nodes[1].node.get_and_clear_pending_events();
7963 }
7964
7965 #[test]
7966 fn test_announce_disable_channels() {
7967         // Create 2 channels between A and B. Disconnect B. Call timer_chan_freshness_every_min and check for generated
7968         // ChannelUpdate. Reconnect B, reestablish and check there is non-generated ChannelUpdate.
7969
7970         let chanmon_cfgs = create_chanmon_cfgs(2);
7971         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7972         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7973         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7974
7975         let short_id_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
7976         let short_id_2 = create_announced_chan_between_nodes(&nodes, 1, 0, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
7977         let short_id_3 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
7978
7979         // Disconnect peers
7980         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
7981         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
7982
7983         nodes[0].node.timer_chan_freshness_every_min(); // dirty -> stagged
7984         nodes[0].node.timer_chan_freshness_every_min(); // staged -> fresh
7985         let msg_events = nodes[0].node.get_and_clear_pending_msg_events();
7986         assert_eq!(msg_events.len(), 3);
7987         for e in msg_events {
7988                 match e {
7989                         MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
7990                                 let short_id = msg.contents.short_channel_id;
7991                                 // Check generated channel_update match list in PendingChannelUpdate
7992                                 if short_id != short_id_1 && short_id != short_id_2 && short_id != short_id_3 {
7993                                         panic!("Generated ChannelUpdate for wrong chan!");
7994                                 }
7995                         },
7996                         _ => panic!("Unexpected event"),
7997                 }
7998         }
7999         // Reconnect peers
8000         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
8001         let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
8002         assert_eq!(reestablish_1.len(), 3);
8003         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
8004         let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
8005         assert_eq!(reestablish_2.len(), 3);
8006
8007         // Reestablish chan_1
8008         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
8009         handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
8010         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
8011         handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
8012         // Reestablish chan_2
8013         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[1]);
8014         handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
8015         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[1]);
8016         handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
8017         // Reestablish chan_3
8018         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[2]);
8019         handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
8020         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[2]);
8021         handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
8022
8023         nodes[0].node.timer_chan_freshness_every_min();
8024         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
8025 }
8026
8027 #[test]
8028 fn test_bump_penalty_txn_on_revoked_commitment() {
8029         // In case of penalty txn with too low feerates for getting into mempools, RBF-bump them to be sure
8030         // we're able to claim outputs on revoked commitment transaction before timelocks expiration
8031
8032         let chanmon_cfgs = create_chanmon_cfgs(2);
8033         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8034         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
8035         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8036
8037         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known());
8038         let logger = test_utils::TestLogger::new();
8039
8040
8041         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
8042         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
8043         let route = get_route(&nodes[1].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[0].node.get_our_node_id(), None, &Vec::new(), 3000000, 30, &logger).unwrap();
8044         send_along_route(&nodes[1], route, &vec!(&nodes[0])[..], 3000000);
8045
8046         let revoked_txn = get_local_commitment_txn!(nodes[0], chan.2);
8047         // Revoked commitment txn with 4 outputs : to_local, to_remote, 1 outgoing HTLC, 1 incoming HTLC
8048         assert_eq!(revoked_txn[0].output.len(), 4);
8049         assert_eq!(revoked_txn[0].input.len(), 1);
8050         assert_eq!(revoked_txn[0].input[0].previous_output.txid, chan.3.txid());
8051         let revoked_txid = revoked_txn[0].txid();
8052
8053         let mut penalty_sum = 0;
8054         for outp in revoked_txn[0].output.iter() {
8055                 if outp.script_pubkey.is_v0_p2wsh() {
8056                         penalty_sum += outp.value;
8057                 }
8058         }
8059
8060         // Connect blocks to change height_timer range to see if we use right soonest_timelock
8061         let header_114 = connect_blocks(&nodes[1].block_notifier, 114, 0, false, Default::default());
8062
8063         // Actually revoke tx by claiming a HTLC
8064         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
8065         let header = BlockHeader { version: 0x20000000, prev_blockhash: header_114, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8066         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_txn[0].clone()] }, 115);
8067         check_added_monitors!(nodes[1], 1);
8068
8069         // One or more justice tx should have been broadcast, check it
8070         let penalty_1;
8071         let feerate_1;
8072         {
8073                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
8074                 assert_eq!(node_txn.len(), 3); // justice tx (broadcasted from ChannelMonitor) + local commitment tx + local HTLC-timeout (broadcasted from ChannelManager)
8075                 assert_eq!(node_txn[0].input.len(), 3); // Penalty txn claims to_local, offered_htlc and received_htlc outputs
8076                 assert_eq!(node_txn[0].output.len(), 1);
8077                 check_spends!(node_txn[0], revoked_txn[0]);
8078                 let fee_1 = penalty_sum - node_txn[0].output[0].value;
8079                 feerate_1 = fee_1 * 1000 / node_txn[0].get_weight() as u64;
8080                 penalty_1 = node_txn[0].txid();
8081                 node_txn.clear();
8082         };
8083
8084         // After exhaustion of height timer, a new bumped justice tx should have been broadcast, check it
8085         let header = connect_blocks(&nodes[1].block_notifier, 3, 115,  true, header.bitcoin_hash());
8086         let mut penalty_2 = penalty_1;
8087         let mut feerate_2 = 0;
8088         {
8089                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
8090                 assert_eq!(node_txn.len(), 1);
8091                 if node_txn[0].input[0].previous_output.txid == revoked_txid {
8092                         assert_eq!(node_txn[0].input.len(), 3); // Penalty txn claims to_local, offered_htlc and received_htlc outputs
8093                         assert_eq!(node_txn[0].output.len(), 1);
8094                         check_spends!(node_txn[0], revoked_txn[0]);
8095                         penalty_2 = node_txn[0].txid();
8096                         // Verify new bumped tx is different from last claiming transaction, we don't want spurrious rebroadcast
8097                         assert_ne!(penalty_2, penalty_1);
8098                         let fee_2 = penalty_sum - node_txn[0].output[0].value;
8099                         feerate_2 = fee_2 * 1000 / node_txn[0].get_weight() as u64;
8100                         // Verify 25% bump heuristic
8101                         assert!(feerate_2 * 100 >= feerate_1 * 125);
8102                         node_txn.clear();
8103                 }
8104         }
8105         assert_ne!(feerate_2, 0);
8106
8107         // After exhaustion of height timer for a 2nd time, a new bumped justice tx should have been broadcast, check it
8108         connect_blocks(&nodes[1].block_notifier, 3, 118, true, header);
8109         let penalty_3;
8110         let mut feerate_3 = 0;
8111         {
8112                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
8113                 assert_eq!(node_txn.len(), 1);
8114                 if node_txn[0].input[0].previous_output.txid == revoked_txid {
8115                         assert_eq!(node_txn[0].input.len(), 3); // Penalty txn claims to_local, offered_htlc and received_htlc outputs
8116                         assert_eq!(node_txn[0].output.len(), 1);
8117                         check_spends!(node_txn[0], revoked_txn[0]);
8118                         penalty_3 = node_txn[0].txid();
8119                         // Verify new bumped tx is different from last claiming transaction, we don't want spurrious rebroadcast
8120                         assert_ne!(penalty_3, penalty_2);
8121                         let fee_3 = penalty_sum - node_txn[0].output[0].value;
8122                         feerate_3 = fee_3 * 1000 / node_txn[0].get_weight() as u64;
8123                         // Verify 25% bump heuristic
8124                         assert!(feerate_3 * 100 >= feerate_2 * 125);
8125                         node_txn.clear();
8126                 }
8127         }
8128         assert_ne!(feerate_3, 0);
8129
8130         nodes[1].node.get_and_clear_pending_events();
8131         nodes[1].node.get_and_clear_pending_msg_events();
8132 }
8133
8134 #[test]
8135 fn test_bump_penalty_txn_on_revoked_htlcs() {
8136         // In case of penalty txn with too low feerates for getting into mempools, RBF-bump them to sure
8137         // we're able to claim outputs on revoked HTLC transactions before timelocks expiration
8138
8139         let chanmon_cfgs = create_chanmon_cfgs(2);
8140         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8141         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
8142         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8143
8144         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known());
8145         // Lock HTLC in both directions
8146         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3_000_000).0;
8147         route_payment(&nodes[1], &vec!(&nodes[0])[..], 3_000_000).0;
8148
8149         let revoked_local_txn = get_local_commitment_txn!(nodes[1], chan.2);
8150         assert_eq!(revoked_local_txn[0].input.len(), 1);
8151         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid());
8152
8153         // Revoke local commitment tx
8154         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
8155
8156         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8157         // B will generate both revoked HTLC-timeout/HTLC-preimage txn from revoked commitment tx
8158         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
8159         check_closed_broadcast!(nodes[1], false);
8160         check_added_monitors!(nodes[1], 1);
8161
8162         let revoked_htlc_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
8163         assert_eq!(revoked_htlc_txn.len(), 4);
8164         if revoked_htlc_txn[0].input[0].witness.last().unwrap().len() == ACCEPTED_HTLC_SCRIPT_WEIGHT {
8165                 assert_eq!(revoked_htlc_txn[0].input.len(), 1);
8166                 check_spends!(revoked_htlc_txn[0], revoked_local_txn[0]);
8167                 assert_eq!(revoked_htlc_txn[1].input.len(), 1);
8168                 assert_eq!(revoked_htlc_txn[1].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
8169                 check_spends!(revoked_htlc_txn[1], revoked_local_txn[0]);
8170         } else if revoked_htlc_txn[1].input[0].witness.last().unwrap().len() == ACCEPTED_HTLC_SCRIPT_WEIGHT {
8171                 assert_eq!(revoked_htlc_txn[1].input.len(), 1);
8172                 check_spends!(revoked_htlc_txn[1], revoked_local_txn[0]);
8173                 assert_eq!(revoked_htlc_txn[0].input.len(), 1);
8174                 assert_eq!(revoked_htlc_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
8175                 check_spends!(revoked_htlc_txn[0], revoked_local_txn[0]);
8176         }
8177
8178         // Broadcast set of revoked txn on A
8179         let header_128 = connect_blocks(&nodes[0].block_notifier, 128, 0, true, header.bitcoin_hash());
8180         expect_pending_htlcs_forwardable_ignore!(nodes[0]);
8181
8182         let header_129 = BlockHeader { version: 0x20000000, prev_blockhash: header_128, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8183         nodes[0].block_notifier.block_connected(&Block { header: header_129, txdata: vec![revoked_local_txn[0].clone(), revoked_htlc_txn[0].clone(), revoked_htlc_txn[1].clone()] }, 129);
8184         let first;
8185         let feerate_1;
8186         let penalty_txn;
8187         {
8188                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
8189                 assert_eq!(node_txn.len(), 5); // 3 penalty txn on revoked commitment tx + A commitment tx + 1 penalty tnx on revoked HTLC txn
8190                 // Verify claim tx are spending revoked HTLC txn
8191                 assert_eq!(node_txn[4].input.len(), 2);
8192                 assert_eq!(node_txn[4].output.len(), 1);
8193                 check_spends!(node_txn[4], revoked_htlc_txn[0], revoked_htlc_txn[1]);
8194                 first = node_txn[4].txid();
8195                 // Store both feerates for later comparison
8196                 let fee_1 = revoked_htlc_txn[0].output[0].value + revoked_htlc_txn[1].output[0].value - node_txn[4].output[0].value;
8197                 feerate_1 = fee_1 * 1000 / node_txn[4].get_weight() as u64;
8198                 penalty_txn = vec![node_txn[0].clone(), node_txn[1].clone(), node_txn[2].clone()];
8199                 node_txn.clear();
8200         }
8201
8202         // Connect three more block to see if bumped penalty are issued for HTLC txn
8203         let header_130 = BlockHeader { version: 0x20000000, prev_blockhash: header_129.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8204         nodes[0].block_notifier.block_connected(&Block { header: header_130, txdata: penalty_txn }, 130);
8205         {
8206                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
8207                 assert_eq!(node_txn.len(), 2); // 2 bumped penalty txn on revoked commitment tx
8208
8209                 check_spends!(node_txn[0], revoked_local_txn[0]);
8210                 check_spends!(node_txn[1], revoked_local_txn[0]);
8211
8212                 node_txn.clear();
8213         };
8214
8215         // Few more blocks to confirm penalty txn
8216         let header_135 = connect_blocks(&nodes[0].block_notifier, 5, 130, true, header_130.bitcoin_hash());
8217         assert!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().is_empty());
8218         let header_144 = connect_blocks(&nodes[0].block_notifier, 9, 135, true, header_135);
8219         let node_txn = {
8220                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
8221                 assert_eq!(node_txn.len(), 1);
8222
8223                 assert_eq!(node_txn[0].input.len(), 2);
8224                 check_spends!(node_txn[0], revoked_htlc_txn[0], revoked_htlc_txn[1]);
8225                 // Verify bumped tx is different and 25% bump heuristic
8226                 assert_ne!(first, node_txn[0].txid());
8227                 let fee_2 = revoked_htlc_txn[0].output[0].value + revoked_htlc_txn[1].output[0].value - node_txn[0].output[0].value;
8228                 let feerate_2 = fee_2 * 1000 / node_txn[0].get_weight() as u64;
8229                 assert!(feerate_2 * 100 > feerate_1 * 125);
8230                 let txn = vec![node_txn[0].clone()];
8231                 node_txn.clear();
8232                 txn
8233         };
8234         // Broadcast claim txn and confirm blocks to avoid further bumps on this outputs
8235         let header_145 = BlockHeader { version: 0x20000000, prev_blockhash: header_144, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8236         nodes[0].block_notifier.block_connected(&Block { header: header_145, txdata: node_txn }, 145);
8237         connect_blocks(&nodes[0].block_notifier, 20, 145, true, header_145.bitcoin_hash());
8238         {
8239                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
8240                 // We verify than no new transaction has been broadcast because previously
8241                 // we were buggy on this exact behavior by not tracking for monitoring remote HTLC outputs (see #411)
8242                 // which means we wouldn't see a spend of them by a justice tx and bumped justice tx
8243                 // were generated forever instead of safe cleaning after confirmation and ANTI_REORG_SAFE_DELAY blocks.
8244                 // Enforce spending of revoked htlc output by claiming transaction remove request as expected and dry
8245                 // up bumped justice generation.
8246                 assert_eq!(node_txn.len(), 0);
8247                 node_txn.clear();
8248         }
8249         check_closed_broadcast!(nodes[0], false);
8250         check_added_monitors!(nodes[0], 1);
8251 }
8252
8253 #[test]
8254 fn test_bump_penalty_txn_on_remote_commitment() {
8255         // In case of claim txn with too low feerates for getting into mempools, RBF-bump them to be sure
8256         // we're able to claim outputs on remote commitment transaction before timelocks expiration
8257
8258         // Create 2 HTLCs
8259         // Provide preimage for one
8260         // Check aggregation
8261
8262         let chanmon_cfgs = create_chanmon_cfgs(2);
8263         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8264         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
8265         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8266
8267         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known());
8268         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
8269         route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000).0;
8270
8271         // Remote commitment txn with 4 outputs : to_local, to_remote, 1 outgoing HTLC, 1 incoming HTLC
8272         let remote_txn = get_local_commitment_txn!(nodes[0], chan.2);
8273         assert_eq!(remote_txn[0].output.len(), 4);
8274         assert_eq!(remote_txn[0].input.len(), 1);
8275         assert_eq!(remote_txn[0].input[0].previous_output.txid, chan.3.txid());
8276
8277         // Claim a HTLC without revocation (provide B monitor with preimage)
8278         nodes[1].node.claim_funds(payment_preimage, &None, 3_000_000);
8279         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8280         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![remote_txn[0].clone()] }, 1);
8281         check_added_monitors!(nodes[1], 2);
8282
8283         // One or more claim tx should have been broadcast, check it
8284         let timeout;
8285         let preimage;
8286         let feerate_timeout;
8287         let feerate_preimage;
8288         {
8289                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
8290                 assert_eq!(node_txn.len(), 5); // 2 * claim tx (broadcasted from ChannelMonitor) + local commitment tx + local HTLC-timeout + local HTLC-success (broadcasted from ChannelManager)
8291                 assert_eq!(node_txn[0].input.len(), 1);
8292                 assert_eq!(node_txn[1].input.len(), 1);
8293                 check_spends!(node_txn[0], remote_txn[0]);
8294                 check_spends!(node_txn[1], remote_txn[0]);
8295                 check_spends!(node_txn[2], chan.3);
8296                 check_spends!(node_txn[3], node_txn[2]);
8297                 check_spends!(node_txn[4], node_txn[2]);
8298                 if node_txn[0].input[0].witness.last().unwrap().len() == ACCEPTED_HTLC_SCRIPT_WEIGHT {
8299                         timeout = node_txn[0].txid();
8300                         let index = node_txn[0].input[0].previous_output.vout;
8301                         let fee = remote_txn[0].output[index as usize].value - node_txn[0].output[0].value;
8302                         feerate_timeout = fee * 1000 / node_txn[0].get_weight() as u64;
8303
8304                         preimage = node_txn[1].txid();
8305                         let index = node_txn[1].input[0].previous_output.vout;
8306                         let fee = remote_txn[0].output[index as usize].value - node_txn[1].output[0].value;
8307                         feerate_preimage = fee * 1000 / node_txn[1].get_weight() as u64;
8308                 } else {
8309                         timeout = node_txn[1].txid();
8310                         let index = node_txn[1].input[0].previous_output.vout;
8311                         let fee = remote_txn[0].output[index as usize].value - node_txn[1].output[0].value;
8312                         feerate_timeout = fee * 1000 / node_txn[1].get_weight() as u64;
8313
8314                         preimage = node_txn[0].txid();
8315                         let index = node_txn[0].input[0].previous_output.vout;
8316                         let fee = remote_txn[0].output[index as usize].value - node_txn[0].output[0].value;
8317                         feerate_preimage = fee * 1000 / node_txn[0].get_weight() as u64;
8318                 }
8319                 node_txn.clear();
8320         };
8321         assert_ne!(feerate_timeout, 0);
8322         assert_ne!(feerate_preimage, 0);
8323
8324         // After exhaustion of height timer, new bumped claim txn should have been broadcast, check it
8325         connect_blocks(&nodes[1].block_notifier, 15, 1,  true, header.bitcoin_hash());
8326         {
8327                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
8328                 assert_eq!(node_txn.len(), 2);
8329                 assert_eq!(node_txn[0].input.len(), 1);
8330                 assert_eq!(node_txn[1].input.len(), 1);
8331                 check_spends!(node_txn[0], remote_txn[0]);
8332                 check_spends!(node_txn[1], remote_txn[0]);
8333                 if node_txn[0].input[0].witness.last().unwrap().len() == ACCEPTED_HTLC_SCRIPT_WEIGHT {
8334                         let index = node_txn[0].input[0].previous_output.vout;
8335                         let fee = remote_txn[0].output[index as usize].value - node_txn[0].output[0].value;
8336                         let new_feerate = fee * 1000 / node_txn[0].get_weight() as u64;
8337                         assert!(new_feerate * 100 > feerate_timeout * 125);
8338                         assert_ne!(timeout, node_txn[0].txid());
8339
8340                         let index = node_txn[1].input[0].previous_output.vout;
8341                         let fee = remote_txn[0].output[index as usize].value - node_txn[1].output[0].value;
8342                         let new_feerate = fee * 1000 / node_txn[1].get_weight() as u64;
8343                         assert!(new_feerate * 100 > feerate_preimage * 125);
8344                         assert_ne!(preimage, node_txn[1].txid());
8345                 } else {
8346                         let index = node_txn[1].input[0].previous_output.vout;
8347                         let fee = remote_txn[0].output[index as usize].value - node_txn[1].output[0].value;
8348                         let new_feerate = fee * 1000 / node_txn[1].get_weight() as u64;
8349                         assert!(new_feerate * 100 > feerate_timeout * 125);
8350                         assert_ne!(timeout, node_txn[1].txid());
8351
8352                         let index = node_txn[0].input[0].previous_output.vout;
8353                         let fee = remote_txn[0].output[index as usize].value - node_txn[0].output[0].value;
8354                         let new_feerate = fee * 1000 / node_txn[0].get_weight() as u64;
8355                         assert!(new_feerate * 100 > feerate_preimage * 125);
8356                         assert_ne!(preimage, node_txn[0].txid());
8357                 }
8358                 node_txn.clear();
8359         }
8360
8361         nodes[1].node.get_and_clear_pending_events();
8362         nodes[1].node.get_and_clear_pending_msg_events();
8363 }
8364
8365 #[test]
8366 fn test_set_outpoints_partial_claiming() {
8367         // - remote party claim tx, new bump tx
8368         // - disconnect remote claiming tx, new bump
8369         // - disconnect tx, see no tx anymore
8370         let chanmon_cfgs = create_chanmon_cfgs(2);
8371         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8372         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
8373         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8374
8375         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known());
8376         let payment_preimage_1 = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3_000_000).0;
8377         let payment_preimage_2 = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3_000_000).0;
8378
8379         // Remote commitment txn with 4 outputs: to_local, to_remote, 2 outgoing HTLC
8380         let remote_txn = get_local_commitment_txn!(nodes[1], chan.2);
8381         assert_eq!(remote_txn.len(), 3);
8382         assert_eq!(remote_txn[0].output.len(), 4);
8383         assert_eq!(remote_txn[0].input.len(), 1);
8384         assert_eq!(remote_txn[0].input[0].previous_output.txid, chan.3.txid());
8385         check_spends!(remote_txn[1], remote_txn[0]);
8386         check_spends!(remote_txn[2], remote_txn[0]);
8387
8388         // Connect blocks on node A to advance height towards TEST_FINAL_CLTV
8389         let prev_header_100 = connect_blocks(&nodes[1].block_notifier, 100, 0, false, Default::default());
8390         // Provide node A with both preimage
8391         nodes[0].node.claim_funds(payment_preimage_1, &None, 3_000_000);
8392         nodes[0].node.claim_funds(payment_preimage_2, &None, 3_000_000);
8393         check_added_monitors!(nodes[0], 2);
8394         nodes[0].node.get_and_clear_pending_events();
8395         nodes[0].node.get_and_clear_pending_msg_events();
8396
8397         // Connect blocks on node A commitment transaction
8398         let header = BlockHeader { version: 0x20000000, prev_blockhash: prev_header_100, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8399         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![remote_txn[0].clone()] }, 101);
8400         check_closed_broadcast!(nodes[0], false);
8401         check_added_monitors!(nodes[0], 1);
8402         // Verify node A broadcast tx claiming both HTLCs
8403         {
8404                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
8405                 // ChannelMonitor: claim tx, ChannelManager: local commitment tx + HTLC-Success*2
8406                 assert_eq!(node_txn.len(), 4);
8407                 check_spends!(node_txn[0], remote_txn[0]);
8408                 check_spends!(node_txn[1], chan.3);
8409                 check_spends!(node_txn[2], node_txn[1]);
8410                 check_spends!(node_txn[3], node_txn[1]);
8411                 assert_eq!(node_txn[0].input.len(), 2);
8412                 node_txn.clear();
8413         }
8414
8415         // Connect blocks on node B
8416         connect_blocks(&nodes[1].block_notifier, 135, 0, false, Default::default());
8417         check_closed_broadcast!(nodes[1], false);
8418         check_added_monitors!(nodes[1], 1);
8419         // Verify node B broadcast 2 HTLC-timeout txn
8420         let partial_claim_tx = {
8421                 let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
8422                 assert_eq!(node_txn.len(), 3);
8423                 check_spends!(node_txn[1], node_txn[0]);
8424                 check_spends!(node_txn[2], node_txn[0]);
8425                 assert_eq!(node_txn[1].input.len(), 1);
8426                 assert_eq!(node_txn[2].input.len(), 1);
8427                 node_txn[1].clone()
8428         };
8429
8430         // Broadcast partial claim on node A, should regenerate a claiming tx with HTLC dropped
8431         let header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8432         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![partial_claim_tx.clone()] }, 102);
8433         {
8434                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
8435                 assert_eq!(node_txn.len(), 1);
8436                 check_spends!(node_txn[0], remote_txn[0]);
8437                 assert_eq!(node_txn[0].input.len(), 1); //dropped HTLC
8438                 node_txn.clear();
8439         }
8440         nodes[0].node.get_and_clear_pending_msg_events();
8441
8442         // Disconnect last block on node A, should regenerate a claiming tx with HTLC dropped
8443         nodes[0].block_notifier.block_disconnected(&header, 102);
8444         {
8445                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
8446                 assert_eq!(node_txn.len(), 1);
8447                 check_spends!(node_txn[0], remote_txn[0]);
8448                 assert_eq!(node_txn[0].input.len(), 2); //resurrected HTLC
8449                 node_txn.clear();
8450         }
8451
8452         //// Disconnect one more block and then reconnect multiple no transaction should be generated
8453         nodes[0].block_notifier.block_disconnected(&header, 101);
8454         connect_blocks(&nodes[1].block_notifier, 15, 101, false, prev_header_100);
8455         {
8456                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
8457                 assert_eq!(node_txn.len(), 0);
8458                 node_txn.clear();
8459         }
8460 }
8461
8462 #[test]
8463 fn test_counterparty_raa_skip_no_crash() {
8464         // Previously, if our counterparty sent two RAAs in a row without us having provided a
8465         // commitment transaction, we would have happily carried on and provided them the next
8466         // commitment transaction based on one RAA forward. This would probably eventually have led to
8467         // channel closure, but it would not have resulted in funds loss. Still, our
8468         // EnforcingChannelKeys would have paniced as it doesn't like jumps into the future. Here, we
8469         // check simply that the channel is closed in response to such an RAA, but don't check whether
8470         // we decide to punish our counterparty for revoking their funds (as we don't currently
8471         // implement that).
8472         let chanmon_cfgs = create_chanmon_cfgs(2);
8473         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8474         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
8475         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8476         let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).2;
8477
8478         let mut guard = nodes[0].node.channel_state.lock().unwrap();
8479         let local_keys = &guard.by_id.get_mut(&channel_id).unwrap().local_keys;
8480         const INITIAL_COMMITMENT_NUMBER: u64 = (1 << 48) - 1;
8481         let next_per_commitment_point = PublicKey::from_secret_key(&Secp256k1::new(),
8482                 &SecretKey::from_slice(&local_keys.release_commitment_secret(INITIAL_COMMITMENT_NUMBER - 2)).unwrap());
8483         let per_commitment_secret = local_keys.release_commitment_secret(INITIAL_COMMITMENT_NUMBER);
8484
8485         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(),
8486                 &msgs::RevokeAndACK { channel_id, per_commitment_secret, next_per_commitment_point });
8487         assert_eq!(check_closed_broadcast!(nodes[1], true).unwrap().data, "Received an unexpected revoke_and_ack");
8488         check_added_monitors!(nodes[1], 1);
8489 }
8490
8491 #[test]
8492 fn test_bump_txn_sanitize_tracking_maps() {
8493         // Sanitizing pendning_claim_request and claimable_outpoints used to be buggy,
8494         // verify we clean then right after expiration of ANTI_REORG_DELAY.
8495
8496         let chanmon_cfgs = create_chanmon_cfgs(2);
8497         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8498         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
8499         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8500
8501         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known());
8502         // Lock HTLC in both directions
8503         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9_000_000).0;
8504         route_payment(&nodes[1], &vec!(&nodes[0])[..], 9_000_000).0;
8505
8506         let revoked_local_txn = get_local_commitment_txn!(nodes[1], chan.2);
8507         assert_eq!(revoked_local_txn[0].input.len(), 1);
8508         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid());
8509
8510         // Revoke local commitment tx
8511         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 9_000_000);
8512
8513         // Broadcast set of revoked txn on A
8514         let header_128 = connect_blocks(&nodes[0].block_notifier, 128, 0,  false, Default::default());
8515         expect_pending_htlcs_forwardable_ignore!(nodes[0]);
8516
8517         let header_129 = BlockHeader { version: 0x20000000, prev_blockhash: header_128, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8518         nodes[0].block_notifier.block_connected(&Block { header: header_129, txdata: vec![revoked_local_txn[0].clone()] }, 129);
8519         check_closed_broadcast!(nodes[0], false);
8520         check_added_monitors!(nodes[0], 1);
8521         let penalty_txn = {
8522                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
8523                 assert_eq!(node_txn.len(), 4); //ChannelMonitor: justice txn * 3, ChannelManager: local commitment tx
8524                 check_spends!(node_txn[0], revoked_local_txn[0]);
8525                 check_spends!(node_txn[1], revoked_local_txn[0]);
8526                 check_spends!(node_txn[2], revoked_local_txn[0]);
8527                 let penalty_txn = vec![node_txn[0].clone(), node_txn[1].clone(), node_txn[2].clone()];
8528                 node_txn.clear();
8529                 penalty_txn
8530         };
8531         let header_130 = BlockHeader { version: 0x20000000, prev_blockhash: header_129.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8532         nodes[0].block_notifier.block_connected(&Block { header: header_130, txdata: penalty_txn }, 130);
8533         connect_blocks(&nodes[0].block_notifier, 5, 130,  false, header_130.bitcoin_hash());
8534         {
8535                 let monitors = nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap();
8536                 if let Some(monitor) = monitors.get(&OutPoint { txid: chan.3.txid(), index: 0 }) {
8537                         assert!(monitor.onchain_tx_handler.pending_claim_requests.is_empty());
8538                         assert!(monitor.onchain_tx_handler.claimable_outpoints.is_empty());
8539                 }
8540         }
8541 }
8542
8543 #[test]
8544 fn test_override_channel_config() {
8545         let chanmon_cfgs = create_chanmon_cfgs(2);
8546         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8547         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
8548         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8549
8550         // Node0 initiates a channel to node1 using the override config.
8551         let mut override_config = UserConfig::default();
8552         override_config.own_channel_config.our_to_self_delay = 200;
8553
8554         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 16_000_000, 12_000_000, 42, Some(override_config)).unwrap();
8555
8556         // Assert the channel created by node0 is using the override config.
8557         let res = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
8558         assert_eq!(res.channel_flags, 0);
8559         assert_eq!(res.to_self_delay, 200);
8560 }
8561
8562 #[test]
8563 fn test_override_0msat_htlc_minimum() {
8564         let mut zero_config = UserConfig::default();
8565         zero_config.own_channel_config.our_htlc_minimum_msat = 0;
8566         let chanmon_cfgs = create_chanmon_cfgs(2);
8567         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8568         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(zero_config.clone())]);
8569         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8570
8571         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 16_000_000, 12_000_000, 42, Some(zero_config)).unwrap();
8572         let res = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
8573         assert_eq!(res.htlc_minimum_msat, 1);
8574
8575         nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &res);
8576         let res = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
8577         assert_eq!(res.htlc_minimum_msat, 1);
8578 }
8579
8580 #[test]
8581 fn test_simple_payment_secret() {
8582         // Simple test of sending a payment with a payment_secret present. This does not use any AMP
8583         // features, however.
8584         let chanmon_cfgs = create_chanmon_cfgs(3);
8585         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
8586         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
8587         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
8588
8589         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
8590         create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
8591         let logger = test_utils::TestLogger::new();
8592
8593         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(&nodes[0]);
8594         let payment_secret = PaymentSecret([0xdb; 32]);
8595         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
8596         let route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[2].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
8597         send_along_route_with_secret(&nodes[0], route, &[&[&nodes[1], &nodes[2]]], 100000, payment_hash, Some(payment_secret.clone()));
8598         // Claiming with all the correct values but the wrong secret should result in nothing...
8599         assert_eq!(nodes[2].node.claim_funds(payment_preimage, &None, 100_000), false);
8600         assert_eq!(nodes[2].node.claim_funds(payment_preimage, &Some(PaymentSecret([42; 32])), 100_000), false);
8601         // ...but with the right secret we should be able to claim all the way back
8602         claim_payment_along_route_with_secret(&nodes[0], &[&[&nodes[1], &nodes[2]]], false, payment_preimage, Some(payment_secret.clone()), 100_000);
8603 }
8604
8605 #[test]
8606 fn test_simple_mpp() {
8607         // Simple test of sending a multi-path payment.
8608         let chanmon_cfgs = create_chanmon_cfgs(4);
8609         let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
8610         let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
8611         let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
8612
8613         let chan_1_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
8614         let chan_2_id = create_announced_chan_between_nodes(&nodes, 0, 2, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
8615         let chan_3_id = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
8616         let chan_4_id = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
8617         let logger = test_utils::TestLogger::new();
8618
8619         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(&nodes[0]);
8620         let payment_secret = PaymentSecret([0xdb; 32]);
8621         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
8622         let mut route = get_route(&nodes[0].node.get_our_node_id(), &net_graph_msg_handler.network_graph.read().unwrap(), &nodes[3].node.get_our_node_id(), None, &[], 100000, TEST_FINAL_CLTV, &logger).unwrap();
8623         let path = route.paths[0].clone();
8624         route.paths.push(path);
8625         route.paths[0][0].pubkey = nodes[1].node.get_our_node_id();
8626         route.paths[0][0].short_channel_id = chan_1_id;
8627         route.paths[0][1].short_channel_id = chan_3_id;
8628         route.paths[1][0].pubkey = nodes[2].node.get_our_node_id();
8629         route.paths[1][0].short_channel_id = chan_2_id;
8630         route.paths[1][1].short_channel_id = chan_4_id;
8631         send_along_route_with_secret(&nodes[0], route, &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]], 200_000, payment_hash, Some(payment_secret.clone()));
8632         // Claiming with all the correct values but the wrong secret should result in nothing...
8633         assert_eq!(nodes[3].node.claim_funds(payment_preimage, &None, 200_000), false);
8634         assert_eq!(nodes[3].node.claim_funds(payment_preimage, &Some(PaymentSecret([42; 32])), 200_000), false);
8635         // ...but with the right secret we should be able to claim all the way back
8636         claim_payment_along_route_with_secret(&nodes[0], &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]], false, payment_preimage, Some(payment_secret), 200_000);
8637 }
8638
8639 #[test]
8640 fn test_update_err_monitor_lockdown() {
8641         // Our monitor will lock update of local commitment transaction if a broadcastion condition
8642         // has been fulfilled (either force-close from Channel or block height requiring a HTLC-
8643         // timeout). Trying to update monitor after lockdown should return a ChannelMonitorUpdateErr.
8644         //
8645         // This scenario may happen in a watchtower setup, where watchtower process a block height
8646         // triggering a timeout while a slow-block-processing ChannelManager receives a local signed
8647         // commitment at same time.
8648
8649         let chanmon_cfgs = create_chanmon_cfgs(2);
8650         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8651         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
8652         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8653
8654         // Create some initial channel
8655         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
8656         let outpoint = OutPoint { txid: chan_1.3.txid(), index: 0 };
8657
8658         // Rebalance the network to generate htlc in the two directions
8659         send_payment(&nodes[0], &vec!(&nodes[1])[..], 10_000_000, 10_000_000);
8660
8661         // Route a HTLC from node 0 to node 1 (but don't settle)
8662         let preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9_000_000).0;
8663
8664         // Copy SimpleManyChannelMonitor to simulate a watchtower and update block height of node 0 until its ChannelMonitor timeout HTLC onchain
8665         let logger = test_utils::TestLogger::with_id(format!("node {}", 0));
8666         let chain_monitor = chaininterface::ChainWatchInterfaceUtil::new(Network::Testnet);
8667         let watchtower = {
8668                 let monitors = nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap();
8669                 let monitor = monitors.get(&outpoint).unwrap();
8670                 let mut w = test_utils::TestVecWriter(Vec::new());
8671                 monitor.write_for_disk(&mut w).unwrap();
8672                 let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor<EnforcingChannelKeys>)>::read(
8673                                 &mut ::std::io::Cursor::new(&w.0)).unwrap().1;
8674                 assert!(new_monitor == *monitor);
8675                 let watchtower = test_utils::TestChannelMonitor::new(&chain_monitor, &chanmon_cfgs[0].tx_broadcaster, &logger, &chanmon_cfgs[0].fee_estimator);
8676                 assert!(watchtower.add_monitor(outpoint, new_monitor).is_ok());
8677                 watchtower
8678         };
8679         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8680         watchtower.simple_monitor.block_connected(&header, 200, &vec![], &vec![]);
8681
8682         // Try to update ChannelMonitor
8683         assert!(nodes[1].node.claim_funds(preimage, &None, 9_000_000));
8684         check_added_monitors!(nodes[1], 1);
8685         let updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
8686         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
8687         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
8688         if let Some(ref mut channel) = nodes[0].node.channel_state.lock().unwrap().by_id.get_mut(&chan_1.2) {
8689                 if let Ok((_, _, _, update)) = channel.commitment_signed(&updates.commitment_signed, &node_cfgs[0].fee_estimator, &node_cfgs[0].logger) {
8690                         if let Err(_) =  watchtower.simple_monitor.update_monitor(outpoint, update.clone()) {} else { assert!(false); }
8691                         if let Ok(_) = nodes[0].chan_monitor.update_monitor(outpoint, update) {} else { assert!(false); }
8692                 } else { assert!(false); }
8693         } else { assert!(false); };
8694         // Our local monitor is in-sync and hasn't processed yet timeout
8695         check_added_monitors!(nodes[0], 1);
8696         let events = nodes[0].node.get_and_clear_pending_events();
8697         assert_eq!(events.len(), 1);
8698 }