_ Git - rust-lightning/blob - lightning/src/ln/functional_tests.rs

   1 //! Tests that test standing up a network of ChannelManagers, creating channels, sending
   2 //! payments/messages between them, and often checking the resulting ChannelMonitors are able to
   3 //! claim outputs on-chain.
   4
   5 use chain::transaction::OutPoint;
   6 use chain::keysinterface::{ChannelKeys, KeysInterface, SpendableOutputDescriptor};
   7 use chain::chaininterface;
   8 use chain::chaininterface::{ChainListener, ChainWatchInterfaceUtil, BlockNotifier};
   9 use ln::channel::{COMMITMENT_TX_BASE_WEIGHT, COMMITMENT_TX_WEIGHT_PER_HTLC};
  10 use ln::channelmanager::{ChannelManager,ChannelManagerReadArgs,HTLCForwardInfo,RAACommitmentOrder, PaymentPreimage, PaymentHash, PaymentSecret, PaymentSendFailure, BREAKDOWN_TIMEOUT};
  11 use ln::channelmonitor::{ChannelMonitor, CLTV_CLAIM_BUFFER, LATENCY_GRACE_PERIOD_BLOCKS, ManyChannelMonitor, ANTI_REORG_DELAY};
  12 use ln::channelmonitor;
  13 use ln::channel::{Channel, ChannelError};
  14 use ln::{chan_utils, onion_utils};
  15 use routing::router::{Route, RouteHop, get_route};
  16 use ln::features::{ChannelFeatures, InitFeatures, NodeFeatures};
  17 use ln::msgs;
  18 use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler,HTLCFailChannelUpdate, ErrorAction, OptionalField};
  19 use util::enforcing_trait_impls::EnforcingChannelKeys;
  20 use util::{byte_utils, test_utils};
  21 use util::events::{Event, EventsProvider, MessageSendEvent, MessageSendEventsProvider};
  22 use util::errors::APIError;
  23 use util::ser::{Writeable, Writer, ReadableArgs, Readable};
  24 use util::config::UserConfig;
  25
  26 use bitcoin::util::hash::BitcoinHash;
  27 use bitcoin::hashes::sha256d::Hash as Sha256dHash;
  28 use bitcoin::hashes::HashEngine;
  29 use bitcoin::hash_types::{Txid, BlockHash, WPubkeyHash};
  30 use bitcoin::util::bip143;
  31 use bitcoin::util::address::Address;
  32 use bitcoin::util::bip32::{ChildNumber, ExtendedPubKey, ExtendedPrivKey};
  33 use bitcoin::blockdata::block::{Block, BlockHeader};
  34 use bitcoin::blockdata::transaction::{Transaction, TxOut, TxIn, SigHashType, OutPoint as BitcoinOutPoint};
  35 use bitcoin::blockdata::script::{Builder, Script};
  36 use bitcoin::blockdata::opcodes;
  37 use bitcoin::blockdata::constants::genesis_block;
  38 use bitcoin::network::constants::Network;
  39
  40 use bitcoin::hashes::sha256::Hash as Sha256;
  41 use bitcoin::hashes::Hash;
  42
  43 use bitcoin::secp256k1::{Secp256k1, Message};
  44 use bitcoin::secp256k1::key::{PublicKey,SecretKey};
  45
  46 use regex;
  47
  48 use std::collections::{BTreeSet, HashMap, HashSet};
  49 use std::default::Default;
  50 use std::sync::{Arc, Mutex};
  51 use std::sync::atomic::Ordering;
  52 use std::{mem, io};
  53
  54 use ln::functional_test_utils::*;
  55
  56 #[test]
  57 fn test_insane_channel_opens() {
  58         // Stand up a network of 2 nodes
  59         let chanmon_cfgs = create_chanmon_cfgs(2);
  60         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
  61         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
  62         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
  63
  64         // Instantiate channel parameters where we push the maximum msats given our
  65         // funding satoshis
  66         let channel_value_sat = 31337; // same as funding satoshis
  67         let channel_reserve_satoshis = Channel::<EnforcingChannelKeys>::get_remote_channel_reserve_satoshis(channel_value_sat);
  68         let push_msat = (channel_value_sat - channel_reserve_satoshis) * 1000;
  69
  70         // Have node0 initiate a channel to node1 with aforementioned parameters
  71         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_sat, push_msat, 42, None).unwrap();
  72
  73         // Extract the channel open message from node0 to node1
  74         let open_channel_message = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
  75
  76         // Test helper that asserts we get the correct error string given a mutator
  77         // that supposedly makes the channel open message insane
  78         let insane_open_helper = |expected_error_str: &str, message_mutator: fn(msgs::OpenChannel) -> msgs::OpenChannel| {
  79                 nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &message_mutator(open_channel_message.clone()));
  80                 let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
  81                 assert_eq!(msg_events.len(), 1);
  82                 let expected_regex = regex::Regex::new(expected_error_str).unwrap();
  83                 if let MessageSendEvent::HandleError { ref action, .. } = msg_events[0] {
  84                         match action {
  85                                 &ErrorAction::SendErrorMessage { .. } => {
  86                                         nodes[1].logger.assert_log_regex("lightning::ln::channelmanager".to_string(), expected_regex, 1);
  87                                 },
  88                                 _ => panic!("unexpected event!"),
  89                         }
  90                 } else { assert!(false); }
  91         };
  92
  93         use ln::channel::MAX_FUNDING_SATOSHIS;
  94         use ln::channelmanager::MAX_LOCAL_BREAKDOWN_TIMEOUT;
  95
  96         // Test all mutations that would make the channel open message insane
  97         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 });
  98
  99         insane_open_helper("Bogus channel_reserve_satoshis", |mut msg| { msg.channel_reserve_satoshis = msg.funding_satoshis + 1; msg });
 100
 101         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 });
 102
 103         insane_open_helper("Peer never wants payout outputs?", |mut msg| { msg.dust_limit_satoshis = msg.funding_satoshis + 1 ; msg });
 104
 105         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 });
 106
 107         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 });
 108
 109         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 });
 110
 111         insane_open_helper("0 max_accepted_htlcs makes for a useless channel", |mut msg| { msg.max_accepted_htlcs = 0; msg });
 112
 113         insane_open_helper("max_accepted_htlcs was 484. It must not be larger than 483", |mut msg| { msg.max_accepted_htlcs = 484; msg });
 114 }
 115
 116 #[test]
 117 fn test_async_inbound_update_fee() {
 118         let chanmon_cfgs = create_chanmon_cfgs(2);
 119         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 120         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 121         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 122         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 123         let logger = test_utils::TestLogger::new();
 124         let channel_id = chan.2;
 125
 126         // balancing
 127         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 128
 129         // A                                        B
 130         // update_fee                            ->
 131         // send (1) commitment_signed            -.
 132         //                                       <- update_add_htlc/commitment_signed
 133         // send (2) RAA (awaiting remote revoke) -.
 134         // (1) commitment_signed is delivered    ->
 135         //                                       .- send (3) RAA (awaiting remote revoke)
 136         // (2) RAA is delivered                  ->
 137         //                                       .- send (4) commitment_signed
 138         //                                       <- (3) RAA is delivered
 139         // send (5) commitment_signed            -.
 140         //                                       <- (4) commitment_signed is delivered
 141         // send (6) RAA                          -.
 142         // (5) commitment_signed is delivered    ->
 143         //                                       <- RAA
 144         // (6) RAA is delivered                  ->
 145
 146         // First nodes[0] generates an update_fee
 147         nodes[0].node.update_fee(channel_id, get_feerate!(nodes[0], channel_id) + 20).unwrap();
 148         check_added_monitors!(nodes[0], 1);
 149
 150         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 151         assert_eq!(events_0.len(), 1);
 152         let (update_msg, commitment_signed) = match events_0[0] { // (1)
 153                 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fee, ref commitment_signed, .. }, .. } => {
 154                         (update_fee.as_ref(), commitment_signed)
 155                 },
 156                 _ => panic!("Unexpected event"),
 157         };
 158
 159         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
 160
 161         // ...but before it's delivered, nodes[1] starts to send a payment back to nodes[0]...
 162         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 163         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 164         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();
 165         check_added_monitors!(nodes[1], 1);
 166
 167         let payment_event = {
 168                 let mut events_1 = nodes[1].node.get_and_clear_pending_msg_events();
 169                 assert_eq!(events_1.len(), 1);
 170                 SendEvent::from_event(events_1.remove(0))
 171         };
 172         assert_eq!(payment_event.node_id, nodes[0].node.get_our_node_id());
 173         assert_eq!(payment_event.msgs.len(), 1);
 174
 175         // ...now when the messages get delivered everyone should be happy
 176         nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
 177         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &payment_event.commitment_msg); // (2)
 178         let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 179         // nodes[0] is awaiting nodes[1] revoke_and_ack so get_event_msg's assert(len == 1) passes
 180         check_added_monitors!(nodes[0], 1);
 181
 182         // deliver(1), generate (3):
 183         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed);
 184         let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
 185         // nodes[1] is awaiting nodes[0] revoke_and_ack so get_event_msg's assert(len == 1) passes
 186         check_added_monitors!(nodes[1], 1);
 187
 188         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_and_ack); // deliver (2)
 189         let bs_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 190         assert!(bs_update.update_add_htlcs.is_empty()); // (4)
 191         assert!(bs_update.update_fulfill_htlcs.is_empty()); // (4)
 192         assert!(bs_update.update_fail_htlcs.is_empty()); // (4)
 193         assert!(bs_update.update_fail_malformed_htlcs.is_empty()); // (4)
 194         assert!(bs_update.update_fee.is_none()); // (4)
 195         check_added_monitors!(nodes[1], 1);
 196
 197         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack); // deliver (3)
 198         let as_update = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 199         assert!(as_update.update_add_htlcs.is_empty()); // (5)
 200         assert!(as_update.update_fulfill_htlcs.is_empty()); // (5)
 201         assert!(as_update.update_fail_htlcs.is_empty()); // (5)
 202         assert!(as_update.update_fail_malformed_htlcs.is_empty()); // (5)
 203         assert!(as_update.update_fee.is_none()); // (5)
 204         check_added_monitors!(nodes[0], 1);
 205
 206         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_update.commitment_signed); // deliver (4)
 207         let as_second_revoke = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 208         // only (6) so get_event_msg's assert(len == 1) passes
 209         check_added_monitors!(nodes[0], 1);
 210
 211         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_update.commitment_signed); // deliver (5)
 212         let bs_second_revoke = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
 213         check_added_monitors!(nodes[1], 1);
 214
 215         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_second_revoke);
 216         check_added_monitors!(nodes[0], 1);
 217
 218         let events_2 = nodes[0].node.get_and_clear_pending_events();
 219         assert_eq!(events_2.len(), 1);
 220         match events_2[0] {
 221                 Event::PendingHTLCsForwardable {..} => {}, // If we actually processed we'd receive the payment
 222                 _ => panic!("Unexpected event"),
 223         }
 224
 225         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_second_revoke); // deliver (6)
 226         check_added_monitors!(nodes[1], 1);
 227 }
 228
 229 #[test]
 230 fn test_update_fee_unordered_raa() {
 231         // Just the intro to the previous test followed by an out-of-order RAA (which caused a
 232         // crash in an earlier version of the update_fee patch)
 233         let chanmon_cfgs = create_chanmon_cfgs(2);
 234         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 235         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 236         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 237         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 238         let channel_id = chan.2;
 239         let logger = test_utils::TestLogger::new();
 240
 241         // balancing
 242         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 243
 244         // First nodes[0] generates an update_fee
 245         nodes[0].node.update_fee(channel_id, get_feerate!(nodes[0], channel_id) + 20).unwrap();
 246         check_added_monitors!(nodes[0], 1);
 247
 248         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 249         assert_eq!(events_0.len(), 1);
 250         let update_msg = match events_0[0] { // (1)
 251                 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fee, .. }, .. } => {
 252                         update_fee.as_ref()
 253                 },
 254                 _ => panic!("Unexpected event"),
 255         };
 256
 257         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
 258
 259         // ...but before it's delivered, nodes[1] starts to send a payment back to nodes[0]...
 260         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 261         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 262         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();
 263         check_added_monitors!(nodes[1], 1);
 264
 265         let payment_event = {
 266                 let mut events_1 = nodes[1].node.get_and_clear_pending_msg_events();
 267                 assert_eq!(events_1.len(), 1);
 268                 SendEvent::from_event(events_1.remove(0))
 269         };
 270         assert_eq!(payment_event.node_id, nodes[0].node.get_our_node_id());
 271         assert_eq!(payment_event.msgs.len(), 1);
 272
 273         // ...now when the messages get delivered everyone should be happy
 274         nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
 275         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &payment_event.commitment_msg); // (2)
 276         let as_revoke_msg = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 277         // nodes[0] is awaiting nodes[1] revoke_and_ack so get_event_msg's assert(len == 1) passes
 278         check_added_monitors!(nodes[0], 1);
 279
 280         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_msg); // deliver (2)
 281         check_added_monitors!(nodes[1], 1);
 282
 283         // We can't continue, sadly, because our (1) now has a bogus signature
 284 }
 285
 286 #[test]
 287 fn test_multi_flight_update_fee() {
 288         let chanmon_cfgs = create_chanmon_cfgs(2);
 289         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 290         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 291         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 292         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 293         let channel_id = chan.2;
 294
 295         // A                                        B
 296         // update_fee/commitment_signed          ->
 297         //                                       .- send (1) RAA and (2) commitment_signed
 298         // update_fee (never committed)          ->
 299         // (3) update_fee                        ->
 300         // We have to manually generate the above update_fee, it is allowed by the protocol but we
 301         // don't track which updates correspond to which revoke_and_ack responses so we're in
 302         // AwaitingRAA mode and will not generate the update_fee yet.
 303         //                                       <- (1) RAA delivered
 304         // (3) is generated and send (4) CS      -.
 305         // Note that A cannot generate (4) prior to (1) being delivered as it otherwise doesn't
 306         // know the per_commitment_point to use for it.
 307         //                                       <- (2) commitment_signed delivered
 308         // revoke_and_ack                        ->
 309         //                                          B should send no response here
 310         // (4) commitment_signed delivered       ->
 311         //                                       <- RAA/commitment_signed delivered
 312         // revoke_and_ack                        ->
 313
 314         // First nodes[0] generates an update_fee
 315         let initial_feerate = get_feerate!(nodes[0], channel_id);
 316         nodes[0].node.update_fee(channel_id, initial_feerate + 20).unwrap();
 317         check_added_monitors!(nodes[0], 1);
 318
 319         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 320         assert_eq!(events_0.len(), 1);
 321         let (update_msg_1, commitment_signed_1) = match events_0[0] { // (1)
 322                 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fee, ref commitment_signed, .. }, .. } => {
 323                         (update_fee.as_ref().unwrap(), commitment_signed)
 324                 },
 325                 _ => panic!("Unexpected event"),
 326         };
 327
 328         // Deliver first update_fee/commitment_signed pair, generating (1) and (2):
 329         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg_1);
 330         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed_1);
 331         let (bs_revoke_msg, bs_commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 332         check_added_monitors!(nodes[1], 1);
 333
 334         // nodes[0] is awaiting a revoke from nodes[1] before it will create a new commitment
 335         // transaction:
 336         nodes[0].node.update_fee(channel_id, initial_feerate + 40).unwrap();
 337         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
 338         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 339
 340         // Create the (3) update_fee message that nodes[0] will generate before it does...
 341         let mut update_msg_2 = msgs::UpdateFee {
 342                 channel_id: update_msg_1.channel_id.clone(),
 343                 feerate_per_kw: (initial_feerate + 30) as u32,
 344         };
 345
 346         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &update_msg_2);
 347
 348         update_msg_2.feerate_per_kw = (initial_feerate + 40) as u32;
 349         // Deliver (3)
 350         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &update_msg_2);
 351
 352         // Deliver (1), generating (3) and (4)
 353         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_msg);
 354         let as_second_update = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 355         check_added_monitors!(nodes[0], 1);
 356         assert!(as_second_update.update_add_htlcs.is_empty());
 357         assert!(as_second_update.update_fulfill_htlcs.is_empty());
 358         assert!(as_second_update.update_fail_htlcs.is_empty());
 359         assert!(as_second_update.update_fail_malformed_htlcs.is_empty());
 360         // Check that the update_fee newly generated matches what we delivered:
 361         assert_eq!(as_second_update.update_fee.as_ref().unwrap().channel_id, update_msg_2.channel_id);
 362         assert_eq!(as_second_update.update_fee.as_ref().unwrap().feerate_per_kw, update_msg_2.feerate_per_kw);
 363
 364         // Deliver (2) commitment_signed
 365         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_commitment_signed);
 366         let as_revoke_msg = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 367         check_added_monitors!(nodes[0], 1);
 368         // No commitment_signed so get_event_msg's assert(len == 1) passes
 369
 370         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_msg);
 371         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 372         check_added_monitors!(nodes[1], 1);
 373
 374         // Delever (4)
 375         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_second_update.commitment_signed);
 376         let (bs_second_revoke, bs_second_commitment) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 377         check_added_monitors!(nodes[1], 1);
 378
 379         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_second_revoke);
 380         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 381         check_added_monitors!(nodes[0], 1);
 382
 383         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_second_commitment);
 384         let as_second_revoke = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 385         // No commitment_signed so get_event_msg's assert(len == 1) passes
 386         check_added_monitors!(nodes[0], 1);
 387
 388         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_second_revoke);
 389         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 390         check_added_monitors!(nodes[1], 1);
 391 }
 392
 393 #[test]
 394 fn test_1_conf_open() {
 395         // Previously, if the minium_depth config was set to 1, we'd never send a funding_locked. This
 396         // tests that we properly send one in that case.
 397         let mut alice_config = UserConfig::default();
 398         alice_config.own_channel_config.minimum_depth = 1;
 399         alice_config.channel_options.announced_channel = true;
 400         alice_config.peer_channel_config_limits.force_announced_channel_preference = false;
 401         let mut bob_config = UserConfig::default();
 402         bob_config.own_channel_config.minimum_depth = 1;
 403         bob_config.channel_options.announced_channel = true;
 404         bob_config.peer_channel_config_limits.force_announced_channel_preference = false;
 405         let chanmon_cfgs = create_chanmon_cfgs(2);
 406         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 407         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[Some(alice_config), Some(bob_config)]);
 408         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 409
 410         let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::known(), InitFeatures::known());
 411         assert!(nodes[0].chain_monitor.does_match_tx(&tx));
 412         assert!(nodes[1].chain_monitor.does_match_tx(&tx));
 413
 414         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
 415         nodes[1].block_notifier.block_connected_checked(&header, 1, &[&tx; 1], &[tx.version as usize; 1]);
 416         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()));
 417
 418         nodes[0].block_notifier.block_connected_checked(&header, 1, &[&tx; 1], &[tx.version as usize; 1]);
 419         let (funding_locked, _) = create_chan_between_nodes_with_value_confirm_second(&nodes[1], &nodes[0]);
 420         let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked);
 421
 422         for node in nodes {
 423                 assert!(node.net_graph_msg_handler.handle_channel_announcement(&announcement).unwrap());
 424                 node.net_graph_msg_handler.handle_channel_update(&as_update).unwrap();
 425                 node.net_graph_msg_handler.handle_channel_update(&bs_update).unwrap();
 426         }
 427 }
 428
 429 fn do_test_sanity_on_in_flight_opens(steps: u8) {
 430         // Previously, we had issues deserializing channels when we hadn't connected the first block
 431         // after creation. To catch that and similar issues, we lean on the Node::drop impl to test
 432         // serialization round-trips and simply do steps towards opening a channel and then drop the
 433         // Node objects.
 434
 435         let chanmon_cfgs = create_chanmon_cfgs(2);
 436         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 437         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 438         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 439
 440         if steps & 0b1000_0000 != 0{
 441                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
 442                 nodes[0].block_notifier.block_connected_checked(&header, 1, &Vec::new(), &[0; 0]);
 443                 nodes[1].block_notifier.block_connected_checked(&header, 1, &Vec::new(), &[0; 0]);
 444         }
 445
 446         if steps & 0x0f == 0 { return; }
 447         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 100000, 10001, 42, None).unwrap();
 448         let open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
 449
 450         if steps & 0x0f == 1 { return; }
 451         nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &open_channel);
 452         let accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
 453
 454         if steps & 0x0f == 2 { return; }
 455         nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), InitFeatures::known(), &accept_channel);
 456
 457         let (temporary_channel_id, tx, funding_output) = create_funding_transaction(&nodes[0], 100000, 42);
 458
 459         if steps & 0x0f == 3 { return; }
 460         nodes[0].node.funding_transaction_generated(&temporary_channel_id, funding_output);
 461         check_added_monitors!(nodes[0], 0);
 462         let funding_created = get_event_msg!(nodes[0], MessageSendEvent::SendFundingCreated, nodes[1].node.get_our_node_id());
 463
 464         if steps & 0x0f == 4 { return; }
 465         nodes[1].node.handle_funding_created(&nodes[0].node.get_our_node_id(), &funding_created);
 466         {
 467                 let mut added_monitors = nodes[1].chan_monitor.added_monitors.lock().unwrap();
 468                 assert_eq!(added_monitors.len(), 1);
 469                 assert_eq!(added_monitors[0].0, funding_output);
 470                 added_monitors.clear();
 471         }
 472         let funding_signed = get_event_msg!(nodes[1], MessageSendEvent::SendFundingSigned, nodes[0].node.get_our_node_id());
 473
 474         if steps & 0x0f == 5 { return; }
 475         nodes[0].node.handle_funding_signed(&nodes[1].node.get_our_node_id(), &funding_signed);
 476         {
 477                 let mut added_monitors = nodes[0].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
 483         let events_4 = nodes[0].node.get_and_clear_pending_events();
 484         assert_eq!(events_4.len(), 1);
 485         match events_4[0] {
 486                 Event::FundingBroadcastSafe { ref funding_txo, user_channel_id } => {
 487                         assert_eq!(user_channel_id, 42);
 488                         assert_eq!(*funding_txo, funding_output);
 489                 },
 490                 _ => panic!("Unexpected event"),
 491         };
 492
 493         if steps & 0x0f == 6 { return; }
 494         create_chan_between_nodes_with_value_confirm_first(&nodes[0], &nodes[1], &tx);
 495
 496         if steps & 0x0f == 7 { return; }
 497         confirm_transaction(&nodes[0].block_notifier, &nodes[0].chain_monitor, &tx, tx.version);
 498         create_chan_between_nodes_with_value_confirm_second(&nodes[1], &nodes[0]);
 499 }
 500
 501 #[test]
 502 fn test_sanity_on_in_flight_opens() {
 503         do_test_sanity_on_in_flight_opens(0);
 504         do_test_sanity_on_in_flight_opens(0 | 0b1000_0000);
 505         do_test_sanity_on_in_flight_opens(1);
 506         do_test_sanity_on_in_flight_opens(1 | 0b1000_0000);
 507         do_test_sanity_on_in_flight_opens(2);
 508         do_test_sanity_on_in_flight_opens(2 | 0b1000_0000);
 509         do_test_sanity_on_in_flight_opens(3);
 510         do_test_sanity_on_in_flight_opens(3 | 0b1000_0000);
 511         do_test_sanity_on_in_flight_opens(4);
 512         do_test_sanity_on_in_flight_opens(4 | 0b1000_0000);
 513         do_test_sanity_on_in_flight_opens(5);
 514         do_test_sanity_on_in_flight_opens(5 | 0b1000_0000);
 515         do_test_sanity_on_in_flight_opens(6);
 516         do_test_sanity_on_in_flight_opens(6 | 0b1000_0000);
 517         do_test_sanity_on_in_flight_opens(7);
 518         do_test_sanity_on_in_flight_opens(7 | 0b1000_0000);
 519         do_test_sanity_on_in_flight_opens(8);
 520         do_test_sanity_on_in_flight_opens(8 | 0b1000_0000);
 521 }
 522
 523 #[test]
 524 fn test_update_fee_vanilla() {
 525         let chanmon_cfgs = create_chanmon_cfgs(2);
 526         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 527         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 528         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 529         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 530         let channel_id = chan.2;
 531
 532         let feerate = get_feerate!(nodes[0], channel_id);
 533         nodes[0].node.update_fee(channel_id, feerate+25).unwrap();
 534         check_added_monitors!(nodes[0], 1);
 535
 536         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 537         assert_eq!(events_0.len(), 1);
 538         let (update_msg, commitment_signed) = match events_0[0] {
 539                         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 } } => {
 540                         (update_fee.as_ref(), commitment_signed)
 541                 },
 542                 _ => panic!("Unexpected event"),
 543         };
 544         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
 545
 546         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed);
 547         let (revoke_msg, commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 548         check_added_monitors!(nodes[1], 1);
 549
 550         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke_msg);
 551         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 552         check_added_monitors!(nodes[0], 1);
 553
 554         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_signed);
 555         let revoke_msg = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 556         // No commitment_signed so get_event_msg's assert(len == 1) passes
 557         check_added_monitors!(nodes[0], 1);
 558
 559         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &revoke_msg);
 560         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 561         check_added_monitors!(nodes[1], 1);
 562 }
 563
 564 #[test]
 565 fn test_update_fee_that_funder_cannot_afford() {
 566         let chanmon_cfgs = create_chanmon_cfgs(2);
 567         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 568         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 569         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 570         let channel_value = 1888;
 571         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, channel_value, 700000, InitFeatures::known(), InitFeatures::known());
 572         let channel_id = chan.2;
 573
 574         let feerate = 260;
 575         nodes[0].node.update_fee(channel_id, feerate).unwrap();
 576         check_added_monitors!(nodes[0], 1);
 577         let update_msg = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 578
 579         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &update_msg.update_fee.unwrap());
 580
 581         commitment_signed_dance!(nodes[1], nodes[0], update_msg.commitment_signed, false);
 582
 583         //Confirm that the new fee based on the last local commitment txn is what we expected based on the feerate of 260 set above.
 584         //This value results in a fee that is exactly what the funder can afford (277 sat + 1000 sat channel reserve)
 585         {
 586                 let commitment_tx = get_local_commitment_txn!(nodes[1], channel_id)[0].clone();
 587
 588                 //We made sure neither party's funds are below the dust limit so -2 non-HTLC txns from number of outputs
 589                 let num_htlcs = commitment_tx.output.len() - 2;
 590                 let total_fee: u64 = feerate as u64 * (COMMITMENT_TX_BASE_WEIGHT + (num_htlcs as u64) * COMMITMENT_TX_WEIGHT_PER_HTLC) / 1000;
 591                 let mut actual_fee = commitment_tx.output.iter().fold(0, |acc, output| acc + output.value);
 592                 actual_fee = channel_value - actual_fee;
 593                 assert_eq!(total_fee, actual_fee);
 594         }
 595
 596         //Add 2 to the previous fee rate to the final fee increases by 1 (with no HTLCs the fee is essentially
 597         //fee_rate*(724/1000) so the increment of 1*0.724 is rounded back down)
 598         nodes[0].node.update_fee(channel_id, feerate+2).unwrap();
 599         check_added_monitors!(nodes[0], 1);
 600
 601         let update2_msg = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 602
 603         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), &update2_msg.update_fee.unwrap());
 604
 605         //While producing the commitment_signed response after handling a received update_fee request the
 606         //check to see if the funder, who sent the update_fee request, can afford the new fee (funder_balance >= fee+channel_reserve)
 607         //Should produce and error.
 608         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &update2_msg.commitment_signed);
 609         nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Funding remote cannot afford proposed new fee".to_string(), 1);
 610         check_added_monitors!(nodes[1], 1);
 611         check_closed_broadcast!(nodes[1], true);
 612 }
 613
 614 #[test]
 615 fn test_update_fee_with_fundee_update_add_htlc() {
 616         let chanmon_cfgs = create_chanmon_cfgs(2);
 617         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 618         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 619         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 620         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 621         let channel_id = chan.2;
 622         let logger = test_utils::TestLogger::new();
 623
 624         // balancing
 625         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
 626
 627         let feerate = get_feerate!(nodes[0], channel_id);
 628         nodes[0].node.update_fee(channel_id, feerate+20).unwrap();
 629         check_added_monitors!(nodes[0], 1);
 630
 631         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 632         assert_eq!(events_0.len(), 1);
 633         let (update_msg, commitment_signed) = match events_0[0] {
 634                         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 } } => {
 635                         (update_fee.as_ref(), commitment_signed)
 636                 },
 637                 _ => panic!("Unexpected event"),
 638         };
 639         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
 640         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed);
 641         let (revoke_msg, commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 642         check_added_monitors!(nodes[1], 1);
 643
 644         let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[1]);
 645         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
 646         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();
 647
 648         // nothing happens since node[1] is in AwaitingRemoteRevoke
 649         nodes[1].node.send_payment(&route, our_payment_hash, &None).unwrap();
 650         {
 651                 let mut added_monitors = nodes[0].chan_monitor.added_monitors.lock().unwrap();
 652                 assert_eq!(added_monitors.len(), 0);
 653                 added_monitors.clear();
 654         }
 655         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
 656         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 657         // node[1] has nothing to do
 658
 659         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke_msg);
 660         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 661         check_added_monitors!(nodes[0], 1);
 662
 663         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_signed);
 664         let revoke_msg = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 665         // No commitment_signed so get_event_msg's assert(len == 1) passes
 666         check_added_monitors!(nodes[0], 1);
 667         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &revoke_msg);
 668         check_added_monitors!(nodes[1], 1);
 669         // AwaitingRemoteRevoke ends here
 670
 671         let commitment_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 672         assert_eq!(commitment_update.update_add_htlcs.len(), 1);
 673         assert_eq!(commitment_update.update_fulfill_htlcs.len(), 0);
 674         assert_eq!(commitment_update.update_fail_htlcs.len(), 0);
 675         assert_eq!(commitment_update.update_fail_malformed_htlcs.len(), 0);
 676         assert_eq!(commitment_update.update_fee.is_none(), true);
 677
 678         nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &commitment_update.update_add_htlcs[0]);
 679         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_update.commitment_signed);
 680         check_added_monitors!(nodes[0], 1);
 681         let (revoke, commitment_signed) = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 682
 683         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &revoke);
 684         check_added_monitors!(nodes[1], 1);
 685         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 686
 687         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &commitment_signed);
 688         check_added_monitors!(nodes[1], 1);
 689         let revoke = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
 690         // No commitment_signed so get_event_msg's assert(len == 1) passes
 691
 692         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke);
 693         check_added_monitors!(nodes[0], 1);
 694         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 695
 696         expect_pending_htlcs_forwardable!(nodes[0]);
 697
 698         let events = nodes[0].node.get_and_clear_pending_events();
 699         assert_eq!(events.len(), 1);
 700         match events[0] {
 701                 Event::PaymentReceived { .. } => { },
 702                 _ => panic!("Unexpected event"),
 703         };
 704
 705         claim_payment(&nodes[1], &vec!(&nodes[0])[..], our_payment_preimage, 800_000);
 706
 707         send_payment(&nodes[1], &vec!(&nodes[0])[..], 800000, 800_000);
 708         send_payment(&nodes[0], &vec!(&nodes[1])[..], 800000, 800_000);
 709         close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true);
 710 }
 711
 712 #[test]
 713 fn test_update_fee() {
 714         let chanmon_cfgs = create_chanmon_cfgs(2);
 715         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 716         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 717         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 718         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 719         let channel_id = chan.2;
 720
 721         // A                                        B
 722         // (1) update_fee/commitment_signed      ->
 723         //                                       <- (2) revoke_and_ack
 724         //                                       .- send (3) commitment_signed
 725         // (4) update_fee/commitment_signed      ->
 726         //                                       .- send (5) revoke_and_ack (no CS as we're awaiting a revoke)
 727         //                                       <- (3) commitment_signed delivered
 728         // send (6) revoke_and_ack               -.
 729         //                                       <- (5) deliver revoke_and_ack
 730         // (6) deliver revoke_and_ack            ->
 731         //                                       .- send (7) commitment_signed in response to (4)
 732         //                                       <- (7) deliver commitment_signed
 733         // revoke_and_ack                        ->
 734
 735         // Create and deliver (1)...
 736         let feerate = get_feerate!(nodes[0], channel_id);
 737         nodes[0].node.update_fee(channel_id, feerate+20).unwrap();
 738         check_added_monitors!(nodes[0], 1);
 739
 740         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 741         assert_eq!(events_0.len(), 1);
 742         let (update_msg, commitment_signed) = match events_0[0] {
 743                         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 } } => {
 744                         (update_fee.as_ref(), commitment_signed)
 745                 },
 746                 _ => panic!("Unexpected event"),
 747         };
 748         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
 749
 750         // Generate (2) and (3):
 751         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed);
 752         let (revoke_msg, commitment_signed_0) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 753         check_added_monitors!(nodes[1], 1);
 754
 755         // Deliver (2):
 756         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke_msg);
 757         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 758         check_added_monitors!(nodes[0], 1);
 759
 760         // Create and deliver (4)...
 761         nodes[0].node.update_fee(channel_id, feerate+30).unwrap();
 762         check_added_monitors!(nodes[0], 1);
 763         let events_0 = nodes[0].node.get_and_clear_pending_msg_events();
 764         assert_eq!(events_0.len(), 1);
 765         let (update_msg, commitment_signed) = match events_0[0] {
 766                         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 } } => {
 767                         (update_fee.as_ref(), commitment_signed)
 768                 },
 769                 _ => panic!("Unexpected event"),
 770         };
 771
 772         nodes[1].node.handle_update_fee(&nodes[0].node.get_our_node_id(), update_msg.unwrap());
 773         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), commitment_signed);
 774         check_added_monitors!(nodes[1], 1);
 775         // ... creating (5)
 776         let revoke_msg = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
 777         // No commitment_signed so get_event_msg's assert(len == 1) passes
 778
 779         // Handle (3), creating (6):
 780         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_signed_0);
 781         check_added_monitors!(nodes[0], 1);
 782         let revoke_msg_0 = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 783         // No commitment_signed so get_event_msg's assert(len == 1) passes
 784
 785         // Deliver (5):
 786         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &revoke_msg);
 787         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 788         check_added_monitors!(nodes[0], 1);
 789
 790         // Deliver (6), creating (7):
 791         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &revoke_msg_0);
 792         let commitment_update = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 793         assert!(commitment_update.update_add_htlcs.is_empty());
 794         assert!(commitment_update.update_fulfill_htlcs.is_empty());
 795         assert!(commitment_update.update_fail_htlcs.is_empty());
 796         assert!(commitment_update.update_fail_malformed_htlcs.is_empty());
 797         assert!(commitment_update.update_fee.is_none());
 798         check_added_monitors!(nodes[1], 1);
 799
 800         // Deliver (7)
 801         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_update.commitment_signed);
 802         check_added_monitors!(nodes[0], 1);
 803         let revoke_msg = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
 804         // No commitment_signed so get_event_msg's assert(len == 1) passes
 805
 806         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &revoke_msg);
 807         check_added_monitors!(nodes[1], 1);
 808         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 809
 810         assert_eq!(get_feerate!(nodes[0], channel_id), feerate + 30);
 811         assert_eq!(get_feerate!(nodes[1], channel_id), feerate + 30);
 812         close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true);
 813 }
 814
 815 #[test]
 816 fn pre_funding_lock_shutdown_test() {
 817         // Test sending a shutdown prior to funding_locked after funding generation
 818         let chanmon_cfgs = create_chanmon_cfgs(2);
 819         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
 820         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
 821         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
 822         let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 8000000, 0, InitFeatures::known(), InitFeatures::known());
 823         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
 824         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![tx.clone()]}, 1);
 825         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![tx.clone()]}, 1);
 826
 827         nodes[0].node.close_channel(&OutPoint { txid: tx.txid(), index: 0 }.to_channel_id()).unwrap();
 828         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
 829         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
 830         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 831         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
 832
 833         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
 834         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
 835         let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
 836         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap());
 837         let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
 838         assert!(node_0_none.is_none());
 839
 840         assert!(nodes[0].node.list_channels().is_empty());
 841         assert!(nodes[1].node.list_channels().is_empty());
 842 }
 843
 844 #[test]
 845 fn updates_shutdown_wait() {
 846         // Test sending a shutdown with outstanding updates pending
 847         let chanmon_cfgs = create_chanmon_cfgs(3);
 848         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
 849         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
 850         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
 851         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 852         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
 853         let logger = test_utils::TestLogger::new();
 854
 855         let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
 856
 857         nodes[0].node.close_channel(&chan_1.2).unwrap();
 858         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
 859         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
 860         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 861         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
 862
 863         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
 864         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 865
 866         let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
 867
 868         let net_graph_msg_handler0 = &nodes[0].net_graph_msg_handler;
 869         let net_graph_msg_handler1 = &nodes[1].net_graph_msg_handler;
 870         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();
 871         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();
 872         unwrap_send_err!(nodes[0].node.send_payment(&route_1, payment_hash, &None), true, APIError::ChannelUnavailable {..}, {});
 873         unwrap_send_err!(nodes[1].node.send_payment(&route_2, payment_hash, &None), true, APIError::ChannelUnavailable {..}, {});
 874
 875         assert!(nodes[2].node.claim_funds(our_payment_preimage, &None, 100_000));
 876         check_added_monitors!(nodes[2], 1);
 877         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
 878         assert!(updates.update_add_htlcs.is_empty());
 879         assert!(updates.update_fail_htlcs.is_empty());
 880         assert!(updates.update_fail_malformed_htlcs.is_empty());
 881         assert!(updates.update_fee.is_none());
 882         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
 883         nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
 884         check_added_monitors!(nodes[1], 1);
 885         let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 886         commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false);
 887
 888         assert!(updates_2.update_add_htlcs.is_empty());
 889         assert!(updates_2.update_fail_htlcs.is_empty());
 890         assert!(updates_2.update_fail_malformed_htlcs.is_empty());
 891         assert!(updates_2.update_fee.is_none());
 892         assert_eq!(updates_2.update_fulfill_htlcs.len(), 1);
 893         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]);
 894         commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
 895
 896         let events = nodes[0].node.get_and_clear_pending_events();
 897         assert_eq!(events.len(), 1);
 898         match events[0] {
 899                 Event::PaymentSent { ref payment_preimage } => {
 900                         assert_eq!(our_payment_preimage, *payment_preimage);
 901                 },
 902                 _ => panic!("Unexpected event"),
 903         }
 904
 905         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
 906         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
 907         let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
 908         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap());
 909         let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
 910         assert!(node_0_none.is_none());
 911
 912         assert!(nodes[0].node.list_channels().is_empty());
 913
 914         assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
 915         nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
 916         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
 917         assert!(nodes[1].node.list_channels().is_empty());
 918         assert!(nodes[2].node.list_channels().is_empty());
 919 }
 920
 921 #[test]
 922 fn htlc_fail_async_shutdown() {
 923         // Test HTLCs fail if shutdown starts even if messages are delivered out-of-order
 924         let chanmon_cfgs = create_chanmon_cfgs(3);
 925         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
 926         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
 927         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
 928         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
 929         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
 930         let logger = test_utils::TestLogger::new();
 931
 932         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
 933         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
 934         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();
 935         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
 936         check_added_monitors!(nodes[0], 1);
 937         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
 938         assert_eq!(updates.update_add_htlcs.len(), 1);
 939         assert!(updates.update_fulfill_htlcs.is_empty());
 940         assert!(updates.update_fail_htlcs.is_empty());
 941         assert!(updates.update_fail_malformed_htlcs.is_empty());
 942         assert!(updates.update_fee.is_none());
 943
 944         nodes[1].node.close_channel(&chan_1.2).unwrap();
 945         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
 946         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
 947         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
 948
 949         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
 950         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &updates.commitment_signed);
 951         check_added_monitors!(nodes[1], 1);
 952         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
 953         commitment_signed_dance!(nodes[1], nodes[0], (), false, true, false);
 954
 955         let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
 956         assert!(updates_2.update_add_htlcs.is_empty());
 957         assert!(updates_2.update_fulfill_htlcs.is_empty());
 958         assert_eq!(updates_2.update_fail_htlcs.len(), 1);
 959         assert!(updates_2.update_fail_malformed_htlcs.is_empty());
 960         assert!(updates_2.update_fee.is_none());
 961
 962         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fail_htlcs[0]);
 963         commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
 964
 965         expect_payment_failed!(nodes[0], our_payment_hash, false);
 966
 967         let msg_events = nodes[0].node.get_and_clear_pending_msg_events();
 968         assert_eq!(msg_events.len(), 2);
 969         let node_0_closing_signed = match msg_events[0] {
 970                 MessageSendEvent::SendClosingSigned { ref node_id, ref msg } => {
 971                         assert_eq!(*node_id, nodes[1].node.get_our_node_id());
 972                         (*msg).clone()
 973                 },
 974                 _ => panic!("Unexpected event"),
 975         };
 976         match msg_events[1] {
 977                 MessageSendEvent::PaymentFailureNetworkUpdate { update: msgs::HTLCFailChannelUpdate::ChannelUpdateMessage { ref msg }} => {
 978                         assert_eq!(msg.contents.short_channel_id, chan_1.0.contents.short_channel_id);
 979                 },
 980                 _ => panic!("Unexpected event"),
 981         }
 982
 983         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
 984         nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
 985         let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
 986         nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap());
 987         let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
 988         assert!(node_0_none.is_none());
 989
 990         assert!(nodes[0].node.list_channels().is_empty());
 991
 992         assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
 993         nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
 994         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
 995         assert!(nodes[1].node.list_channels().is_empty());
 996         assert!(nodes[2].node.list_channels().is_empty());
 997 }
 998
 999 fn do_test_shutdown_rebroadcast(recv_count: u8) {
1000         // Test that shutdown/closing_signed is re-sent on reconnect with a variable number of
1001         // messages delivered prior to disconnect
1002         let chanmon_cfgs = create_chanmon_cfgs(3);
1003         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
1004         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
1005         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1006         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
1007         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
1008
1009         let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 100000);
1010
1011         nodes[1].node.close_channel(&chan_1.2).unwrap();
1012         let node_1_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1013         if recv_count > 0 {
1014                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_shutdown);
1015                 let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1016                 if recv_count > 1 {
1017                         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
1018                 }
1019         }
1020
1021         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
1022         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
1023
1024         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
1025         let node_0_reestablish = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReestablish, nodes[1].node.get_our_node_id());
1026         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
1027         let node_1_reestablish = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
1028
1029         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &node_0_reestablish);
1030         let node_1_2nd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1031         assert!(node_1_shutdown == node_1_2nd_shutdown);
1032
1033         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &node_1_reestablish);
1034         let node_0_2nd_shutdown = if recv_count > 0 {
1035                 let node_0_2nd_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1036                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown);
1037                 node_0_2nd_shutdown
1038         } else {
1039                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1040                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_2nd_shutdown);
1041                 get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id())
1042         };
1043         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_2nd_shutdown);
1044
1045         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1046         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1047
1048         assert!(nodes[2].node.claim_funds(our_payment_preimage, &None, 100_000));
1049         check_added_monitors!(nodes[2], 1);
1050         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
1051         assert!(updates.update_add_htlcs.is_empty());
1052         assert!(updates.update_fail_htlcs.is_empty());
1053         assert!(updates.update_fail_malformed_htlcs.is_empty());
1054         assert!(updates.update_fee.is_none());
1055         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
1056         nodes[1].node.handle_update_fulfill_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
1057         check_added_monitors!(nodes[1], 1);
1058         let updates_2 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1059         commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false);
1060
1061         assert!(updates_2.update_add_htlcs.is_empty());
1062         assert!(updates_2.update_fail_htlcs.is_empty());
1063         assert!(updates_2.update_fail_malformed_htlcs.is_empty());
1064         assert!(updates_2.update_fee.is_none());
1065         assert_eq!(updates_2.update_fulfill_htlcs.len(), 1);
1066         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates_2.update_fulfill_htlcs[0]);
1067         commitment_signed_dance!(nodes[0], nodes[1], updates_2.commitment_signed, false, true);
1068
1069         let events = nodes[0].node.get_and_clear_pending_events();
1070         assert_eq!(events.len(), 1);
1071         match events[0] {
1072                 Event::PaymentSent { ref payment_preimage } => {
1073                         assert_eq!(our_payment_preimage, *payment_preimage);
1074                 },
1075                 _ => panic!("Unexpected event"),
1076         }
1077
1078         let node_0_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
1079         if recv_count > 0 {
1080                 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_closing_signed);
1081                 let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
1082                 assert!(node_1_closing_signed.is_some());
1083         }
1084
1085         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
1086         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
1087
1088         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
1089         let node_0_2nd_reestablish = get_event_msg!(nodes[0], MessageSendEvent::SendChannelReestablish, nodes[1].node.get_our_node_id());
1090         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
1091         if recv_count == 0 {
1092                 // If all closing_signeds weren't delivered we can just resume where we left off...
1093                 let node_1_2nd_reestablish = get_event_msg!(nodes[1], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
1094
1095                 nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &node_1_2nd_reestablish);
1096                 let node_0_3rd_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
1097                 assert!(node_0_2nd_shutdown == node_0_3rd_shutdown);
1098
1099                 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &node_0_2nd_reestablish);
1100                 let node_1_3rd_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
1101                 assert!(node_1_3rd_shutdown == node_1_2nd_shutdown);
1102
1103                 nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_3rd_shutdown);
1104                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1105
1106                 nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_1_3rd_shutdown);
1107                 let node_0_2nd_closing_signed = get_event_msg!(nodes[0], MessageSendEvent::SendClosingSigned, nodes[1].node.get_our_node_id());
1108                 assert!(node_0_closing_signed == node_0_2nd_closing_signed);
1109
1110                 nodes[1].node.handle_closing_signed(&nodes[0].node.get_our_node_id(), &node_0_2nd_closing_signed);
1111                 let (_, node_1_closing_signed) = get_closing_signed_broadcast!(nodes[1].node, nodes[0].node.get_our_node_id());
1112                 nodes[0].node.handle_closing_signed(&nodes[1].node.get_our_node_id(), &node_1_closing_signed.unwrap());
1113                 let (_, node_0_none) = get_closing_signed_broadcast!(nodes[0].node, nodes[1].node.get_our_node_id());
1114                 assert!(node_0_none.is_none());
1115         } else {
1116                 // If one node, however, received + responded with an identical closing_signed we end
1117                 // up erroring and node[0] will try to broadcast its own latest commitment transaction.
1118                 // There isn't really anything better we can do simply, but in the future we might
1119                 // explore storing a set of recently-closed channels that got disconnected during
1120                 // closing_signed and avoiding broadcasting local commitment txn for some timeout to
1121                 // give our counterparty enough time to (potentially) broadcast a cooperative closing
1122                 // transaction.
1123                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1124
1125                 nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &node_0_2nd_reestablish);
1126                 let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
1127                 assert_eq!(msg_events.len(), 1);
1128                 if let MessageSendEvent::HandleError { ref action, .. } = msg_events[0] {
1129                         match action {
1130                                 &ErrorAction::SendErrorMessage { ref msg } => {
1131                                         nodes[0].node.handle_error(&nodes[1].node.get_our_node_id(), &msg);
1132                                         assert_eq!(msg.channel_id, chan_1.2);
1133                                 },
1134                                 _ => panic!("Unexpected event!"),
1135                         }
1136                 } else { panic!("Needed SendErrorMessage close"); }
1137
1138                 // get_closing_signed_broadcast usually eats the BroadcastChannelUpdate for us and
1139                 // checks it, but in this case nodes[0] didn't ever get a chance to receive a
1140                 // closing_signed so we do it ourselves
1141                 check_closed_broadcast!(nodes[0], false);
1142                 check_added_monitors!(nodes[0], 1);
1143         }
1144
1145         assert!(nodes[0].node.list_channels().is_empty());
1146
1147         assert_eq!(nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().len(), 1);
1148         nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clear();
1149         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, true);
1150         assert!(nodes[1].node.list_channels().is_empty());
1151         assert!(nodes[2].node.list_channels().is_empty());
1152 }
1153
1154 #[test]
1155 fn test_shutdown_rebroadcast() {
1156         do_test_shutdown_rebroadcast(0);
1157         do_test_shutdown_rebroadcast(1);
1158         do_test_shutdown_rebroadcast(2);
1159 }
1160
1161 #[test]
1162 fn fake_network_test() {
1163         // Simple test which builds a network of ChannelManagers, connects them to each other, and
1164         // tests that payments get routed and transactions broadcast in semi-reasonable ways.
1165         let chanmon_cfgs = create_chanmon_cfgs(4);
1166         let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
1167         let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
1168         let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
1169
1170         // Create some initial channels
1171         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
1172         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
1173         let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
1174
1175         // Rebalance the network a bit by relaying one payment through all the channels...
1176         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
1177         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
1178         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
1179         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 8000000, 8_000_000);
1180
1181         // Send some more payments
1182         send_payment(&nodes[1], &vec!(&nodes[2], &nodes[3])[..], 1000000, 1_000_000);
1183         send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1], &nodes[0])[..], 1000000, 1_000_000);
1184         send_payment(&nodes[3], &vec!(&nodes[2], &nodes[1])[..], 1000000, 1_000_000);
1185
1186         // Test failure packets
1187         let payment_hash_1 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], 1000000).1;
1188         fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3])[..], payment_hash_1);
1189
1190         // Add a new channel that skips 3
1191         let chan_4 = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known());
1192
1193         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 1000000, 1_000_000);
1194         send_payment(&nodes[2], &vec!(&nodes[3])[..], 1000000, 1_000_000);
1195         send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
1196         send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
1197         send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
1198         send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
1199         send_payment(&nodes[1], &vec!(&nodes[3])[..], 8000000, 8_000_000);
1200
1201         // Do some rebalance loop payments, simultaneously
1202         let mut hops = Vec::with_capacity(3);
1203         hops.push(RouteHop {
1204                 pubkey: nodes[2].node.get_our_node_id(),
1205                 node_features: NodeFeatures::empty(),
1206                 short_channel_id: chan_2.0.contents.short_channel_id,
1207                 channel_features: ChannelFeatures::empty(),
1208                 fee_msat: 0,
1209                 cltv_expiry_delta: chan_3.0.contents.cltv_expiry_delta as u32
1210         });
1211         hops.push(RouteHop {
1212                 pubkey: nodes[3].node.get_our_node_id(),
1213                 node_features: NodeFeatures::empty(),
1214                 short_channel_id: chan_3.0.contents.short_channel_id,
1215                 channel_features: ChannelFeatures::empty(),
1216                 fee_msat: 0,
1217                 cltv_expiry_delta: chan_4.1.contents.cltv_expiry_delta as u32
1218         });
1219         hops.push(RouteHop {
1220                 pubkey: nodes[1].node.get_our_node_id(),
1221                 node_features: NodeFeatures::empty(),
1222                 short_channel_id: chan_4.0.contents.short_channel_id,
1223                 channel_features: ChannelFeatures::empty(),
1224                 fee_msat: 1000000,
1225                 cltv_expiry_delta: TEST_FINAL_CLTV,
1226         });
1227         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;
1228         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;
1229         let payment_preimage_1 = send_along_route(&nodes[1], Route { paths: vec![hops] }, &vec!(&nodes[2], &nodes[3], &nodes[1])[..], 1000000).0;
1230
1231         let mut hops = Vec::with_capacity(3);
1232         hops.push(RouteHop {
1233                 pubkey: nodes[3].node.get_our_node_id(),
1234                 node_features: NodeFeatures::empty(),
1235                 short_channel_id: chan_4.0.contents.short_channel_id,
1236                 channel_features: ChannelFeatures::empty(),
1237                 fee_msat: 0,
1238                 cltv_expiry_delta: chan_3.1.contents.cltv_expiry_delta as u32
1239         });
1240         hops.push(RouteHop {
1241                 pubkey: nodes[2].node.get_our_node_id(),
1242                 node_features: NodeFeatures::empty(),
1243                 short_channel_id: chan_3.0.contents.short_channel_id,
1244                 channel_features: ChannelFeatures::empty(),
1245                 fee_msat: 0,
1246                 cltv_expiry_delta: chan_2.1.contents.cltv_expiry_delta as u32
1247         });
1248         hops.push(RouteHop {
1249                 pubkey: nodes[1].node.get_our_node_id(),
1250                 node_features: NodeFeatures::empty(),
1251                 short_channel_id: chan_2.0.contents.short_channel_id,
1252                 channel_features: ChannelFeatures::empty(),
1253                 fee_msat: 1000000,
1254                 cltv_expiry_delta: TEST_FINAL_CLTV,
1255         });
1256         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;
1257         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;
1258         let payment_hash_2 = send_along_route(&nodes[1], Route { paths: vec![hops] }, &vec!(&nodes[3], &nodes[2], &nodes[1])[..], 1000000).1;
1259
1260         // Claim the rebalances...
1261         fail_payment(&nodes[1], &vec!(&nodes[3], &nodes[2], &nodes[1])[..], payment_hash_2);
1262         claim_payment(&nodes[1], &vec!(&nodes[2], &nodes[3], &nodes[1])[..], payment_preimage_1, 1_000_000);
1263
1264         // Add a duplicate new channel from 2 to 4
1265         let chan_5 = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known());
1266
1267         // Send some payments across both channels
1268         let payment_preimage_3 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000).0;
1269         let payment_preimage_4 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000).0;
1270         let payment_preimage_5 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000).0;
1271
1272
1273         route_over_limit(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], 3000000);
1274         let events = nodes[0].node.get_and_clear_pending_msg_events();
1275         assert_eq!(events.len(), 0);
1276         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);
1277
1278         //TODO: Test that routes work again here as we've been notified that the channel is full
1279
1280         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_3, 3_000_000);
1281         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_4, 3_000_000);
1282         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[3])[..], payment_preimage_5, 3_000_000);
1283
1284         // Close down the channels...
1285         close_channel(&nodes[0], &nodes[1], &chan_1.2, chan_1.3, true);
1286         close_channel(&nodes[1], &nodes[2], &chan_2.2, chan_2.3, false);
1287         close_channel(&nodes[2], &nodes[3], &chan_3.2, chan_3.3, true);
1288         close_channel(&nodes[1], &nodes[3], &chan_4.2, chan_4.3, false);
1289         close_channel(&nodes[1], &nodes[3], &chan_5.2, chan_5.3, false);
1290 }
1291
1292 #[test]
1293 fn holding_cell_htlc_counting() {
1294         // Tests that HTLCs in the holding cell count towards the pending HTLC limits on outbound HTLCs
1295         // to ensure we don't end up with HTLCs sitting around in our holding cell for several
1296         // commitment dance rounds.
1297         let chanmon_cfgs = create_chanmon_cfgs(3);
1298         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
1299         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
1300         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1301         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
1302         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
1303         let logger = test_utils::TestLogger::new();
1304
1305         let mut payments = Vec::new();
1306         for _ in 0..::ln::channel::OUR_MAX_HTLCS {
1307                 let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[0]);
1308                 let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
1309                 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();
1310                 nodes[1].node.send_payment(&route, payment_hash, &None).unwrap();
1311                 payments.push((payment_preimage, payment_hash));
1312         }
1313         check_added_monitors!(nodes[1], 1);
1314
1315         let mut events = nodes[1].node.get_and_clear_pending_msg_events();
1316         assert_eq!(events.len(), 1);
1317         let initial_payment_event = SendEvent::from_event(events.pop().unwrap());
1318         assert_eq!(initial_payment_event.node_id, nodes[2].node.get_our_node_id());
1319
1320         // There is now one HTLC in an outbound commitment transaction and (OUR_MAX_HTLCS - 1) HTLCs in
1321         // the holding cell waiting on B's RAA to send. At this point we should not be able to add
1322         // another HTLC.
1323         let (_, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
1324         {
1325                 let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
1326                 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();
1327                 unwrap_send_err!(nodes[1].node.send_payment(&route, payment_hash_1, &None), true, APIError::ChannelUnavailable { ref err },
1328                         assert!(regex::Regex::new(r"Cannot push more than their max accepted HTLCs \(\d+\)").unwrap().is_match(err)));
1329                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1330                 nodes[1].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot push more than their max accepted HTLCs".to_string(), 1);
1331         }
1332
1333         // This should also be true if we try to forward a payment.
1334         let (_, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
1335         {
1336                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
1337                 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();
1338                 nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap();
1339                 check_added_monitors!(nodes[0], 1);
1340         }
1341
1342         let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1343         assert_eq!(events.len(), 1);
1344         let payment_event = SendEvent::from_event(events.pop().unwrap());
1345         assert_eq!(payment_event.node_id, nodes[1].node.get_our_node_id());
1346
1347         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
1348         commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
1349         // We have to forward pending HTLCs twice - once tries to forward the payment forward (and
1350         // fails), the second will process the resulting failure and fail the HTLC backward.
1351         expect_pending_htlcs_forwardable!(nodes[1]);
1352         expect_pending_htlcs_forwardable!(nodes[1]);
1353         check_added_monitors!(nodes[1], 1);
1354
1355         let bs_fail_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
1356         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &bs_fail_updates.update_fail_htlcs[0]);
1357         commitment_signed_dance!(nodes[0], nodes[1], bs_fail_updates.commitment_signed, false, true);
1358
1359         let events = nodes[0].node.get_and_clear_pending_msg_events();
1360         assert_eq!(events.len(), 1);
1361         match events[0] {
1362                 MessageSendEvent::PaymentFailureNetworkUpdate { update: msgs::HTLCFailChannelUpdate::ChannelUpdateMessage { ref msg }} => {
1363                         assert_eq!(msg.contents.short_channel_id, chan_2.0.contents.short_channel_id);
1364                 },
1365                 _ => panic!("Unexpected event"),
1366         }
1367
1368         expect_payment_failed!(nodes[0], payment_hash_2, false);
1369
1370         // Now forward all the pending HTLCs and claim them back
1371         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &initial_payment_event.msgs[0]);
1372         nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &initial_payment_event.commitment_msg);
1373         check_added_monitors!(nodes[2], 1);
1374
1375         let (bs_revoke_and_ack, bs_commitment_signed) = get_revoke_commit_msgs!(nodes[2], nodes[1].node.get_our_node_id());
1376         nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &bs_revoke_and_ack);
1377         check_added_monitors!(nodes[1], 1);
1378         let as_updates = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
1379
1380         nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &bs_commitment_signed);
1381         check_added_monitors!(nodes[1], 1);
1382         let as_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[2].node.get_our_node_id());
1383
1384         for ref update in as_updates.update_add_htlcs.iter() {
1385                 nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), update);
1386         }
1387         nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &as_updates.commitment_signed);
1388         check_added_monitors!(nodes[2], 1);
1389         nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_raa);
1390         check_added_monitors!(nodes[2], 1);
1391         let (bs_revoke_and_ack, bs_commitment_signed) = get_revoke_commit_msgs!(nodes[2], nodes[1].node.get_our_node_id());
1392
1393         nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &bs_revoke_and_ack);
1394         check_added_monitors!(nodes[1], 1);
1395         nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &bs_commitment_signed);
1396         check_added_monitors!(nodes[1], 1);
1397         let as_final_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[2].node.get_our_node_id());
1398
1399         nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_final_raa);
1400         check_added_monitors!(nodes[2], 1);
1401
1402         expect_pending_htlcs_forwardable!(nodes[2]);
1403
1404         let events = nodes[2].node.get_and_clear_pending_events();
1405         assert_eq!(events.len(), payments.len());
1406         for (event, &(_, ref hash)) in events.iter().zip(payments.iter()) {
1407                 match event {
1408                         &Event::PaymentReceived { ref payment_hash, .. } => {
1409                                 assert_eq!(*payment_hash, *hash);
1410                         },
1411                         _ => panic!("Unexpected event"),
1412                 };
1413         }
1414
1415         for (preimage, _) in payments.drain(..) {
1416                 claim_payment(&nodes[1], &[&nodes[2]], preimage, 100_000);
1417         }
1418
1419         send_payment(&nodes[0], &[&nodes[1], &nodes[2]], 1000000, 1_000_000);
1420 }
1421
1422 #[test]
1423 fn duplicate_htlc_test() {
1424         // Test that we accept duplicate payment_hash HTLCs across the network and that
1425         // claiming/failing them are all separate and don't affect each other
1426         let chanmon_cfgs = create_chanmon_cfgs(6);
1427         let node_cfgs = create_node_cfgs(6, &chanmon_cfgs);
1428         let node_chanmgrs = create_node_chanmgrs(6, &node_cfgs, &[None, None, None, None, None, None]);
1429         let mut nodes = create_network(6, &node_cfgs, &node_chanmgrs);
1430
1431         // Create some initial channels to route via 3 to 4/5 from 0/1/2
1432         create_announced_chan_between_nodes(&nodes, 0, 3, InitFeatures::known(), InitFeatures::known());
1433         create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known());
1434         create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
1435         create_announced_chan_between_nodes(&nodes, 3, 4, InitFeatures::known(), InitFeatures::known());
1436         create_announced_chan_between_nodes(&nodes, 3, 5, InitFeatures::known(), InitFeatures::known());
1437
1438         let (payment_preimage, payment_hash) = route_payment(&nodes[0], &vec!(&nodes[3], &nodes[4])[..], 1000000);
1439
1440         *nodes[0].network_payment_count.borrow_mut() -= 1;
1441         assert_eq!(route_payment(&nodes[1], &vec!(&nodes[3])[..], 1000000).0, payment_preimage);
1442
1443         *nodes[0].network_payment_count.borrow_mut() -= 1;
1444         assert_eq!(route_payment(&nodes[2], &vec!(&nodes[3], &nodes[5])[..], 1000000).0, payment_preimage);
1445
1446         claim_payment(&nodes[0], &vec!(&nodes[3], &nodes[4])[..], payment_preimage, 1_000_000);
1447         fail_payment(&nodes[2], &vec!(&nodes[3], &nodes[5])[..], payment_hash);
1448         claim_payment(&nodes[1], &vec!(&nodes[3])[..], payment_preimage, 1_000_000);
1449 }
1450
1451 #[test]
1452 fn test_duplicate_htlc_different_direction_onchain() {
1453         // Test that ChannelMonitor doesn't generate 2 preimage txn
1454         // when we have 2 HTLCs with same preimage that go across a node
1455         // in opposite directions.
1456         let chanmon_cfgs = create_chanmon_cfgs(2);
1457         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1458         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1459         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1460
1461         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
1462         let logger = test_utils::TestLogger::new();
1463
1464         // balancing
1465         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
1466
1467         let (payment_preimage, payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 900_000);
1468
1469         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
1470         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();
1471         send_along_route_with_hash(&nodes[1], route, &vec!(&nodes[0])[..], 800_000, payment_hash);
1472
1473         // Provide preimage to node 0 by claiming payment
1474         nodes[0].node.claim_funds(payment_preimage, &None, 800_000);
1475         check_added_monitors!(nodes[0], 1);
1476
1477         // Broadcast node 1 commitment txn
1478         let remote_txn = get_local_commitment_txn!(nodes[1], chan_1.2);
1479
1480         assert_eq!(remote_txn[0].output.len(), 4); // 1 local, 1 remote, 1 htlc inbound, 1 htlc outbound
1481         let mut has_both_htlcs = 0; // check htlcs match ones committed
1482         for outp in remote_txn[0].output.iter() {
1483                 if outp.value == 800_000 / 1000 {
1484                         has_both_htlcs += 1;
1485                 } else if outp.value == 900_000 / 1000 {
1486                         has_both_htlcs += 1;
1487                 }
1488         }
1489         assert_eq!(has_both_htlcs, 2);
1490
1491         let header = BlockHeader { version: 0x2000_0000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
1492         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![remote_txn[0].clone()] }, 1);
1493         check_added_monitors!(nodes[0], 1);
1494
1495         // Check we only broadcast 1 timeout tx
1496         let claim_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
1497         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()) };
1498         assert_eq!(claim_txn.len(), 5);
1499         check_spends!(claim_txn[2], chan_1.3);
1500         check_spends!(claim_txn[3], claim_txn[2]);
1501         assert_eq!(htlc_pair.0.input.len(), 1);
1502         assert_eq!(htlc_pair.0.input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT); // HTLC 1 <--> 0, preimage tx
1503         check_spends!(htlc_pair.0, remote_txn[0]);
1504         assert_eq!(htlc_pair.1.input.len(), 1);
1505         assert_eq!(htlc_pair.1.input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT); // HTLC 0 <--> 1, timeout tx
1506         check_spends!(htlc_pair.1, remote_txn[0]);
1507
1508         let events = nodes[0].node.get_and_clear_pending_msg_events();
1509         assert_eq!(events.len(), 2);
1510         for e in events {
1511                 match e {
1512                         MessageSendEvent::BroadcastChannelUpdate { .. } => {},
1513                         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, .. } } => {
1514                                 assert!(update_add_htlcs.is_empty());
1515                                 assert!(update_fail_htlcs.is_empty());
1516                                 assert_eq!(update_fulfill_htlcs.len(), 1);
1517                                 assert!(update_fail_malformed_htlcs.is_empty());
1518                                 assert_eq!(nodes[1].node.get_our_node_id(), *node_id);
1519                         },
1520                         _ => panic!("Unexpected event"),
1521                 }
1522         }
1523 }
1524
1525 #[test]
1526 fn test_basic_channel_reserve() {
1527         let chanmon_cfgs = create_chanmon_cfgs(2);
1528         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1529         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1530         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1531         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
1532         let logger = test_utils::TestLogger::new();
1533
1534         let chan_stat = get_channel_value_stat!(nodes[0], chan.2);
1535         let channel_reserve = chan_stat.channel_reserve_msat;
1536
1537         // The 2* and +1 are for the fee spike reserve.
1538         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
1539         let commit_tx_fee = 2 * commit_tx_fee_msat(get_feerate!(nodes[0], chan.2), 1 + 1);
1540         let max_can_send = 5000000 - channel_reserve - commit_tx_fee;
1541         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
1542         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();
1543         let err = nodes[0].node.send_payment(&route, our_payment_hash, &None).err().unwrap();
1544         match err {
1545                 PaymentSendFailure::AllFailedRetrySafe(ref fails) => {
1546                         match &fails[0] {
1547                                 &APIError::ChannelUnavailable{ref err} =>
1548                                         assert!(regex::Regex::new(r"Cannot send value that would put us under local channel reserve value \(\d+\)").unwrap().is_match(err)),
1549                                 _ => panic!("Unexpected error variant"),
1550                         }
1551                 },
1552                 _ => panic!("Unexpected error variant"),
1553         }
1554         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1555         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);
1556
1557         send_payment(&nodes[0], &vec![&nodes[1]], max_can_send, max_can_send);
1558 }
1559
1560 #[test]
1561 fn test_fee_spike_violation_fails_htlc() {
1562         let chanmon_cfgs = create_chanmon_cfgs(2);
1563         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1564         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1565         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1566         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
1567         let logger = test_utils::TestLogger::new();
1568
1569         macro_rules! get_route_and_payment_hash {
1570                 ($recv_value: expr) => {{
1571                         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[1]);
1572                         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler.network_graph.read().unwrap();
1573                         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();
1574                         (route, payment_hash, payment_preimage)
1575                 }}
1576         };
1577
1578         let (route, payment_hash, _) = get_route_and_payment_hash!(3460001);
1579         // Need to manually create the update_add_htlc message to go around the channel reserve check in send_htlc()
1580         let secp_ctx = Secp256k1::new();
1581         let session_priv = SecretKey::from_slice(&[42; 32]).expect("RNG is bad!");
1582
1583         let cur_height = nodes[1].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
1584
1585         let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route.paths[0], &session_priv).unwrap();
1586         let (onion_payloads, htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 3460001, &None, cur_height).unwrap();
1587         let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash);
1588         let msg = msgs::UpdateAddHTLC {
1589                 channel_id: chan.2,
1590                 htlc_id: 0,
1591                 amount_msat: htlc_msat,
1592                 payment_hash: payment_hash,
1593                 cltv_expiry: htlc_cltv,
1594                 onion_routing_packet: onion_packet,
1595         };
1596
1597         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &msg);
1598
1599         // Now manually create the commitment_signed message corresponding to the update_add
1600         // nodes[0] just sent. In the code for construction of this message, "local" refers
1601         // to the sender of the message, and "remote" refers to the receiver.
1602
1603         let feerate_per_kw = get_feerate!(nodes[0], chan.2);
1604
1605         const INITIAL_COMMITMENT_NUMBER: u64 = (1 << 48) - 1;
1606
1607         // Get the EnforcingChannelKeys for each channel, which will be used to (1) get the keys
1608         // needed to sign the new commitment tx and (2) sign the new commitment tx.
1609         let (local_revocation_basepoint, local_htlc_basepoint, local_payment_point, local_secret, local_secret2) = {
1610                 let chan_lock = nodes[0].node.channel_state.lock().unwrap();
1611                 let local_chan = chan_lock.by_id.get(&chan.2).unwrap();
1612                 let chan_keys = local_chan.get_local_keys();
1613                 let pubkeys = chan_keys.pubkeys();
1614                 (pubkeys.revocation_basepoint, pubkeys.htlc_basepoint, pubkeys.payment_point,
1615                  chan_keys.release_commitment_secret(INITIAL_COMMITMENT_NUMBER), chan_keys.release_commitment_secret(INITIAL_COMMITMENT_NUMBER - 2))
1616         };
1617         let (remote_delayed_payment_basepoint, remote_htlc_basepoint, remote_payment_point, remote_secret1) = {
1618                 let chan_lock = nodes[1].node.channel_state.lock().unwrap();
1619                 let remote_chan = chan_lock.by_id.get(&chan.2).unwrap();
1620                 let chan_keys = remote_chan.get_local_keys();
1621                 let pubkeys = chan_keys.pubkeys();
1622                 (pubkeys.delayed_payment_basepoint, pubkeys.htlc_basepoint, pubkeys.payment_point,
1623                  chan_keys.release_commitment_secret(INITIAL_COMMITMENT_NUMBER - 1))
1624         };
1625
1626         // Assemble the set of keys we can use for signatures for our commitment_signed message.
1627         let commitment_secret = SecretKey::from_slice(&remote_secret1).unwrap();
1628         let per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &commitment_secret);
1629         let commit_tx_keys = chan_utils::TxCreationKeys::new(&secp_ctx, &per_commitment_point, &remote_delayed_payment_basepoint,
1630                 &remote_htlc_basepoint, &local_revocation_basepoint, &local_htlc_basepoint).unwrap();
1631
1632         // Build the remote commitment transaction so we can sign it, and then later use the
1633         // signature for the commitment_signed message.
1634         let local_chan_balance = 1313;
1635         let static_payment_pk = local_payment_point.serialize();
1636         let remote_commit_tx_output = TxOut {
1637                                 script_pubkey: Builder::new().push_opcode(opcodes::all::OP_PUSHBYTES_0)
1638                                                              .push_slice(&WPubkeyHash::hash(&static_payment_pk)[..])
1639                                                              .into_script(),
1640                 value: local_chan_balance as u64
1641         };
1642
1643         let local_commit_tx_output = TxOut {
1644                 script_pubkey: chan_utils::get_revokeable_redeemscript(&commit_tx_keys.revocation_key,
1645                                                                                BREAKDOWN_TIMEOUT,
1646                                                                                &commit_tx_keys.a_delayed_payment_key).to_v0_p2wsh(),
1647                                 value: 95000,
1648         };
1649
1650         let accepted_htlc_info = chan_utils::HTLCOutputInCommitment {
1651                 offered: false,
1652                 amount_msat: 3460001,
1653                 cltv_expiry: htlc_cltv,
1654                 payment_hash: payment_hash,
1655                 transaction_output_index: Some(1),
1656         };
1657
1658         let htlc_output = TxOut {
1659                 script_pubkey: chan_utils::get_htlc_redeemscript(&accepted_htlc_info, &commit_tx_keys).to_v0_p2wsh(),
1660                 value: 3460001 / 1000
1661         };
1662
1663         let commit_tx_obscure_factor = {
1664                 let mut sha = Sha256::engine();
1665                 let remote_payment_point = &remote_payment_point.serialize();
1666                 sha.input(&local_payment_point.serialize());
1667                 sha.input(remote_payment_point);
1668                 let res = Sha256::from_engine(sha).into_inner();
1669
1670                 ((res[26] as u64) << 5*8) |
1671                 ((res[27] as u64) << 4*8) |
1672                 ((res[28] as u64) << 3*8) |
1673                 ((res[29] as u64) << 2*8) |
1674                 ((res[30] as u64) << 1*8) |
1675                 ((res[31] as u64) << 0*8)
1676         };
1677         let commitment_number = 1;
1678         let obscured_commitment_transaction_number = commit_tx_obscure_factor ^ commitment_number;
1679         let lock_time = ((0x20 as u32) << 8*3) | ((obscured_commitment_transaction_number & 0xffffffu64) as u32);
1680         let input = TxIn {
1681                 previous_output: BitcoinOutPoint { txid: chan.3.txid(), vout: 0 },
1682                 script_sig: Script::new(),
1683                 sequence: ((0x80 as u32) << 8*3) | ((obscured_commitment_transaction_number >> 3*8) as u32),
1684                 witness: Vec::new(),
1685         };
1686
1687         let commit_tx = Transaction {
1688                 version: 2,
1689                 lock_time,
1690                 input: vec![input],
1691                 output: vec![remote_commit_tx_output, htlc_output, local_commit_tx_output],
1692         };
1693         let res = {
1694                 let local_chan_lock = nodes[0].node.channel_state.lock().unwrap();
1695                 let local_chan = local_chan_lock.by_id.get(&chan.2).unwrap();
1696                 let local_chan_keys = local_chan.get_local_keys();
1697                 local_chan_keys.sign_remote_commitment(feerate_per_kw, &commit_tx, &commit_tx_keys, &[&accepted_htlc_info],
1698                 BREAKDOWN_TIMEOUT, &secp_ctx).unwrap()
1699         };
1700
1701         let commit_signed_msg = msgs::CommitmentSigned {
1702                 channel_id: chan.2,
1703                 signature: res.0,
1704                 htlc_signatures: res.1
1705         };
1706
1707         // Send the commitment_signed message to the nodes[1].
1708         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &commit_signed_msg);
1709         let _ = nodes[1].node.get_and_clear_pending_msg_events();
1710
1711         // Send the RAA to nodes[1].
1712         let per_commitment_secret = local_secret;
1713         let next_secret = SecretKey::from_slice(&local_secret2).unwrap();
1714         let next_per_commitment_point = PublicKey::from_secret_key(&secp_ctx, &next_secret);
1715         let raa_msg = msgs::RevokeAndACK{ channel_id: chan.2, per_commitment_secret, next_per_commitment_point};
1716         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &raa_msg);
1717
1718         let events = nodes[1].node.get_and_clear_pending_msg_events();
1719         assert_eq!(events.len(), 1);
1720         // Make sure the HTLC failed in the way we expect.
1721         match events[0] {
1722                 MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fail_htlcs, .. }, .. } => {
1723                         assert_eq!(update_fail_htlcs.len(), 1);
1724                         update_fail_htlcs[0].clone()
1725                 },
1726                 _ => panic!("Unexpected event"),
1727         };
1728         nodes[1].logger.assert_log("lightning::ln::channel".to_string(), "Attempting to fail HTLC due to fee spike buffer violation".to_string(), 1);
1729
1730         check_added_monitors!(nodes[1], 2);
1731 }
1732
1733 #[test]
1734 fn test_chan_reserve_violation_outbound_htlc_inbound_chan() {
1735         let mut chanmon_cfgs = create_chanmon_cfgs(2);
1736         // Set the fee rate for the channel very high, to the point where the fundee
1737         // sending any amount would result in a channel reserve violation. In this test
1738         // we check that we would be prevented from sending an HTLC in this situation.
1739         chanmon_cfgs[0].fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 6000 };
1740         chanmon_cfgs[1].fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 6000 };
1741         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1742         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1743         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1744         let _ = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
1745         let logger = test_utils::TestLogger::new();
1746
1747         macro_rules! get_route_and_payment_hash {
1748                 ($recv_value: expr) => {{
1749                         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[1]);
1750                         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
1751                         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();
1752                         (route, payment_hash, payment_preimage)
1753                 }}
1754         };
1755
1756         let (route, our_payment_hash, _) = get_route_and_payment_hash!(1000);
1757         unwrap_send_err!(nodes[1].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
1758                 assert_eq!(err, "Cannot send value that would put them under remote channel reserve value"));
1759         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
1760         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);
1761 }
1762
1763 #[test]
1764 fn test_chan_reserve_violation_inbound_htlc_outbound_channel() {
1765         let mut chanmon_cfgs = create_chanmon_cfgs(2);
1766         // Set the fee rate for the channel very high, to the point where the funder
1767         // receiving 1 update_add_htlc would result in them closing the channel due
1768         // to channel reserve violation. This close could also happen if the fee went
1769         // up a more realistic amount, but many HTLCs were outstanding at the time of
1770         // the update_add_htlc.
1771         chanmon_cfgs[0].fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 6000 };
1772         chanmon_cfgs[1].fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 6000 };
1773         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
1774         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
1775         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
1776         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
1777         let logger = test_utils::TestLogger::new();
1778
1779         macro_rules! get_route_and_payment_hash {
1780                 ($recv_value: expr) => {{
1781                         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[1]);
1782                         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
1783                         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();
1784                         (route, payment_hash, payment_preimage)
1785                 }}
1786         };
1787
1788         let (route, payment_hash, _) = get_route_and_payment_hash!(1000);
1789         // Need to manually create the update_add_htlc message to go around the channel reserve check in send_htlc()
1790         let secp_ctx = Secp256k1::new();
1791         let session_priv = SecretKey::from_slice(&[42; 32]).unwrap();
1792         let cur_height = nodes[1].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
1793         let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route.paths[0], &session_priv).unwrap();
1794         let (onion_payloads, htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 1000, &None, cur_height).unwrap();
1795         let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash);
1796         let msg = msgs::UpdateAddHTLC {
1797                 channel_id: chan.2,
1798                 htlc_id: 1,
1799                 amount_msat: htlc_msat + 1,
1800                 payment_hash: payment_hash,
1801                 cltv_expiry: htlc_cltv,
1802                 onion_routing_packet: onion_packet,
1803         };
1804
1805         nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &msg);
1806         // Check that the payment failed and the channel is closed in response to the malicious UpdateAdd.
1807         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);
1808         assert_eq!(nodes[0].node.list_channels().len(), 0);
1809         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
1810         assert_eq!(err_msg.data, "Cannot receive value that would put us under local channel reserve value");
1811         check_added_monitors!(nodes[0], 1);
1812 }
1813
1814 #[test]
1815 fn test_chan_reserve_violation_inbound_htlc_inbound_chan() {
1816         let chanmon_cfgs = create_chanmon_cfgs(3);
1817         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
1818         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
1819         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1820         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
1821         let _ = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
1822         let logger = test_utils::TestLogger::new();
1823
1824         macro_rules! get_route_and_payment_hash {
1825                 ($recv_value: expr) => {{
1826                         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[0]);
1827                         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
1828                         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();
1829                         (route, payment_hash, payment_preimage)
1830                 }}
1831         };
1832
1833         let feemsat = 239;
1834         let total_routing_fee_msat = (nodes.len() - 2) as u64 * feemsat;
1835         let chan_stat = get_channel_value_stat!(nodes[0], chan.2);
1836         let feerate = get_feerate!(nodes[0], chan.2);
1837
1838         // Add a 2* and +1 for the fee spike reserve.
1839         let commit_tx_fee_2_htlc = 2*commit_tx_fee_msat(feerate, 2 + 1);
1840         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;
1841         let amt_msat_1 = recv_value_1 + total_routing_fee_msat;
1842
1843         // Add a pending HTLC.
1844         let (route_1, our_payment_hash_1, _) = get_route_and_payment_hash!(amt_msat_1);
1845         let payment_event_1 = {
1846                 nodes[0].node.send_payment(&route_1, our_payment_hash_1, &None).unwrap();
1847                 check_added_monitors!(nodes[0], 1);
1848
1849                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1850                 assert_eq!(events.len(), 1);
1851                 SendEvent::from_event(events.remove(0))
1852         };
1853         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event_1.msgs[0]);
1854
1855         // Attempt to trigger a channel reserve violation --> payment failure.
1856         let commit_tx_fee_2_htlcs = commit_tx_fee_msat(feerate, 2);
1857         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;
1858         let amt_msat_2 = recv_value_2 + total_routing_fee_msat;
1859         let (route_2, _, _) = get_route_and_payment_hash!(amt_msat_2);
1860
1861         // Need to manually create the update_add_htlc message to go around the channel reserve check in send_htlc()
1862         let secp_ctx = Secp256k1::new();
1863         let session_priv = SecretKey::from_slice(&[42; 32]).unwrap();
1864         let cur_height = nodes[0].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
1865         let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route_2.paths[0], &session_priv).unwrap();
1866         let (onion_payloads, htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route_2.paths[0], recv_value_2, &None, cur_height).unwrap();
1867         let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &our_payment_hash_1);
1868         let msg = msgs::UpdateAddHTLC {
1869                 channel_id: chan.2,
1870                 htlc_id: 1,
1871                 amount_msat: htlc_msat + 1,
1872                 payment_hash: our_payment_hash_1,
1873                 cltv_expiry: htlc_cltv,
1874                 onion_routing_packet: onion_packet,
1875         };
1876
1877         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &msg);
1878         // Check that the payment failed and the channel is closed in response to the malicious UpdateAdd.
1879         nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Remote HTLC add would put them under remote reserve value".to_string(), 1);
1880         assert_eq!(nodes[1].node.list_channels().len(), 1);
1881         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
1882         assert_eq!(err_msg.data, "Remote HTLC add would put them under remote reserve value");
1883         check_added_monitors!(nodes[1], 1);
1884 }
1885
1886 fn commit_tx_fee_msat(feerate: u32, num_htlcs: u64) -> u64 {
1887         (COMMITMENT_TX_BASE_WEIGHT + num_htlcs * COMMITMENT_TX_WEIGHT_PER_HTLC) * feerate as u64 / 1000 * 1000
1888 }
1889
1890 #[test]
1891 fn test_channel_reserve_holding_cell_htlcs() {
1892         let chanmon_cfgs = create_chanmon_cfgs(3);
1893         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
1894         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
1895         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
1896         let chan_1 = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 190000, 1001, InitFeatures::known(), InitFeatures::known());
1897         let chan_2 = create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 190000, 1001, InitFeatures::known(), InitFeatures::known());
1898         let logger = test_utils::TestLogger::new();
1899
1900         let mut stat01 = get_channel_value_stat!(nodes[0], chan_1.2);
1901         let mut stat11 = get_channel_value_stat!(nodes[1], chan_1.2);
1902
1903         let mut stat12 = get_channel_value_stat!(nodes[1], chan_2.2);
1904         let mut stat22 = get_channel_value_stat!(nodes[2], chan_2.2);
1905
1906         macro_rules! get_route_and_payment_hash {
1907                 ($recv_value: expr) => {{
1908                         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(nodes[0]);
1909                         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
1910                         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();
1911                         (route, payment_hash, payment_preimage)
1912                 }}
1913         };
1914
1915         macro_rules! expect_forward {
1916                 ($node: expr) => {{
1917                         let mut events = $node.node.get_and_clear_pending_msg_events();
1918                         assert_eq!(events.len(), 1);
1919                         check_added_monitors!($node, 1);
1920                         let payment_event = SendEvent::from_event(events.remove(0));
1921                         payment_event
1922                 }}
1923         }
1924
1925         let feemsat = 239; // somehow we know?
1926         let total_fee_msat = (nodes.len() - 2) as u64 * feemsat;
1927         let feerate = get_feerate!(nodes[0], chan_1.2);
1928
1929         let recv_value_0 = stat01.their_max_htlc_value_in_flight_msat - total_fee_msat;
1930
1931         // attempt to send amt_msat > their_max_htlc_value_in_flight_msat
1932         {
1933                 let (route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value_0 + 1);
1934                 assert!(route.paths[0].iter().rev().skip(1).all(|h| h.fee_msat == feemsat));
1935                 unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
1936                         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)));
1937                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
1938                 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);
1939         }
1940
1941         // channel reserve is bigger than their_max_htlc_value_in_flight_msat so loop to deplete
1942         // nodes[0]'s wealth
1943         loop {
1944                 let amt_msat = recv_value_0 + total_fee_msat;
1945                 // 3 for the 3 HTLCs that will be sent, 2* and +1 for the fee spike reserve.
1946                 // Also, ensure that each payment has enough to be over the dust limit to
1947                 // ensure it'll be included in each commit tx fee calculation.
1948                 let commit_tx_fee_all_htlcs = 2*commit_tx_fee_msat(feerate, 3 + 1);
1949                 let ensure_htlc_amounts_above_dust_buffer = 3 * (stat01.their_dust_limit_msat + 1000);
1950                 if stat01.value_to_self_msat < stat01.channel_reserve_msat + commit_tx_fee_all_htlcs + ensure_htlc_amounts_above_dust_buffer + amt_msat {
1951                         break;
1952                 }
1953                 send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_0, recv_value_0);
1954
1955                 let (stat01_, stat11_, stat12_, stat22_) = (
1956                         get_channel_value_stat!(nodes[0], chan_1.2),
1957                         get_channel_value_stat!(nodes[1], chan_1.2),
1958                         get_channel_value_stat!(nodes[1], chan_2.2),
1959                         get_channel_value_stat!(nodes[2], chan_2.2),
1960                 );
1961
1962                 assert_eq!(stat01_.value_to_self_msat, stat01.value_to_self_msat - amt_msat);
1963                 assert_eq!(stat11_.value_to_self_msat, stat11.value_to_self_msat + amt_msat);
1964                 assert_eq!(stat12_.value_to_self_msat, stat12.value_to_self_msat - (amt_msat - feemsat));
1965                 assert_eq!(stat22_.value_to_self_msat, stat22.value_to_self_msat + (amt_msat - feemsat));
1966                 stat01 = stat01_; stat11 = stat11_; stat12 = stat12_; stat22 = stat22_;
1967         }
1968
1969         // adding pending output.
1970         // 2* and +1 HTLCs on the commit tx fee for the fee spike reserve.
1971         // The reason we're dividing by two here is as follows: the dividend is the total outbound liquidity
1972         // after fees, the channel reserve, and the fee spike buffer are removed. We eventually want to
1973         // divide this quantity into 3 portions, that will each be sent in an HTLC. This allows us
1974         // to test channel channel reserve policy at the edges of what amount is sendable, i.e.
1975         // cases where 1 msat over X amount will cause a payment failure, but anything less than
1976         // that can be sent successfully. So, dividing by two is a somewhat arbitrary way of getting
1977         // the amount of the first of these aforementioned 3 payments. The reason we split into 3 payments
1978         // is to test the behavior of the holding cell with respect to channel reserve and commit tx fee
1979         // policy.
1980         let commit_tx_fee_2_htlcs = 2*commit_tx_fee_msat(feerate, 2 + 1);
1981         let recv_value_1 = (stat01.value_to_self_msat - stat01.channel_reserve_msat - total_fee_msat - commit_tx_fee_2_htlcs)/2;
1982         let amt_msat_1 = recv_value_1 + total_fee_msat;
1983
1984         let (route_1, our_payment_hash_1, our_payment_preimage_1) = get_route_and_payment_hash!(recv_value_1);
1985         let payment_event_1 = {
1986                 nodes[0].node.send_payment(&route_1, our_payment_hash_1, &None).unwrap();
1987                 check_added_monitors!(nodes[0], 1);
1988
1989                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
1990                 assert_eq!(events.len(), 1);
1991                 SendEvent::from_event(events.remove(0))
1992         };
1993         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event_1.msgs[0]);
1994
1995         // channel reserve test with htlc pending output > 0
1996         let recv_value_2 = stat01.value_to_self_msat - amt_msat_1 - stat01.channel_reserve_msat - total_fee_msat - commit_tx_fee_2_htlcs;
1997         {
1998                 let (route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value_2 + 1);
1999                 unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
2000                         assert!(regex::Regex::new(r"Cannot send value that would put us under local channel reserve value \(\d+\)").unwrap().is_match(err)));
2001                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
2002         }
2003
2004         // split the rest to test holding cell
2005         let commit_tx_fee_3_htlcs = 2*commit_tx_fee_msat(feerate, 3 + 1);
2006         let additional_htlc_cost_msat = commit_tx_fee_3_htlcs - commit_tx_fee_2_htlcs;
2007         let recv_value_21 = recv_value_2/2 - additional_htlc_cost_msat/2;
2008         let recv_value_22 = recv_value_2 - recv_value_21 - total_fee_msat - additional_htlc_cost_msat;
2009         {
2010                 let stat = get_channel_value_stat!(nodes[0], chan_1.2);
2011                 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);
2012         }
2013
2014         // now see if they go through on both sides
2015         let (route_21, our_payment_hash_21, our_payment_preimage_21) = get_route_and_payment_hash!(recv_value_21);
2016         // but this will stuck in the holding cell
2017         nodes[0].node.send_payment(&route_21, our_payment_hash_21, &None).unwrap();
2018         check_added_monitors!(nodes[0], 0);
2019         let events = nodes[0].node.get_and_clear_pending_events();
2020         assert_eq!(events.len(), 0);
2021
2022         // test with outbound holding cell amount > 0
2023         {
2024                 let (route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value_22+1);
2025                 unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
2026                         assert!(regex::Regex::new(r"Cannot send value that would put us under local channel reserve value \(\d+\)").unwrap().is_match(err)));
2027                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
2028                 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);
2029         }
2030
2031         let (route_22, our_payment_hash_22, our_payment_preimage_22) = get_route_and_payment_hash!(recv_value_22);
2032         // this will also stuck in the holding cell
2033         nodes[0].node.send_payment(&route_22, our_payment_hash_22, &None).unwrap();
2034         check_added_monitors!(nodes[0], 0);
2035         assert!(nodes[0].node.get_and_clear_pending_events().is_empty());
2036         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
2037
2038         // flush the pending htlc
2039         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event_1.commitment_msg);
2040         let (as_revoke_and_ack, as_commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
2041         check_added_monitors!(nodes[1], 1);
2042
2043         // the pending htlc should be promoted to committed
2044         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_revoke_and_ack);
2045         check_added_monitors!(nodes[0], 1);
2046         let commitment_update_2 = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
2047
2048         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &as_commitment_signed);
2049         let bs_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
2050         // No commitment_signed so get_event_msg's assert(len == 1) passes
2051         check_added_monitors!(nodes[0], 1);
2052
2053         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &bs_revoke_and_ack);
2054         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
2055         check_added_monitors!(nodes[1], 1);
2056
2057         expect_pending_htlcs_forwardable!(nodes[1]);
2058
2059         let ref payment_event_11 = expect_forward!(nodes[1]);
2060         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_11.msgs[0]);
2061         commitment_signed_dance!(nodes[2], nodes[1], payment_event_11.commitment_msg, false);
2062
2063         expect_pending_htlcs_forwardable!(nodes[2]);
2064         expect_payment_received!(nodes[2], our_payment_hash_1, recv_value_1);
2065
2066         // flush the htlcs in the holding cell
2067         assert_eq!(commitment_update_2.update_add_htlcs.len(), 2);
2068         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &commitment_update_2.update_add_htlcs[0]);
2069         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &commitment_update_2.update_add_htlcs[1]);
2070         commitment_signed_dance!(nodes[1], nodes[0], &commitment_update_2.commitment_signed, false);
2071         expect_pending_htlcs_forwardable!(nodes[1]);
2072
2073         let ref payment_event_3 = expect_forward!(nodes[1]);
2074         assert_eq!(payment_event_3.msgs.len(), 2);
2075         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_3.msgs[0]);
2076         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event_3.msgs[1]);
2077
2078         commitment_signed_dance!(nodes[2], nodes[1], &payment_event_3.commitment_msg, false);
2079         expect_pending_htlcs_forwardable!(nodes[2]);
2080
2081         let events = nodes[2].node.get_and_clear_pending_events();
2082         assert_eq!(events.len(), 2);
2083         match events[0] {
2084                 Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
2085                         assert_eq!(our_payment_hash_21, *payment_hash);
2086                         assert_eq!(*payment_secret, None);
2087                         assert_eq!(recv_value_21, amt);
2088                 },
2089                 _ => panic!("Unexpected event"),
2090         }
2091         match events[1] {
2092                 Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
2093                         assert_eq!(our_payment_hash_22, *payment_hash);
2094                         assert_eq!(None, *payment_secret);
2095                         assert_eq!(recv_value_22, amt);
2096                 },
2097                 _ => panic!("Unexpected event"),
2098         }
2099
2100         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_1, recv_value_1);
2101         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_21, recv_value_21);
2102         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), our_payment_preimage_22, recv_value_22);
2103
2104         let commit_tx_fee_0_htlcs = 2*commit_tx_fee_msat(feerate, 1);
2105         let recv_value_3 = commit_tx_fee_2_htlcs - commit_tx_fee_0_htlcs - total_fee_msat;
2106         {
2107                 let (route, our_payment_hash, _) = get_route_and_payment_hash!(recv_value_3 + 1);
2108                 let err = nodes[0].node.send_payment(&route, our_payment_hash, &None).err().unwrap();
2109                 match err {
2110                         PaymentSendFailure::AllFailedRetrySafe(ref fails) => {
2111                                 match &fails[0] {
2112                                         &APIError::ChannelUnavailable{ref err} =>
2113                                                 assert!(regex::Regex::new(r"Cannot send value that would put us under local channel reserve value \(\d+\)").unwrap().is_match(err)),
2114                                         _ => panic!("Unexpected error variant"),
2115                                 }
2116                         },
2117                         _ => panic!("Unexpected error variant"),
2118                 }
2119                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
2120                 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);
2121         }
2122
2123         send_payment(&nodes[0], &vec![&nodes[1], &nodes[2]][..], recv_value_3, recv_value_3);
2124
2125         let commit_tx_fee_1_htlc = 2*commit_tx_fee_msat(feerate, 1 + 1);
2126         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);
2127         let stat0 = get_channel_value_stat!(nodes[0], chan_1.2);
2128         assert_eq!(stat0.value_to_self_msat, expected_value_to_self);
2129         assert_eq!(stat0.value_to_self_msat, stat0.channel_reserve_msat + commit_tx_fee_1_htlc);
2130
2131         let stat2 = get_channel_value_stat!(nodes[2], chan_2.2);
2132         assert_eq!(stat2.value_to_self_msat, stat22.value_to_self_msat + recv_value_1 + recv_value_21 + recv_value_22 + recv_value_3);
2133 }
2134
2135 #[test]
2136 fn channel_reserve_in_flight_removes() {
2137         // In cases where one side claims an HTLC, it thinks it has additional available funds that it
2138         // can send to its counterparty, but due to update ordering, the other side may not yet have
2139         // considered those HTLCs fully removed.
2140         // This tests that we don't count HTLCs which will not be included in the next remote
2141         // commitment transaction towards the reserve value (as it implies no commitment transaction
2142         // will be generated which violates the remote reserve value).
2143         // This was broken previously, and discovered by the chanmon_fail_consistency fuzz test.
2144         // To test this we:
2145         //  * route two HTLCs from A to B (note that, at a high level, this test is checking that, when
2146         //    you consider the values of both of these HTLCs, B may not send an HTLC back to A, but if
2147         //    you only consider the value of the first HTLC, it may not),
2148         //  * start routing a third HTLC from A to B,
2149         //  * claim the first two HTLCs (though B will generate an update_fulfill for one, and put
2150         //    the other claim in its holding cell, as it immediately goes into AwaitingRAA),
2151         //  * deliver the first fulfill from B
2152         //  * deliver the update_add and an RAA from A, resulting in B freeing the second holding cell
2153         //    claim,
2154         //  * deliver A's response CS and RAA.
2155         //    This results in A having the second HTLC in AwaitingRemovedRemoteRevoke, but B having
2156         //    removed it fully. B now has the push_msat plus the first two HTLCs in value.
2157         //  * Now B happily sends another HTLC, potentially violating its reserve value from A's point
2158         //    of view (if A counts the AwaitingRemovedRemoteRevoke HTLC).
2159         let chanmon_cfgs = create_chanmon_cfgs(2);
2160         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2161         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
2162         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2163         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2164         let logger = test_utils::TestLogger::new();
2165
2166         let b_chan_values = get_channel_value_stat!(nodes[1], chan_1.2);
2167         // Route the first two HTLCs.
2168         let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], b_chan_values.channel_reserve_msat - b_chan_values.value_to_self_msat - 10000);
2169         let (payment_preimage_2, _) = route_payment(&nodes[0], &[&nodes[1]], 20000);
2170
2171         // Start routing the third HTLC (this is just used to get everyone in the right state).
2172         let (payment_preimage_3, payment_hash_3) = get_payment_preimage_hash!(nodes[0]);
2173         let send_1 = {
2174                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
2175                 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();
2176                 nodes[0].node.send_payment(&route, payment_hash_3, &None).unwrap();
2177                 check_added_monitors!(nodes[0], 1);
2178                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
2179                 assert_eq!(events.len(), 1);
2180                 SendEvent::from_event(events.remove(0))
2181         };
2182
2183         // Now claim both of the first two HTLCs on B's end, putting B in AwaitingRAA and generating an
2184         // initial fulfill/CS.
2185         assert!(nodes[1].node.claim_funds(payment_preimage_1, &None, b_chan_values.channel_reserve_msat - b_chan_values.value_to_self_msat - 10000));
2186         check_added_monitors!(nodes[1], 1);
2187         let bs_removes = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
2188
2189         // This claim goes in B's holding cell, allowing us to have a pending B->A RAA which does not
2190         // remove the second HTLC when we send the HTLC back from B to A.
2191         assert!(nodes[1].node.claim_funds(payment_preimage_2, &None, 20000));
2192         check_added_monitors!(nodes[1], 1);
2193         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
2194
2195         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &bs_removes.update_fulfill_htlcs[0]);
2196         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_removes.commitment_signed);
2197         check_added_monitors!(nodes[0], 1);
2198         let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
2199         expect_payment_sent!(nodes[0], payment_preimage_1);
2200
2201         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &send_1.msgs[0]);
2202         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &send_1.commitment_msg);
2203         check_added_monitors!(nodes[1], 1);
2204         // B is already AwaitingRAA, so cant generate a CS here
2205         let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
2206
2207         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
2208         check_added_monitors!(nodes[1], 1);
2209         let bs_cs = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
2210
2211         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_raa);
2212         check_added_monitors!(nodes[0], 1);
2213         let as_cs = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
2214
2215         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_cs.commitment_signed);
2216         check_added_monitors!(nodes[1], 1);
2217         let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
2218
2219         // The second HTLCis removed, but as A is in AwaitingRAA it can't generate a CS here, so the
2220         // RAA that B generated above doesn't fully resolve the second HTLC from A's point of view.
2221         // However, the RAA A generates here *does* fully resolve the HTLC from B's point of view (as A
2222         // can no longer broadcast a commitment transaction with it and B has the preimage so can go
2223         // on-chain as necessary).
2224         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &bs_cs.update_fulfill_htlcs[0]);
2225         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_cs.commitment_signed);
2226         check_added_monitors!(nodes[0], 1);
2227         let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
2228         expect_payment_sent!(nodes[0], payment_preimage_2);
2229
2230         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
2231         check_added_monitors!(nodes[1], 1);
2232         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
2233
2234         expect_pending_htlcs_forwardable!(nodes[1]);
2235         expect_payment_received!(nodes[1], payment_hash_3, 100000);
2236
2237         // Note that as this RAA was generated before the delivery of the update_fulfill it shouldn't
2238         // resolve the second HTLC from A's point of view.
2239         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_raa);
2240         check_added_monitors!(nodes[0], 1);
2241         let as_cs = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
2242
2243         // Now that B doesn't have the second RAA anymore, but A still does, send a payment from B back
2244         // to A to ensure that A doesn't count the almost-removed HTLC in update_add processing.
2245         let (payment_preimage_4, payment_hash_4) = get_payment_preimage_hash!(nodes[1]);
2246         let send_2 = {
2247                 let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
2248                 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();
2249                 nodes[1].node.send_payment(&route, payment_hash_4, &None).unwrap();
2250                 check_added_monitors!(nodes[1], 1);
2251                 let mut events = nodes[1].node.get_and_clear_pending_msg_events();
2252                 assert_eq!(events.len(), 1);
2253                 SendEvent::from_event(events.remove(0))
2254         };
2255
2256         nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &send_2.msgs[0]);
2257         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &send_2.commitment_msg);
2258         check_added_monitors!(nodes[0], 1);
2259         let as_raa = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
2260
2261         // Now just resolve all the outstanding messages/HTLCs for completeness...
2262
2263         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_cs.commitment_signed);
2264         check_added_monitors!(nodes[1], 1);
2265         let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
2266
2267         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_raa);
2268         check_added_monitors!(nodes[1], 1);
2269
2270         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_raa);
2271         check_added_monitors!(nodes[0], 1);
2272         let as_cs = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
2273
2274         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_cs.commitment_signed);
2275         check_added_monitors!(nodes[1], 1);
2276         let bs_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
2277
2278         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_raa);
2279         check_added_monitors!(nodes[0], 1);
2280
2281         expect_pending_htlcs_forwardable!(nodes[0]);
2282         expect_payment_received!(nodes[0], payment_hash_4, 10000);
2283
2284         claim_payment(&nodes[1], &[&nodes[0]], payment_preimage_4, 10_000);
2285         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_3, 100_000);
2286 }
2287
2288 #[test]
2289 fn channel_monitor_network_test() {
2290         // Simple test which builds a network of ChannelManagers, connects them to each other, and
2291         // tests that ChannelMonitor is able to recover from various states.
2292         let chanmon_cfgs = create_chanmon_cfgs(5);
2293         let node_cfgs = create_node_cfgs(5, &chanmon_cfgs);
2294         let node_chanmgrs = create_node_chanmgrs(5, &node_cfgs, &[None, None, None, None, None]);
2295         let nodes = create_network(5, &node_cfgs, &node_chanmgrs);
2296
2297         // Create some initial channels
2298         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2299         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
2300         let chan_3 = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
2301         let chan_4 = create_announced_chan_between_nodes(&nodes, 3, 4, InitFeatures::known(), InitFeatures::known());
2302
2303         // Rebalance the network a bit by relaying one payment through all the channels...
2304         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
2305         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
2306         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
2307         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2], &nodes[3], &nodes[4])[..], 8000000, 8_000_000);
2308
2309         // Simple case with no pending HTLCs:
2310         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), true);
2311         check_added_monitors!(nodes[1], 1);
2312         {
2313                 let mut node_txn = test_txn_broadcast(&nodes[1], &chan_1, None, HTLCType::NONE);
2314                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2315                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![node_txn.drain(..).next().unwrap()] }, 1);
2316                 check_added_monitors!(nodes[0], 1);
2317                 test_txn_broadcast(&nodes[0], &chan_1, None, HTLCType::NONE);
2318         }
2319         get_announce_close_broadcast_events(&nodes, 0, 1);
2320         assert_eq!(nodes[0].node.list_channels().len(), 0);
2321         assert_eq!(nodes[1].node.list_channels().len(), 1);
2322
2323         // One pending HTLC is discarded by the force-close:
2324         let payment_preimage_1 = route_payment(&nodes[1], &vec!(&nodes[2], &nodes[3])[..], 3000000).0;
2325
2326         // Simple case of one pending HTLC to HTLC-Timeout
2327         nodes[1].node.peer_disconnected(&nodes[2].node.get_our_node_id(), true);
2328         check_added_monitors!(nodes[1], 1);
2329         {
2330                 let mut node_txn = test_txn_broadcast(&nodes[1], &chan_2, None, HTLCType::TIMEOUT);
2331                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2332                 nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![node_txn.drain(..).next().unwrap()] }, 1);
2333                 check_added_monitors!(nodes[2], 1);
2334                 test_txn_broadcast(&nodes[2], &chan_2, None, HTLCType::NONE);
2335         }
2336         get_announce_close_broadcast_events(&nodes, 1, 2);
2337         assert_eq!(nodes[1].node.list_channels().len(), 0);
2338         assert_eq!(nodes[2].node.list_channels().len(), 1);
2339
2340         macro_rules! claim_funds {
2341                 ($node: expr, $prev_node: expr, $preimage: expr, $amount: expr) => {
2342                         {
2343                                 assert!($node.node.claim_funds($preimage, &None, $amount));
2344                                 check_added_monitors!($node, 1);
2345
2346                                 let events = $node.node.get_and_clear_pending_msg_events();
2347                                 assert_eq!(events.len(), 1);
2348                                 match events[0] {
2349                                         MessageSendEvent::UpdateHTLCs { ref node_id, updates: msgs::CommitmentUpdate { ref update_add_htlcs, ref update_fail_htlcs, .. } } => {
2350                                                 assert!(update_add_htlcs.is_empty());
2351                                                 assert!(update_fail_htlcs.is_empty());
2352                                                 assert_eq!(*node_id, $prev_node.node.get_our_node_id());
2353                                         },
2354                                         _ => panic!("Unexpected event"),
2355                                 };
2356                         }
2357                 }
2358         }
2359
2360         // nodes[3] gets the preimage, but nodes[2] already disconnected, resulting in a nodes[2]
2361         // HTLC-Timeout and a nodes[3] claim against it (+ its own announces)
2362         nodes[2].node.peer_disconnected(&nodes[3].node.get_our_node_id(), true);
2363         check_added_monitors!(nodes[2], 1);
2364         let node2_commitment_txid;
2365         {
2366                 let node_txn = test_txn_broadcast(&nodes[2], &chan_3, None, HTLCType::TIMEOUT);
2367                 node2_commitment_txid = node_txn[0].txid();
2368
2369                 // Claim the payment on nodes[3], giving it knowledge of the preimage
2370                 claim_funds!(nodes[3], nodes[2], payment_preimage_1, 3_000_000);
2371
2372                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2373                 nodes[3].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone()] }, 1);
2374                 check_added_monitors!(nodes[3], 1);
2375
2376                 check_preimage_claim(&nodes[3], &node_txn);
2377         }
2378         get_announce_close_broadcast_events(&nodes, 2, 3);
2379         assert_eq!(nodes[2].node.list_channels().len(), 0);
2380         assert_eq!(nodes[3].node.list_channels().len(), 1);
2381
2382         { // Cheat and reset nodes[4]'s height to 1
2383                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2384                 nodes[4].block_notifier.block_connected(&Block { header, txdata: vec![] }, 1);
2385         }
2386
2387         assert_eq!(nodes[3].node.latest_block_height.load(Ordering::Acquire), 1);
2388         assert_eq!(nodes[4].node.latest_block_height.load(Ordering::Acquire), 1);
2389         // One pending HTLC to time out:
2390         let payment_preimage_2 = route_payment(&nodes[3], &vec!(&nodes[4])[..], 3000000).0;
2391         // CLTV expires at TEST_FINAL_CLTV + 1 (current height) + 1 (added in send_payment for
2392         // buffer space).
2393
2394         {
2395                 let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2396                 nodes[3].block_notifier.block_connected_checked(&header, 2, &Vec::new()[..], &[0; 0]);
2397                 for i in 3..TEST_FINAL_CLTV + 2 + LATENCY_GRACE_PERIOD_BLOCKS + 1 {
2398                         header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2399                         nodes[3].block_notifier.block_connected_checked(&header, i, &Vec::new()[..], &[0; 0]);
2400                 }
2401                 check_added_monitors!(nodes[3], 1);
2402
2403                 // Clear bumped claiming txn spending node 2 commitment tx. Bumped txn are generated after reaching some height timer.
2404                 {
2405                         let mut node_txn = nodes[3].tx_broadcaster.txn_broadcasted.lock().unwrap();
2406                         node_txn.retain(|tx| {
2407                                 if tx.input[0].previous_output.txid == node2_commitment_txid {
2408                                         false
2409                                 } else { true }
2410                         });
2411                 }
2412
2413                 let node_txn = test_txn_broadcast(&nodes[3], &chan_4, None, HTLCType::TIMEOUT);
2414
2415                 // Claim the payment on nodes[4], giving it knowledge of the preimage
2416                 claim_funds!(nodes[4], nodes[3], payment_preimage_2, 3_000_000);
2417
2418                 header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2419
2420                 nodes[4].block_notifier.block_connected_checked(&header, 2, &Vec::new()[..], &[0; 0]);
2421                 for i in 3..TEST_FINAL_CLTV + 2 - CLTV_CLAIM_BUFFER + 1 {
2422                         header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2423                         nodes[4].block_notifier.block_connected_checked(&header, i, &Vec::new()[..], &[0; 0]);
2424                 }
2425
2426                 check_added_monitors!(nodes[4], 1);
2427                 test_txn_broadcast(&nodes[4], &chan_4, None, HTLCType::SUCCESS);
2428
2429                 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2430                 nodes[4].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone()] }, TEST_FINAL_CLTV - 5);
2431
2432                 check_preimage_claim(&nodes[4], &node_txn);
2433         }
2434         get_announce_close_broadcast_events(&nodes, 3, 4);
2435         assert_eq!(nodes[3].node.list_channels().len(), 0);
2436         assert_eq!(nodes[4].node.list_channels().len(), 0);
2437 }
2438
2439 #[test]
2440 fn test_justice_tx() {
2441         // Test justice txn built on revoked HTLC-Success tx, against both sides
2442         let mut alice_config = UserConfig::default();
2443         alice_config.channel_options.announced_channel = true;
2444         alice_config.peer_channel_config_limits.force_announced_channel_preference = false;
2445         alice_config.own_channel_config.our_to_self_delay = 6 * 24 * 5;
2446         let mut bob_config = UserConfig::default();
2447         bob_config.channel_options.announced_channel = true;
2448         bob_config.peer_channel_config_limits.force_announced_channel_preference = false;
2449         bob_config.own_channel_config.our_to_self_delay = 6 * 24 * 3;
2450         let user_cfgs = [Some(alice_config), Some(bob_config)];
2451         let chanmon_cfgs = create_chanmon_cfgs(2);
2452         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2453         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &user_cfgs);
2454         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2455         // Create some new channels:
2456         let chan_5 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2457
2458         // A pending HTLC which will be revoked:
2459         let payment_preimage_3 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
2460         // Get the will-be-revoked local txn from nodes[0]
2461         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_5.2);
2462         assert_eq!(revoked_local_txn.len(), 2); // First commitment tx, then HTLC tx
2463         assert_eq!(revoked_local_txn[0].input.len(), 1);
2464         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_5.3.txid());
2465         assert_eq!(revoked_local_txn[0].output.len(), 2); // Only HTLC and output back to 0 are present
2466         assert_eq!(revoked_local_txn[1].input.len(), 1);
2467         assert_eq!(revoked_local_txn[1].input[0].previous_output.txid, revoked_local_txn[0].txid());
2468         assert_eq!(revoked_local_txn[1].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT); // HTLC-Timeout
2469         // Revoke the old state
2470         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3, 3_000_000);
2471
2472         {
2473                 let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2474                 nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2475                 {
2476                         let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2477                         assert_eq!(node_txn.len(), 2); // ChannelMonitor: penalty tx, ChannelManager: local commitment tx
2478                         assert_eq!(node_txn[0].input.len(), 2); // We should claim the revoked output and the HTLC output
2479
2480                         check_spends!(node_txn[0], revoked_local_txn[0]);
2481                         node_txn.swap_remove(0);
2482                         node_txn.truncate(1);
2483                 }
2484                 check_added_monitors!(nodes[1], 1);
2485                 test_txn_broadcast(&nodes[1], &chan_5, None, HTLCType::NONE);
2486
2487                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2488                 // Verify broadcast of revoked HTLC-timeout
2489                 let node_txn = test_txn_broadcast(&nodes[0], &chan_5, Some(revoked_local_txn[0].clone()), HTLCType::TIMEOUT);
2490                 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2491                 check_added_monitors!(nodes[0], 1);
2492                 // Broadcast revoked HTLC-timeout on node 1
2493                 nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[1].clone()] }, 1);
2494                 test_revoked_htlc_claim_txn_broadcast(&nodes[1], node_txn[1].clone(), revoked_local_txn[0].clone());
2495         }
2496         get_announce_close_broadcast_events(&nodes, 0, 1);
2497
2498         assert_eq!(nodes[0].node.list_channels().len(), 0);
2499         assert_eq!(nodes[1].node.list_channels().len(), 0);
2500
2501         // We test justice_tx build by A on B's revoked HTLC-Success tx
2502         // Create some new channels:
2503         let chan_6 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2504         {
2505                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2506                 node_txn.clear();
2507         }
2508
2509         // A pending HTLC which will be revoked:
2510         let payment_preimage_4 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
2511         // Get the will-be-revoked local txn from B
2512         let revoked_local_txn = get_local_commitment_txn!(nodes[1], chan_6.2);
2513         assert_eq!(revoked_local_txn.len(), 1); // Only commitment tx
2514         assert_eq!(revoked_local_txn[0].input.len(), 1);
2515         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_6.3.txid());
2516         assert_eq!(revoked_local_txn[0].output.len(), 2); // Only HTLC and output back to A are present
2517         // Revoke the old state
2518         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_4, 3_000_000);
2519         {
2520                 let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2521                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2522                 {
2523                         let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
2524                         assert_eq!(node_txn.len(), 2); //ChannelMonitor: penalty tx, ChannelManager: local commitment tx
2525                         assert_eq!(node_txn[0].input.len(), 1); // We claim the received HTLC output
2526
2527                         check_spends!(node_txn[0], revoked_local_txn[0]);
2528                         node_txn.swap_remove(0);
2529                 }
2530                 check_added_monitors!(nodes[0], 1);
2531                 test_txn_broadcast(&nodes[0], &chan_6, None, HTLCType::NONE);
2532
2533                 nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2534                 let node_txn = test_txn_broadcast(&nodes[1], &chan_6, Some(revoked_local_txn[0].clone()), HTLCType::SUCCESS);
2535                 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2536                 check_added_monitors!(nodes[1], 1);
2537                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[1].clone()] }, 1);
2538                 test_revoked_htlc_claim_txn_broadcast(&nodes[0], node_txn[1].clone(), revoked_local_txn[0].clone());
2539         }
2540         get_announce_close_broadcast_events(&nodes, 0, 1);
2541         assert_eq!(nodes[0].node.list_channels().len(), 0);
2542         assert_eq!(nodes[1].node.list_channels().len(), 0);
2543 }
2544
2545 #[test]
2546 fn revoked_output_claim() {
2547         // Simple test to ensure a node will claim a revoked output when a stale remote commitment
2548         // transaction is broadcast by its counterparty
2549         let chanmon_cfgs = create_chanmon_cfgs(2);
2550         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2551         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
2552         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2553         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2554         // node[0] is gonna to revoke an old state thus node[1] should be able to claim the revoked output
2555         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
2556         assert_eq!(revoked_local_txn.len(), 1);
2557         // Only output is the full channel value back to nodes[0]:
2558         assert_eq!(revoked_local_txn[0].output.len(), 1);
2559         // Send a payment through, updating everyone's latest commitment txn
2560         send_payment(&nodes[0], &vec!(&nodes[1])[..], 5000000, 5_000_000);
2561
2562         // Inform nodes[1] that nodes[0] broadcast a stale tx
2563         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2564         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2565         check_added_monitors!(nodes[1], 1);
2566         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2567         assert_eq!(node_txn.len(), 2); // ChannelMonitor: justice tx against revoked to_local output, ChannelManager: local commitment tx
2568
2569         check_spends!(node_txn[0], revoked_local_txn[0]);
2570         check_spends!(node_txn[1], chan_1.3);
2571
2572         // Inform nodes[0] that a watchtower cheated on its behalf, so it will force-close the chan
2573         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2574         get_announce_close_broadcast_events(&nodes, 0, 1);
2575         check_added_monitors!(nodes[0], 1)
2576 }
2577
2578 #[test]
2579 fn claim_htlc_outputs_shared_tx() {
2580         // Node revoked old state, htlcs haven't time out yet, claim them in shared justice tx
2581         let chanmon_cfgs = create_chanmon_cfgs(2);
2582         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2583         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
2584         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2585
2586         // Create some new channel:
2587         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2588
2589         // Rebalance the network to generate htlc in the two directions
2590         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
2591         // 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
2592         let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
2593         let (_payment_preimage_2, payment_hash_2) = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000);
2594
2595         // Get the will-be-revoked local txn from node[0]
2596         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
2597         assert_eq!(revoked_local_txn.len(), 2); // commitment tx + 1 HTLC-Timeout tx
2598         assert_eq!(revoked_local_txn[0].input.len(), 1);
2599         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
2600         assert_eq!(revoked_local_txn[1].input.len(), 1);
2601         assert_eq!(revoked_local_txn[1].input[0].previous_output.txid, revoked_local_txn[0].txid());
2602         assert_eq!(revoked_local_txn[1].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT); // HTLC-Timeout
2603         check_spends!(revoked_local_txn[1], revoked_local_txn[0]);
2604
2605         //Revoke the old state
2606         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1, 3_000_000);
2607
2608         {
2609                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2610                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2611                 check_added_monitors!(nodes[0], 1);
2612                 nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
2613                 check_added_monitors!(nodes[1], 1);
2614                 connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
2615                 expect_payment_failed!(nodes[1], payment_hash_2, true);
2616
2617                 let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2618                 assert_eq!(node_txn.len(), 3); // ChannelMonitor: penalty tx, ChannelManager: local commitment + HTLC-timeout
2619
2620                 assert_eq!(node_txn[0].input.len(), 3); // Claim the revoked output + both revoked HTLC outputs
2621                 check_spends!(node_txn[0], revoked_local_txn[0]);
2622
2623                 let mut witness_lens = BTreeSet::new();
2624                 witness_lens.insert(node_txn[0].input[0].witness.last().unwrap().len());
2625                 witness_lens.insert(node_txn[0].input[1].witness.last().unwrap().len());
2626                 witness_lens.insert(node_txn[0].input[2].witness.last().unwrap().len());
2627                 assert_eq!(witness_lens.len(), 3);
2628                 assert_eq!(*witness_lens.iter().skip(0).next().unwrap(), 77); // revoked to_local
2629                 assert_eq!(*witness_lens.iter().skip(1).next().unwrap(), OFFERED_HTLC_SCRIPT_WEIGHT); // revoked offered HTLC
2630                 assert_eq!(*witness_lens.iter().skip(2).next().unwrap(), ACCEPTED_HTLC_SCRIPT_WEIGHT); // revoked received HTLC
2631
2632                 // Next nodes[1] broadcasts its current local tx state:
2633                 assert_eq!(node_txn[1].input.len(), 1);
2634                 assert_eq!(node_txn[1].input[0].previous_output.txid, chan_1.3.txid()); //Spending funding tx unique txouput, tx broadcasted by ChannelManager
2635
2636                 assert_eq!(node_txn[2].input.len(), 1);
2637                 let witness_script = node_txn[2].clone().input[0].witness.pop().unwrap();
2638                 assert_eq!(witness_script.len(), OFFERED_HTLC_SCRIPT_WEIGHT); //Spending an offered htlc output
2639                 assert_eq!(node_txn[2].input[0].previous_output.txid, node_txn[1].txid());
2640                 assert_ne!(node_txn[2].input[0].previous_output.txid, node_txn[0].input[0].previous_output.txid);
2641                 assert_ne!(node_txn[2].input[0].previous_output.txid, node_txn[0].input[1].previous_output.txid);
2642         }
2643         get_announce_close_broadcast_events(&nodes, 0, 1);
2644         assert_eq!(nodes[0].node.list_channels().len(), 0);
2645         assert_eq!(nodes[1].node.list_channels().len(), 0);
2646 }
2647
2648 #[test]
2649 fn claim_htlc_outputs_single_tx() {
2650         // Node revoked old state, htlcs have timed out, claim each of them in separated justice tx
2651         let chanmon_cfgs = create_chanmon_cfgs(2);
2652         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
2653         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
2654         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
2655
2656         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2657
2658         // Rebalance the network to generate htlc in the two directions
2659         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
2660         // 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
2661         // time as two different claim transactions as we're gonna to timeout htlc with given a high current height
2662         let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
2663         let (_payment_preimage_2, payment_hash_2) = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000);
2664
2665         // Get the will-be-revoked local txn from node[0]
2666         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
2667
2668         //Revoke the old state
2669         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_1, 3_000_000);
2670
2671         {
2672                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
2673                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 200);
2674                 check_added_monitors!(nodes[0], 1);
2675                 nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 200);
2676                 check_added_monitors!(nodes[1], 1);
2677                 expect_pending_htlcs_forwardable_ignore!(nodes[0]);
2678
2679                 connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 200, true, header.bitcoin_hash());
2680                 expect_payment_failed!(nodes[1], payment_hash_2, true);
2681
2682                 let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2683                 assert_eq!(node_txn.len(), 9);
2684                 // ChannelMonitor: justice tx revoked offered htlc, justice tx revoked received htlc, justice tx revoked to_local (3)
2685                 // ChannelManager: local commmitment + local HTLC-timeout (2)
2686                 // 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)
2687                 // ChannelMonitor: local commitment + local HTLC-timeout (2)
2688
2689                 // Check the pair local commitment and HTLC-timeout broadcast due to HTLC expiration
2690                 assert_eq!(node_txn[2].input.len(), 1);
2691                 check_spends!(node_txn[2], chan_1.3);
2692                 assert_eq!(node_txn[3].input.len(), 1);
2693                 let witness_script = node_txn[3].input[0].witness.last().unwrap();
2694                 assert_eq!(witness_script.len(), OFFERED_HTLC_SCRIPT_WEIGHT); //Spending an offered htlc output
2695                 check_spends!(node_txn[3], node_txn[2]);
2696
2697                 // Justice transactions are indices 1-2-4
2698                 assert_eq!(node_txn[0].input.len(), 1);
2699                 assert_eq!(node_txn[1].input.len(), 1);
2700                 assert_eq!(node_txn[4].input.len(), 1);
2701
2702                 check_spends!(node_txn[0], revoked_local_txn[0]);
2703                 check_spends!(node_txn[1], revoked_local_txn[0]);
2704                 check_spends!(node_txn[4], revoked_local_txn[0]);
2705
2706                 let mut witness_lens = BTreeSet::new();
2707                 witness_lens.insert(node_txn[0].input[0].witness.last().unwrap().len());
2708                 witness_lens.insert(node_txn[1].input[0].witness.last().unwrap().len());
2709                 witness_lens.insert(node_txn[4].input[0].witness.last().unwrap().len());
2710                 assert_eq!(witness_lens.len(), 3);
2711                 assert_eq!(*witness_lens.iter().skip(0).next().unwrap(), 77); // revoked to_local
2712                 assert_eq!(*witness_lens.iter().skip(1).next().unwrap(), OFFERED_HTLC_SCRIPT_WEIGHT); // revoked offered HTLC
2713                 assert_eq!(*witness_lens.iter().skip(2).next().unwrap(), ACCEPTED_HTLC_SCRIPT_WEIGHT); // revoked received HTLC
2714         }
2715         get_announce_close_broadcast_events(&nodes, 0, 1);
2716         assert_eq!(nodes[0].node.list_channels().len(), 0);
2717         assert_eq!(nodes[1].node.list_channels().len(), 0);
2718 }
2719
2720 #[test]
2721 fn test_htlc_on_chain_success() {
2722         // Test that in case of a unilateral close onchain, we detect the state of output thanks to
2723         // ChainWatchInterface and pass the preimage backward accordingly. So here we test that ChannelManager is
2724         // broadcasting the right event to other nodes in payment path.
2725         // We test with two HTLCs simultaneously as that was not handled correctly in the past.
2726         // A --------------------> B ----------------------> C (preimage)
2727         // First, C should claim the HTLC outputs via HTLC-Success when its own latest local
2728         // commitment transaction was broadcast.
2729         // Then, B should learn the preimage from said transactions, attempting to claim backwards
2730         // towards B.
2731         // B should be able to claim via preimage if A then broadcasts its local tx.
2732         // Finally, when A sees B's latest local commitment transaction it should be able to claim
2733         // the HTLC outputs via the preimage it learned (which, once confirmed should generate a
2734         // PaymentSent event).
2735
2736         let chanmon_cfgs = create_chanmon_cfgs(3);
2737         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
2738         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
2739         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
2740
2741         // Create some initial channels
2742         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2743         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
2744
2745         // Rebalance the network a bit by relaying one payment through all the channels...
2746         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
2747         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
2748
2749         let (our_payment_preimage, _payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
2750         let (our_payment_preimage_2, _payment_hash_2) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
2751         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
2752
2753         // Broadcast legit commitment tx from C on B's chain
2754         // Broadcast HTLC Success transaction by C on received output from C's commitment tx on B's chain
2755         let commitment_tx = get_local_commitment_txn!(nodes[2], chan_2.2);
2756         assert_eq!(commitment_tx.len(), 1);
2757         check_spends!(commitment_tx[0], chan_2.3);
2758         nodes[2].node.claim_funds(our_payment_preimage, &None, 3_000_000);
2759         nodes[2].node.claim_funds(our_payment_preimage_2, &None, 3_000_000);
2760         check_added_monitors!(nodes[2], 2);
2761         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
2762         assert!(updates.update_add_htlcs.is_empty());
2763         assert!(updates.update_fail_htlcs.is_empty());
2764         assert!(updates.update_fail_malformed_htlcs.is_empty());
2765         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
2766
2767         nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
2768         check_closed_broadcast!(nodes[2], false);
2769         check_added_monitors!(nodes[2], 1);
2770         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)
2771         assert_eq!(node_txn.len(), 5);
2772         assert_eq!(node_txn[0], node_txn[3]);
2773         assert_eq!(node_txn[1], node_txn[4]);
2774         assert_eq!(node_txn[2], commitment_tx[0]);
2775         check_spends!(node_txn[0], commitment_tx[0]);
2776         check_spends!(node_txn[1], commitment_tx[0]);
2777         assert_eq!(node_txn[0].input[0].witness.clone().last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
2778         assert_eq!(node_txn[1].input[0].witness.clone().last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
2779         assert!(node_txn[0].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2780         assert!(node_txn[1].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2781         assert_eq!(node_txn[0].lock_time, 0);
2782         assert_eq!(node_txn[1].lock_time, 0);
2783
2784         // Verify that B's ChannelManager is able to extract preimage from HTLC Success tx and pass it backward
2785         nodes[1].block_notifier.block_connected(&Block { header, txdata: node_txn}, 1);
2786         {
2787                 let mut added_monitors = nodes[1].chan_monitor.added_monitors.lock().unwrap();
2788                 assert_eq!(added_monitors.len(), 1);
2789                 assert_eq!(added_monitors[0].0.txid, chan_2.3.txid());
2790                 added_monitors.clear();
2791         }
2792         let events = nodes[1].node.get_and_clear_pending_msg_events();
2793         {
2794                 let mut added_monitors = nodes[1].chan_monitor.added_monitors.lock().unwrap();
2795                 assert_eq!(added_monitors.len(), 2);
2796                 assert_eq!(added_monitors[0].0.txid, chan_1.3.txid());
2797                 assert_eq!(added_monitors[1].0.txid, chan_1.3.txid());
2798                 added_monitors.clear();
2799         }
2800         assert_eq!(events.len(), 2);
2801         match events[0] {
2802                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
2803                 _ => panic!("Unexpected event"),
2804         }
2805         match events[1] {
2806                 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, .. } } => {
2807                         assert!(update_add_htlcs.is_empty());
2808                         assert!(update_fail_htlcs.is_empty());
2809                         assert_eq!(update_fulfill_htlcs.len(), 1);
2810                         assert!(update_fail_malformed_htlcs.is_empty());
2811                         assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
2812                 },
2813                 _ => panic!("Unexpected event"),
2814         };
2815         macro_rules! check_tx_local_broadcast {
2816                 ($node: expr, $htlc_offered: expr, $commitment_tx: expr, $chan_tx: expr) => { {
2817                         let mut node_txn = $node.tx_broadcaster.txn_broadcasted.lock().unwrap();
2818                         assert_eq!(node_txn.len(), 5);
2819                         // Node[1]: ChannelManager: 3 (commitment tx, 2*HTLC-Timeout tx), ChannelMonitor: 2 (timeout tx)
2820                         // Node[0]: ChannelManager: 3 (commtiemtn tx, 2*HTLC-Timeout tx), ChannelMonitor: 2 HTLC-timeout
2821                         check_spends!(node_txn[0], $commitment_tx);
2822                         check_spends!(node_txn[1], $commitment_tx);
2823                         assert_ne!(node_txn[0].lock_time, 0);
2824                         assert_ne!(node_txn[1].lock_time, 0);
2825                         if $htlc_offered {
2826                                 assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2827                                 assert_eq!(node_txn[1].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2828                                 assert!(node_txn[0].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2829                                 assert!(node_txn[1].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2830                         } else {
2831                                 assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
2832                                 assert_eq!(node_txn[1].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
2833                                 assert!(node_txn[0].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
2834                                 assert!(node_txn[1].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
2835                         }
2836                         check_spends!(node_txn[2], $chan_tx);
2837                         check_spends!(node_txn[3], node_txn[2]);
2838                         check_spends!(node_txn[4], node_txn[2]);
2839                         assert_eq!(node_txn[2].input[0].witness.last().unwrap().len(), 71);
2840                         assert_eq!(node_txn[3].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2841                         assert_eq!(node_txn[4].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2842                         assert!(node_txn[3].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2843                         assert!(node_txn[4].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
2844                         assert_ne!(node_txn[3].lock_time, 0);
2845                         assert_ne!(node_txn[4].lock_time, 0);
2846                         node_txn.clear();
2847                 } }
2848         }
2849         // nodes[1] now broadcasts its own local state as a fallback, suggesting an alternate
2850         // commitment transaction with a corresponding HTLC-Timeout transactions, as well as a
2851         // timeout-claim of the output that nodes[2] just claimed via success.
2852         check_tx_local_broadcast!(nodes[1], false, commitment_tx[0], chan_2.3);
2853
2854         // Broadcast legit commitment tx from A on B's chain
2855         // Broadcast preimage tx by B on offered output from A commitment tx  on A's chain
2856         let commitment_tx = get_local_commitment_txn!(nodes[0], chan_1.2);
2857         check_spends!(commitment_tx[0], chan_1.3);
2858         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
2859         check_closed_broadcast!(nodes[1], false);
2860         check_added_monitors!(nodes[1], 1);
2861         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 3 (commitment tx + HTLC-Sucess * 2), ChannelMonitor : 1 (HTLC-Success)
2862         assert_eq!(node_txn.len(), 4);
2863         check_spends!(node_txn[0], commitment_tx[0]);
2864         assert_eq!(node_txn[0].input.len(), 2);
2865         assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2866         assert_eq!(node_txn[0].input[1].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2867         assert_eq!(node_txn[0].lock_time, 0);
2868         assert!(node_txn[0].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
2869         check_spends!(node_txn[1], chan_1.3);
2870         assert_eq!(node_txn[1].input[0].witness.clone().last().unwrap().len(), 71);
2871         check_spends!(node_txn[2], node_txn[1]);
2872         check_spends!(node_txn[3], node_txn[1]);
2873         // We don't bother to check that B can claim the HTLC output on its commitment tx here as
2874         // we already checked the same situation with A.
2875
2876         // Verify that A's ChannelManager is able to extract preimage from preimage tx and generate PaymentSent
2877         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone(), node_txn[0].clone()] }, 1);
2878         check_closed_broadcast!(nodes[0], false);
2879         check_added_monitors!(nodes[0], 1);
2880         let events = nodes[0].node.get_and_clear_pending_events();
2881         assert_eq!(events.len(), 2);
2882         let mut first_claimed = false;
2883         for event in events {
2884                 match event {
2885                         Event::PaymentSent { payment_preimage } => {
2886                                 if payment_preimage == our_payment_preimage {
2887                                         assert!(!first_claimed);
2888                                         first_claimed = true;
2889                                 } else {
2890                                         assert_eq!(payment_preimage, our_payment_preimage_2);
2891                                 }
2892                         },
2893                         _ => panic!("Unexpected event"),
2894                 }
2895         }
2896         check_tx_local_broadcast!(nodes[0], true, commitment_tx[0], chan_1.3);
2897 }
2898
2899 #[test]
2900 fn test_htlc_on_chain_timeout() {
2901         // Test that in case of a unilateral close onchain, we detect the state of output thanks to
2902         // ChainWatchInterface and timeout the HTLC backward accordingly. So here we test that ChannelManager is
2903         // broadcasting the right event to other nodes in payment path.
2904         // A ------------------> B ----------------------> C (timeout)
2905         //    B's commitment tx                 C's commitment tx
2906         //            \                                  \
2907         //         B's HTLC timeout tx               B's timeout tx
2908
2909         let chanmon_cfgs = create_chanmon_cfgs(3);
2910         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
2911         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
2912         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
2913
2914         // Create some intial channels
2915         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
2916         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
2917
2918         // Rebalance the network a bit by relaying one payment thorugh all the channels...
2919         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
2920         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
2921
2922         let (_payment_preimage, payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
2923         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
2924
2925         // Broadcast legit commitment tx from C on B's chain
2926         let commitment_tx = get_local_commitment_txn!(nodes[2], chan_2.2);
2927         check_spends!(commitment_tx[0], chan_2.3);
2928         nodes[2].node.fail_htlc_backwards(&payment_hash, &None);
2929         check_added_monitors!(nodes[2], 0);
2930         expect_pending_htlcs_forwardable!(nodes[2]);
2931         check_added_monitors!(nodes[2], 1);
2932
2933         let events = nodes[2].node.get_and_clear_pending_msg_events();
2934         assert_eq!(events.len(), 1);
2935         match events[0] {
2936                 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, .. } } => {
2937                         assert!(update_add_htlcs.is_empty());
2938                         assert!(!update_fail_htlcs.is_empty());
2939                         assert!(update_fulfill_htlcs.is_empty());
2940                         assert!(update_fail_malformed_htlcs.is_empty());
2941                         assert_eq!(nodes[1].node.get_our_node_id(), *node_id);
2942                 },
2943                 _ => panic!("Unexpected event"),
2944         };
2945         nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
2946         check_closed_broadcast!(nodes[2], false);
2947         check_added_monitors!(nodes[2], 1);
2948         let node_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 1 (commitment tx)
2949         assert_eq!(node_txn.len(), 1);
2950         check_spends!(node_txn[0], chan_2.3);
2951         assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), 71);
2952
2953         // Broadcast timeout transaction by B on received output from C's commitment tx on B's chain
2954         // Verify that B's ChannelManager is able to detect that HTLC is timeout by its own tx and react backward in consequence
2955         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 200);
2956         let timeout_tx;
2957         {
2958                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
2959                 assert_eq!(node_txn.len(), 5); // ChannelManager : 2 (commitment tx, HTLC-Timeout tx), ChannelMonitor : 2 (local commitment tx + HTLC-timeout), 1 timeout tx
2960                 assert_eq!(node_txn[1], node_txn[3]);
2961                 assert_eq!(node_txn[2], node_txn[4]);
2962
2963                 check_spends!(node_txn[0], commitment_tx[0]);
2964                 assert_eq!(node_txn[0].clone().input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
2965
2966                 check_spends!(node_txn[1], chan_2.3);
2967                 check_spends!(node_txn[2], node_txn[1]);
2968                 assert_eq!(node_txn[1].clone().input[0].witness.last().unwrap().len(), 71);
2969                 assert_eq!(node_txn[2].clone().input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
2970
2971                 timeout_tx = node_txn[0].clone();
2972                 node_txn.clear();
2973         }
2974
2975         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![timeout_tx]}, 1);
2976         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
2977         check_added_monitors!(nodes[1], 1);
2978         check_closed_broadcast!(nodes[1], false);
2979
2980         expect_pending_htlcs_forwardable!(nodes[1]);
2981         check_added_monitors!(nodes[1], 1);
2982         let events = nodes[1].node.get_and_clear_pending_msg_events();
2983         assert_eq!(events.len(), 1);
2984         match events[0] {
2985                 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, .. } } => {
2986                         assert!(update_add_htlcs.is_empty());
2987                         assert!(!update_fail_htlcs.is_empty());
2988                         assert!(update_fulfill_htlcs.is_empty());
2989                         assert!(update_fail_malformed_htlcs.is_empty());
2990                         assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
2991                 },
2992                 _ => panic!("Unexpected event"),
2993         };
2994         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
2995         assert_eq!(node_txn.len(), 0);
2996
2997         // Broadcast legit commitment tx from B on A's chain
2998         let commitment_tx = get_local_commitment_txn!(nodes[1], chan_1.2);
2999         check_spends!(commitment_tx[0], chan_1.3);
3000
3001         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 200);
3002         check_closed_broadcast!(nodes[0], false);
3003         check_added_monitors!(nodes[0], 1);
3004         let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 2 (commitment tx, HTLC-Timeout tx), ChannelMonitor : 1 timeout tx
3005         assert_eq!(node_txn.len(), 3);
3006         check_spends!(node_txn[0], commitment_tx[0]);
3007         assert_eq!(node_txn[0].clone().input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
3008         check_spends!(node_txn[1], chan_1.3);
3009         check_spends!(node_txn[2], node_txn[1]);
3010         assert_eq!(node_txn[1].clone().input[0].witness.last().unwrap().len(), 71);
3011         assert_eq!(node_txn[2].clone().input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
3012 }
3013
3014 #[test]
3015 fn test_simple_commitment_revoked_fail_backward() {
3016         // Test that in case of a revoked commitment tx, we detect the resolution of output by justice tx
3017         // and fail backward accordingly.
3018
3019         let chanmon_cfgs = create_chanmon_cfgs(3);
3020         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
3021         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
3022         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
3023
3024         // Create some initial channels
3025         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3026         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
3027
3028         let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
3029         // Get the will-be-revoked local txn from nodes[2]
3030         let revoked_local_txn = get_local_commitment_txn!(nodes[2], chan_2.2);
3031         // Revoke the old state
3032         claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage, 3_000_000);
3033
3034         let (_, payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], 3000000);
3035
3036         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
3037         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
3038         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
3039         check_added_monitors!(nodes[1], 1);
3040         check_closed_broadcast!(nodes[1], false);
3041
3042         expect_pending_htlcs_forwardable!(nodes[1]);
3043         check_added_monitors!(nodes[1], 1);
3044         let events = nodes[1].node.get_and_clear_pending_msg_events();
3045         assert_eq!(events.len(), 1);
3046         match events[0] {
3047                 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, .. } } => {
3048                         assert!(update_add_htlcs.is_empty());
3049                         assert_eq!(update_fail_htlcs.len(), 1);
3050                         assert!(update_fulfill_htlcs.is_empty());
3051                         assert!(update_fail_malformed_htlcs.is_empty());
3052                         assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
3053
3054                         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlcs[0]);
3055                         commitment_signed_dance!(nodes[0], nodes[1], commitment_signed, false, true);
3056
3057                         let events = nodes[0].node.get_and_clear_pending_msg_events();
3058                         assert_eq!(events.len(), 1);
3059                         match events[0] {
3060                                 MessageSendEvent::PaymentFailureNetworkUpdate { .. } => {},
3061                                 _ => panic!("Unexpected event"),
3062                         }
3063                         expect_payment_failed!(nodes[0], payment_hash, false);
3064                 },
3065                 _ => panic!("Unexpected event"),
3066         }
3067 }
3068
3069 fn do_test_commitment_revoked_fail_backward_exhaustive(deliver_bs_raa: bool, use_dust: bool, no_to_remote: bool) {
3070         // Test that if our counterparty broadcasts a revoked commitment transaction we fail all
3071         // pending HTLCs on that channel backwards even if the HTLCs aren't present in our latest
3072         // commitment transaction anymore.
3073         // To do this, we have the peer which will broadcast a revoked commitment transaction send
3074         // a number of update_fail/commitment_signed updates without ever sending the RAA in
3075         // response to our commitment_signed. This is somewhat misbehavior-y, though not
3076         // technically disallowed and we should probably handle it reasonably.
3077         // Note that this is pretty exhaustive as an outbound HTLC which we haven't yet
3078         // failed/fulfilled backwards must be in at least one of the latest two remote commitment
3079         // transactions:
3080         // * Once we move it out of our holding cell/add it, we will immediately include it in a
3081         //   commitment_signed (implying it will be in the latest remote commitment transaction).
3082         // * Once they remove it, we will send a (the first) commitment_signed without the HTLC,
3083         //   and once they revoke the previous commitment transaction (allowing us to send a new
3084         //   commitment_signed) we will be free to fail/fulfill the HTLC backwards.
3085         let chanmon_cfgs = create_chanmon_cfgs(3);
3086         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
3087         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
3088         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
3089
3090         // Create some initial channels
3091         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3092         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
3093
3094         let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], if no_to_remote { 10_000 } else { 3_000_000 });
3095         // Get the will-be-revoked local txn from nodes[2]
3096         let revoked_local_txn = get_local_commitment_txn!(nodes[2], chan_2.2);
3097         assert_eq!(revoked_local_txn[0].output.len(), if no_to_remote { 1 } else { 2 });
3098         // Revoke the old state
3099         claim_payment(&nodes[0], &[&nodes[1], &nodes[2]], payment_preimage, if no_to_remote { 10_000 } else { 3_000_000});
3100
3101         let value = if use_dust {
3102                 // The dust limit applied to HTLC outputs considers the fee of the HTLC transaction as
3103                 // well, so HTLCs at exactly the dust limit will not be included in commitment txn.
3104                 nodes[2].node.channel_state.lock().unwrap().by_id.get(&chan_2.2).unwrap().our_dust_limit_satoshis * 1000
3105         } else { 3000000 };
3106
3107         let (_, first_payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], value);
3108         let (_, second_payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], value);
3109         let (_, third_payment_hash) = route_payment(&nodes[0], &[&nodes[1], &nodes[2]], value);
3110
3111         assert!(nodes[2].node.fail_htlc_backwards(&first_payment_hash, &None));
3112         expect_pending_htlcs_forwardable!(nodes[2]);
3113         check_added_monitors!(nodes[2], 1);
3114         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
3115         assert!(updates.update_add_htlcs.is_empty());
3116         assert!(updates.update_fulfill_htlcs.is_empty());
3117         assert!(updates.update_fail_malformed_htlcs.is_empty());
3118         assert_eq!(updates.update_fail_htlcs.len(), 1);
3119         assert!(updates.update_fee.is_none());
3120         nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
3121         let bs_raa = commitment_signed_dance!(nodes[1], nodes[2], updates.commitment_signed, false, true, false, true);
3122         // Drop the last RAA from 3 -> 2
3123
3124         assert!(nodes[2].node.fail_htlc_backwards(&second_payment_hash, &None));
3125         expect_pending_htlcs_forwardable!(nodes[2]);
3126         check_added_monitors!(nodes[2], 1);
3127         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
3128         assert!(updates.update_add_htlcs.is_empty());
3129         assert!(updates.update_fulfill_htlcs.is_empty());
3130         assert!(updates.update_fail_malformed_htlcs.is_empty());
3131         assert_eq!(updates.update_fail_htlcs.len(), 1);
3132         assert!(updates.update_fee.is_none());
3133         nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
3134         nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &updates.commitment_signed);
3135         check_added_monitors!(nodes[1], 1);
3136         // Note that nodes[1] is in AwaitingRAA, so won't send a CS
3137         let as_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[2].node.get_our_node_id());
3138         nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_raa);
3139         check_added_monitors!(nodes[2], 1);
3140
3141         assert!(nodes[2].node.fail_htlc_backwards(&third_payment_hash, &None));
3142         expect_pending_htlcs_forwardable!(nodes[2]);
3143         check_added_monitors!(nodes[2], 1);
3144         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
3145         assert!(updates.update_add_htlcs.is_empty());
3146         assert!(updates.update_fulfill_htlcs.is_empty());
3147         assert!(updates.update_fail_malformed_htlcs.is_empty());
3148         assert_eq!(updates.update_fail_htlcs.len(), 1);
3149         assert!(updates.update_fee.is_none());
3150         nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
3151         // At this point first_payment_hash has dropped out of the latest two commitment
3152         // transactions that nodes[1] is tracking...
3153         nodes[1].node.handle_commitment_signed(&nodes[2].node.get_our_node_id(), &updates.commitment_signed);
3154         check_added_monitors!(nodes[1], 1);
3155         // Note that nodes[1] is (still) in AwaitingRAA, so won't send a CS
3156         let as_raa = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[2].node.get_our_node_id());
3157         nodes[2].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &as_raa);
3158         check_added_monitors!(nodes[2], 1);
3159
3160         // Add a fourth HTLC, this one will get sequestered away in nodes[1]'s holding cell waiting
3161         // on nodes[2]'s RAA.
3162         let (_, fourth_payment_hash) = get_payment_preimage_hash!(nodes[0]);
3163         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
3164         let logger = test_utils::TestLogger::new();
3165         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();
3166         nodes[1].node.send_payment(&route, fourth_payment_hash, &None).unwrap();
3167         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
3168         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
3169         check_added_monitors!(nodes[1], 0);
3170
3171         if deliver_bs_raa {
3172                 nodes[1].node.handle_revoke_and_ack(&nodes[2].node.get_our_node_id(), &bs_raa);
3173                 // One monitor for the new revocation preimage, no second on as we won't generate a new
3174                 // commitment transaction for nodes[0] until process_pending_htlc_forwards().
3175                 check_added_monitors!(nodes[1], 1);
3176                 let events = nodes[1].node.get_and_clear_pending_events();
3177                 assert_eq!(events.len(), 1);
3178                 match events[0] {
3179                         Event::PendingHTLCsForwardable { .. } => { },
3180                         _ => panic!("Unexpected event"),
3181                 };
3182                 // Deliberately don't process the pending fail-back so they all fail back at once after
3183                 // block connection just like the !deliver_bs_raa case
3184         }
3185
3186         let mut failed_htlcs = HashSet::new();
3187         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
3188
3189         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
3190         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
3191         check_added_monitors!(nodes[1], 1);
3192         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
3193
3194         let events = nodes[1].node.get_and_clear_pending_events();
3195         assert_eq!(events.len(), if deliver_bs_raa { 1 } else { 2 });
3196         match events[0] {
3197                 Event::PaymentFailed { ref payment_hash, .. } => {
3198                         assert_eq!(*payment_hash, fourth_payment_hash);
3199                 },
3200                 _ => panic!("Unexpected event"),
3201         }
3202         if !deliver_bs_raa {
3203                 match events[1] {
3204                         Event::PendingHTLCsForwardable { .. } => { },
3205                         _ => panic!("Unexpected event"),
3206                 };
3207         }
3208         nodes[1].node.process_pending_htlc_forwards();
3209         check_added_monitors!(nodes[1], 1);
3210
3211         let events = nodes[1].node.get_and_clear_pending_msg_events();
3212         assert_eq!(events.len(), if deliver_bs_raa { 3 } else { 2 });
3213         match events[if deliver_bs_raa { 1 } else { 0 }] {
3214                 MessageSendEvent::BroadcastChannelUpdate { msg: msgs::ChannelUpdate { .. } } => {},
3215                 _ => panic!("Unexpected event"),
3216         }
3217         if deliver_bs_raa {
3218                 match events[0] {
3219                         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, .. } } => {
3220                                 assert_eq!(nodes[2].node.get_our_node_id(), *node_id);
3221                                 assert_eq!(update_add_htlcs.len(), 1);
3222                                 assert!(update_fulfill_htlcs.is_empty());
3223                                 assert!(update_fail_htlcs.is_empty());
3224                                 assert!(update_fail_malformed_htlcs.is_empty());
3225                         },
3226                         _ => panic!("Unexpected event"),
3227                 }
3228         }
3229         match events[if deliver_bs_raa { 2 } else { 1 }] {
3230                 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, .. } } => {
3231                         assert!(update_add_htlcs.is_empty());
3232                         assert_eq!(update_fail_htlcs.len(), 3);
3233                         assert!(update_fulfill_htlcs.is_empty());
3234                         assert!(update_fail_malformed_htlcs.is_empty());
3235                         assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
3236
3237                         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlcs[0]);
3238                         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlcs[1]);
3239                         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlcs[2]);
3240
3241                         commitment_signed_dance!(nodes[0], nodes[1], commitment_signed, false, true);
3242
3243                         let events = nodes[0].node.get_and_clear_pending_msg_events();
3244                         // If we delivered B's RAA we got an unknown preimage error, not something
3245                         // that we should update our routing table for.
3246                         assert_eq!(events.len(), if deliver_bs_raa { 2 } else { 3 });
3247                         for event in events {
3248                                 match event {
3249                                         MessageSendEvent::PaymentFailureNetworkUpdate { .. } => {},
3250                                         _ => panic!("Unexpected event"),
3251                                 }
3252                         }
3253                         let events = nodes[0].node.get_and_clear_pending_events();
3254                         assert_eq!(events.len(), 3);
3255                         match events[0] {
3256                                 Event::PaymentFailed { ref payment_hash, .. } => {
3257                                         assert!(failed_htlcs.insert(payment_hash.0));
3258                                 },
3259                                 _ => panic!("Unexpected event"),
3260                         }
3261                         match events[1] {
3262                                 Event::PaymentFailed { ref payment_hash, .. } => {
3263                                         assert!(failed_htlcs.insert(payment_hash.0));
3264                                 },
3265                                 _ => panic!("Unexpected event"),
3266                         }
3267                         match events[2] {
3268                                 Event::PaymentFailed { ref payment_hash, .. } => {
3269                                         assert!(failed_htlcs.insert(payment_hash.0));
3270                                 },
3271                                 _ => panic!("Unexpected event"),
3272                         }
3273                 },
3274                 _ => panic!("Unexpected event"),
3275         }
3276
3277         assert!(failed_htlcs.contains(&first_payment_hash.0));
3278         assert!(failed_htlcs.contains(&second_payment_hash.0));
3279         assert!(failed_htlcs.contains(&third_payment_hash.0));
3280 }
3281
3282 #[test]
3283 fn test_commitment_revoked_fail_backward_exhaustive_a() {
3284         do_test_commitment_revoked_fail_backward_exhaustive(false, true, false);
3285         do_test_commitment_revoked_fail_backward_exhaustive(true, true, false);
3286         do_test_commitment_revoked_fail_backward_exhaustive(false, false, false);
3287         do_test_commitment_revoked_fail_backward_exhaustive(true, false, false);
3288 }
3289
3290 #[test]
3291 fn test_commitment_revoked_fail_backward_exhaustive_b() {
3292         do_test_commitment_revoked_fail_backward_exhaustive(false, true, true);
3293         do_test_commitment_revoked_fail_backward_exhaustive(true, true, true);
3294         do_test_commitment_revoked_fail_backward_exhaustive(false, false, true);
3295         do_test_commitment_revoked_fail_backward_exhaustive(true, false, true);
3296 }
3297
3298 #[test]
3299 fn fail_backward_pending_htlc_upon_channel_failure() {
3300         let chanmon_cfgs = create_chanmon_cfgs(2);
3301         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
3302         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
3303         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
3304         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1_000_000, 500_000_000, InitFeatures::known(), InitFeatures::known());
3305         let logger = test_utils::TestLogger::new();
3306
3307         // Alice -> Bob: Route a payment but without Bob sending revoke_and_ack.
3308         {
3309                 let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
3310                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3311                 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();
3312                 nodes[0].node.send_payment(&route, payment_hash, &None).unwrap();
3313                 check_added_monitors!(nodes[0], 1);
3314
3315                 let payment_event = {
3316                         let mut events = nodes[0].node.get_and_clear_pending_msg_events();
3317                         assert_eq!(events.len(), 1);
3318                         SendEvent::from_event(events.remove(0))
3319                 };
3320                 assert_eq!(payment_event.node_id, nodes[1].node.get_our_node_id());
3321                 assert_eq!(payment_event.msgs.len(), 1);
3322         }
3323
3324         // Alice -> Bob: Route another payment but now Alice waits for Bob's earlier revoke_and_ack.
3325         let (_, failed_payment_hash) = get_payment_preimage_hash!(nodes[0]);
3326         {
3327                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3328                 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();
3329                 nodes[0].node.send_payment(&route, failed_payment_hash, &None).unwrap();
3330                 check_added_monitors!(nodes[0], 0);
3331
3332                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
3333         }
3334
3335         // Alice <- Bob: Send a malformed update_add_htlc so Alice fails the channel.
3336         {
3337                 let (_, payment_hash) = get_payment_preimage_hash!(nodes[1]);
3338
3339                 let secp_ctx = Secp256k1::new();
3340                 let session_priv = SecretKey::from_slice(&[42; 32]).unwrap();
3341                 let current_height = nodes[1].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
3342                 let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
3343                 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();
3344                 let (onion_payloads, _amount_msat, cltv_expiry) = onion_utils::build_onion_payloads(&route.paths[0], 50_000, &None, current_height).unwrap();
3345                 let onion_keys = onion_utils::construct_onion_keys(&secp_ctx, &route.paths[0], &session_priv).unwrap();
3346                 let onion_routing_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash);
3347
3348                 // Send a 0-msat update_add_htlc to fail the channel.
3349                 let update_add_htlc = msgs::UpdateAddHTLC {
3350                         channel_id: chan.2,
3351                         htlc_id: 0,
3352                         amount_msat: 0,
3353                         payment_hash,
3354                         cltv_expiry,
3355                         onion_routing_packet,
3356                 };
3357                 nodes[0].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &update_add_htlc);
3358         }
3359
3360         // Check that Alice fails backward the pending HTLC from the second payment.
3361         expect_payment_failed!(nodes[0], failed_payment_hash, true);
3362         check_closed_broadcast!(nodes[0], true);
3363         check_added_monitors!(nodes[0], 1);
3364 }
3365
3366 #[test]
3367 fn test_htlc_ignore_latest_remote_commitment() {
3368         // Test that HTLC transactions spending the latest remote commitment transaction are simply
3369         // ignored if we cannot claim them. This originally tickled an invalid unwrap().
3370         let chanmon_cfgs = create_chanmon_cfgs(2);
3371         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
3372         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
3373         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
3374         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3375
3376         route_payment(&nodes[0], &[&nodes[1]], 10000000);
3377         nodes[0].node.force_close_channel(&nodes[0].node.list_channels()[0].channel_id);
3378         check_closed_broadcast!(nodes[0], false);
3379         check_added_monitors!(nodes[0], 1);
3380
3381         let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
3382         assert_eq!(node_txn.len(), 2);
3383
3384         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
3385         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone(), node_txn[1].clone()]}, 1);
3386         check_closed_broadcast!(nodes[1], false);
3387         check_added_monitors!(nodes[1], 1);
3388
3389         // Duplicate the block_connected call since this may happen due to other listeners
3390         // registering new transactions
3391         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone(), node_txn[1].clone()]}, 1);
3392 }
3393
3394 #[test]
3395 fn test_force_close_fail_back() {
3396         // Check which HTLCs are failed-backwards on channel force-closure
3397         let chanmon_cfgs = create_chanmon_cfgs(3);
3398         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
3399         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
3400         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
3401         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3402         create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
3403         let logger = test_utils::TestLogger::new();
3404
3405         let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
3406
3407         let mut payment_event = {
3408                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3409                 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();
3410                 nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
3411                 check_added_monitors!(nodes[0], 1);
3412
3413                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
3414                 assert_eq!(events.len(), 1);
3415                 SendEvent::from_event(events.remove(0))
3416         };
3417
3418         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
3419         commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
3420
3421         expect_pending_htlcs_forwardable!(nodes[1]);
3422
3423         let mut events_2 = nodes[1].node.get_and_clear_pending_msg_events();
3424         assert_eq!(events_2.len(), 1);
3425         payment_event = SendEvent::from_event(events_2.remove(0));
3426         assert_eq!(payment_event.msgs.len(), 1);
3427
3428         check_added_monitors!(nodes[1], 1);
3429         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
3430         nodes[2].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &payment_event.commitment_msg);
3431         check_added_monitors!(nodes[2], 1);
3432         let (_, _) = get_revoke_commit_msgs!(nodes[2], nodes[1].node.get_our_node_id());
3433
3434         // nodes[2] now has the latest commitment transaction, but hasn't revoked its previous
3435         // state or updated nodes[1]' state. Now force-close and broadcast that commitment/HTLC
3436         // transaction and ensure nodes[1] doesn't fail-backwards (this was originally a bug!).
3437
3438         nodes[2].node.force_close_channel(&payment_event.commitment_msg.channel_id);
3439         check_closed_broadcast!(nodes[2], false);
3440         check_added_monitors!(nodes[2], 1);
3441         let tx = {
3442                 let mut node_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap();
3443                 // Note that we don't bother broadcasting the HTLC-Success transaction here as we don't
3444                 // have a use for it unless nodes[2] learns the preimage somehow, the funds will go
3445                 // back to nodes[1] upon timeout otherwise.
3446                 assert_eq!(node_txn.len(), 1);
3447                 node_txn.remove(0)
3448         };
3449
3450         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
3451         nodes[1].block_notifier.block_connected_checked(&header, 1, &[&tx], &[1]);
3452
3453         // Note no UpdateHTLCs event here from nodes[1] to nodes[0]!
3454         check_closed_broadcast!(nodes[1], false);
3455         check_added_monitors!(nodes[1], 1);
3456
3457         // Now check that if we add the preimage to ChannelMonitor it broadcasts our HTLC-Success..
3458         {
3459                 let mut monitors = nodes[2].chan_monitor.simple_monitor.monitors.lock().unwrap();
3460                 monitors.get_mut(&OutPoint{ txid: Txid::from_slice(&payment_event.commitment_msg.channel_id[..]).unwrap(), index: 0 }).unwrap()
3461                         .provide_payment_preimage(&our_payment_hash, &our_payment_preimage);
3462         }
3463         nodes[2].block_notifier.block_connected_checked(&header, 1, &[&tx], &[1]);
3464         let node_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap();
3465         assert_eq!(node_txn.len(), 1);
3466         assert_eq!(node_txn[0].input.len(), 1);
3467         assert_eq!(node_txn[0].input[0].previous_output.txid, tx.txid());
3468         assert_eq!(node_txn[0].lock_time, 0); // Must be an HTLC-Success
3469         assert_eq!(node_txn[0].input[0].witness.len(), 5); // Must be an HTLC-Success
3470
3471         check_spends!(node_txn[0], tx);
3472 }
3473
3474 #[test]
3475 fn test_unconf_chan() {
3476         // After creating a chan between nodes, we disconnect all blocks previously seen to force a channel close on nodes[0] side
3477         let chanmon_cfgs = create_chanmon_cfgs(2);
3478         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
3479         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
3480         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
3481         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3482
3483         let channel_state = nodes[0].node.channel_state.lock().unwrap();
3484         assert_eq!(channel_state.by_id.len(), 1);
3485         assert_eq!(channel_state.short_to_id.len(), 1);
3486         mem::drop(channel_state);
3487
3488         let mut headers = Vec::new();
3489         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
3490         headers.push(header.clone());
3491         for _i in 2..100 {
3492                 header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
3493                 headers.push(header.clone());
3494         }
3495         let mut height = 99;
3496         while !headers.is_empty() {
3497                 nodes[0].node.block_disconnected(&headers.pop().unwrap(), height);
3498                 height -= 1;
3499         }
3500         check_closed_broadcast!(nodes[0], false);
3501         check_added_monitors!(nodes[0], 1);
3502         let channel_state = nodes[0].node.channel_state.lock().unwrap();
3503         assert_eq!(channel_state.by_id.len(), 0);
3504         assert_eq!(channel_state.short_to_id.len(), 0);
3505 }
3506
3507 #[test]
3508 fn test_simple_peer_disconnect() {
3509         // Test that we can reconnect when there are no lost messages
3510         let chanmon_cfgs = create_chanmon_cfgs(3);
3511         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
3512         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
3513         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
3514         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3515         create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
3516
3517         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3518         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3519         reconnect_nodes(&nodes[0], &nodes[1], (true, true), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3520
3521         let payment_preimage_1 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).0;
3522         let payment_hash_2 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).1;
3523         fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_hash_2);
3524         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_1, 1_000_000);
3525
3526         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3527         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3528         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3529
3530         let payment_preimage_3 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).0;
3531         let payment_preimage_4 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).0;
3532         let payment_hash_5 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).1;
3533         let payment_hash_6 = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 1000000).1;
3534
3535         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3536         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3537
3538         claim_payment_along_route(&nodes[0], &vec!(&nodes[1], &nodes[2]), true, payment_preimage_3, 1_000_000);
3539         fail_payment_along_route(&nodes[0], &[&nodes[1], &nodes[2]], true, payment_hash_5);
3540
3541         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (1, 0), (1, 0), (false, false));
3542         {
3543                 let events = nodes[0].node.get_and_clear_pending_events();
3544                 assert_eq!(events.len(), 2);
3545                 match events[0] {
3546                         Event::PaymentSent { payment_preimage } => {
3547                                 assert_eq!(payment_preimage, payment_preimage_3);
3548                         },
3549                         _ => panic!("Unexpected event"),
3550                 }
3551                 match events[1] {
3552                         Event::PaymentFailed { payment_hash, rejected_by_dest, .. } => {
3553                                 assert_eq!(payment_hash, payment_hash_5);
3554                                 assert!(rejected_by_dest);
3555                         },
3556                         _ => panic!("Unexpected event"),
3557                 }
3558         }
3559
3560         claim_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_preimage_4, 1_000_000);
3561         fail_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), payment_hash_6);
3562 }
3563
3564 fn do_test_drop_messages_peer_disconnect(messages_delivered: u8) {
3565         // Test that we can reconnect when in-flight HTLC updates get dropped
3566         let chanmon_cfgs = create_chanmon_cfgs(2);
3567         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
3568         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
3569         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
3570         if messages_delivered == 0 {
3571                 create_chan_between_nodes_with_value_a(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::known(), InitFeatures::known());
3572                 // nodes[1] doesn't receive the funding_locked message (it'll be re-sent on reconnect)
3573         } else {
3574                 create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3575         }
3576
3577         let (payment_preimage_1, payment_hash_1) = get_payment_preimage_hash!(nodes[0]);
3578
3579         let logger = test_utils::TestLogger::new();
3580         let payment_event = {
3581                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3582                 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();
3583                 nodes[0].node.send_payment(&route, payment_hash_1, &None).unwrap();
3584                 check_added_monitors!(nodes[0], 1);
3585
3586                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
3587                 assert_eq!(events.len(), 1);
3588                 SendEvent::from_event(events.remove(0))
3589         };
3590         assert_eq!(nodes[1].node.get_our_node_id(), payment_event.node_id);
3591
3592         if messages_delivered < 2 {
3593                 // Drop the payment_event messages, and let them get re-generated in reconnect_nodes!
3594         } else {
3595                 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
3596                 if messages_delivered >= 3 {
3597                         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &payment_event.commitment_msg);
3598                         check_added_monitors!(nodes[1], 1);
3599                         let (bs_revoke_and_ack, bs_commitment_signed) = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
3600
3601                         if messages_delivered >= 4 {
3602                                 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack);
3603                                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
3604                                 check_added_monitors!(nodes[0], 1);
3605
3606                                 if messages_delivered >= 5 {
3607                                         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_commitment_signed);
3608                                         let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
3609                                         // No commitment_signed so get_event_msg's assert(len == 1) passes
3610                                         check_added_monitors!(nodes[0], 1);
3611
3612                                         if messages_delivered >= 6 {
3613                                                 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_and_ack);
3614                                                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
3615                                                 check_added_monitors!(nodes[1], 1);
3616                                         }
3617                                 }
3618                         }
3619                 }
3620         }
3621
3622         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3623         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3624         if messages_delivered < 3 {
3625                 // Even if the funding_locked messages get exchanged, as long as nothing further was
3626                 // received on either side, both sides will need to resend them.
3627                 reconnect_nodes(&nodes[0], &nodes[1], (true, true), (0, 1), (0, 0), (0, 0), (0, 0), (false, false));
3628         } else if messages_delivered == 3 {
3629                 // nodes[0] still wants its RAA + commitment_signed
3630                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (-1, 0), (0, 0), (0, 0), (0, 0), (true, false));
3631         } else if messages_delivered == 4 {
3632                 // nodes[0] still wants its commitment_signed
3633                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (-1, 0), (0, 0), (0, 0), (0, 0), (false, false));
3634         } else if messages_delivered == 5 {
3635                 // nodes[1] still wants its final RAA
3636                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, true));
3637         } else if messages_delivered == 6 {
3638                 // Everything was delivered...
3639                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3640         }
3641
3642         let events_1 = nodes[1].node.get_and_clear_pending_events();
3643         assert_eq!(events_1.len(), 1);
3644         match events_1[0] {
3645                 Event::PendingHTLCsForwardable { .. } => { },
3646                 _ => panic!("Unexpected event"),
3647         };
3648
3649         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3650         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3651         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3652
3653         nodes[1].node.process_pending_htlc_forwards();
3654
3655         let events_2 = nodes[1].node.get_and_clear_pending_events();
3656         assert_eq!(events_2.len(), 1);
3657         match events_2[0] {
3658                 Event::PaymentReceived { ref payment_hash, ref payment_secret, amt } => {
3659                         assert_eq!(payment_hash_1, *payment_hash);
3660                         assert_eq!(*payment_secret, None);
3661                         assert_eq!(amt, 1000000);
3662                 },
3663                 _ => panic!("Unexpected event"),
3664         }
3665
3666         nodes[1].node.claim_funds(payment_preimage_1, &None, 1_000_000);
3667         check_added_monitors!(nodes[1], 1);
3668
3669         let events_3 = nodes[1].node.get_and_clear_pending_msg_events();
3670         assert_eq!(events_3.len(), 1);
3671         let (update_fulfill_htlc, commitment_signed) = match events_3[0] {
3672                 MessageSendEvent::UpdateHTLCs { ref node_id, ref updates } => {
3673                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
3674                         assert!(updates.update_add_htlcs.is_empty());
3675                         assert!(updates.update_fail_htlcs.is_empty());
3676                         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
3677                         assert!(updates.update_fail_malformed_htlcs.is_empty());
3678                         assert!(updates.update_fee.is_none());
3679                         (updates.update_fulfill_htlcs[0].clone(), updates.commitment_signed.clone())
3680                 },
3681                 _ => panic!("Unexpected event"),
3682         };
3683
3684         if messages_delivered >= 1 {
3685                 nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_htlc);
3686
3687                 let events_4 = nodes[0].node.get_and_clear_pending_events();
3688                 assert_eq!(events_4.len(), 1);
3689                 match events_4[0] {
3690                         Event::PaymentSent { ref payment_preimage } => {
3691                                 assert_eq!(payment_preimage_1, *payment_preimage);
3692                         },
3693                         _ => panic!("Unexpected event"),
3694                 }
3695
3696                 if messages_delivered >= 2 {
3697                         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &commitment_signed);
3698                         check_added_monitors!(nodes[0], 1);
3699                         let (as_revoke_and_ack, as_commitment_signed) = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
3700
3701                         if messages_delivered >= 3 {
3702                                 nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_and_ack);
3703                                 assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
3704                                 check_added_monitors!(nodes[1], 1);
3705
3706                                 if messages_delivered >= 4 {
3707                                         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_commitment_signed);
3708                                         let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
3709                                         // No commitment_signed so get_event_msg's assert(len == 1) passes
3710                                         check_added_monitors!(nodes[1], 1);
3711
3712                                         if messages_delivered >= 5 {
3713                                                 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack);
3714                                                 assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
3715                                                 check_added_monitors!(nodes[0], 1);
3716                                         }
3717                                 }
3718                         }
3719                 }
3720         }
3721
3722         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3723         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3724         if messages_delivered < 2 {
3725                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (1, 0), (0, 0), (0, 0), (false, false));
3726                 //TODO: Deduplicate PaymentSent events, then enable this if:
3727                 //if messages_delivered < 1 {
3728                         let events_4 = nodes[0].node.get_and_clear_pending_events();
3729                         assert_eq!(events_4.len(), 1);
3730                         match events_4[0] {
3731                                 Event::PaymentSent { ref payment_preimage } => {
3732                                         assert_eq!(payment_preimage_1, *payment_preimage);
3733                                 },
3734                                 _ => panic!("Unexpected event"),
3735                         }
3736                 //}
3737         } else if messages_delivered == 2 {
3738                 // nodes[0] still wants its RAA + commitment_signed
3739                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, -1), (0, 0), (0, 0), (0, 0), (false, true));
3740         } else if messages_delivered == 3 {
3741                 // nodes[0] still wants its commitment_signed
3742                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, -1), (0, 0), (0, 0), (0, 0), (false, false));
3743         } else if messages_delivered == 4 {
3744                 // nodes[1] still wants its final RAA
3745                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (true, false));
3746         } else if messages_delivered == 5 {
3747                 // Everything was delivered...
3748                 reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3749         }
3750
3751         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3752         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3753         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3754
3755         // Channel should still work fine...
3756         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3757         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();
3758         let payment_preimage_2 = send_along_route(&nodes[0], route, &[&nodes[1]], 1000000).0;
3759         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
3760 }
3761
3762 #[test]
3763 fn test_drop_messages_peer_disconnect_a() {
3764         do_test_drop_messages_peer_disconnect(0);
3765         do_test_drop_messages_peer_disconnect(1);
3766         do_test_drop_messages_peer_disconnect(2);
3767         do_test_drop_messages_peer_disconnect(3);
3768 }
3769
3770 #[test]
3771 fn test_drop_messages_peer_disconnect_b() {
3772         do_test_drop_messages_peer_disconnect(4);
3773         do_test_drop_messages_peer_disconnect(5);
3774         do_test_drop_messages_peer_disconnect(6);
3775 }
3776
3777 #[test]
3778 fn test_funding_peer_disconnect() {
3779         // Test that we can lock in our funding tx while disconnected
3780         let chanmon_cfgs = create_chanmon_cfgs(2);
3781         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
3782         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
3783         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
3784         let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::known(), InitFeatures::known());
3785
3786         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3787         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3788
3789         confirm_transaction(&nodes[0].block_notifier, &nodes[0].chain_monitor, &tx, tx.version);
3790         let events_1 = nodes[0].node.get_and_clear_pending_msg_events();
3791         assert_eq!(events_1.len(), 1);
3792         match events_1[0] {
3793                 MessageSendEvent::SendFundingLocked { ref node_id, msg: _ } => {
3794                         assert_eq!(*node_id, nodes[1].node.get_our_node_id());
3795                 },
3796                 _ => panic!("Unexpected event"),
3797         }
3798
3799         reconnect_nodes(&nodes[0], &nodes[1], (false, true), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3800
3801         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3802         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3803
3804         confirm_transaction(&nodes[1].block_notifier, &nodes[1].chain_monitor, &tx, tx.version);
3805         let events_2 = nodes[1].node.get_and_clear_pending_msg_events();
3806         assert_eq!(events_2.len(), 2);
3807         let funding_locked = match events_2[0] {
3808                 MessageSendEvent::SendFundingLocked { ref node_id, ref msg } => {
3809                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
3810                         msg.clone()
3811                 },
3812                 _ => panic!("Unexpected event"),
3813         };
3814         let bs_announcement_sigs = match events_2[1] {
3815                 MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } => {
3816                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
3817                         msg.clone()
3818                 },
3819                 _ => panic!("Unexpected event"),
3820         };
3821
3822         reconnect_nodes(&nodes[0], &nodes[1], (true, true), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
3823
3824         nodes[0].node.handle_funding_locked(&nodes[1].node.get_our_node_id(), &funding_locked);
3825         nodes[0].node.handle_announcement_signatures(&nodes[1].node.get_our_node_id(), &bs_announcement_sigs);
3826         let events_3 = nodes[0].node.get_and_clear_pending_msg_events();
3827         assert_eq!(events_3.len(), 2);
3828         let as_announcement_sigs = match events_3[0] {
3829                 MessageSendEvent::SendAnnouncementSignatures { ref node_id, ref msg } => {
3830                         assert_eq!(*node_id, nodes[1].node.get_our_node_id());
3831                         msg.clone()
3832                 },
3833                 _ => panic!("Unexpected event"),
3834         };
3835         let (as_announcement, as_update) = match events_3[1] {
3836                 MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } => {
3837                         (msg.clone(), update_msg.clone())
3838                 },
3839                 _ => panic!("Unexpected event"),
3840         };
3841
3842         nodes[1].node.handle_announcement_signatures(&nodes[0].node.get_our_node_id(), &as_announcement_sigs);
3843         let events_4 = nodes[1].node.get_and_clear_pending_msg_events();
3844         assert_eq!(events_4.len(), 1);
3845         let (_, bs_update) = match events_4[0] {
3846                 MessageSendEvent::BroadcastChannelAnnouncement { ref msg, ref update_msg } => {
3847                         (msg.clone(), update_msg.clone())
3848                 },
3849                 _ => panic!("Unexpected event"),
3850         };
3851
3852         nodes[0].net_graph_msg_handler.handle_channel_announcement(&as_announcement).unwrap();
3853         nodes[0].net_graph_msg_handler.handle_channel_update(&bs_update).unwrap();
3854         nodes[0].net_graph_msg_handler.handle_channel_update(&as_update).unwrap();
3855
3856         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3857         let logger = test_utils::TestLogger::new();
3858         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();
3859         let (payment_preimage, _) = send_along_route(&nodes[0], route, &[&nodes[1]], 1000000);
3860         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage, 1_000_000);
3861 }
3862
3863 #[test]
3864 fn test_drop_messages_peer_disconnect_dual_htlc() {
3865         // Test that we can handle reconnecting when both sides of a channel have pending
3866         // commitment_updates when we disconnect.
3867         let chanmon_cfgs = create_chanmon_cfgs(2);
3868         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
3869         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
3870         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
3871         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
3872         let logger = test_utils::TestLogger::new();
3873
3874         let (payment_preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
3875
3876         // Now try to send a second payment which will fail to send
3877         let (payment_preimage_2, payment_hash_2) = get_payment_preimage_hash!(nodes[0]);
3878         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
3879         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();
3880         nodes[0].node.send_payment(&route, payment_hash_2, &None).unwrap();
3881         check_added_monitors!(nodes[0], 1);
3882
3883         let events_1 = nodes[0].node.get_and_clear_pending_msg_events();
3884         assert_eq!(events_1.len(), 1);
3885         match events_1[0] {
3886                 MessageSendEvent::UpdateHTLCs { .. } => {},
3887                 _ => panic!("Unexpected event"),
3888         }
3889
3890         assert!(nodes[1].node.claim_funds(payment_preimage_1, &None, 1_000_000));
3891         check_added_monitors!(nodes[1], 1);
3892
3893         let events_2 = nodes[1].node.get_and_clear_pending_msg_events();
3894         assert_eq!(events_2.len(), 1);
3895         match events_2[0] {
3896                 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 } } => {
3897                         assert_eq!(*node_id, nodes[0].node.get_our_node_id());
3898                         assert!(update_add_htlcs.is_empty());
3899                         assert_eq!(update_fulfill_htlcs.len(), 1);
3900                         assert!(update_fail_htlcs.is_empty());
3901                         assert!(update_fail_malformed_htlcs.is_empty());
3902                         assert!(update_fee.is_none());
3903
3904                         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_htlcs[0]);
3905                         let events_3 = nodes[0].node.get_and_clear_pending_events();
3906                         assert_eq!(events_3.len(), 1);
3907                         match events_3[0] {
3908                                 Event::PaymentSent { ref payment_preimage } => {
3909                                         assert_eq!(*payment_preimage, payment_preimage_1);
3910                                 },
3911                                 _ => panic!("Unexpected event"),
3912                         }
3913
3914                         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), commitment_signed);
3915                         let _ = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
3916                         // No commitment_signed so get_event_msg's assert(len == 1) passes
3917                         check_added_monitors!(nodes[0], 1);
3918                 },
3919                 _ => panic!("Unexpected event"),
3920         }
3921
3922         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
3923         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
3924
3925         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
3926         let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
3927         assert_eq!(reestablish_1.len(), 1);
3928         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
3929         let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
3930         assert_eq!(reestablish_2.len(), 1);
3931
3932         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
3933         let as_resp = handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
3934         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
3935         let bs_resp = handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
3936
3937         assert!(as_resp.0.is_none());
3938         assert!(bs_resp.0.is_none());
3939
3940         assert!(bs_resp.1.is_none());
3941         assert!(bs_resp.2.is_none());
3942
3943         assert!(as_resp.3 == RAACommitmentOrder::CommitmentFirst);
3944
3945         assert_eq!(as_resp.2.as_ref().unwrap().update_add_htlcs.len(), 1);
3946         assert!(as_resp.2.as_ref().unwrap().update_fulfill_htlcs.is_empty());
3947         assert!(as_resp.2.as_ref().unwrap().update_fail_htlcs.is_empty());
3948         assert!(as_resp.2.as_ref().unwrap().update_fail_malformed_htlcs.is_empty());
3949         assert!(as_resp.2.as_ref().unwrap().update_fee.is_none());
3950         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &as_resp.2.as_ref().unwrap().update_add_htlcs[0]);
3951         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_resp.2.as_ref().unwrap().commitment_signed);
3952         let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
3953         // No commitment_signed so get_event_msg's assert(len == 1) passes
3954         check_added_monitors!(nodes[1], 1);
3955
3956         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), as_resp.1.as_ref().unwrap());
3957         let bs_second_commitment_signed = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
3958         assert!(bs_second_commitment_signed.update_add_htlcs.is_empty());
3959         assert!(bs_second_commitment_signed.update_fulfill_htlcs.is_empty());
3960         assert!(bs_second_commitment_signed.update_fail_htlcs.is_empty());
3961         assert!(bs_second_commitment_signed.update_fail_malformed_htlcs.is_empty());
3962         assert!(bs_second_commitment_signed.update_fee.is_none());
3963         check_added_monitors!(nodes[1], 1);
3964
3965         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack);
3966         let as_commitment_signed = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
3967         assert!(as_commitment_signed.update_add_htlcs.is_empty());
3968         assert!(as_commitment_signed.update_fulfill_htlcs.is_empty());
3969         assert!(as_commitment_signed.update_fail_htlcs.is_empty());
3970         assert!(as_commitment_signed.update_fail_malformed_htlcs.is_empty());
3971         assert!(as_commitment_signed.update_fee.is_none());
3972         check_added_monitors!(nodes[0], 1);
3973
3974         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_second_commitment_signed.commitment_signed);
3975         let as_revoke_and_ack = get_event_msg!(nodes[0], MessageSendEvent::SendRevokeAndACK, nodes[1].node.get_our_node_id());
3976         // No commitment_signed so get_event_msg's assert(len == 1) passes
3977         check_added_monitors!(nodes[0], 1);
3978
3979         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_commitment_signed.commitment_signed);
3980         let bs_second_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
3981         // No commitment_signed so get_event_msg's assert(len == 1) passes
3982         check_added_monitors!(nodes[1], 1);
3983
3984         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_revoke_and_ack);
3985         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
3986         check_added_monitors!(nodes[1], 1);
3987
3988         expect_pending_htlcs_forwardable!(nodes[1]);
3989
3990         let events_5 = nodes[1].node.get_and_clear_pending_events();
3991         assert_eq!(events_5.len(), 1);
3992         match events_5[0] {
3993                 Event::PaymentReceived { ref payment_hash, ref payment_secret, amt: _ } => {
3994                         assert_eq!(payment_hash_2, *payment_hash);
3995                         assert_eq!(*payment_secret, None);
3996                 },
3997                 _ => panic!("Unexpected event"),
3998         }
3999
4000         nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_second_revoke_and_ack);
4001         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
4002         check_added_monitors!(nodes[0], 1);
4003
4004         claim_payment(&nodes[0], &[&nodes[1]], payment_preimage_2, 1_000_000);
4005 }
4006
4007 fn do_test_htlc_timeout(send_partial_mpp: bool) {
4008         // If the user fails to claim/fail an HTLC within the HTLC CLTV timeout we fail it for them
4009         // to avoid our counterparty failing the channel.
4010         let chanmon_cfgs = create_chanmon_cfgs(2);
4011         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4012         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4013         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4014
4015         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4016         let logger = test_utils::TestLogger::new();
4017
4018         let our_payment_hash = if send_partial_mpp {
4019                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
4020                 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();
4021                 let (_, our_payment_hash) = get_payment_preimage_hash!(&nodes[0]);
4022                 let payment_secret = PaymentSecret([0xdb; 32]);
4023                 // Use the utility function send_payment_along_path to send the payment with MPP data which
4024                 // indicates there are more HTLCs coming.
4025                 nodes[0].node.send_payment_along_path(&route.paths[0], &our_payment_hash, &Some(payment_secret), 200000, CHAN_CONFIRM_DEPTH).unwrap();
4026                 check_added_monitors!(nodes[0], 1);
4027                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
4028                 assert_eq!(events.len(), 1);
4029                 // Now do the relevant commitment_signed/RAA dances along the path, noting that the final
4030                 // hop should *not* yet generate any PaymentReceived event(s).
4031                 pass_along_path(&nodes[0], &[&nodes[1]], 100000, our_payment_hash, Some(payment_secret), events.drain(..).next().unwrap(), false);
4032                 our_payment_hash
4033         } else {
4034                 route_payment(&nodes[0], &[&nodes[1]], 100000).1
4035         };
4036
4037         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4038         nodes[0].block_notifier.block_connected_checked(&header, 101, &[], &[]);
4039         nodes[1].block_notifier.block_connected_checked(&header, 101, &[], &[]);
4040         for i in 102..TEST_FINAL_CLTV + 100 + 1 - CLTV_CLAIM_BUFFER - LATENCY_GRACE_PERIOD_BLOCKS {
4041                 header.prev_blockhash = header.bitcoin_hash();
4042                 nodes[0].block_notifier.block_connected_checked(&header, i, &[], &[]);
4043                 nodes[1].block_notifier.block_connected_checked(&header, i, &[], &[]);
4044         }
4045
4046         expect_pending_htlcs_forwardable!(nodes[1]);
4047
4048         check_added_monitors!(nodes[1], 1);
4049         let htlc_timeout_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
4050         assert!(htlc_timeout_updates.update_add_htlcs.is_empty());
4051         assert_eq!(htlc_timeout_updates.update_fail_htlcs.len(), 1);
4052         assert!(htlc_timeout_updates.update_fail_malformed_htlcs.is_empty());
4053         assert!(htlc_timeout_updates.update_fee.is_none());
4054
4055         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &htlc_timeout_updates.update_fail_htlcs[0]);
4056         commitment_signed_dance!(nodes[0], nodes[1], htlc_timeout_updates.commitment_signed, false);
4057         // 100_000 msat as u64, followed by a height of 123 as u32
4058         let mut expected_failure_data = byte_utils::be64_to_array(100_000).to_vec();
4059         expected_failure_data.extend_from_slice(&byte_utils::be32_to_array(123));
4060         expect_payment_failed!(nodes[0], our_payment_hash, true, 0x4000 | 15, &expected_failure_data[..]);
4061 }
4062
4063 #[test]
4064 fn test_htlc_timeout() {
4065         do_test_htlc_timeout(true);
4066         do_test_htlc_timeout(false);
4067 }
4068
4069 fn do_test_holding_cell_htlc_add_timeouts(forwarded_htlc: bool) {
4070         // Tests that HTLCs in the holding cell are timed out after the requisite number of blocks.
4071         let chanmon_cfgs = create_chanmon_cfgs(3);
4072         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
4073         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
4074         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
4075         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4076         create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
4077         let logger = test_utils::TestLogger::new();
4078
4079         // Route a first payment to get the 1 -> 2 channel in awaiting_raa...
4080         let (_, first_payment_hash) = get_payment_preimage_hash!(nodes[0]);
4081         {
4082                 let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
4083                 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();
4084                 nodes[1].node.send_payment(&route, first_payment_hash, &None).unwrap();
4085         }
4086         assert_eq!(nodes[1].node.get_and_clear_pending_msg_events().len(), 1);
4087         check_added_monitors!(nodes[1], 1);
4088
4089         // Now attempt to route a second payment, which should be placed in the holding cell
4090         let (_, second_payment_hash) = get_payment_preimage_hash!(nodes[0]);
4091         if forwarded_htlc {
4092                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
4093                 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();
4094                 nodes[0].node.send_payment(&route, second_payment_hash, &None).unwrap();
4095                 check_added_monitors!(nodes[0], 1);
4096                 let payment_event = SendEvent::from_event(nodes[0].node.get_and_clear_pending_msg_events().remove(0));
4097                 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
4098                 commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
4099                 expect_pending_htlcs_forwardable!(nodes[1]);
4100                 check_added_monitors!(nodes[1], 0);
4101         } else {
4102                 let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
4103                 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();
4104                 nodes[1].node.send_payment(&route, second_payment_hash, &None).unwrap();
4105                 check_added_monitors!(nodes[1], 0);
4106         }
4107
4108         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4109         nodes[1].block_notifier.block_connected_checked(&header, 101, &[], &[]);
4110         for i in 102..TEST_FINAL_CLTV + 100 - CLTV_CLAIM_BUFFER - LATENCY_GRACE_PERIOD_BLOCKS {
4111                 header.prev_blockhash = header.bitcoin_hash();
4112                 nodes[1].block_notifier.block_connected_checked(&header, i, &[], &[]);
4113         }
4114
4115         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4116         assert!(nodes[1].node.get_and_clear_pending_events().is_empty());
4117
4118         header.prev_blockhash = header.bitcoin_hash();
4119         nodes[1].block_notifier.block_connected_checked(&header, TEST_FINAL_CLTV + 100 - CLTV_CLAIM_BUFFER - LATENCY_GRACE_PERIOD_BLOCKS, &[], &[]);
4120
4121         if forwarded_htlc {
4122                 expect_pending_htlcs_forwardable!(nodes[1]);
4123                 check_added_monitors!(nodes[1], 1);
4124                 let fail_commit = nodes[1].node.get_and_clear_pending_msg_events();
4125                 assert_eq!(fail_commit.len(), 1);
4126                 match fail_commit[0] {
4127                         MessageSendEvent::UpdateHTLCs { updates: msgs::CommitmentUpdate { ref update_fail_htlcs, ref commitment_signed, .. }, .. } => {
4128                                 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlcs[0]);
4129                                 commitment_signed_dance!(nodes[0], nodes[1], commitment_signed, true, true);
4130                         },
4131                         _ => unreachable!(),
4132                 }
4133                 expect_payment_failed!(nodes[0], second_payment_hash, false);
4134                 if let &MessageSendEvent::PaymentFailureNetworkUpdate { ref update } = &nodes[0].node.get_and_clear_pending_msg_events()[0] {
4135                         match update {
4136                                 &HTLCFailChannelUpdate::ChannelUpdateMessage { .. } => {},
4137                                 _ => panic!("Unexpected event"),
4138                         }
4139                 } else {
4140                         panic!("Unexpected event");
4141                 }
4142         } else {
4143                 expect_payment_failed!(nodes[1], second_payment_hash, true);
4144         }
4145 }
4146
4147 #[test]
4148 fn test_holding_cell_htlc_add_timeouts() {
4149         do_test_holding_cell_htlc_add_timeouts(false);
4150         do_test_holding_cell_htlc_add_timeouts(true);
4151 }
4152
4153 #[test]
4154 fn test_invalid_channel_announcement() {
4155         //Test BOLT 7 channel_announcement msg requirement for final node, gather data to build customed channel_announcement msgs
4156         let secp_ctx = Secp256k1::new();
4157         let chanmon_cfgs = create_chanmon_cfgs(2);
4158         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4159         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4160         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4161
4162         let chan_announcement = create_chan_between_nodes(&nodes[0], &nodes[1], InitFeatures::known(), InitFeatures::known());
4163
4164         let a_channel_lock = nodes[0].node.channel_state.lock().unwrap();
4165         let b_channel_lock = nodes[1].node.channel_state.lock().unwrap();
4166         let as_chan = a_channel_lock.by_id.get(&chan_announcement.3).unwrap();
4167         let bs_chan = b_channel_lock.by_id.get(&chan_announcement.3).unwrap();
4168
4169         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 } );
4170
4171         let as_bitcoin_key = as_chan.get_local_keys().inner.local_channel_pubkeys.funding_pubkey;
4172         let bs_bitcoin_key = bs_chan.get_local_keys().inner.local_channel_pubkeys.funding_pubkey;
4173
4174         let as_network_key = nodes[0].node.get_our_node_id();
4175         let bs_network_key = nodes[1].node.get_our_node_id();
4176
4177         let were_node_one = as_bitcoin_key.serialize()[..] < bs_bitcoin_key.serialize()[..];
4178
4179         let mut chan_announcement;
4180
4181         macro_rules! dummy_unsigned_msg {
4182                 () => {
4183                         msgs::UnsignedChannelAnnouncement {
4184                                 features: ChannelFeatures::known(),
4185                                 chain_hash: genesis_block(Network::Testnet).header.bitcoin_hash(),
4186                                 short_channel_id: as_chan.get_short_channel_id().unwrap(),
4187                                 node_id_1: if were_node_one { as_network_key } else { bs_network_key },
4188                                 node_id_2: if were_node_one { bs_network_key } else { as_network_key },
4189                                 bitcoin_key_1: if were_node_one { as_bitcoin_key } else { bs_bitcoin_key },
4190                                 bitcoin_key_2: if were_node_one { bs_bitcoin_key } else { as_bitcoin_key },
4191                                 excess_data: Vec::new(),
4192                         };
4193                 }
4194         }
4195
4196         macro_rules! sign_msg {
4197                 ($unsigned_msg: expr) => {
4198                         let msghash = Message::from_slice(&Sha256dHash::hash(&$unsigned_msg.encode()[..])[..]).unwrap();
4199                         let as_bitcoin_sig = secp_ctx.sign(&msghash, &as_chan.get_local_keys().inner.funding_key);
4200                         let bs_bitcoin_sig = secp_ctx.sign(&msghash, &bs_chan.get_local_keys().inner.funding_key);
4201                         let as_node_sig = secp_ctx.sign(&msghash, &nodes[0].keys_manager.get_node_secret());
4202                         let bs_node_sig = secp_ctx.sign(&msghash, &nodes[1].keys_manager.get_node_secret());
4203                         chan_announcement = msgs::ChannelAnnouncement {
4204                                 node_signature_1 : if were_node_one { as_node_sig } else { bs_node_sig},
4205                                 node_signature_2 : if were_node_one { bs_node_sig } else { as_node_sig},
4206                                 bitcoin_signature_1: if were_node_one { as_bitcoin_sig } else { bs_bitcoin_sig },
4207                                 bitcoin_signature_2 : if were_node_one { bs_bitcoin_sig } else { as_bitcoin_sig },
4208                                 contents: $unsigned_msg
4209                         }
4210                 }
4211         }
4212
4213         let unsigned_msg = dummy_unsigned_msg!();
4214         sign_msg!(unsigned_msg);
4215         assert_eq!(nodes[0].net_graph_msg_handler.handle_channel_announcement(&chan_announcement).unwrap(), true);
4216         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 } );
4217
4218         // Configured with Network::Testnet
4219         let mut unsigned_msg = dummy_unsigned_msg!();
4220         unsigned_msg.chain_hash = genesis_block(Network::Bitcoin).header.bitcoin_hash();
4221         sign_msg!(unsigned_msg);
4222         assert!(nodes[0].net_graph_msg_handler.handle_channel_announcement(&chan_announcement).is_err());
4223
4224         let mut unsigned_msg = dummy_unsigned_msg!();
4225         unsigned_msg.chain_hash = BlockHash::hash(&[1,2,3,4,5,6,7,8,9]);
4226         sign_msg!(unsigned_msg);
4227         assert!(nodes[0].net_graph_msg_handler.handle_channel_announcement(&chan_announcement).is_err());
4228 }
4229
4230 #[test]
4231 fn test_no_txn_manager_serialize_deserialize() {
4232         let chanmon_cfgs = create_chanmon_cfgs(2);
4233         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4234         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4235         let logger: test_utils::TestLogger;
4236         let fee_estimator: test_utils::TestFeeEstimator;
4237         let new_chan_monitor: test_utils::TestChannelMonitor;
4238         let keys_manager: test_utils::TestKeysInterface;
4239         let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>;
4240         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4241
4242         let tx = create_chan_between_nodes_with_value_init(&nodes[0], &nodes[1], 100000, 10001, InitFeatures::known(), InitFeatures::known());
4243
4244         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4245
4246         let nodes_0_serialized = nodes[0].node.encode();
4247         let mut chan_0_monitor_serialized = test_utils::TestVecWriter(Vec::new());
4248         nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter().next().unwrap().1.write_for_disk(&mut chan_0_monitor_serialized).unwrap();
4249
4250         logger = test_utils::TestLogger::new();
4251         fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
4252         new_chan_monitor = test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), &logger, &fee_estimator);
4253         nodes[0].chan_monitor = &new_chan_monitor;
4254         let mut chan_0_monitor_read = &chan_0_monitor_serialized.0[..];
4255         let (_, mut chan_0_monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut chan_0_monitor_read).unwrap();
4256         assert!(chan_0_monitor_read.is_empty());
4257
4258         let mut nodes_0_read = &nodes_0_serialized[..];
4259         let config = UserConfig::default();
4260         keys_manager = test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet);
4261         let (_, nodes_0_deserialized_tmp) = {
4262                 let mut channel_monitors = HashMap::new();
4263                 channel_monitors.insert(chan_0_monitor.get_funding_txo().0, &mut chan_0_monitor);
4264                 <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
4265                         default_config: config,
4266                         keys_manager: &keys_manager,
4267                         fee_estimator: &fee_estimator,
4268                         monitor: nodes[0].chan_monitor,
4269                         tx_broadcaster: nodes[0].tx_broadcaster.clone(),
4270                         logger: &logger,
4271                         channel_monitors: &mut channel_monitors,
4272                 }).unwrap()
4273         };
4274         nodes_0_deserialized = nodes_0_deserialized_tmp;
4275         assert!(nodes_0_read.is_empty());
4276
4277         assert!(nodes[0].chan_monitor.add_monitor(chan_0_monitor.get_funding_txo().0, chan_0_monitor).is_ok());
4278         nodes[0].node = &nodes_0_deserialized;
4279         nodes[0].block_notifier.register_listener(nodes[0].node);
4280         assert_eq!(nodes[0].node.list_channels().len(), 1);
4281         check_added_monitors!(nodes[0], 1);
4282
4283         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
4284         let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
4285         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
4286         let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
4287
4288         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
4289         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4290         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
4291         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
4292
4293         let (funding_locked, _) = create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
4294         let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked);
4295         for node in nodes.iter() {
4296                 assert!(node.net_graph_msg_handler.handle_channel_announcement(&announcement).unwrap());
4297                 node.net_graph_msg_handler.handle_channel_update(&as_update).unwrap();
4298                 node.net_graph_msg_handler.handle_channel_update(&bs_update).unwrap();
4299         }
4300
4301         send_payment(&nodes[0], &[&nodes[1]], 1000000, 1_000_000);
4302 }
4303
4304 #[test]
4305 fn test_manager_serialize_deserialize_events() {
4306         // This test makes sure the events field in ChannelManager survives de/serialization
4307         let chanmon_cfgs = create_chanmon_cfgs(2);
4308         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4309         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4310         let fee_estimator: test_utils::TestFeeEstimator;
4311         let logger: test_utils::TestLogger;
4312         let new_chan_monitor: test_utils::TestChannelMonitor;
4313         let keys_manager: test_utils::TestKeysInterface;
4314         let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>;
4315         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4316
4317         // Start creating a channel, but stop right before broadcasting the event message FundingBroadcastSafe
4318         let channel_value = 100000;
4319         let push_msat = 10001;
4320         let a_flags = InitFeatures::known();
4321         let b_flags = InitFeatures::known();
4322         let node_a = nodes.pop().unwrap();
4323         let node_b = nodes.pop().unwrap();
4324         node_a.node.create_channel(node_b.node.get_our_node_id(), channel_value, push_msat, 42, None).unwrap();
4325         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()));
4326         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()));
4327
4328         let (temporary_channel_id, tx, funding_output) = create_funding_transaction(&node_a, channel_value, 42);
4329
4330         node_a.node.funding_transaction_generated(&temporary_channel_id, funding_output);
4331         check_added_monitors!(node_a, 0);
4332
4333         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()));
4334         {
4335                 let mut added_monitors = node_b.chan_monitor.added_monitors.lock().unwrap();
4336                 assert_eq!(added_monitors.len(), 1);
4337                 assert_eq!(added_monitors[0].0, funding_output);
4338                 added_monitors.clear();
4339         }
4340
4341         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()));
4342         {
4343                 let mut added_monitors = node_a.chan_monitor.added_monitors.lock().unwrap();
4344                 assert_eq!(added_monitors.len(), 1);
4345                 assert_eq!(added_monitors[0].0, funding_output);
4346                 added_monitors.clear();
4347         }
4348         // Normally, this is where node_a would check for a FundingBroadcastSafe event, but the test de/serializes first instead
4349
4350         nodes.push(node_a);
4351         nodes.push(node_b);
4352
4353         // Start the de/seriailization process mid-channel creation to check that the channel manager will hold onto events that are serialized
4354         let nodes_0_serialized = nodes[0].node.encode();
4355         let mut chan_0_monitor_serialized = test_utils::TestVecWriter(Vec::new());
4356         nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter().next().unwrap().1.write_for_disk(&mut chan_0_monitor_serialized).unwrap();
4357
4358         fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
4359         logger = test_utils::TestLogger::new();
4360         new_chan_monitor = test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), &logger, &fee_estimator);
4361         nodes[0].chan_monitor = &new_chan_monitor;
4362         let mut chan_0_monitor_read = &chan_0_monitor_serialized.0[..];
4363         let (_, mut chan_0_monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut chan_0_monitor_read).unwrap();
4364         assert!(chan_0_monitor_read.is_empty());
4365
4366         let mut nodes_0_read = &nodes_0_serialized[..];
4367         let config = UserConfig::default();
4368         keys_manager = test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet);
4369         let (_, nodes_0_deserialized_tmp) = {
4370                 let mut channel_monitors = HashMap::new();
4371                 channel_monitors.insert(chan_0_monitor.get_funding_txo().0, &mut chan_0_monitor);
4372                 <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
4373                         default_config: config,
4374                         keys_manager: &keys_manager,
4375                         fee_estimator: &fee_estimator,
4376                         monitor: nodes[0].chan_monitor,
4377                         tx_broadcaster: nodes[0].tx_broadcaster.clone(),
4378                         logger: &logger,
4379                         channel_monitors: &mut channel_monitors,
4380                 }).unwrap()
4381         };
4382         nodes_0_deserialized = nodes_0_deserialized_tmp;
4383         assert!(nodes_0_read.is_empty());
4384
4385         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4386
4387         assert!(nodes[0].chan_monitor.add_monitor(chan_0_monitor.get_funding_txo().0, chan_0_monitor).is_ok());
4388         nodes[0].node = &nodes_0_deserialized;
4389
4390         // After deserializing, make sure the FundingBroadcastSafe event is still held by the channel manager
4391         let events_4 = nodes[0].node.get_and_clear_pending_events();
4392         assert_eq!(events_4.len(), 1);
4393         match events_4[0] {
4394                 Event::FundingBroadcastSafe { ref funding_txo, user_channel_id } => {
4395                         assert_eq!(user_channel_id, 42);
4396                         assert_eq!(*funding_txo, funding_output);
4397                 },
4398                 _ => panic!("Unexpected event"),
4399         };
4400
4401         // Make sure the channel is functioning as though the de/serialization never happened
4402         nodes[0].block_notifier.register_listener(nodes[0].node);
4403         assert_eq!(nodes[0].node.list_channels().len(), 1);
4404         check_added_monitors!(nodes[0], 1);
4405
4406         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
4407         let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
4408         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
4409         let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
4410
4411         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
4412         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
4413         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
4414         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
4415
4416         let (funding_locked, _) = create_chan_between_nodes_with_value_confirm(&nodes[0], &nodes[1], &tx);
4417         let (announcement, as_update, bs_update) = create_chan_between_nodes_with_value_b(&nodes[0], &nodes[1], &funding_locked);
4418         for node in nodes.iter() {
4419                 assert!(node.net_graph_msg_handler.handle_channel_announcement(&announcement).unwrap());
4420                 node.net_graph_msg_handler.handle_channel_update(&as_update).unwrap();
4421                 node.net_graph_msg_handler.handle_channel_update(&bs_update).unwrap();
4422         }
4423
4424         send_payment(&nodes[0], &[&nodes[1]], 1000000, 1_000_000);
4425 }
4426
4427 #[test]
4428 fn test_simple_manager_serialize_deserialize() {
4429         let chanmon_cfgs = create_chanmon_cfgs(2);
4430         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4431         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4432         let logger: test_utils::TestLogger;
4433         let fee_estimator: test_utils::TestFeeEstimator;
4434         let new_chan_monitor: test_utils::TestChannelMonitor;
4435         let keys_manager: test_utils::TestKeysInterface;
4436         let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>;
4437         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4438         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4439
4440         let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
4441         let (_, our_payment_hash) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
4442
4443         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4444
4445         let nodes_0_serialized = nodes[0].node.encode();
4446         let mut chan_0_monitor_serialized = test_utils::TestVecWriter(Vec::new());
4447         nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter().next().unwrap().1.write_for_disk(&mut chan_0_monitor_serialized).unwrap();
4448
4449         logger = test_utils::TestLogger::new();
4450         fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
4451         new_chan_monitor = test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), &logger, &fee_estimator);
4452         nodes[0].chan_monitor = &new_chan_monitor;
4453         let mut chan_0_monitor_read = &chan_0_monitor_serialized.0[..];
4454         let (_, mut chan_0_monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut chan_0_monitor_read).unwrap();
4455         assert!(chan_0_monitor_read.is_empty());
4456
4457         let mut nodes_0_read = &nodes_0_serialized[..];
4458         keys_manager = test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet);
4459         let (_, nodes_0_deserialized_tmp) = {
4460                 let mut channel_monitors = HashMap::new();
4461                 channel_monitors.insert(chan_0_monitor.get_funding_txo().0, &mut chan_0_monitor);
4462                 <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
4463                         default_config: UserConfig::default(),
4464                         keys_manager: &keys_manager,
4465                         fee_estimator: &fee_estimator,
4466                         monitor: nodes[0].chan_monitor,
4467                         tx_broadcaster: nodes[0].tx_broadcaster.clone(),
4468                         logger: &logger,
4469                         channel_monitors: &mut channel_monitors,
4470                 }).unwrap()
4471         };
4472         nodes_0_deserialized = nodes_0_deserialized_tmp;
4473         assert!(nodes_0_read.is_empty());
4474
4475         assert!(nodes[0].chan_monitor.add_monitor(chan_0_monitor.get_funding_txo().0, chan_0_monitor).is_ok());
4476         nodes[0].node = &nodes_0_deserialized;
4477         check_added_monitors!(nodes[0], 1);
4478
4479         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
4480
4481         fail_payment(&nodes[0], &[&nodes[1]], our_payment_hash);
4482         claim_payment(&nodes[0], &[&nodes[1]], our_payment_preimage, 1_000_000);
4483 }
4484
4485 #[test]
4486 fn test_manager_serialize_deserialize_inconsistent_monitor() {
4487         // Test deserializing a ChannelManager with an out-of-date ChannelMonitor
4488         let chanmon_cfgs = create_chanmon_cfgs(4);
4489         let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
4490         let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
4491         let logger: test_utils::TestLogger;
4492         let fee_estimator: test_utils::TestFeeEstimator;
4493         let new_chan_monitor: test_utils::TestChannelMonitor;
4494         let keys_manager: test_utils::TestKeysInterface;
4495         let nodes_0_deserialized: ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>;
4496         let mut nodes = create_network(4, &node_cfgs, &node_chanmgrs);
4497         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4498         create_announced_chan_between_nodes(&nodes, 2, 0, InitFeatures::known(), InitFeatures::known());
4499         let (_, _, channel_id, funding_tx) = create_announced_chan_between_nodes(&nodes, 0, 3, InitFeatures::known(), InitFeatures::known());
4500
4501         let mut node_0_stale_monitors_serialized = Vec::new();
4502         for monitor in nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter() {
4503                 let mut writer = test_utils::TestVecWriter(Vec::new());
4504                 monitor.1.write_for_disk(&mut writer).unwrap();
4505                 node_0_stale_monitors_serialized.push(writer.0);
4506         }
4507
4508         let (our_payment_preimage, _) = route_payment(&nodes[2], &[&nodes[0], &nodes[1]], 1000000);
4509
4510         // Serialize the ChannelManager here, but the monitor we keep up-to-date
4511         let nodes_0_serialized = nodes[0].node.encode();
4512
4513         route_payment(&nodes[0], &[&nodes[3]], 1000000);
4514         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4515         nodes[2].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4516         nodes[3].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
4517
4518         // Now the ChannelMonitor (which is now out-of-sync with ChannelManager for channel w/
4519         // nodes[3])
4520         let mut node_0_monitors_serialized = Vec::new();
4521         for monitor in nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter() {
4522                 let mut writer = test_utils::TestVecWriter(Vec::new());
4523                 monitor.1.write_for_disk(&mut writer).unwrap();
4524                 node_0_monitors_serialized.push(writer.0);
4525         }
4526
4527         logger = test_utils::TestLogger::new();
4528         fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
4529         new_chan_monitor = test_utils::TestChannelMonitor::new(nodes[0].chain_monitor.clone(), nodes[0].tx_broadcaster.clone(), &logger, &fee_estimator);
4530         nodes[0].chan_monitor = &new_chan_monitor;
4531
4532         let mut node_0_stale_monitors = Vec::new();
4533         for serialized in node_0_stale_monitors_serialized.iter() {
4534                 let mut read = &serialized[..];
4535                 let (_, monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut read).unwrap();
4536                 assert!(read.is_empty());
4537                 node_0_stale_monitors.push(monitor);
4538         }
4539
4540         let mut node_0_monitors = Vec::new();
4541         for serialized in node_0_monitors_serialized.iter() {
4542                 let mut read = &serialized[..];
4543                 let (_, monitor) = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut read).unwrap();
4544                 assert!(read.is_empty());
4545                 node_0_monitors.push(monitor);
4546         }
4547
4548         keys_manager = test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet);
4549
4550         let mut nodes_0_read = &nodes_0_serialized[..];
4551         if let Err(msgs::DecodeError::InvalidValue) =
4552                 <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
4553                 default_config: UserConfig::default(),
4554                 keys_manager: &keys_manager,
4555                 fee_estimator: &fee_estimator,
4556                 monitor: nodes[0].chan_monitor,
4557                 tx_broadcaster: nodes[0].tx_broadcaster.clone(),
4558                 logger: &logger,
4559                 channel_monitors: &mut node_0_stale_monitors.iter_mut().map(|monitor| { (monitor.get_funding_txo().0, monitor) }).collect(),
4560         }) { } else {
4561                 panic!("If the monitor(s) are stale, this indicates a bug and we should get an Err return");
4562         };
4563
4564         let mut nodes_0_read = &nodes_0_serialized[..];
4565         let (_, nodes_0_deserialized_tmp) =
4566                 <(BlockHash, ChannelManager<EnforcingChannelKeys, &test_utils::TestChannelMonitor, &test_utils::TestBroadcaster, &test_utils::TestKeysInterface, &test_utils::TestFeeEstimator, &test_utils::TestLogger>)>::read(&mut nodes_0_read, ChannelManagerReadArgs {
4567                 default_config: UserConfig::default(),
4568                 keys_manager: &keys_manager,
4569                 fee_estimator: &fee_estimator,
4570                 monitor: nodes[0].chan_monitor,
4571                 tx_broadcaster: nodes[0].tx_broadcaster.clone(),
4572                 logger: &logger,
4573                 channel_monitors: &mut node_0_monitors.iter_mut().map(|monitor| { (monitor.get_funding_txo().0, monitor) }).collect(),
4574         }).unwrap();
4575         nodes_0_deserialized = nodes_0_deserialized_tmp;
4576         assert!(nodes_0_read.is_empty());
4577
4578         { // Channel close should result in a commitment tx and an HTLC tx
4579                 let txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
4580                 assert_eq!(txn.len(), 2);
4581                 assert_eq!(txn[0].input[0].previous_output.txid, funding_tx.txid());
4582                 assert_eq!(txn[1].input[0].previous_output.txid, txn[0].txid());
4583         }
4584
4585         for monitor in node_0_monitors.drain(..) {
4586                 assert!(nodes[0].chan_monitor.add_monitor(monitor.get_funding_txo().0, monitor).is_ok());
4587                 check_added_monitors!(nodes[0], 1);
4588         }
4589         nodes[0].node = &nodes_0_deserialized;
4590
4591         // nodes[1] and nodes[2] have no lost state with nodes[0]...
4592         reconnect_nodes(&nodes[0], &nodes[1], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
4593         reconnect_nodes(&nodes[0], &nodes[2], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
4594         //... and we can even still claim the payment!
4595         claim_payment(&nodes[2], &[&nodes[0], &nodes[1]], our_payment_preimage, 1_000_000);
4596
4597         nodes[3].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
4598         let reestablish = get_event_msg!(nodes[3], MessageSendEvent::SendChannelReestablish, nodes[0].node.get_our_node_id());
4599         nodes[0].node.peer_connected(&nodes[3].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
4600         nodes[0].node.handle_channel_reestablish(&nodes[3].node.get_our_node_id(), &reestablish);
4601         let msg_events = nodes[0].node.get_and_clear_pending_msg_events();
4602         assert_eq!(msg_events.len(), 1);
4603         if let MessageSendEvent::HandleError { ref action, .. } = msg_events[0] {
4604                 match action {
4605                         &ErrorAction::SendErrorMessage { ref msg } => {
4606                                 assert_eq!(msg.channel_id, channel_id);
4607                         },
4608                         _ => panic!("Unexpected event!"),
4609                 }
4610         }
4611 }
4612
4613 macro_rules! check_spendable_outputs {
4614         ($node: expr, $der_idx: expr, $keysinterface: expr, $chan_value: expr) => {
4615                 {
4616                         let events = $node.chan_monitor.simple_monitor.get_and_clear_pending_events();
4617                         let mut txn = Vec::new();
4618                         for event in events {
4619                                 match event {
4620                                         Event::SpendableOutputs { ref outputs } => {
4621                                                 for outp in outputs {
4622                                                         match *outp {
4623                                                                 SpendableOutputDescriptor::StaticOutputRemotePayment { ref outpoint, ref output, ref key_derivation_params } => {
4624                                                                         let input = TxIn {
4625                                                                                 previous_output: outpoint.clone(),
4626                                                                                 script_sig: Script::new(),
4627                                                                                 sequence: 0,
4628                                                                                 witness: Vec::new(),
4629                                                                         };
4630                                                                         let outp = TxOut {
4631                                                                                 script_pubkey: Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(),
4632                                                                                 value: output.value,
4633                                                                         };
4634                                                                         let mut spend_tx = Transaction {
4635                                                                                 version: 2,
4636                                                                                 lock_time: 0,
4637                                                                                 input: vec![input],
4638                                                                                 output: vec![outp],
4639                                                                         };
4640                                                                         let secp_ctx = Secp256k1::new();
4641                                                                         let keys = $keysinterface.derive_channel_keys($chan_value, key_derivation_params.0, key_derivation_params.1);
4642                                                                         let remotepubkey = keys.pubkeys().payment_point;
4643                                                                         let witness_script = Address::p2pkh(&::bitcoin::PublicKey{compressed: true, key: remotepubkey}, Network::Testnet).script_pubkey();
4644                                                                         let sighash = Message::from_slice(&bip143::SighashComponents::new(&spend_tx).sighash_all(&spend_tx.input[0], &witness_script, output.value)[..]).unwrap();
4645                                                                         let remotesig = secp_ctx.sign(&sighash, &keys.inner.payment_key);
4646                                                                         spend_tx.input[0].witness.push(remotesig.serialize_der().to_vec());
4647                                                                         spend_tx.input[0].witness[0].push(SigHashType::All as u8);
4648                                                                         spend_tx.input[0].witness.push(remotepubkey.serialize().to_vec());
4649                                                                         txn.push(spend_tx);
4650                                                                 },
4651                                                                 SpendableOutputDescriptor::DynamicOutputP2WSH { ref outpoint, ref per_commitment_point, ref to_self_delay, ref output, ref key_derivation_params, ref remote_revocation_pubkey } => {
4652                                                                         let input = TxIn {
4653                                                                                 previous_output: outpoint.clone(),
4654                                                                                 script_sig: Script::new(),
4655                                                                                 sequence: *to_self_delay as u32,
4656                                                                                 witness: Vec::new(),
4657                                                                         };
4658                                                                         let outp = TxOut {
4659                                                                                 script_pubkey: Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(),
4660                                                                                 value: output.value,
4661                                                                         };
4662                                                                         let mut spend_tx = Transaction {
4663                                                                                 version: 2,
4664                                                                                 lock_time: 0,
4665                                                                                 input: vec![input],
4666                                                                                 output: vec![outp],
4667                                                                         };
4668                                                                         let secp_ctx = Secp256k1::new();
4669                                                                         let keys = $keysinterface.derive_channel_keys($chan_value, key_derivation_params.0, key_derivation_params.1);
4670                                                                         if let Ok(delayed_payment_key) = chan_utils::derive_private_key(&secp_ctx, &per_commitment_point, &keys.inner.delayed_payment_base_key) {
4671
4672                                                                                 let delayed_payment_pubkey = PublicKey::from_secret_key(&secp_ctx, &delayed_payment_key);
4673                                                                                 let witness_script = chan_utils::get_revokeable_redeemscript(remote_revocation_pubkey, *to_self_delay, &delayed_payment_pubkey);
4674                                                                                 let sighash = Message::from_slice(&bip143::SighashComponents::new(&spend_tx).sighash_all(&spend_tx.input[0], &witness_script, output.value)[..]).unwrap();
4675                                                                                 let local_delayedsig = secp_ctx.sign(&sighash, &delayed_payment_key);
4676                                                                                 spend_tx.input[0].witness.push(local_delayedsig.serialize_der().to_vec());
4677                                                                                 spend_tx.input[0].witness[0].push(SigHashType::All as u8);
4678                                                                                 spend_tx.input[0].witness.push(vec!()); //MINIMALIF
4679                                                                                 spend_tx.input[0].witness.push(witness_script.clone().into_bytes());
4680                                                                         } else { panic!() }
4681                                                                         txn.push(spend_tx);
4682                                                                 },
4683                                                                 SpendableOutputDescriptor::StaticOutput { ref outpoint, ref output } => {
4684                                                                         let secp_ctx = Secp256k1::new();
4685                                                                         let input = TxIn {
4686                                                                                 previous_output: outpoint.clone(),
4687                                                                                 script_sig: Script::new(),
4688                                                                                 sequence: 0,
4689                                                                                 witness: Vec::new(),
4690                                                                         };
4691                                                                         let outp = TxOut {
4692                                                                                 script_pubkey: Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(),
4693                                                                                 value: output.value,
4694                                                                         };
4695                                                                         let mut spend_tx = Transaction {
4696                                                                                 version: 2,
4697                                                                                 lock_time: 0,
4698                                                                                 input: vec![input],
4699                                                                                 output: vec![outp.clone()],
4700                                                                         };
4701                                                                         let secret = {
4702                                                                                 match ExtendedPrivKey::new_master(Network::Testnet, &$node.node_seed) {
4703                                                                                         Ok(master_key) => {
4704                                                                                                 match master_key.ckd_priv(&secp_ctx, ChildNumber::from_hardened_idx($der_idx).expect("key space exhausted")) {
4705                                                                                                         Ok(key) => key,
4706                                                                                                         Err(_) => panic!("Your RNG is busted"),
4707                                                                                                 }
4708                                                                                         }
4709                                                                                         Err(_) => panic!("Your rng is busted"),
4710                                                                                 }
4711                                                                         };
4712                                                                         let pubkey = ExtendedPubKey::from_private(&secp_ctx, &secret).public_key;
4713                                                                         let witness_script = Address::p2pkh(&pubkey, Network::Testnet).script_pubkey();
4714                                                                         let sighash = Message::from_slice(&bip143::SighashComponents::new(&spend_tx).sighash_all(&spend_tx.input[0], &witness_script, output.value)[..]).unwrap();
4715                                                                         let sig = secp_ctx.sign(&sighash, &secret.private_key.key);
4716                                                                         spend_tx.input[0].witness.push(sig.serialize_der().to_vec());
4717                                                                         spend_tx.input[0].witness[0].push(SigHashType::All as u8);
4718                                                                         spend_tx.input[0].witness.push(pubkey.key.serialize().to_vec());
4719                                                                         txn.push(spend_tx);
4720                                                                 },
4721                                                         }
4722                                                 }
4723                                         },
4724                                         _ => panic!("Unexpected event"),
4725                                 };
4726                         }
4727                         txn
4728                 }
4729         }
4730 }
4731
4732 #[test]
4733 fn test_claim_sizeable_push_msat() {
4734         // Incidentally test SpendableOutput event generation due to detection of to_local output on commitment tx
4735         let chanmon_cfgs = create_chanmon_cfgs(2);
4736         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4737         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4738         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4739
4740         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 99000000, InitFeatures::known(), InitFeatures::known());
4741         nodes[1].node.force_close_channel(&chan.2);
4742         check_closed_broadcast!(nodes[1], false);
4743         check_added_monitors!(nodes[1], 1);
4744         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
4745         assert_eq!(node_txn.len(), 1);
4746         check_spends!(node_txn[0], chan.3);
4747         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
4748
4749         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4750         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone()] }, 0);
4751         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
4752
4753         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
4754         assert_eq!(spend_txn.len(), 1);
4755         check_spends!(spend_txn[0], node_txn[0]);
4756 }
4757
4758 #[test]
4759 fn test_claim_on_remote_sizeable_push_msat() {
4760         // Same test as previous, just test on remote commitment tx, as per_commitment_point registration changes following you're funder/fundee and
4761         // to_remote output is encumbered by a P2WPKH
4762         let chanmon_cfgs = create_chanmon_cfgs(2);
4763         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4764         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4765         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4766
4767         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 99000000, InitFeatures::known(), InitFeatures::known());
4768         nodes[0].node.force_close_channel(&chan.2);
4769         check_closed_broadcast!(nodes[0], false);
4770         check_added_monitors!(nodes[0], 1);
4771
4772         let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
4773         assert_eq!(node_txn.len(), 1);
4774         check_spends!(node_txn[0], chan.3);
4775         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
4776
4777         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4778         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone()] }, 0);
4779         check_closed_broadcast!(nodes[1], false);
4780         check_added_monitors!(nodes[1], 1);
4781         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
4782
4783         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
4784         assert_eq!(spend_txn.len(), 2);
4785         assert_eq!(spend_txn[0], spend_txn[1]);
4786         check_spends!(spend_txn[0], node_txn[0]);
4787 }
4788
4789 #[test]
4790 fn test_claim_on_remote_revoked_sizeable_push_msat() {
4791         // Same test as previous, just test on remote revoked commitment tx, as per_commitment_point registration changes following you're funder/fundee and
4792         // to_remote output is encumbered by a P2WPKH
4793
4794         let chanmon_cfgs = create_chanmon_cfgs(2);
4795         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4796         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4797         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4798
4799         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 59000000, InitFeatures::known(), InitFeatures::known());
4800         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
4801         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan.2);
4802         assert_eq!(revoked_local_txn[0].input.len(), 1);
4803         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid());
4804
4805         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
4806         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4807         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 0);
4808         check_closed_broadcast!(nodes[1], false);
4809         check_added_monitors!(nodes[1], 1);
4810
4811         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
4812         let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4813         nodes[1].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone()] }, 1);
4814         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
4815
4816         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
4817         assert_eq!(spend_txn.len(), 3);
4818         assert_eq!(spend_txn[0], spend_txn[1]); // to_remote output on revoked remote commitment_tx
4819         check_spends!(spend_txn[0], revoked_local_txn[0]);
4820         check_spends!(spend_txn[2], node_txn[0]);
4821 }
4822
4823 #[test]
4824 fn test_static_spendable_outputs_preimage_tx() {
4825         let chanmon_cfgs = create_chanmon_cfgs(2);
4826         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4827         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4828         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4829
4830         // Create some initial channels
4831         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4832
4833         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
4834
4835         let commitment_tx = get_local_commitment_txn!(nodes[0], chan_1.2);
4836         assert_eq!(commitment_tx[0].input.len(), 1);
4837         assert_eq!(commitment_tx[0].input[0].previous_output.txid, chan_1.3.txid());
4838
4839         // Settle A's commitment tx on B's chain
4840         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4841         assert!(nodes[1].node.claim_funds(payment_preimage, &None, 3_000_000));
4842         check_added_monitors!(nodes[1], 1);
4843         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()] }, 1);
4844         check_added_monitors!(nodes[1], 1);
4845         let events = nodes[1].node.get_and_clear_pending_msg_events();
4846         match events[0] {
4847                 MessageSendEvent::UpdateHTLCs { .. } => {},
4848                 _ => panic!("Unexpected event"),
4849         }
4850         match events[1] {
4851                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
4852                 _ => panic!("Unexepected event"),
4853         }
4854
4855         // Check B's monitor was able to send back output descriptor event for preimage tx on A's commitment tx
4856         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap(); // ChannelManager : 2 (local commitment tx + HTLC-Success), ChannelMonitor: preimage tx
4857         assert_eq!(node_txn.len(), 3);
4858         check_spends!(node_txn[0], commitment_tx[0]);
4859         assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
4860         check_spends!(node_txn[1], chan_1.3);
4861         check_spends!(node_txn[2], node_txn[1]);
4862
4863         let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4864         nodes[1].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone()] }, 1);
4865         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
4866
4867         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
4868         assert_eq!(spend_txn.len(), 1);
4869         check_spends!(spend_txn[0], node_txn[0]);
4870 }
4871
4872 #[test]
4873 fn test_static_spendable_outputs_timeout_tx() {
4874         let chanmon_cfgs = create_chanmon_cfgs(2);
4875         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4876         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4877         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4878
4879         // Create some initial channels
4880         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4881
4882         // Rebalance the network a bit by relaying one payment through all the channels ...
4883         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
4884
4885         let (_, our_payment_hash) = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3_000_000);
4886
4887         let commitment_tx = get_local_commitment_txn!(nodes[0], chan_1.2);
4888         assert_eq!(commitment_tx[0].input.len(), 1);
4889         assert_eq!(commitment_tx[0].input[0].previous_output.txid, chan_1.3.txid());
4890
4891         // Settle A's commitment tx on B' chain
4892         let header = BlockHeader { version: 0x2000_0000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
4893         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()] }, 0);
4894         check_added_monitors!(nodes[1], 1);
4895         let events = nodes[1].node.get_and_clear_pending_msg_events();
4896         match events[0] {
4897                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
4898                 _ => panic!("Unexpected event"),
4899         }
4900
4901         // Check B's monitor was able to send back output descriptor event for timeout tx on A's commitment tx
4902         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
4903         assert_eq!(node_txn.len(), 3); // ChannelManager : 2 (local commitent tx + HTLC-timeout), ChannelMonitor: timeout tx
4904         check_spends!(node_txn[0],  commitment_tx[0].clone());
4905         assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
4906         check_spends!(node_txn[1], chan_1.3.clone());
4907         check_spends!(node_txn[2], node_txn[1]);
4908
4909         let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4910         nodes[1].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone()] }, 1);
4911         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
4912         expect_payment_failed!(nodes[1], our_payment_hash, true);
4913
4914         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
4915         assert_eq!(spend_txn.len(), 3); // SpendableOutput: remote_commitment_tx.to_remote (*2), timeout_tx.output (*1)
4916         check_spends!(spend_txn[2], node_txn[0].clone());
4917 }
4918
4919 #[test]
4920 fn test_static_spendable_outputs_justice_tx_revoked_commitment_tx() {
4921         let chanmon_cfgs = create_chanmon_cfgs(2);
4922         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4923         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4924         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4925
4926         // Create some initial channels
4927         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4928
4929         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
4930         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
4931         assert_eq!(revoked_local_txn[0].input.len(), 1);
4932         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
4933
4934         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
4935
4936         let  header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4937         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 0);
4938         check_closed_broadcast!(nodes[1], false);
4939         check_added_monitors!(nodes[1], 1);
4940
4941         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
4942         assert_eq!(node_txn.len(), 2);
4943         assert_eq!(node_txn[0].input.len(), 2);
4944         check_spends!(node_txn[0], revoked_local_txn[0]);
4945
4946         let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4947         nodes[1].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone()] }, 1);
4948         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
4949
4950         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
4951         assert_eq!(spend_txn.len(), 1);
4952         check_spends!(spend_txn[0], node_txn[0]);
4953 }
4954
4955 #[test]
4956 fn test_static_spendable_outputs_justice_tx_revoked_htlc_timeout_tx() {
4957         let chanmon_cfgs = create_chanmon_cfgs(2);
4958         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
4959         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
4960         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
4961
4962         // Create some initial channels
4963         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
4964
4965         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
4966         let revoked_local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
4967         assert_eq!(revoked_local_txn[0].input.len(), 1);
4968         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
4969
4970         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
4971
4972         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
4973         // A will generate HTLC-Timeout from revoked commitment tx
4974         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
4975         check_closed_broadcast!(nodes[0], false);
4976         check_added_monitors!(nodes[0], 1);
4977
4978         let revoked_htlc_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
4979         assert_eq!(revoked_htlc_txn.len(), 2);
4980         assert_eq!(revoked_htlc_txn[0].input.len(), 1);
4981         assert_eq!(revoked_htlc_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
4982         check_spends!(revoked_htlc_txn[0], revoked_local_txn[0]);
4983         check_spends!(revoked_htlc_txn[1], chan_1.3);
4984
4985         // B will generate justice tx from A's revoked commitment/HTLC tx
4986         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone(), revoked_htlc_txn[0].clone()] }, 0);
4987         check_closed_broadcast!(nodes[1], false);
4988         check_added_monitors!(nodes[1], 1);
4989
4990         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
4991         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
4992         assert_eq!(node_txn[0].input.len(), 2);
4993         check_spends!(node_txn[0], revoked_local_txn[0]);
4994         check_spends!(node_txn[1], chan_1.3);
4995         assert_eq!(node_txn[2].input.len(), 1);
4996         check_spends!(node_txn[2], revoked_htlc_txn[0]);
4997         assert_eq!(node_txn[3].input.len(), 1);
4998         check_spends!(node_txn[3], revoked_local_txn[0]);
4999
5000         let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5001         nodes[1].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone(), node_txn[2].clone()] }, 1);
5002         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
5003
5004         // Check B's ChannelMonitor was able to generate the right spendable output descriptor
5005         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
5006         assert_eq!(spend_txn.len(), 2);
5007         check_spends!(spend_txn[0], node_txn[0]);
5008         check_spends!(spend_txn[1], node_txn[2]);
5009 }
5010
5011 #[test]
5012 fn test_static_spendable_outputs_justice_tx_revoked_htlc_success_tx() {
5013         let chanmon_cfgs = create_chanmon_cfgs(2);
5014         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
5015         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
5016         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
5017
5018         // Create some initial channels
5019         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5020
5021         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
5022         let revoked_local_txn = get_local_commitment_txn!(nodes[1], chan_1.2);
5023         assert_eq!(revoked_local_txn[0].input.len(), 1);
5024         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan_1.3.txid());
5025
5026         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
5027
5028         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5029         // B will generate HTLC-Success from revoked commitment tx
5030         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
5031         check_closed_broadcast!(nodes[1], false);
5032         check_added_monitors!(nodes[1], 1);
5033         let revoked_htlc_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5034
5035         assert_eq!(revoked_htlc_txn.len(), 2);
5036         assert_eq!(revoked_htlc_txn[0].input.len(), 1);
5037         assert_eq!(revoked_htlc_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5038         check_spends!(revoked_htlc_txn[0], revoked_local_txn[0]);
5039
5040         // A will generate justice tx from B's revoked commitment/HTLC tx
5041         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone(), revoked_htlc_txn[0].clone()] }, 1);
5042         check_closed_broadcast!(nodes[0], false);
5043         check_added_monitors!(nodes[0], 1);
5044
5045         let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
5046         assert_eq!(node_txn.len(), 3); // ChannelMonitor: justice tx on revoked commitment, justice tx on revoked HTLC-success, ChannelManager: local commitment tx
5047         assert_eq!(node_txn[2].input.len(), 1);
5048         check_spends!(node_txn[2], revoked_htlc_txn[0]);
5049
5050         let header_1 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5051         nodes[0].block_notifier.block_connected(&Block { header: header_1, txdata: vec![node_txn[0].clone(), node_txn[2].clone()] }, 1);
5052         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 1, true, header.bitcoin_hash());
5053
5054         // Check A's ChannelMonitor was able to generate the right spendable output descriptor
5055         let spend_txn = check_spendable_outputs!(nodes[0], 1, node_cfgs[0].keys_manager, 100000);
5056         assert_eq!(spend_txn.len(), 5); // Duplicated SpendableOutput due to block rescan after revoked htlc output tracking
5057         assert_eq!(spend_txn[0], spend_txn[1]);
5058         assert_eq!(spend_txn[0], spend_txn[2]);
5059         check_spends!(spend_txn[0], revoked_local_txn[0]); // spending to_remote output from revoked local tx
5060         check_spends!(spend_txn[3], node_txn[0]); // spending justice tx output from revoked local tx htlc received output
5061         check_spends!(spend_txn[4], node_txn[2]); // spending justice tx output on htlc success tx
5062 }
5063
5064 #[test]
5065 fn test_onchain_to_onchain_claim() {
5066         // Test that in case of channel closure, we detect the state of output thanks to
5067         // ChainWatchInterface and claim HTLC on downstream peer's remote commitment tx.
5068         // First, have C claim an HTLC against its own latest commitment transaction.
5069         // Then, broadcast these to B, which should update the monitor downstream on the A<->B
5070         // channel.
5071         // Finally, check that B will claim the HTLC output if A's latest commitment transaction
5072         // gets broadcast.
5073
5074         let chanmon_cfgs = create_chanmon_cfgs(3);
5075         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
5076         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
5077         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
5078
5079         // Create some initial channels
5080         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5081         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
5082
5083         // Rebalance the network a bit by relaying one payment through all the channels ...
5084         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
5085         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 8000000, 8_000_000);
5086
5087         let (payment_preimage, _payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2]), 3000000);
5088         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
5089         let commitment_tx = get_local_commitment_txn!(nodes[2], chan_2.2);
5090         check_spends!(commitment_tx[0], chan_2.3);
5091         nodes[2].node.claim_funds(payment_preimage, &None, 3_000_000);
5092         check_added_monitors!(nodes[2], 1);
5093         let updates = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
5094         assert!(updates.update_add_htlcs.is_empty());
5095         assert!(updates.update_fail_htlcs.is_empty());
5096         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
5097         assert!(updates.update_fail_malformed_htlcs.is_empty());
5098
5099         nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
5100         check_closed_broadcast!(nodes[2], false);
5101         check_added_monitors!(nodes[2], 1);
5102
5103         let c_txn = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().clone(); // ChannelManager : 2 (commitment tx, HTLC-Success tx), ChannelMonitor : 1 (HTLC-Success tx)
5104         assert_eq!(c_txn.len(), 3);
5105         assert_eq!(c_txn[0], c_txn[2]);
5106         assert_eq!(commitment_tx[0], c_txn[1]);
5107         check_spends!(c_txn[1], chan_2.3);
5108         check_spends!(c_txn[2], c_txn[1]);
5109         assert_eq!(c_txn[1].input[0].witness.clone().last().unwrap().len(), 71);
5110         assert_eq!(c_txn[2].input[0].witness.clone().last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5111         assert!(c_txn[0].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
5112         assert_eq!(c_txn[0].lock_time, 0); // Success tx
5113
5114         // 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
5115         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![c_txn[1].clone(), c_txn[2].clone()]}, 1);
5116         {
5117                 let mut b_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5118                 // ChannelMonitor: claim tx, ChannelManager: local commitment tx + HTLC-timeout tx
5119                 assert_eq!(b_txn.len(), 3);
5120                 check_spends!(b_txn[1], chan_2.3); // B local commitment tx, issued by ChannelManager
5121                 check_spends!(b_txn[2], b_txn[1]); // HTLC-Timeout on B local commitment tx, issued by ChannelManager
5122                 assert_eq!(b_txn[2].input[0].witness.clone().last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
5123                 assert!(b_txn[2].output[0].script_pubkey.is_v0_p2wsh()); // revokeable output
5124                 assert_ne!(b_txn[2].lock_time, 0); // Timeout tx
5125                 check_spends!(b_txn[0], c_txn[1]); // timeout tx on C remote commitment tx, issued by ChannelMonitor, * 2 due to block rescan
5126                 assert_eq!(b_txn[0].input[0].witness.clone().last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5127                 assert!(b_txn[0].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
5128                 assert_ne!(b_txn[2].lock_time, 0); // Timeout tx
5129                 b_txn.clear();
5130         }
5131         check_added_monitors!(nodes[1], 1);
5132         let msg_events = nodes[1].node.get_and_clear_pending_msg_events();
5133         check_added_monitors!(nodes[1], 1);
5134         match msg_events[0] {
5135                 MessageSendEvent::BroadcastChannelUpdate {  .. } => {},
5136                 _ => panic!("Unexpected event"),
5137         }
5138         match msg_events[1] {
5139                 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, .. } } => {
5140                         assert!(update_add_htlcs.is_empty());
5141                         assert!(update_fail_htlcs.is_empty());
5142                         assert_eq!(update_fulfill_htlcs.len(), 1);
5143                         assert!(update_fail_malformed_htlcs.is_empty());
5144                         assert_eq!(nodes[0].node.get_our_node_id(), *node_id);
5145                 },
5146                 _ => panic!("Unexpected event"),
5147         };
5148         // Broadcast A's commitment tx on B's chain to see if we are able to claim inbound HTLC with our HTLC-Success tx
5149         let commitment_tx = get_local_commitment_txn!(nodes[0], chan_1.2);
5150         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![commitment_tx[0].clone()]}, 1);
5151         let b_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5152         // ChannelMonitor: HTLC-Success tx, ChannelManager: local commitment tx + HTLC-Success tx
5153         assert_eq!(b_txn.len(), 3);
5154         check_spends!(b_txn[1], chan_1.3);
5155         check_spends!(b_txn[2], b_txn[1]);
5156         check_spends!(b_txn[0], commitment_tx[0]);
5157         assert_eq!(b_txn[0].input[0].witness.clone().last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
5158         assert!(b_txn[0].output[0].script_pubkey.is_v0_p2wpkh()); // direct payment
5159         assert_eq!(b_txn[0].lock_time, 0); // Success tx
5160
5161         check_closed_broadcast!(nodes[1], false);
5162         check_added_monitors!(nodes[1], 1);
5163 }
5164
5165 #[test]
5166 fn test_duplicate_payment_hash_one_failure_one_success() {
5167         // Topology : A --> B --> C
5168         // We route 2 payments with same hash between B and C, one will be timeout, the other successfully claim
5169         let chanmon_cfgs = create_chanmon_cfgs(3);
5170         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
5171         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
5172         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
5173
5174         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5175         let chan_2 = create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
5176
5177         let (our_payment_preimage, duplicate_payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 900000);
5178         *nodes[0].network_payment_count.borrow_mut() -= 1;
5179         assert_eq!(route_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 900000).1, duplicate_payment_hash);
5180
5181         let commitment_txn = get_local_commitment_txn!(nodes[2], chan_2.2);
5182         assert_eq!(commitment_txn[0].input.len(), 1);
5183         check_spends!(commitment_txn[0], chan_2.3);
5184
5185         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5186         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![commitment_txn[0].clone()] }, 1);
5187         check_closed_broadcast!(nodes[1], false);
5188         check_added_monitors!(nodes[1], 1);
5189
5190         let htlc_timeout_tx;
5191         { // Extract one of the two HTLC-Timeout transaction
5192                 let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5193                 // ChannelMonitor: timeout tx * 2, ChannelManager: local commitment tx + HTLC-timeout * 2
5194                 assert_eq!(node_txn.len(), 5);
5195                 check_spends!(node_txn[0], commitment_txn[0]);
5196                 assert_eq!(node_txn[0].input.len(), 1);
5197                 check_spends!(node_txn[1], commitment_txn[0]);
5198                 assert_eq!(node_txn[1].input.len(), 1);
5199                 assert_ne!(node_txn[0].input[0], node_txn[1].input[0]);
5200                 assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5201                 assert_eq!(node_txn[1].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5202                 check_spends!(node_txn[2], chan_2.3);
5203                 check_spends!(node_txn[3], node_txn[2]);
5204                 check_spends!(node_txn[4], node_txn[2]);
5205                 htlc_timeout_tx = node_txn[1].clone();
5206         }
5207
5208         nodes[2].node.claim_funds(our_payment_preimage, &None, 900_000);
5209         nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![commitment_txn[0].clone()] }, 1);
5210         check_added_monitors!(nodes[2], 3);
5211         let events = nodes[2].node.get_and_clear_pending_msg_events();
5212         match events[0] {
5213                 MessageSendEvent::UpdateHTLCs { .. } => {},
5214                 _ => panic!("Unexpected event"),
5215         }
5216         match events[1] {
5217                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5218                 _ => panic!("Unexepected event"),
5219         }
5220         let htlc_success_txn: Vec<_> = nodes[2].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
5221         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)
5222         check_spends!(htlc_success_txn[2], chan_2.3);
5223         check_spends!(htlc_success_txn[3], htlc_success_txn[2]);
5224         check_spends!(htlc_success_txn[4], htlc_success_txn[2]);
5225         assert_eq!(htlc_success_txn[0], htlc_success_txn[3]);
5226         assert_eq!(htlc_success_txn[0].input.len(), 1);
5227         assert_eq!(htlc_success_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5228         assert_eq!(htlc_success_txn[1], htlc_success_txn[4]);
5229         assert_eq!(htlc_success_txn[1].input.len(), 1);
5230         assert_eq!(htlc_success_txn[1].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5231         assert_ne!(htlc_success_txn[0].input[0], htlc_success_txn[1].input[0]);
5232         check_spends!(htlc_success_txn[0], commitment_txn[0]);
5233         check_spends!(htlc_success_txn[1], commitment_txn[0]);
5234
5235         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![htlc_timeout_tx] }, 200);
5236         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 200, true, header.bitcoin_hash());
5237         expect_pending_htlcs_forwardable!(nodes[1]);
5238         let htlc_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5239         assert!(htlc_updates.update_add_htlcs.is_empty());
5240         assert_eq!(htlc_updates.update_fail_htlcs.len(), 1);
5241         assert_eq!(htlc_updates.update_fail_htlcs[0].htlc_id, 1);
5242         assert!(htlc_updates.update_fulfill_htlcs.is_empty());
5243         assert!(htlc_updates.update_fail_malformed_htlcs.is_empty());
5244         check_added_monitors!(nodes[1], 1);
5245
5246         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &htlc_updates.update_fail_htlcs[0]);
5247         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
5248         {
5249                 commitment_signed_dance!(nodes[0], nodes[1], &htlc_updates.commitment_signed, false, true);
5250                 let events = nodes[0].node.get_and_clear_pending_msg_events();
5251                 assert_eq!(events.len(), 1);
5252                 match events[0] {
5253                         MessageSendEvent::PaymentFailureNetworkUpdate { update: msgs::HTLCFailChannelUpdate::ChannelClosed { .. }  } => {
5254                         },
5255                         _ => { panic!("Unexpected event"); }
5256                 }
5257         }
5258         expect_payment_failed!(nodes[0], duplicate_payment_hash, false);
5259
5260         // Solve 2nd HTLC by broadcasting on B's chain HTLC-Success Tx from C
5261         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![htlc_success_txn[0].clone()] }, 200);
5262         let updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5263         assert!(updates.update_add_htlcs.is_empty());
5264         assert!(updates.update_fail_htlcs.is_empty());
5265         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
5266         assert_eq!(updates.update_fulfill_htlcs[0].htlc_id, 0);
5267         assert!(updates.update_fail_malformed_htlcs.is_empty());
5268         check_added_monitors!(nodes[1], 1);
5269
5270         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
5271         commitment_signed_dance!(nodes[0], nodes[1], &updates.commitment_signed, false);
5272
5273         let events = nodes[0].node.get_and_clear_pending_events();
5274         match events[0] {
5275                 Event::PaymentSent { ref payment_preimage } => {
5276                         assert_eq!(*payment_preimage, our_payment_preimage);
5277                 }
5278                 _ => panic!("Unexpected event"),
5279         }
5280 }
5281
5282 #[test]
5283 fn test_dynamic_spendable_outputs_local_htlc_success_tx() {
5284         let chanmon_cfgs = create_chanmon_cfgs(2);
5285         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
5286         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
5287         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
5288
5289         // Create some initial channels
5290         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5291
5292         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9000000).0;
5293         let local_txn = get_local_commitment_txn!(nodes[1], chan_1.2);
5294         assert_eq!(local_txn[0].input.len(), 1);
5295         check_spends!(local_txn[0], chan_1.3);
5296
5297         // Give B knowledge of preimage to be able to generate a local HTLC-Success Tx
5298         nodes[1].node.claim_funds(payment_preimage, &None, 9_000_000);
5299         check_added_monitors!(nodes[1], 1);
5300         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5301         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![local_txn[0].clone()] }, 1);
5302         check_added_monitors!(nodes[1], 1);
5303         let events = nodes[1].node.get_and_clear_pending_msg_events();
5304         match events[0] {
5305                 MessageSendEvent::UpdateHTLCs { .. } => {},
5306                 _ => panic!("Unexpected event"),
5307         }
5308         match events[1] {
5309                 MessageSendEvent::BroadcastChannelUpdate { .. } => {},
5310                 _ => panic!("Unexepected event"),
5311         }
5312         let node_txn = {
5313                 let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
5314                 assert_eq!(node_txn[0].input.len(), 1);
5315                 assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
5316                 check_spends!(node_txn[0], local_txn[0]);
5317                 vec![node_txn[0].clone(), node_txn[2].clone()]
5318         };
5319
5320         let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5321         nodes[1].block_notifier.block_connected(&Block { header: header_201, txdata: node_txn.clone() }, 201);
5322         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 201, true, header_201.bitcoin_hash());
5323
5324         // Verify that B is able to spend its own HTLC-Success tx thanks to spendable output event given back by its ChannelMonitor
5325         let spend_txn = check_spendable_outputs!(nodes[1], 1, node_cfgs[1].keys_manager, 100000);
5326         assert_eq!(spend_txn.len(), 2);
5327         check_spends!(spend_txn[0], node_txn[0]);
5328         check_spends!(spend_txn[1], node_txn[1]);
5329 }
5330
5331 fn do_test_fail_backwards_unrevoked_remote_announce(deliver_last_raa: bool, announce_latest: bool) {
5332         // Test that we fail backwards the full set of HTLCs we need to when remote broadcasts an
5333         // unrevoked commitment transaction.
5334         // This includes HTLCs which were below the dust threshold as well as HTLCs which were awaiting
5335         // a remote RAA before they could be failed backwards (and combinations thereof).
5336         // We also test duplicate-hash HTLCs by adding two nodes on each side of the target nodes which
5337         // use the same payment hashes.
5338         // Thus, we use a six-node network:
5339         //
5340         // A \         / E
5341         //    - C - D -
5342         // B /         \ F
5343         // And test where C fails back to A/B when D announces its latest commitment transaction
5344         let chanmon_cfgs = create_chanmon_cfgs(6);
5345         let node_cfgs = create_node_cfgs(6, &chanmon_cfgs);
5346         let node_chanmgrs = create_node_chanmgrs(6, &node_cfgs, &[None, None, None, None, None, None]);
5347         let nodes = create_network(6, &node_cfgs, &node_chanmgrs);
5348         let logger = test_utils::TestLogger::new();
5349
5350         create_announced_chan_between_nodes(&nodes, 0, 2, InitFeatures::known(), InitFeatures::known());
5351         create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
5352         let chan = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known());
5353         create_announced_chan_between_nodes(&nodes, 3, 4, InitFeatures::known(), InitFeatures::known());
5354         create_announced_chan_between_nodes(&nodes, 3, 5, InitFeatures::known(), InitFeatures::known());
5355
5356         // Rebalance and check output sanity...
5357         send_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 500000, 500_000);
5358         send_payment(&nodes[1], &[&nodes[2], &nodes[3], &nodes[5]], 500000, 500_000);
5359         assert_eq!(get_local_commitment_txn!(nodes[3], chan.2)[0].output.len(), 2);
5360
5361         let ds_dust_limit = nodes[3].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
5362         // 0th HTLC:
5363         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
5364         // 1st HTLC:
5365         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
5366         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
5367         let our_node_id = &nodes[1].node.get_our_node_id();
5368         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();
5369         // 2nd HTLC:
5370         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
5371         // 3rd HTLC:
5372         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
5373         // 4th HTLC:
5374         let (_, payment_hash_3) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 1000000);
5375         // 5th HTLC:
5376         let (_, payment_hash_4) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 1000000);
5377         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();
5378         // 6th HTLC:
5379         send_along_route_with_hash(&nodes[1], route.clone(), &[&nodes[2], &nodes[3], &nodes[5]], 1000000, payment_hash_3);
5380         // 7th HTLC:
5381         send_along_route_with_hash(&nodes[1], route, &[&nodes[2], &nodes[3], &nodes[5]], 1000000, payment_hash_4);
5382
5383         // 8th HTLC:
5384         let (_, payment_hash_5) = route_payment(&nodes[0], &[&nodes[2], &nodes[3], &nodes[4]], 1000000);
5385         // 9th HTLC:
5386         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();
5387         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
5388
5389         // 10th HTLC:
5390         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
5391         // 11th HTLC:
5392         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();
5393         send_along_route_with_hash(&nodes[1], route, &[&nodes[2], &nodes[3], &nodes[5]], 1000000, payment_hash_6);
5394
5395         // Double-check that six of the new HTLC were added
5396         // We now have six HTLCs pending over the dust limit and six HTLCs under the dust limit (ie,
5397         // with to_local and to_remote outputs, 8 outputs and 6 HTLCs not included).
5398         assert_eq!(get_local_commitment_txn!(nodes[3], chan.2).len(), 1);
5399         assert_eq!(get_local_commitment_txn!(nodes[3], chan.2)[0].output.len(), 8);
5400
5401         // Now fail back three of the over-dust-limit and three of the under-dust-limit payments in one go.
5402         // Fail 0th below-dust, 4th above-dust, 8th above-dust, 10th below-dust HTLCs
5403         assert!(nodes[4].node.fail_htlc_backwards(&payment_hash_1, &None));
5404         assert!(nodes[4].node.fail_htlc_backwards(&payment_hash_3, &None));
5405         assert!(nodes[4].node.fail_htlc_backwards(&payment_hash_5, &None));
5406         assert!(nodes[4].node.fail_htlc_backwards(&payment_hash_6, &None));
5407         check_added_monitors!(nodes[4], 0);
5408         expect_pending_htlcs_forwardable!(nodes[4]);
5409         check_added_monitors!(nodes[4], 1);
5410
5411         let four_removes = get_htlc_update_msgs!(nodes[4], nodes[3].node.get_our_node_id());
5412         nodes[3].node.handle_update_fail_htlc(&nodes[4].node.get_our_node_id(), &four_removes.update_fail_htlcs[0]);
5413         nodes[3].node.handle_update_fail_htlc(&nodes[4].node.get_our_node_id(), &four_removes.update_fail_htlcs[1]);
5414         nodes[3].node.handle_update_fail_htlc(&nodes[4].node.get_our_node_id(), &four_removes.update_fail_htlcs[2]);
5415         nodes[3].node.handle_update_fail_htlc(&nodes[4].node.get_our_node_id(), &four_removes.update_fail_htlcs[3]);
5416         commitment_signed_dance!(nodes[3], nodes[4], four_removes.commitment_signed, false);
5417
5418         // Fail 3rd below-dust and 7th above-dust HTLCs
5419         assert!(nodes[5].node.fail_htlc_backwards(&payment_hash_2, &None));
5420         assert!(nodes[5].node.fail_htlc_backwards(&payment_hash_4, &None));
5421         check_added_monitors!(nodes[5], 0);
5422         expect_pending_htlcs_forwardable!(nodes[5]);
5423         check_added_monitors!(nodes[5], 1);
5424
5425         let two_removes = get_htlc_update_msgs!(nodes[5], nodes[3].node.get_our_node_id());
5426         nodes[3].node.handle_update_fail_htlc(&nodes[5].node.get_our_node_id(), &two_removes.update_fail_htlcs[0]);
5427         nodes[3].node.handle_update_fail_htlc(&nodes[5].node.get_our_node_id(), &two_removes.update_fail_htlcs[1]);
5428         commitment_signed_dance!(nodes[3], nodes[5], two_removes.commitment_signed, false);
5429
5430         let ds_prev_commitment_tx = get_local_commitment_txn!(nodes[3], chan.2);
5431
5432         expect_pending_htlcs_forwardable!(nodes[3]);
5433         check_added_monitors!(nodes[3], 1);
5434         let six_removes = get_htlc_update_msgs!(nodes[3], nodes[2].node.get_our_node_id());
5435         nodes[2].node.handle_update_fail_htlc(&nodes[3].node.get_our_node_id(), &six_removes.update_fail_htlcs[0]);
5436         nodes[2].node.handle_update_fail_htlc(&nodes[3].node.get_our_node_id(), &six_removes.update_fail_htlcs[1]);
5437         nodes[2].node.handle_update_fail_htlc(&nodes[3].node.get_our_node_id(), &six_removes.update_fail_htlcs[2]);
5438         nodes[2].node.handle_update_fail_htlc(&nodes[3].node.get_our_node_id(), &six_removes.update_fail_htlcs[3]);
5439         nodes[2].node.handle_update_fail_htlc(&nodes[3].node.get_our_node_id(), &six_removes.update_fail_htlcs[4]);
5440         nodes[2].node.handle_update_fail_htlc(&nodes[3].node.get_our_node_id(), &six_removes.update_fail_htlcs[5]);
5441         if deliver_last_raa {
5442                 commitment_signed_dance!(nodes[2], nodes[3], six_removes.commitment_signed, false);
5443         } else {
5444                 let _cs_last_raa = commitment_signed_dance!(nodes[2], nodes[3], six_removes.commitment_signed, false, true, false, true);
5445         }
5446
5447         // D's latest commitment transaction now contains 1st + 2nd + 9th HTLCs (implicitly, they're
5448         // below the dust limit) and the 5th + 6th + 11th HTLCs. It has failed back the 0th, 3rd, 4th,
5449         // 7th, 8th, and 10th, but as we haven't yet delivered the final RAA to C, the fails haven't
5450         // propagated back to A/B yet (and D has two unrevoked commitment transactions).
5451         //
5452         // We now broadcast the latest commitment transaction, which *should* result in failures for
5453         // the 0th, 1st, 2nd, 3rd, 4th, 7th, 8th, 9th, and 10th HTLCs, ie all the below-dust HTLCs and
5454         // the non-broadcast above-dust HTLCs.
5455         //
5456         // Alternatively, we may broadcast the previous commitment transaction, which should only
5457         // result in failures for the below-dust HTLCs, ie the 0th, 1st, 2nd, 3rd, 9th, and 10th HTLCs.
5458         let ds_last_commitment_tx = get_local_commitment_txn!(nodes[3], chan.2);
5459
5460         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5461         if announce_latest {
5462                 nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![ds_last_commitment_tx[0].clone()]}, 1);
5463         } else {
5464                 nodes[2].block_notifier.block_connected(&Block { header, txdata: vec![ds_prev_commitment_tx[0].clone()]}, 1);
5465         }
5466         connect_blocks(&nodes[2].block_notifier, ANTI_REORG_DELAY - 1, 1, true,  header.bitcoin_hash());
5467         check_closed_broadcast!(nodes[2], false);
5468         expect_pending_htlcs_forwardable!(nodes[2]);
5469         check_added_monitors!(nodes[2], 3);
5470
5471         let cs_msgs = nodes[2].node.get_and_clear_pending_msg_events();
5472         assert_eq!(cs_msgs.len(), 2);
5473         let mut a_done = false;
5474         for msg in cs_msgs {
5475                 match msg {
5476                         MessageSendEvent::UpdateHTLCs { ref node_id, ref updates } => {
5477                                 // Both under-dust HTLCs and the one above-dust HTLC that we had already failed
5478                                 // should be failed-backwards here.
5479                                 let target = if *node_id == nodes[0].node.get_our_node_id() {
5480                                         // If announce_latest, expect 0th, 1st, 4th, 8th, 10th HTLCs, else only 0th, 1st, 10th below-dust HTLCs
5481                                         for htlc in &updates.update_fail_htlcs {
5482                                                 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 });
5483                                         }
5484                                         assert_eq!(updates.update_fail_htlcs.len(), if announce_latest { 5 } else { 3 });
5485                                         assert!(!a_done);
5486                                         a_done = true;
5487                                         &nodes[0]
5488                                 } else {
5489                                         // If announce_latest, expect 2nd, 3rd, 7th, 9th HTLCs, else only 2nd, 3rd, 9th below-dust HTLCs
5490                                         for htlc in &updates.update_fail_htlcs {
5491                                                 assert!(htlc.htlc_id == 1 || htlc.htlc_id == 2 || htlc.htlc_id == 5 || if announce_latest { htlc.htlc_id == 4 } else { false });
5492                                         }
5493                                         assert_eq!(*node_id, nodes[1].node.get_our_node_id());
5494                                         assert_eq!(updates.update_fail_htlcs.len(), if announce_latest { 4 } else { 3 });
5495                                         &nodes[1]
5496                                 };
5497                                 target.node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[0]);
5498                                 target.node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[1]);
5499                                 target.node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[2]);
5500                                 if announce_latest {
5501                                         target.node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[3]);
5502                                         if *node_id == nodes[0].node.get_our_node_id() {
5503                                                 target.node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &updates.update_fail_htlcs[4]);
5504                                         }
5505                                 }
5506                                 commitment_signed_dance!(target, nodes[2], updates.commitment_signed, false, true);
5507                         },
5508                         _ => panic!("Unexpected event"),
5509                 }
5510         }
5511
5512         let as_events = nodes[0].node.get_and_clear_pending_events();
5513         assert_eq!(as_events.len(), if announce_latest { 5 } else { 3 });
5514         let mut as_failds = HashSet::new();
5515         for event in as_events.iter() {
5516                 if let &Event::PaymentFailed { ref payment_hash, ref rejected_by_dest, .. } = event {
5517                         assert!(as_failds.insert(*payment_hash));
5518                         if *payment_hash != payment_hash_2 {
5519                                 assert_eq!(*rejected_by_dest, deliver_last_raa);
5520                         } else {
5521                                 assert!(!rejected_by_dest);
5522                         }
5523                 } else { panic!("Unexpected event"); }
5524         }
5525         assert!(as_failds.contains(&payment_hash_1));
5526         assert!(as_failds.contains(&payment_hash_2));
5527         if announce_latest {
5528                 assert!(as_failds.contains(&payment_hash_3));
5529                 assert!(as_failds.contains(&payment_hash_5));
5530         }
5531         assert!(as_failds.contains(&payment_hash_6));
5532
5533         let bs_events = nodes[1].node.get_and_clear_pending_events();
5534         assert_eq!(bs_events.len(), if announce_latest { 4 } else { 3 });
5535         let mut bs_failds = HashSet::new();
5536         for event in bs_events.iter() {
5537                 if let &Event::PaymentFailed { ref payment_hash, ref rejected_by_dest, .. } = event {
5538                         assert!(bs_failds.insert(*payment_hash));
5539                         if *payment_hash != payment_hash_1 && *payment_hash != payment_hash_5 {
5540                                 assert_eq!(*rejected_by_dest, deliver_last_raa);
5541                         } else {
5542                                 assert!(!rejected_by_dest);
5543                         }
5544                 } else { panic!("Unexpected event"); }
5545         }
5546         assert!(bs_failds.contains(&payment_hash_1));
5547         assert!(bs_failds.contains(&payment_hash_2));
5548         if announce_latest {
5549                 assert!(bs_failds.contains(&payment_hash_4));
5550         }
5551         assert!(bs_failds.contains(&payment_hash_5));
5552
5553         // For each HTLC which was not failed-back by normal process (ie deliver_last_raa), we should
5554         // get a PaymentFailureNetworkUpdate. A should have gotten 4 HTLCs which were failed-back due
5555         // to unknown-preimage-etc, B should have gotten 2. Thus, in the
5556         // announce_latest && deliver_last_raa case, we should have 5-4=1 and 4-2=2
5557         // PaymentFailureNetworkUpdates.
5558         let as_msg_events = nodes[0].node.get_and_clear_pending_msg_events();
5559         assert_eq!(as_msg_events.len(), if deliver_last_raa { 1 } else if !announce_latest { 3 } else { 5 });
5560         let bs_msg_events = nodes[1].node.get_and_clear_pending_msg_events();
5561         assert_eq!(bs_msg_events.len(), if deliver_last_raa { 2 } else if !announce_latest { 3 } else { 4 });
5562         for event in as_msg_events.iter().chain(bs_msg_events.iter()) {
5563                 match event {
5564                         &MessageSendEvent::PaymentFailureNetworkUpdate { .. } => {},
5565                         _ => panic!("Unexpected event"),
5566                 }
5567         }
5568 }
5569
5570 #[test]
5571 fn test_fail_backwards_latest_remote_announce_a() {
5572         do_test_fail_backwards_unrevoked_remote_announce(false, true);
5573 }
5574
5575 #[test]
5576 fn test_fail_backwards_latest_remote_announce_b() {
5577         do_test_fail_backwards_unrevoked_remote_announce(true, true);
5578 }
5579
5580 #[test]
5581 fn test_fail_backwards_previous_remote_announce() {
5582         do_test_fail_backwards_unrevoked_remote_announce(false, false);
5583         // Note that true, true doesn't make sense as it implies we announce a revoked state, which is
5584         // tested for in test_commitment_revoked_fail_backward_exhaustive()
5585 }
5586
5587 #[test]
5588 fn test_dynamic_spendable_outputs_local_htlc_timeout_tx() {
5589         let chanmon_cfgs = create_chanmon_cfgs(2);
5590         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
5591         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
5592         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
5593
5594         // Create some initial channels
5595         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5596
5597         let (_, our_payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9000000);
5598         let local_txn = get_local_commitment_txn!(nodes[0], chan_1.2);
5599         assert_eq!(local_txn[0].input.len(), 1);
5600         check_spends!(local_txn[0], chan_1.3);
5601
5602         // Timeout HTLC on A's chain and so it can generate a HTLC-Timeout tx
5603         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5604         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![local_txn[0].clone()] }, 200);
5605         check_closed_broadcast!(nodes[0], false);
5606         check_added_monitors!(nodes[0], 1);
5607
5608         let htlc_timeout = {
5609                 let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
5610                 assert_eq!(node_txn[0].input.len(), 1);
5611                 assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
5612                 check_spends!(node_txn[0], local_txn[0]);
5613                 node_txn[0].clone()
5614         };
5615
5616         let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5617         nodes[0].block_notifier.block_connected(&Block { header: header_201, txdata: vec![htlc_timeout.clone()] }, 201);
5618         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 201, true, header_201.bitcoin_hash());
5619         expect_payment_failed!(nodes[0], our_payment_hash, true);
5620
5621         // Verify that A is able to spend its own HTLC-Timeout tx thanks to spendable output event given back by its ChannelMonitor
5622         let spend_txn = check_spendable_outputs!(nodes[0], 1, node_cfgs[0].keys_manager, 100000);
5623         assert_eq!(spend_txn.len(), 3);
5624         assert_eq!(spend_txn[0], spend_txn[1]);
5625         check_spends!(spend_txn[0], local_txn[0]);
5626         check_spends!(spend_txn[2], htlc_timeout);
5627 }
5628
5629 #[test]
5630 fn test_key_derivation_params() {
5631         // This test is a copy of test_dynamic_spendable_outputs_local_htlc_timeout_tx, with
5632         // a key manager rotation to test that key_derivation_params returned in DynamicOutputP2WSH
5633         // let us re-derive the channel key set to then derive a delayed_payment_key.
5634
5635         let chanmon_cfgs = create_chanmon_cfgs(3);
5636
5637         // We manually create the node configuration to backup the seed.
5638         let seed = [42; 32];
5639         let keys_manager = test_utils::TestKeysInterface::new(&seed, Network::Testnet);
5640         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);
5641         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 };
5642         let mut node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
5643         node_cfgs.remove(0);
5644         node_cfgs.insert(0, node);
5645
5646         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
5647         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
5648
5649         // Create some initial channels
5650         // Create a dummy channel to advance index by one and thus test re-derivation correctness
5651         // for node 0
5652         let chan_0 = create_announced_chan_between_nodes(&nodes, 0, 2, InitFeatures::known(), InitFeatures::known());
5653         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5654         assert_ne!(chan_0.3.output[0].script_pubkey, chan_1.3.output[0].script_pubkey);
5655
5656         let (_, our_payment_hash) = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9000000);
5657         let local_txn_0 = get_local_commitment_txn!(nodes[0], chan_0.2);
5658         let local_txn_1 = get_local_commitment_txn!(nodes[0], chan_1.2);
5659         assert_eq!(local_txn_1[0].input.len(), 1);
5660         check_spends!(local_txn_1[0], chan_1.3);
5661
5662         // We check funding pubkey are unique
5663         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]));
5664         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]));
5665         if from_0_funding_key_0 == from_1_funding_key_0
5666             || from_0_funding_key_0 == from_1_funding_key_1
5667             || from_0_funding_key_1 == from_1_funding_key_0
5668             || from_0_funding_key_1 == from_1_funding_key_1 {
5669                 panic!("Funding pubkeys aren't unique");
5670         }
5671
5672         // Timeout HTLC on A's chain and so it can generate a HTLC-Timeout tx
5673         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5674         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![local_txn_1[0].clone()] }, 200);
5675         check_closed_broadcast!(nodes[0], false);
5676         check_added_monitors!(nodes[0], 1);
5677
5678         let htlc_timeout = {
5679                 let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
5680                 assert_eq!(node_txn[0].input.len(), 1);
5681                 assert_eq!(node_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
5682                 check_spends!(node_txn[0], local_txn_1[0]);
5683                 node_txn[0].clone()
5684         };
5685
5686         let header_201 = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5687         nodes[0].block_notifier.block_connected(&Block { header: header_201, txdata: vec![htlc_timeout.clone()] }, 201);
5688         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 201, true, header_201.bitcoin_hash());
5689         expect_payment_failed!(nodes[0], our_payment_hash, true);
5690
5691         // Verify that A is able to spend its own HTLC-Timeout tx thanks to spendable output event given back by its ChannelMonitor
5692         let new_keys_manager = test_utils::TestKeysInterface::new(&seed, Network::Testnet);
5693         let spend_txn = check_spendable_outputs!(nodes[0], 1, new_keys_manager, 100000);
5694         assert_eq!(spend_txn.len(), 3);
5695         assert_eq!(spend_txn[0], spend_txn[1]);
5696         check_spends!(spend_txn[0], local_txn_1[0]);
5697         check_spends!(spend_txn[2], htlc_timeout);
5698 }
5699
5700 #[test]
5701 fn test_static_output_closing_tx() {
5702         let chanmon_cfgs = create_chanmon_cfgs(2);
5703         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
5704         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
5705         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
5706
5707         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5708
5709         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
5710         let closing_tx = close_channel(&nodes[0], &nodes[1], &chan.2, chan.3, true).2;
5711
5712         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5713         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![closing_tx.clone()] }, 0);
5714         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 0, true, header.bitcoin_hash());
5715
5716         let spend_txn = check_spendable_outputs!(nodes[0], 2, node_cfgs[0].keys_manager, 100000);
5717         assert_eq!(spend_txn.len(), 1);
5718         check_spends!(spend_txn[0], closing_tx);
5719
5720         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![closing_tx.clone()] }, 0);
5721         connect_blocks(&nodes[1].block_notifier, ANTI_REORG_DELAY - 1, 0, true, header.bitcoin_hash());
5722
5723         let spend_txn = check_spendable_outputs!(nodes[1], 2, node_cfgs[1].keys_manager, 100000);
5724         assert_eq!(spend_txn.len(), 1);
5725         check_spends!(spend_txn[0], closing_tx);
5726 }
5727
5728 fn do_htlc_claim_local_commitment_only(use_dust: bool) {
5729         let chanmon_cfgs = create_chanmon_cfgs(2);
5730         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
5731         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
5732         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
5733         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5734
5735         let (our_payment_preimage, _) = route_payment(&nodes[0], &[&nodes[1]], if use_dust { 50000 } else { 3000000 });
5736
5737         // Claim the payment, but don't deliver A's commitment_signed, resulting in the HTLC only being
5738         // present in B's local commitment transaction, but none of A's commitment transactions.
5739         assert!(nodes[1].node.claim_funds(our_payment_preimage, &None, if use_dust { 50_000 } else { 3_000_000 }));
5740         check_added_monitors!(nodes[1], 1);
5741
5742         let bs_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5743         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &bs_updates.update_fulfill_htlcs[0]);
5744         let events = nodes[0].node.get_and_clear_pending_events();
5745         assert_eq!(events.len(), 1);
5746         match events[0] {
5747                 Event::PaymentSent { payment_preimage } => {
5748                         assert_eq!(payment_preimage, our_payment_preimage);
5749                 },
5750                 _ => panic!("Unexpected event"),
5751         }
5752
5753         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_updates.commitment_signed);
5754         check_added_monitors!(nodes[0], 1);
5755         let as_updates = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
5756         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_updates.0);
5757         check_added_monitors!(nodes[1], 1);
5758
5759         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5760         for i in 1..TEST_FINAL_CLTV - CLTV_CLAIM_BUFFER + CHAN_CONFIRM_DEPTH + 1 {
5761                 nodes[1].block_notifier.block_connected_checked(&header, i, &Vec::new(), &Vec::new());
5762                 header.prev_blockhash = header.bitcoin_hash();
5763         }
5764         test_txn_broadcast(&nodes[1], &chan, None, if use_dust { HTLCType::NONE } else { HTLCType::SUCCESS });
5765         check_closed_broadcast!(nodes[1], false);
5766         check_added_monitors!(nodes[1], 1);
5767 }
5768
5769 fn do_htlc_claim_current_remote_commitment_only(use_dust: bool) {
5770         let chanmon_cfgs = create_chanmon_cfgs(2);
5771         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
5772         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
5773         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
5774         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5775         let logger = test_utils::TestLogger::new();
5776
5777         let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
5778         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
5779         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();
5780         nodes[0].node.send_payment(&route, payment_hash, &None).unwrap();
5781         check_added_monitors!(nodes[0], 1);
5782
5783         let _as_update = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
5784
5785         // As far as A is concerned, the HTLC is now present only in the latest remote commitment
5786         // transaction, however it is not in A's latest local commitment, so we can just broadcast that
5787         // to "time out" the HTLC.
5788
5789         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5790
5791         for i in 1..TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + CHAN_CONFIRM_DEPTH + 1 {
5792                 nodes[0].block_notifier.block_connected(&Block { header, txdata: Vec::new()}, i);
5793                 header.prev_blockhash = header.bitcoin_hash();
5794         }
5795         test_txn_broadcast(&nodes[0], &chan, None, HTLCType::NONE);
5796         check_closed_broadcast!(nodes[0], false);
5797         check_added_monitors!(nodes[0], 1);
5798 }
5799
5800 fn do_htlc_claim_previous_remote_commitment_only(use_dust: bool, check_revoke_no_close: bool) {
5801         let chanmon_cfgs = create_chanmon_cfgs(3);
5802         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
5803         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
5804         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
5805         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
5806
5807         // Fail the payment, but don't deliver A's final RAA, resulting in the HTLC only being present
5808         // in B's previous (unrevoked) commitment transaction, but none of A's commitment transactions.
5809         // Also optionally test that we *don't* fail the channel in case the commitment transaction was
5810         // actually revoked.
5811         let htlc_value = if use_dust { 50000 } else { 3000000 };
5812         let (_, our_payment_hash) = route_payment(&nodes[0], &[&nodes[1]], htlc_value);
5813         assert!(nodes[1].node.fail_htlc_backwards(&our_payment_hash, &None));
5814         expect_pending_htlcs_forwardable!(nodes[1]);
5815         check_added_monitors!(nodes[1], 1);
5816
5817         let bs_updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5818         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &bs_updates.update_fail_htlcs[0]);
5819         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &bs_updates.commitment_signed);
5820         check_added_monitors!(nodes[0], 1);
5821         let as_updates = get_revoke_commit_msgs!(nodes[0], nodes[1].node.get_our_node_id());
5822         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(), &as_updates.0);
5823         check_added_monitors!(nodes[1], 1);
5824         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &as_updates.1);
5825         check_added_monitors!(nodes[1], 1);
5826         let bs_revoke_and_ack = get_event_msg!(nodes[1], MessageSendEvent::SendRevokeAndACK, nodes[0].node.get_our_node_id());
5827
5828         if check_revoke_no_close {
5829                 nodes[0].node.handle_revoke_and_ack(&nodes[1].node.get_our_node_id(), &bs_revoke_and_ack);
5830                 check_added_monitors!(nodes[0], 1);
5831         }
5832
5833         let mut header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5834         for i in 1..TEST_FINAL_CLTV + LATENCY_GRACE_PERIOD_BLOCKS + CHAN_CONFIRM_DEPTH + 1 {
5835                 nodes[0].block_notifier.block_connected_checked(&header, i, &Vec::new(), &Vec::new());
5836                 header.prev_blockhash = header.bitcoin_hash();
5837         }
5838         if !check_revoke_no_close {
5839                 test_txn_broadcast(&nodes[0], &chan, None, HTLCType::NONE);
5840                 check_closed_broadcast!(nodes[0], false);
5841                 check_added_monitors!(nodes[0], 1);
5842         } else {
5843                 expect_payment_failed!(nodes[0], our_payment_hash, true);
5844         }
5845 }
5846
5847 // Test that we close channels on-chain when broadcastable HTLCs reach their timeout window.
5848 // There are only a few cases to test here:
5849 //  * its not really normative behavior, but we test that below-dust HTLCs "included" in
5850 //    broadcastable commitment transactions result in channel closure,
5851 //  * its included in an unrevoked-but-previous remote commitment transaction,
5852 //  * its included in the latest remote or local commitment transactions.
5853 // We test each of the three possible commitment transactions individually and use both dust and
5854 // non-dust HTLCs.
5855 // Note that we don't bother testing both outbound and inbound HTLC failures for each case, and we
5856 // assume they are handled the same across all six cases, as both outbound and inbound failures are
5857 // tested for at least one of the cases in other tests.
5858 #[test]
5859 fn htlc_claim_single_commitment_only_a() {
5860         do_htlc_claim_local_commitment_only(true);
5861         do_htlc_claim_local_commitment_only(false);
5862
5863         do_htlc_claim_current_remote_commitment_only(true);
5864         do_htlc_claim_current_remote_commitment_only(false);
5865 }
5866
5867 #[test]
5868 fn htlc_claim_single_commitment_only_b() {
5869         do_htlc_claim_previous_remote_commitment_only(true, false);
5870         do_htlc_claim_previous_remote_commitment_only(false, false);
5871         do_htlc_claim_previous_remote_commitment_only(true, true);
5872         do_htlc_claim_previous_remote_commitment_only(false, true);
5873 }
5874
5875 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>)
5876         where F1: for <'a> FnMut(&'a mut msgs::UpdateAddHTLC),
5877                                 F2: FnMut(),
5878 {
5879         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);
5880 }
5881
5882 // test_case
5883 // 0: node1 fails backward
5884 // 1: final node fails backward
5885 // 2: payment completed but the user rejects the payment
5886 // 3: final node fails backward (but tamper onion payloads from node0)
5887 // 100: trigger error in the intermediate node and tamper returning fail_htlc
5888 // 200: trigger error in the final node and tamper returning fail_htlc
5889 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>)
5890         where F1: for <'a> FnMut(&'a mut msgs::UpdateAddHTLC),
5891                                 F2: for <'a> FnMut(&'a mut msgs::UpdateFailHTLC),
5892                                 F3: FnMut(),
5893 {
5894
5895         // reset block height
5896         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
5897         for ix in 0..nodes.len() {
5898                 nodes[ix].block_notifier.block_connected_checked(&header, 1, &[], &[]);
5899         }
5900
5901         macro_rules! expect_event {
5902                 ($node: expr, $event_type: path) => {{
5903                         let events = $node.node.get_and_clear_pending_events();
5904                         assert_eq!(events.len(), 1);
5905                         match events[0] {
5906                                 $event_type { .. } => {},
5907                                 _ => panic!("Unexpected event"),
5908                         }
5909                 }}
5910         }
5911
5912         macro_rules! expect_htlc_forward {
5913                 ($node: expr) => {{
5914                         expect_event!($node, Event::PendingHTLCsForwardable);
5915                         $node.node.process_pending_htlc_forwards();
5916                 }}
5917         }
5918
5919         // 0 ~~> 2 send payment
5920         nodes[0].node.send_payment(&route, payment_hash.clone(), &None).unwrap();
5921         check_added_monitors!(nodes[0], 1);
5922         let update_0 = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
5923         // temper update_add (0 => 1)
5924         let mut update_add_0 = update_0.update_add_htlcs[0].clone();
5925         if test_case == 0 || test_case == 3 || test_case == 100 {
5926                 callback_msg(&mut update_add_0);
5927                 callback_node();
5928         }
5929         // 0 => 1 update_add & CS
5930         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &update_add_0);
5931         commitment_signed_dance!(nodes[1], nodes[0], &update_0.commitment_signed, false, true);
5932
5933         let update_1_0 = match test_case {
5934                 0|100 => { // intermediate node failure; fail backward to 0
5935                         let update_1_0 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5936                         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));
5937                         update_1_0
5938                 },
5939                 1|2|3|200 => { // final node failure; forwarding to 2
5940                         assert!(nodes[1].node.get_and_clear_pending_msg_events().is_empty());
5941                         // forwarding on 1
5942                         if test_case != 200 {
5943                                 callback_node();
5944                         }
5945                         expect_htlc_forward!(&nodes[1]);
5946
5947                         let update_1 = get_htlc_update_msgs!(nodes[1], nodes[2].node.get_our_node_id());
5948                         check_added_monitors!(&nodes[1], 1);
5949                         assert_eq!(update_1.update_add_htlcs.len(), 1);
5950                         // tamper update_add (1 => 2)
5951                         let mut update_add_1 = update_1.update_add_htlcs[0].clone();
5952                         if test_case != 3 && test_case != 200 {
5953                                 callback_msg(&mut update_add_1);
5954                         }
5955
5956                         // 1 => 2
5957                         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &update_add_1);
5958                         commitment_signed_dance!(nodes[2], nodes[1], update_1.commitment_signed, false, true);
5959
5960                         if test_case == 2 || test_case == 200 {
5961                                 expect_htlc_forward!(&nodes[2]);
5962                                 expect_event!(&nodes[2], Event::PaymentReceived);
5963                                 callback_node();
5964                                 expect_pending_htlcs_forwardable!(nodes[2]);
5965                         }
5966
5967                         let update_2_1 = get_htlc_update_msgs!(nodes[2], nodes[1].node.get_our_node_id());
5968                         if test_case == 2 || test_case == 200 {
5969                                 check_added_monitors!(&nodes[2], 1);
5970                         }
5971                         assert!(update_2_1.update_fail_htlcs.len() == 1);
5972
5973                         let mut fail_msg = update_2_1.update_fail_htlcs[0].clone();
5974                         if test_case == 200 {
5975                                 callback_fail(&mut fail_msg);
5976                         }
5977
5978                         // 2 => 1
5979                         nodes[1].node.handle_update_fail_htlc(&nodes[2].node.get_our_node_id(), &fail_msg);
5980                         commitment_signed_dance!(nodes[1], nodes[2], update_2_1.commitment_signed, true);
5981
5982                         // backward fail on 1
5983                         let update_1_0 = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
5984                         assert!(update_1_0.update_fail_htlcs.len() == 1);
5985                         update_1_0
5986                 },
5987                 _ => unreachable!(),
5988         };
5989
5990         // 1 => 0 commitment_signed_dance
5991         if update_1_0.update_fail_htlcs.len() > 0 {
5992                 let mut fail_msg = update_1_0.update_fail_htlcs[0].clone();
5993                 if test_case == 100 {
5994                         callback_fail(&mut fail_msg);
5995                 }
5996                 nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &fail_msg);
5997         } else {
5998                 nodes[0].node.handle_update_fail_malformed_htlc(&nodes[1].node.get_our_node_id(), &update_1_0.update_fail_malformed_htlcs[0]);
5999         };
6000
6001         commitment_signed_dance!(nodes[0], nodes[1], update_1_0.commitment_signed, false, true);
6002
6003         let events = nodes[0].node.get_and_clear_pending_events();
6004         assert_eq!(events.len(), 1);
6005         if let &Event::PaymentFailed { payment_hash:_, ref rejected_by_dest, ref error_code, error_data: _ } = &events[0] {
6006                 assert_eq!(*rejected_by_dest, !expected_retryable);
6007                 assert_eq!(*error_code, expected_error_code);
6008         } else {
6009                 panic!("Uexpected event");
6010         }
6011
6012         let events = nodes[0].node.get_and_clear_pending_msg_events();
6013         if expected_channel_update.is_some() {
6014                 assert_eq!(events.len(), 1);
6015                 match events[0] {
6016                         MessageSendEvent::PaymentFailureNetworkUpdate { ref update } => {
6017                                 match update {
6018                                         &HTLCFailChannelUpdate::ChannelUpdateMessage { .. } => {
6019                                                 if let HTLCFailChannelUpdate::ChannelUpdateMessage { .. } = expected_channel_update.unwrap() {} else {
6020                                                         panic!("channel_update not found!");
6021                                                 }
6022                                         },
6023                                         &HTLCFailChannelUpdate::ChannelClosed { ref short_channel_id, ref is_permanent } => {
6024                                                 if let HTLCFailChannelUpdate::ChannelClosed { short_channel_id: ref expected_short_channel_id, is_permanent: ref expected_is_permanent } = expected_channel_update.unwrap() {
6025                                                         assert!(*short_channel_id == *expected_short_channel_id);
6026                                                         assert!(*is_permanent == *expected_is_permanent);
6027                                                 } else {
6028                                                         panic!("Unexpected message event");
6029                                                 }
6030                                         },
6031                                         &HTLCFailChannelUpdate::NodeFailure { ref node_id, ref is_permanent } => {
6032                                                 if let HTLCFailChannelUpdate::NodeFailure { node_id: ref expected_node_id, is_permanent: ref expected_is_permanent } = expected_channel_update.unwrap() {
6033                                                         assert!(*node_id == *expected_node_id);
6034                                                         assert!(*is_permanent == *expected_is_permanent);
6035                                                 } else {
6036                                                         panic!("Unexpected message event");
6037                                                 }
6038                                         },
6039                                 }
6040                         },
6041                         _ => panic!("Unexpected message event"),
6042                 }
6043         } else {
6044                 assert_eq!(events.len(), 0);
6045         }
6046 }
6047
6048 impl msgs::ChannelUpdate {
6049         fn dummy() -> msgs::ChannelUpdate {
6050                 use bitcoin::secp256k1::ffi::Signature as FFISignature;
6051                 use bitcoin::secp256k1::Signature;
6052                 msgs::ChannelUpdate {
6053                         signature: Signature::from(FFISignature::new()),
6054                         contents: msgs::UnsignedChannelUpdate {
6055                                 chain_hash: BlockHash::hash(&vec![0u8][..]),
6056                                 short_channel_id: 0,
6057                                 timestamp: 0,
6058                                 flags: 0,
6059                                 cltv_expiry_delta: 0,
6060                                 htlc_minimum_msat: 0,
6061                                 htlc_maximum_msat: OptionalField::Absent,
6062                                 fee_base_msat: 0,
6063                                 fee_proportional_millionths: 0,
6064                                 excess_data: vec![],
6065                         }
6066                 }
6067         }
6068 }
6069
6070 struct BogusOnionHopData {
6071         data: Vec<u8>
6072 }
6073 impl BogusOnionHopData {
6074         fn new(orig: msgs::OnionHopData) -> Self {
6075                 Self { data: orig.encode() }
6076         }
6077 }
6078 impl Writeable for BogusOnionHopData {
6079         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), io::Error> {
6080                 writer.write_all(&self.data[..])
6081         }
6082 }
6083
6084 #[test]
6085 fn test_onion_failure() {
6086         use ln::msgs::ChannelUpdate;
6087         use ln::channelmanager::CLTV_FAR_FAR_AWAY;
6088         use bitcoin::secp256k1;
6089
6090         const BADONION: u16 = 0x8000;
6091         const PERM: u16 = 0x4000;
6092         const NODE: u16 = 0x2000;
6093         const UPDATE: u16 = 0x1000;
6094
6095         let chanmon_cfgs = create_chanmon_cfgs(3);
6096         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
6097         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
6098         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
6099         for node in nodes.iter() {
6100                 *node.keys_manager.override_session_priv.lock().unwrap() = Some(SecretKey::from_slice(&[3; 32]).unwrap());
6101         }
6102         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())];
6103         let (_, payment_hash) = get_payment_preimage_hash!(nodes[0]);
6104         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6105         let logger = test_utils::TestLogger::new();
6106         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();
6107         // positve case
6108         send_payment(&nodes[0], &vec!(&nodes[1], &nodes[2])[..], 40000, 40_000);
6109
6110         // intermediate node failure
6111         run_onion_failure_test("invalid_realm", 0, &nodes, &route, &payment_hash, |msg| {
6112                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6113                 let cur_height = nodes[0].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
6114                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6115                 let (mut onion_payloads, _htlc_msat, _htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 40000, &None, cur_height).unwrap();
6116                 let mut new_payloads = Vec::new();
6117                 for payload in onion_payloads.drain(..) {
6118                         new_payloads.push(BogusOnionHopData::new(payload));
6119                 }
6120                 // break the first (non-final) hop payload by swapping the realm (0) byte for a byte
6121                 // describing a length-1 TLV payload, which is obviously bogus.
6122                 new_payloads[0].data[0] = 1;
6123                 msg.onion_routing_packet = onion_utils::construct_onion_packet_bogus_hopdata(new_payloads, onion_keys, [0; 32], &payment_hash);
6124         }, ||{}, 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
6125
6126         // final node failure
6127         run_onion_failure_test("invalid_realm", 3, &nodes, &route, &payment_hash, |msg| {
6128                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6129                 let cur_height = nodes[0].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
6130                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6131                 let (mut onion_payloads, _htlc_msat, _htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 40000, &None, cur_height).unwrap();
6132                 let mut new_payloads = Vec::new();
6133                 for payload in onion_payloads.drain(..) {
6134                         new_payloads.push(BogusOnionHopData::new(payload));
6135                 }
6136                 // break the last-hop payload by swapping the realm (0) byte for a byte describing a
6137                 // length-1 TLV payload, which is obviously bogus.
6138                 new_payloads[1].data[0] = 1;
6139                 msg.onion_routing_packet = onion_utils::construct_onion_packet_bogus_hopdata(new_payloads, onion_keys, [0; 32], &payment_hash);
6140         }, ||{}, false, Some(PERM|22), Some(msgs::HTLCFailChannelUpdate::ChannelClosed{short_channel_id: channels[1].0.contents.short_channel_id, is_permanent: true}));
6141
6142         // the following three with run_onion_failure_test_with_fail_intercept() test only the origin node
6143         // receiving simulated fail messages
6144         // intermediate node failure
6145         run_onion_failure_test_with_fail_intercept("temporary_node_failure", 100, &nodes, &route, &payment_hash, |msg| {
6146                 // trigger error
6147                 msg.amount_msat -= 1;
6148         }, |msg| {
6149                 // and tamper returning error message
6150                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6151                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6152                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], NODE|2, &[0;0]);
6153         }, ||{}, true, Some(NODE|2), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.paths[0][0].pubkey, is_permanent: false}));
6154
6155         // final node failure
6156         run_onion_failure_test_with_fail_intercept("temporary_node_failure", 200, &nodes, &route, &payment_hash, |_msg| {}, |msg| {
6157                 // and tamper returning error message
6158                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6159                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6160                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[1].shared_secret[..], NODE|2, &[0;0]);
6161         }, ||{
6162                 nodes[2].node.fail_htlc_backwards(&payment_hash, &None);
6163         }, true, Some(NODE|2), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.paths[0][1].pubkey, is_permanent: false}));
6164
6165         // intermediate node failure
6166         run_onion_failure_test_with_fail_intercept("permanent_node_failure", 100, &nodes, &route, &payment_hash, |msg| {
6167                 msg.amount_msat -= 1;
6168         }, |msg| {
6169                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6170                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6171                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], PERM|NODE|2, &[0;0]);
6172         }, ||{}, true, Some(PERM|NODE|2), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.paths[0][0].pubkey, is_permanent: true}));
6173
6174         // final node failure
6175         run_onion_failure_test_with_fail_intercept("permanent_node_failure", 200, &nodes, &route, &payment_hash, |_msg| {}, |msg| {
6176                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6177                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6178                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[1].shared_secret[..], PERM|NODE|2, &[0;0]);
6179         }, ||{
6180                 nodes[2].node.fail_htlc_backwards(&payment_hash, &None);
6181         }, false, Some(PERM|NODE|2), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.paths[0][1].pubkey, is_permanent: true}));
6182
6183         // intermediate node failure
6184         run_onion_failure_test_with_fail_intercept("required_node_feature_missing", 100, &nodes, &route, &payment_hash, |msg| {
6185                 msg.amount_msat -= 1;
6186         }, |msg| {
6187                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6188                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6189                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], PERM|NODE|3, &[0;0]);
6190         }, ||{
6191                 nodes[2].node.fail_htlc_backwards(&payment_hash, &None);
6192         }, true, Some(PERM|NODE|3), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.paths[0][0].pubkey, is_permanent: true}));
6193
6194         // final node failure
6195         run_onion_failure_test_with_fail_intercept("required_node_feature_missing", 200, &nodes, &route, &payment_hash, |_msg| {}, |msg| {
6196                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6197                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6198                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[1].shared_secret[..], PERM|NODE|3, &[0;0]);
6199         }, ||{
6200                 nodes[2].node.fail_htlc_backwards(&payment_hash, &None);
6201         }, false, Some(PERM|NODE|3), Some(msgs::HTLCFailChannelUpdate::NodeFailure{node_id: route.paths[0][1].pubkey, is_permanent: true}));
6202
6203         run_onion_failure_test("invalid_onion_version", 0, &nodes, &route, &payment_hash, |msg| { msg.onion_routing_packet.version = 1; }, ||{}, true,
6204                 Some(BADONION|PERM|4), None);
6205
6206         run_onion_failure_test("invalid_onion_hmac", 0, &nodes, &route, &payment_hash, |msg| { msg.onion_routing_packet.hmac = [3; 32]; }, ||{}, true,
6207                 Some(BADONION|PERM|5), None);
6208
6209         run_onion_failure_test("invalid_onion_key", 0, &nodes, &route, &payment_hash, |msg| { msg.onion_routing_packet.public_key = Err(secp256k1::Error::InvalidPublicKey);}, ||{}, true,
6210                 Some(BADONION|PERM|6), None);
6211
6212         run_onion_failure_test_with_fail_intercept("temporary_channel_failure", 100, &nodes, &route, &payment_hash, |msg| {
6213                 msg.amount_msat -= 1;
6214         }, |msg| {
6215                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6216                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6217                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], UPDATE|7, &ChannelUpdate::dummy().encode_with_len()[..]);
6218         }, ||{}, true, Some(UPDATE|7), Some(msgs::HTLCFailChannelUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy()}));
6219
6220         run_onion_failure_test_with_fail_intercept("permanent_channel_failure", 100, &nodes, &route, &payment_hash, |msg| {
6221                 msg.amount_msat -= 1;
6222         }, |msg| {
6223                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6224                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6225                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], PERM|8, &[0;0]);
6226                 // short_channel_id from the processing node
6227         }, ||{}, true, Some(PERM|8), Some(msgs::HTLCFailChannelUpdate::ChannelClosed{short_channel_id: channels[1].0.contents.short_channel_id, is_permanent: true}));
6228
6229         run_onion_failure_test_with_fail_intercept("required_channel_feature_missing", 100, &nodes, &route, &payment_hash, |msg| {
6230                 msg.amount_msat -= 1;
6231         }, |msg| {
6232                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6233                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6234                 msg.reason = onion_utils::build_first_hop_failure_packet(&onion_keys[0].shared_secret[..], PERM|9, &[0;0]);
6235                 // short_channel_id from the processing node
6236         }, ||{}, true, Some(PERM|9), Some(msgs::HTLCFailChannelUpdate::ChannelClosed{short_channel_id: channels[1].0.contents.short_channel_id, is_permanent: true}));
6237
6238         let mut bogus_route = route.clone();
6239         bogus_route.paths[0][1].short_channel_id -= 1;
6240         run_onion_failure_test("unknown_next_peer", 0, &nodes, &bogus_route, &payment_hash, |_| {}, ||{}, true, Some(PERM|10),
6241           Some(msgs::HTLCFailChannelUpdate::ChannelClosed{short_channel_id: bogus_route.paths[0][1].short_channel_id, is_permanent:true}));
6242
6243         let amt_to_forward = nodes[1].node.channel_state.lock().unwrap().by_id.get(&channels[1].2).unwrap().get_their_htlc_minimum_msat() - 1;
6244         let mut bogus_route = route.clone();
6245         let route_len = bogus_route.paths[0].len();
6246         bogus_route.paths[0][route_len-1].fee_msat = amt_to_forward;
6247         run_onion_failure_test("amount_below_minimum", 0, &nodes, &bogus_route, &payment_hash, |_| {}, ||{}, true, Some(UPDATE|11), Some(msgs::HTLCFailChannelUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy()}));
6248
6249         //TODO: with new config API, we will be able to generate both valid and
6250         //invalid channel_update cases.
6251         run_onion_failure_test("fee_insufficient", 0, &nodes, &route, &payment_hash, |msg| {
6252                 msg.amount_msat -= 1;
6253         }, || {}, true, Some(UPDATE|12), Some(msgs::HTLCFailChannelUpdate::ChannelClosed { short_channel_id: channels[0].0.contents.short_channel_id, is_permanent: true}));
6254
6255         run_onion_failure_test("incorrect_cltv_expiry", 0, &nodes, &route, &payment_hash, |msg| {
6256                 // need to violate: cltv_expiry - cltv_expiry_delta >= outgoing_cltv_value
6257                 msg.cltv_expiry -= 1;
6258         }, || {}, true, Some(UPDATE|13), Some(msgs::HTLCFailChannelUpdate::ChannelClosed { short_channel_id: channels[0].0.contents.short_channel_id, is_permanent: true}));
6259
6260         run_onion_failure_test("expiry_too_soon", 0, &nodes, &route, &payment_hash, |msg| {
6261                 let height = msg.cltv_expiry - CLTV_CLAIM_BUFFER - LATENCY_GRACE_PERIOD_BLOCKS + 1;
6262                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
6263
6264                 nodes[1].block_notifier.block_connected_checked(&header, height, &[], &[]);
6265         }, ||{}, true, Some(UPDATE|14), Some(msgs::HTLCFailChannelUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy()}));
6266
6267         run_onion_failure_test("unknown_payment_hash", 2, &nodes, &route, &payment_hash, |_| {}, || {
6268                 nodes[2].node.fail_htlc_backwards(&payment_hash, &None);
6269         }, false, Some(PERM|15), None);
6270
6271         run_onion_failure_test("final_expiry_too_soon", 1, &nodes, &route, &payment_hash, |msg| {
6272                 let height = msg.cltv_expiry - CLTV_CLAIM_BUFFER - LATENCY_GRACE_PERIOD_BLOCKS + 1;
6273                 let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
6274
6275                 nodes[2].block_notifier.block_connected_checked(&header, height, &[], &[]);
6276         }, || {}, true, Some(17), None);
6277
6278         run_onion_failure_test("final_incorrect_cltv_expiry", 1, &nodes, &route, &payment_hash, |_| {}, || {
6279                 for (_, pending_forwards) in nodes[1].node.channel_state.lock().unwrap().forward_htlcs.iter_mut() {
6280                         for f in pending_forwards.iter_mut() {
6281                                 match f {
6282                                         &mut HTLCForwardInfo::AddHTLC { ref mut forward_info, .. } =>
6283                                                 forward_info.outgoing_cltv_value += 1,
6284                                         _ => {},
6285                                 }
6286                         }
6287                 }
6288         }, true, Some(18), None);
6289
6290         run_onion_failure_test("final_incorrect_htlc_amount", 1, &nodes, &route, &payment_hash, |_| {}, || {
6291                 // violate amt_to_forward > msg.amount_msat
6292                 for (_, pending_forwards) in nodes[1].node.channel_state.lock().unwrap().forward_htlcs.iter_mut() {
6293                         for f in pending_forwards.iter_mut() {
6294                                 match f {
6295                                         &mut HTLCForwardInfo::AddHTLC { ref mut forward_info, .. } =>
6296                                                 forward_info.amt_to_forward -= 1,
6297                                         _ => {},
6298                                 }
6299                         }
6300                 }
6301         }, true, Some(19), None);
6302
6303         run_onion_failure_test("channel_disabled", 0, &nodes, &route, &payment_hash, |_| {}, || {
6304                 // disconnect event to the channel between nodes[1] ~ nodes[2]
6305                 nodes[1].node.peer_disconnected(&nodes[2].node.get_our_node_id(), false);
6306                 nodes[2].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
6307         }, true, Some(UPDATE|20), Some(msgs::HTLCFailChannelUpdate::ChannelUpdateMessage{msg: ChannelUpdate::dummy()}));
6308         reconnect_nodes(&nodes[1], &nodes[2], (false, false), (0, 0), (0, 0), (0, 0), (0, 0), (false, false));
6309
6310         run_onion_failure_test("expiry_too_far", 0, &nodes, &route, &payment_hash, |msg| {
6311                 let session_priv = SecretKey::from_slice(&[3; 32]).unwrap();
6312                 let mut route = route.clone();
6313                 let height = 1;
6314                 route.paths[0][1].cltv_expiry_delta += CLTV_FAR_FAR_AWAY + route.paths[0][0].cltv_expiry_delta + 1;
6315                 let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::new(), &route.paths[0], &session_priv).unwrap();
6316                 let (onion_payloads, _, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 40000, &None, height).unwrap();
6317                 let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &payment_hash);
6318                 msg.cltv_expiry = htlc_cltv;
6319                 msg.onion_routing_packet = onion_packet;
6320         }, ||{}, true, Some(21), None);
6321 }
6322
6323 #[test]
6324 #[should_panic]
6325 fn bolt2_open_channel_sending_node_checks_part1() { //This test needs to be on its own as we are catching a panic
6326         let chanmon_cfgs = create_chanmon_cfgs(2);
6327         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6328         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6329         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6330         //Force duplicate channel ids
6331         for node in nodes.iter() {
6332                 *node.keys_manager.override_channel_id_priv.lock().unwrap() = Some([0; 32]);
6333         }
6334
6335         // BOLT #2 spec: Sending node must ensure temporary_channel_id is unique from any other channel ID with the same peer.
6336         let channel_value_satoshis=10000;
6337         let push_msat=10001;
6338         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_satoshis, push_msat, 42, None).unwrap();
6339         let node0_to_1_send_open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
6340         nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &node0_to_1_send_open_channel);
6341
6342         //Create a second channel with a channel_id collision
6343         assert!(nodes[0].node.create_channel(nodes[0].node.get_our_node_id(), channel_value_satoshis, push_msat, 42, None).is_err());
6344 }
6345
6346 #[test]
6347 fn bolt2_open_channel_sending_node_checks_part2() {
6348         let chanmon_cfgs = create_chanmon_cfgs(2);
6349         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6350         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6351         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6352
6353         // BOLT #2 spec: Sending node must set funding_satoshis to less than 2^24 satoshis
6354         let channel_value_satoshis=2^24;
6355         let push_msat=10001;
6356         assert!(nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_satoshis, push_msat, 42, None).is_err());
6357
6358         // BOLT #2 spec: Sending node must set push_msat to equal or less than 1000 * funding_satoshis
6359         let channel_value_satoshis=10000;
6360         // Test when push_msat is equal to 1000 * funding_satoshis.
6361         let push_msat=1000*channel_value_satoshis+1;
6362         assert!(nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), channel_value_satoshis, push_msat, 42, None).is_err());
6363
6364         // BOLT #2 spec: Sending node must set set channel_reserve_satoshis greater than or equal to dust_limit_satoshis
6365         let channel_value_satoshis=10000;
6366         let push_msat=10001;
6367         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
6368         let node0_to_1_send_open_channel = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
6369         assert!(node0_to_1_send_open_channel.channel_reserve_satoshis>=node0_to_1_send_open_channel.dust_limit_satoshis);
6370
6371         // BOLT #2 spec: Sending node must set undefined bits in channel_flags to 0
6372         // 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
6373         assert!(node0_to_1_send_open_channel.channel_flags<=1);
6374
6375         // 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.
6376         assert!(BREAKDOWN_TIMEOUT>0);
6377         assert!(node0_to_1_send_open_channel.to_self_delay==BREAKDOWN_TIMEOUT);
6378
6379         // BOLT #2 spec: Sending node must ensure the chain_hash value identifies the chain it wishes to open the channel within.
6380         let chain_hash=genesis_block(Network::Testnet).header.bitcoin_hash();
6381         assert_eq!(node0_to_1_send_open_channel.chain_hash,chain_hash);
6382
6383         // 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.
6384         assert!(PublicKey::from_slice(&node0_to_1_send_open_channel.funding_pubkey.serialize()).is_ok());
6385         assert!(PublicKey::from_slice(&node0_to_1_send_open_channel.revocation_basepoint.serialize()).is_ok());
6386         assert!(PublicKey::from_slice(&node0_to_1_send_open_channel.htlc_basepoint.serialize()).is_ok());
6387         assert!(PublicKey::from_slice(&node0_to_1_send_open_channel.payment_point.serialize()).is_ok());
6388         assert!(PublicKey::from_slice(&node0_to_1_send_open_channel.delayed_payment_basepoint.serialize()).is_ok());
6389 }
6390
6391 // BOLT 2 Requirements for the Sender when constructing and sending an update_add_htlc message.
6392 // 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.
6393 //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.
6394
6395 #[test]
6396 fn test_update_add_htlc_bolt2_sender_value_below_minimum_msat() {
6397         //BOLT2 Requirement: MUST NOT offer amount_msat below the receiving node's htlc_minimum_msat (same validation check catches both of these)
6398         let chanmon_cfgs = create_chanmon_cfgs(2);
6399         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6400         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6401         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6402         let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6403
6404         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6405         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6406         let logger = test_utils::TestLogger::new();
6407         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();
6408         route.paths[0][0].fee_msat = 100;
6409
6410         unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
6411                 assert!(regex::Regex::new(r"Cannot send less than their minimum HTLC value \(\d+\)").unwrap().is_match(err)));
6412         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
6413         nodes[0].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot send less than their minimum HTLC value".to_string(), 1);
6414 }
6415
6416 #[test]
6417 fn test_update_add_htlc_bolt2_sender_zero_value_msat() {
6418         //BOLT2 Requirement: MUST offer amount_msat greater than 0.
6419         let chanmon_cfgs = create_chanmon_cfgs(2);
6420         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6421         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6422         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6423         let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6424         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6425
6426         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6427         let logger = test_utils::TestLogger::new();
6428         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();
6429         route.paths[0][0].fee_msat = 0;
6430         unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
6431                 assert_eq!(err, "Cannot send 0-msat HTLC"));
6432
6433         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
6434         nodes[0].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot send 0-msat HTLC".to_string(), 1);
6435 }
6436
6437 #[test]
6438 fn test_update_add_htlc_bolt2_receiver_zero_value_msat() {
6439         //BOLT2 Requirement: MUST offer amount_msat greater than 0.
6440         let chanmon_cfgs = create_chanmon_cfgs(2);
6441         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6442         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6443         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6444         let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6445
6446         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6447         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6448         let logger = test_utils::TestLogger::new();
6449         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();
6450         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6451         check_added_monitors!(nodes[0], 1);
6452         let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6453         updates.update_add_htlcs[0].amount_msat = 0;
6454
6455         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6456         nodes[1].logger.assert_log("lightning::ln::channelmanager".to_string(), "Remote side tried to send a 0-msat HTLC".to_string(), 1);
6457         check_closed_broadcast!(nodes[1], true).unwrap();
6458         check_added_monitors!(nodes[1], 1);
6459 }
6460
6461 #[test]
6462 fn test_update_add_htlc_bolt2_sender_cltv_expiry_too_high() {
6463         //BOLT 2 Requirement: MUST set cltv_expiry less than 500000000.
6464         //It is enforced when constructing a route.
6465         let chanmon_cfgs = create_chanmon_cfgs(2);
6466         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6467         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6468         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6469         let _chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 0, InitFeatures::known(), InitFeatures::known());
6470         let logger = test_utils::TestLogger::new();
6471
6472         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6473
6474         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6475         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();
6476         unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::RouteError { ref err },
6477                 assert_eq!(err, &"Channel CLTV overflowed?"));
6478 }
6479
6480 #[test]
6481 fn test_update_add_htlc_bolt2_sender_exceed_max_htlc_num_and_htlc_id_increment() {
6482         //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.
6483         //BOLT 2 Requirement: for the first HTLC it offers MUST set id to 0.
6484         //BOLT 2 Requirement: MUST increase the value of id by 1 for each successive offer.
6485         let chanmon_cfgs = create_chanmon_cfgs(2);
6486         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6487         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6488         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6489         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 0, InitFeatures::known(), InitFeatures::known());
6490         let max_accepted_htlcs = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().their_max_accepted_htlcs as u64;
6491
6492         let logger = test_utils::TestLogger::new();
6493         for i in 0..max_accepted_htlcs {
6494                 let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6495                 let payment_event = {
6496                         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6497                         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();
6498                         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6499                         check_added_monitors!(nodes[0], 1);
6500
6501                         let mut events = nodes[0].node.get_and_clear_pending_msg_events();
6502                         assert_eq!(events.len(), 1);
6503                         if let MessageSendEvent::UpdateHTLCs { node_id: _, updates: msgs::CommitmentUpdate{ update_add_htlcs: ref htlcs, .. }, } = events[0] {
6504                                 assert_eq!(htlcs[0].htlc_id, i);
6505                         } else {
6506                                 assert!(false);
6507                         }
6508                         SendEvent::from_event(events.remove(0))
6509                 };
6510                 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
6511                 check_added_monitors!(nodes[1], 0);
6512                 commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
6513
6514                 expect_pending_htlcs_forwardable!(nodes[1]);
6515                 expect_payment_received!(nodes[1], our_payment_hash, 100000);
6516         }
6517         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6518         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6519         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();
6520         unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
6521                 assert!(regex::Regex::new(r"Cannot push more than their max accepted HTLCs \(\d+\)").unwrap().is_match(err)));
6522
6523         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
6524         nodes[0].logger.assert_log_contains("lightning::ln::channelmanager".to_string(), "Cannot push more than their max accepted HTLCs".to_string(), 1);
6525 }
6526
6527 #[test]
6528 fn test_update_add_htlc_bolt2_sender_exceed_max_htlc_value_in_flight() {
6529         //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.
6530         let chanmon_cfgs = create_chanmon_cfgs(2);
6531         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6532         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6533         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6534         let channel_value = 100000;
6535         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, channel_value, 0, InitFeatures::known(), InitFeatures::known());
6536         let max_in_flight = get_channel_value_stat!(nodes[0], chan.2).their_max_htlc_value_in_flight_msat;
6537
6538         send_payment(&nodes[0], &vec!(&nodes[1])[..], max_in_flight, max_in_flight);
6539
6540         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6541         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6542         let logger = test_utils::TestLogger::new();
6543         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();
6544         unwrap_send_err!(nodes[0].node.send_payment(&route, our_payment_hash, &None), true, APIError::ChannelUnavailable { ref err },
6545                 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)));
6546
6547         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
6548         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);
6549
6550         send_payment(&nodes[0], &[&nodes[1]], max_in_flight, max_in_flight);
6551 }
6552
6553 // BOLT 2 Requirements for the Receiver when handling an update_add_htlc message.
6554 #[test]
6555 fn test_update_add_htlc_bolt2_receiver_check_amount_received_more_than_min() {
6556         //BOLT2 Requirement: receiving an amount_msat equal to 0, OR less than its own htlc_minimum_msat -> SHOULD fail the channel.
6557         let chanmon_cfgs = create_chanmon_cfgs(2);
6558         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6559         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6560         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6561         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6562         let htlc_minimum_msat: u64;
6563         {
6564                 let chan_lock = nodes[0].node.channel_state.lock().unwrap();
6565                 let channel = chan_lock.by_id.get(&chan.2).unwrap();
6566                 htlc_minimum_msat = channel.get_our_htlc_minimum_msat();
6567         }
6568
6569         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6570         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6571         let logger = test_utils::TestLogger::new();
6572         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();
6573         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6574         check_added_monitors!(nodes[0], 1);
6575         let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6576         updates.update_add_htlcs[0].amount_msat = htlc_minimum_msat-1;
6577         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6578         assert!(nodes[1].node.list_channels().is_empty());
6579         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
6580         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()));
6581         check_added_monitors!(nodes[1], 1);
6582 }
6583
6584 #[test]
6585 fn test_update_add_htlc_bolt2_receiver_sender_can_afford_amount_sent() {
6586         //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
6587         let chanmon_cfgs = create_chanmon_cfgs(2);
6588         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6589         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6590         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6591         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6592         let logger = test_utils::TestLogger::new();
6593
6594         let chan_stat = get_channel_value_stat!(nodes[0], chan.2);
6595         let channel_reserve = chan_stat.channel_reserve_msat;
6596         let feerate = get_feerate!(nodes[0], chan.2);
6597         // The 2* and +1 are for the fee spike reserve.
6598         let commit_tx_fee_outbound = 2 * commit_tx_fee_msat(feerate, 1 + 1);
6599
6600         let max_can_send = 5000000 - channel_reserve - commit_tx_fee_outbound;
6601         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6602         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6603         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();
6604         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6605         check_added_monitors!(nodes[0], 1);
6606         let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6607
6608         // Even though channel-initiator senders are required to respect the fee_spike_reserve,
6609         // at this time channel-initiatee receivers are not required to enforce that senders
6610         // respect the fee_spike_reserve.
6611         updates.update_add_htlcs[0].amount_msat = max_can_send + commit_tx_fee_outbound + 1;
6612         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6613
6614         assert!(nodes[1].node.list_channels().is_empty());
6615         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
6616         assert_eq!(err_msg.data, "Remote HTLC add would put them under remote reserve value");
6617         check_added_monitors!(nodes[1], 1);
6618 }
6619
6620 #[test]
6621 fn test_update_add_htlc_bolt2_receiver_check_max_htlc_limit() {
6622         //BOLT 2 Requirement: if a sending node adds more than its max_accepted_htlcs HTLCs to its local commitment transaction: SHOULD fail the channel
6623         //BOLT 2 Requirement: MUST allow multiple HTLCs with the same payment_hash.
6624         let chanmon_cfgs = create_chanmon_cfgs(2);
6625         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6626         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6627         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6628         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6629         let logger = test_utils::TestLogger::new();
6630
6631         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6632         let session_priv = SecretKey::from_slice(&[42; 32]).unwrap();
6633
6634         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6635         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();
6636
6637         let cur_height = nodes[0].node.latest_block_height.load(Ordering::Acquire) as u32 + 1;
6638         let onion_keys = onion_utils::construct_onion_keys(&Secp256k1::signing_only(), &route.paths[0], &session_priv).unwrap();
6639         let (onion_payloads, _htlc_msat, htlc_cltv) = onion_utils::build_onion_payloads(&route.paths[0], 3999999, &None, cur_height).unwrap();
6640         let onion_packet = onion_utils::construct_onion_packet(onion_payloads, onion_keys, [0; 32], &our_payment_hash);
6641
6642         let mut msg = msgs::UpdateAddHTLC {
6643                 channel_id: chan.2,
6644                 htlc_id: 0,
6645                 amount_msat: 1000,
6646                 payment_hash: our_payment_hash,
6647                 cltv_expiry: htlc_cltv,
6648                 onion_routing_packet: onion_packet.clone(),
6649         };
6650
6651         for i in 0..super::channel::OUR_MAX_HTLCS {
6652                 msg.htlc_id = i as u64;
6653                 nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &msg);
6654         }
6655         msg.htlc_id = (super::channel::OUR_MAX_HTLCS) as u64;
6656         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &msg);
6657
6658         assert!(nodes[1].node.list_channels().is_empty());
6659         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
6660         assert!(regex::Regex::new(r"Remote tried to push more than our max accepted HTLCs \(\d+\)").unwrap().is_match(err_msg.data.as_str()));
6661         check_added_monitors!(nodes[1], 1);
6662 }
6663
6664 #[test]
6665 fn test_update_add_htlc_bolt2_receiver_check_max_in_flight_msat() {
6666         //OR adds more than its max_htlc_value_in_flight_msat worth of offered HTLCs to its local commitment transaction: SHOULD fail the channel
6667         let chanmon_cfgs = create_chanmon_cfgs(2);
6668         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6669         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6670         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6671         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
6672         let logger = test_utils::TestLogger::new();
6673
6674         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6675         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6676         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();
6677         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6678         check_added_monitors!(nodes[0], 1);
6679         let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6680         updates.update_add_htlcs[0].amount_msat = get_channel_value_stat!(nodes[1], chan.2).their_max_htlc_value_in_flight_msat + 1;
6681         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6682
6683         assert!(nodes[1].node.list_channels().is_empty());
6684         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
6685         assert!(regex::Regex::new("Remote HTLC add would put them over our max HTLC value").unwrap().is_match(err_msg.data.as_str()));
6686         check_added_monitors!(nodes[1], 1);
6687 }
6688
6689 #[test]
6690 fn test_update_add_htlc_bolt2_receiver_check_cltv_expiry() {
6691         //BOLT2 Requirement: if sending node sets cltv_expiry to greater or equal to 500000000: SHOULD fail the channel.
6692         let chanmon_cfgs = create_chanmon_cfgs(2);
6693         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6694         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6695         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6696         let logger = test_utils::TestLogger::new();
6697
6698         create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 100000, 95000000, InitFeatures::known(), InitFeatures::known());
6699         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6700         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6701         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();
6702         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6703         check_added_monitors!(nodes[0], 1);
6704         let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6705         updates.update_add_htlcs[0].cltv_expiry = 500000000;
6706         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6707
6708         assert!(nodes[1].node.list_channels().is_empty());
6709         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
6710         assert_eq!(err_msg.data,"Remote provided CLTV expiry in seconds instead of block height");
6711         check_added_monitors!(nodes[1], 1);
6712 }
6713
6714 #[test]
6715 fn test_update_add_htlc_bolt2_receiver_check_repeated_id_ignore() {
6716         //BOLT 2 requirement: if the sender did not previously acknowledge the commitment of that HTLC: MUST ignore a repeated id value after a reconnection.
6717         // We test this by first testing that that repeated HTLCs pass commitment signature checks
6718         // after disconnect and that non-sequential htlc_ids result in a channel failure.
6719         let chanmon_cfgs = create_chanmon_cfgs(2);
6720         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6721         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6722         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6723         let logger = test_utils::TestLogger::new();
6724
6725         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
6726         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6727         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6728         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();
6729         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6730         check_added_monitors!(nodes[0], 1);
6731         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6732         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6733
6734         //Disconnect and Reconnect
6735         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
6736         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
6737         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
6738         let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
6739         assert_eq!(reestablish_1.len(), 1);
6740         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
6741         let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
6742         assert_eq!(reestablish_2.len(), 1);
6743         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
6744         handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
6745         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
6746         handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
6747
6748         //Resend HTLC
6749         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6750         assert_eq!(updates.commitment_signed.htlc_signatures.len(), 1);
6751         nodes[1].node.handle_commitment_signed(&nodes[0].node.get_our_node_id(), &updates.commitment_signed);
6752         check_added_monitors!(nodes[1], 1);
6753         let _bs_responses = get_revoke_commit_msgs!(nodes[1], nodes[0].node.get_our_node_id());
6754
6755         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6756
6757         assert!(nodes[1].node.list_channels().is_empty());
6758         let err_msg = check_closed_broadcast!(nodes[1], true).unwrap();
6759         assert!(regex::Regex::new(r"Remote skipped HTLC ID \(skipped ID: \d+\)").unwrap().is_match(err_msg.data.as_str()));
6760         check_added_monitors!(nodes[1], 1);
6761 }
6762
6763 #[test]
6764 fn test_update_fulfill_htlc_bolt2_update_fulfill_htlc_before_commitment() {
6765         //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.
6766
6767         let chanmon_cfgs = create_chanmon_cfgs(2);
6768         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6769         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6770         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6771         let logger = test_utils::TestLogger::new();
6772         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
6773         let (our_payment_preimage, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6774         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6775         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();
6776         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6777
6778         check_added_monitors!(nodes[0], 1);
6779         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6780         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6781
6782         let update_msg = msgs::UpdateFulfillHTLC{
6783                 channel_id: chan.2,
6784                 htlc_id: 0,
6785                 payment_preimage: our_payment_preimage,
6786         };
6787
6788         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_msg);
6789
6790         assert!(nodes[0].node.list_channels().is_empty());
6791         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
6792         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()));
6793         check_added_monitors!(nodes[0], 1);
6794 }
6795
6796 #[test]
6797 fn test_update_fulfill_htlc_bolt2_update_fail_htlc_before_commitment() {
6798         //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.
6799
6800         let chanmon_cfgs = create_chanmon_cfgs(2);
6801         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6802         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6803         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6804         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
6805         let logger = test_utils::TestLogger::new();
6806
6807         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6808         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6809         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();
6810         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6811         check_added_monitors!(nodes[0], 1);
6812         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6813         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6814
6815         let update_msg = msgs::UpdateFailHTLC{
6816                 channel_id: chan.2,
6817                 htlc_id: 0,
6818                 reason: msgs::OnionErrorPacket { data: Vec::new()},
6819         };
6820
6821         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_msg);
6822
6823         assert!(nodes[0].node.list_channels().is_empty());
6824         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
6825         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()));
6826         check_added_monitors!(nodes[0], 1);
6827 }
6828
6829 #[test]
6830 fn test_update_fulfill_htlc_bolt2_update_fail_malformed_htlc_before_commitment() {
6831         //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.
6832
6833         let chanmon_cfgs = create_chanmon_cfgs(2);
6834         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6835         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6836         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6837         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
6838         let logger = test_utils::TestLogger::new();
6839
6840         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6841         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6842         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();
6843         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6844         check_added_monitors!(nodes[0], 1);
6845         let updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6846         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6847
6848         let update_msg = msgs::UpdateFailMalformedHTLC{
6849                 channel_id: chan.2,
6850                 htlc_id: 0,
6851                 sha256_of_onion: [1; 32],
6852                 failure_code: 0x8000,
6853         };
6854
6855         nodes[0].node.handle_update_fail_malformed_htlc(&nodes[1].node.get_our_node_id(), &update_msg);
6856
6857         assert!(nodes[0].node.list_channels().is_empty());
6858         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
6859         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()));
6860         check_added_monitors!(nodes[0], 1);
6861 }
6862
6863 #[test]
6864 fn test_update_fulfill_htlc_bolt2_incorrect_htlc_id() {
6865         //BOLT 2 Requirement: A receiving node: if the id does not correspond to an HTLC in its current commitment transaction MUST fail the channel.
6866
6867         let chanmon_cfgs = create_chanmon_cfgs(2);
6868         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6869         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6870         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6871         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
6872
6873         let our_payment_preimage = route_payment(&nodes[0], &[&nodes[1]], 100000).0;
6874
6875         nodes[1].node.claim_funds(our_payment_preimage, &None, 100_000);
6876         check_added_monitors!(nodes[1], 1);
6877
6878         let events = nodes[1].node.get_and_clear_pending_msg_events();
6879         assert_eq!(events.len(), 1);
6880         let mut update_fulfill_msg: msgs::UpdateFulfillHTLC = {
6881                 match events[0] {
6882                         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, .. } } => {
6883                                 assert!(update_add_htlcs.is_empty());
6884                                 assert_eq!(update_fulfill_htlcs.len(), 1);
6885                                 assert!(update_fail_htlcs.is_empty());
6886                                 assert!(update_fail_malformed_htlcs.is_empty());
6887                                 assert!(update_fee.is_none());
6888                                 update_fulfill_htlcs[0].clone()
6889                         },
6890                         _ => panic!("Unexpected event"),
6891                 }
6892         };
6893
6894         update_fulfill_msg.htlc_id = 1;
6895
6896         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_msg);
6897
6898         assert!(nodes[0].node.list_channels().is_empty());
6899         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
6900         assert_eq!(err_msg.data, "Remote tried to fulfill/fail an HTLC we couldn't find");
6901         check_added_monitors!(nodes[0], 1);
6902 }
6903
6904 #[test]
6905 fn test_update_fulfill_htlc_bolt2_wrong_preimage() {
6906         //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.
6907
6908         let chanmon_cfgs = create_chanmon_cfgs(2);
6909         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6910         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6911         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6912         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
6913
6914         let our_payment_preimage = route_payment(&nodes[0], &[&nodes[1]], 100000).0;
6915
6916         nodes[1].node.claim_funds(our_payment_preimage, &None, 100_000);
6917         check_added_monitors!(nodes[1], 1);
6918
6919         let events = nodes[1].node.get_and_clear_pending_msg_events();
6920         assert_eq!(events.len(), 1);
6921         let mut update_fulfill_msg: msgs::UpdateFulfillHTLC = {
6922                 match events[0] {
6923                         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, .. } } => {
6924                                 assert!(update_add_htlcs.is_empty());
6925                                 assert_eq!(update_fulfill_htlcs.len(), 1);
6926                                 assert!(update_fail_htlcs.is_empty());
6927                                 assert!(update_fail_malformed_htlcs.is_empty());
6928                                 assert!(update_fee.is_none());
6929                                 update_fulfill_htlcs[0].clone()
6930                         },
6931                         _ => panic!("Unexpected event"),
6932                 }
6933         };
6934
6935         update_fulfill_msg.payment_preimage = PaymentPreimage([1; 32]);
6936
6937         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &update_fulfill_msg);
6938
6939         assert!(nodes[0].node.list_channels().is_empty());
6940         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
6941         assert!(regex::Regex::new(r"Remote tried to fulfill HTLC \(\d+\) with an incorrect preimage").unwrap().is_match(err_msg.data.as_str()));
6942         check_added_monitors!(nodes[0], 1);
6943 }
6944
6945 #[test]
6946 fn test_update_fulfill_htlc_bolt2_missing_badonion_bit_for_malformed_htlc_message() {
6947         //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.
6948
6949         let chanmon_cfgs = create_chanmon_cfgs(2);
6950         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
6951         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
6952         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
6953         create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
6954         let logger = test_utils::TestLogger::new();
6955
6956         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
6957         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
6958         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();
6959         nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
6960         check_added_monitors!(nodes[0], 1);
6961
6962         let mut updates = get_htlc_update_msgs!(nodes[0], nodes[1].node.get_our_node_id());
6963         updates.update_add_htlcs[0].onion_routing_packet.version = 1; //Produce a malformed HTLC message
6964
6965         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &updates.update_add_htlcs[0]);
6966         check_added_monitors!(nodes[1], 0);
6967         commitment_signed_dance!(nodes[1], nodes[0], updates.commitment_signed, false, true);
6968
6969         let events = nodes[1].node.get_and_clear_pending_msg_events();
6970
6971         let mut update_msg: msgs::UpdateFailMalformedHTLC = {
6972                 match events[0] {
6973                         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, .. } } => {
6974                                 assert!(update_add_htlcs.is_empty());
6975                                 assert!(update_fulfill_htlcs.is_empty());
6976                                 assert!(update_fail_htlcs.is_empty());
6977                                 assert_eq!(update_fail_malformed_htlcs.len(), 1);
6978                                 assert!(update_fee.is_none());
6979                                 update_fail_malformed_htlcs[0].clone()
6980                         },
6981                         _ => panic!("Unexpected event"),
6982                 }
6983         };
6984         update_msg.failure_code &= !0x8000;
6985         nodes[0].node.handle_update_fail_malformed_htlc(&nodes[1].node.get_our_node_id(), &update_msg);
6986
6987         assert!(nodes[0].node.list_channels().is_empty());
6988         let err_msg = check_closed_broadcast!(nodes[0], true).unwrap();
6989         assert_eq!(err_msg.data, "Got update_fail_malformed_htlc with BADONION not set");
6990         check_added_monitors!(nodes[0], 1);
6991 }
6992
6993 #[test]
6994 fn test_update_fulfill_htlc_bolt2_after_malformed_htlc_message_must_forward_update_fail_htlc() {
6995         //BOLT 2 Requirement: a receiving node which has an outgoing HTLC canceled by update_fail_malformed_htlc:
6996         //    * 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.
6997
6998         let chanmon_cfgs = create_chanmon_cfgs(3);
6999         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
7000         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
7001         let mut nodes = create_network(3, &node_cfgs, &node_chanmgrs);
7002         create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
7003         create_announced_chan_between_nodes_with_value(&nodes, 1, 2, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
7004         let logger = test_utils::TestLogger::new();
7005
7006         let (_, our_payment_hash) = get_payment_preimage_hash!(nodes[0]);
7007
7008         //First hop
7009         let mut payment_event = {
7010                 let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
7011                 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();
7012                 nodes[0].node.send_payment(&route, our_payment_hash, &None).unwrap();
7013                 check_added_monitors!(nodes[0], 1);
7014                 let mut events = nodes[0].node.get_and_clear_pending_msg_events();
7015                 assert_eq!(events.len(), 1);
7016                 SendEvent::from_event(events.remove(0))
7017         };
7018         nodes[1].node.handle_update_add_htlc(&nodes[0].node.get_our_node_id(), &payment_event.msgs[0]);
7019         check_added_monitors!(nodes[1], 0);
7020         commitment_signed_dance!(nodes[1], nodes[0], payment_event.commitment_msg, false);
7021         expect_pending_htlcs_forwardable!(nodes[1]);
7022         let mut events_2 = nodes[1].node.get_and_clear_pending_msg_events();
7023         assert_eq!(events_2.len(), 1);
7024         check_added_monitors!(nodes[1], 1);
7025         payment_event = SendEvent::from_event(events_2.remove(0));
7026         assert_eq!(payment_event.msgs.len(), 1);
7027
7028         //Second Hop
7029         payment_event.msgs[0].onion_routing_packet.version = 1; //Produce a malformed HTLC message
7030         nodes[2].node.handle_update_add_htlc(&nodes[1].node.get_our_node_id(), &payment_event.msgs[0]);
7031         check_added_monitors!(nodes[2], 0);
7032         commitment_signed_dance!(nodes[2], nodes[1], payment_event.commitment_msg, false, true);
7033
7034         let events_3 = nodes[2].node.get_and_clear_pending_msg_events();
7035         assert_eq!(events_3.len(), 1);
7036         let update_msg : (msgs::UpdateFailMalformedHTLC, msgs::CommitmentSigned) = {
7037                 match events_3[0] {
7038                         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 } } => {
7039                                 assert!(update_add_htlcs.is_empty());
7040                                 assert!(update_fulfill_htlcs.is_empty());
7041                                 assert!(update_fail_htlcs.is_empty());
7042                                 assert_eq!(update_fail_malformed_htlcs.len(), 1);
7043                                 assert!(update_fee.is_none());
7044                                 (update_fail_malformed_htlcs[0].clone(), commitment_signed.clone())
7045                         },
7046                         _ => panic!("Unexpected event"),
7047                 }
7048         };
7049
7050         nodes[1].node.handle_update_fail_malformed_htlc(&nodes[2].node.get_our_node_id(), &update_msg.0);
7051
7052         check_added_monitors!(nodes[1], 0);
7053         commitment_signed_dance!(nodes[1], nodes[2], update_msg.1, false, true);
7054         expect_pending_htlcs_forwardable!(nodes[1]);
7055         let events_4 = nodes[1].node.get_and_clear_pending_msg_events();
7056         assert_eq!(events_4.len(), 1);
7057
7058         //Confirm that handlinge the update_malformed_htlc message produces an update_fail_htlc message to be forwarded back along the route
7059         match events_4[0] {
7060                 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, .. } } => {
7061                         assert!(update_add_htlcs.is_empty());
7062                         assert!(update_fulfill_htlcs.is_empty());
7063                         assert_eq!(update_fail_htlcs.len(), 1);
7064                         assert!(update_fail_malformed_htlcs.is_empty());
7065                         assert!(update_fee.is_none());
7066                 },
7067                 _ => panic!("Unexpected event"),
7068         };
7069
7070         check_added_monitors!(nodes[1], 1);
7071 }
7072
7073 fn do_test_failure_delay_dust_htlc_local_commitment(announce_latest: bool) {
7074         // Dust-HTLC failure updates must be delayed until failure-trigger tx (in this case local commitment) reach ANTI_REORG_DELAY
7075         // 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
7076         // HTLC could have been removed from lastest local commitment tx but still valid until we get remote RAA
7077
7078         let chanmon_cfgs = create_chanmon_cfgs(2);
7079         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7080         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7081         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7082         let chan =create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
7083
7084         let bs_dust_limit = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
7085
7086         // We route 2 dust-HTLCs between A and B
7087         let (_, payment_hash_1) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
7088         let (_, payment_hash_2) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
7089         route_payment(&nodes[0], &[&nodes[1]], 1000000);
7090
7091         // Cache one local commitment tx as previous
7092         let as_prev_commitment_tx = get_local_commitment_txn!(nodes[0], chan.2);
7093
7094         // Fail one HTLC to prune it in the will-be-latest-local commitment tx
7095         assert!(nodes[1].node.fail_htlc_backwards(&payment_hash_2, &None));
7096         check_added_monitors!(nodes[1], 0);
7097         expect_pending_htlcs_forwardable!(nodes[1]);
7098         check_added_monitors!(nodes[1], 1);
7099
7100         let remove = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
7101         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &remove.update_fail_htlcs[0]);
7102         nodes[0].node.handle_commitment_signed(&nodes[1].node.get_our_node_id(), &remove.commitment_signed);
7103         check_added_monitors!(nodes[0], 1);
7104
7105         // Cache one local commitment tx as lastest
7106         let as_last_commitment_tx = get_local_commitment_txn!(nodes[0], chan.2);
7107
7108         let events = nodes[0].node.get_and_clear_pending_msg_events();
7109         match events[0] {
7110                 MessageSendEvent::SendRevokeAndACK { node_id, .. } => {
7111                         assert_eq!(node_id, nodes[1].node.get_our_node_id());
7112                 },
7113                 _ => panic!("Unexpected event"),
7114         }
7115         match events[1] {
7116                 MessageSendEvent::UpdateHTLCs { node_id, .. } => {
7117                         assert_eq!(node_id, nodes[1].node.get_our_node_id());
7118                 },
7119                 _ => panic!("Unexpected event"),
7120         }
7121
7122         assert_ne!(as_prev_commitment_tx, as_last_commitment_tx);
7123         // Fail the 2 dust-HTLCs, move their failure in maturation buffer (htlc_updated_waiting_threshold_conf)
7124         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7125
7126         if announce_latest {
7127                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![as_last_commitment_tx[0].clone()]}, 1);
7128         } else {
7129                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![as_prev_commitment_tx[0].clone()]}, 1);
7130         }
7131
7132         check_closed_broadcast!(nodes[0], false);
7133         check_added_monitors!(nodes[0], 1);
7134
7135         assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
7136         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 1, true,  header.bitcoin_hash());
7137         let events = nodes[0].node.get_and_clear_pending_events();
7138         // Only 2 PaymentFailed events should show up, over-dust HTLC has to be failed by timeout tx
7139         assert_eq!(events.len(), 2);
7140         let mut first_failed = false;
7141         for event in events {
7142                 match event {
7143                         Event::PaymentFailed { payment_hash, .. } => {
7144                                 if payment_hash == payment_hash_1 {
7145                                         assert!(!first_failed);
7146                                         first_failed = true;
7147                                 } else {
7148                                         assert_eq!(payment_hash, payment_hash_2);
7149                                 }
7150                         }
7151                         _ => panic!("Unexpected event"),
7152                 }
7153         }
7154 }
7155
7156 #[test]
7157 fn test_failure_delay_dust_htlc_local_commitment() {
7158         do_test_failure_delay_dust_htlc_local_commitment(true);
7159         do_test_failure_delay_dust_htlc_local_commitment(false);
7160 }
7161
7162 #[test]
7163 fn test_no_failure_dust_htlc_local_commitment() {
7164         // Transaction filters for failing back dust htlc based on local commitment txn infos has been
7165         // prone to error, we test here that a dummy transaction don't fail them.
7166
7167         let chanmon_cfgs = create_chanmon_cfgs(2);
7168         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7169         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7170         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7171         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
7172
7173         // Rebalance a bit
7174         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
7175
7176         let as_dust_limit = nodes[0].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
7177         let bs_dust_limit = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
7178
7179         // We route 2 dust-HTLCs between A and B
7180         let (preimage_1, _) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
7181         let (preimage_2, _) = route_payment(&nodes[1], &[&nodes[0]], as_dust_limit*1000);
7182
7183         // Build a dummy invalid transaction trying to spend a commitment tx
7184         let input = TxIn {
7185                 previous_output: BitcoinOutPoint { txid: chan.3.txid(), vout: 0 },
7186                 script_sig: Script::new(),
7187                 sequence: 0,
7188                 witness: Vec::new(),
7189         };
7190
7191         let outp = TxOut {
7192                 script_pubkey: Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script(),
7193                 value: 10000,
7194         };
7195
7196         let dummy_tx = Transaction {
7197                 version: 2,
7198                 lock_time: 0,
7199                 input: vec![input],
7200                 output: vec![outp]
7201         };
7202
7203         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7204         nodes[0].chan_monitor.simple_monitor.block_connected(&header, 1, &[&dummy_tx], &[1;1]);
7205         assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
7206         assert_eq!(nodes[0].node.get_and_clear_pending_msg_events().len(), 0);
7207         // We broadcast a few more block to check everything is all right
7208         connect_blocks(&nodes[0].block_notifier, 20, 1, true,  header.bitcoin_hash());
7209         assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
7210         assert_eq!(nodes[0].node.get_and_clear_pending_msg_events().len(), 0);
7211
7212         claim_payment(&nodes[0], &vec!(&nodes[1])[..], preimage_1, bs_dust_limit*1000);
7213         claim_payment(&nodes[1], &vec!(&nodes[0])[..], preimage_2, as_dust_limit*1000);
7214 }
7215
7216 fn do_test_sweep_outbound_htlc_failure_update(revoked: bool, local: bool) {
7217         // Outbound HTLC-failure updates must be cancelled if we get a reorg before we reach ANTI_REORG_DELAY.
7218         // Broadcast of revoked remote commitment tx, trigger failure-update of dust/non-dust HTLCs
7219         // Broadcast of remote commitment tx, trigger failure-update of dust-HTLCs
7220         // Broadcast of timeout tx on remote commitment tx, trigger failure-udate of non-dust HTLCs
7221         // Broadcast of local commitment tx, trigger failure-update of dust-HTLCs
7222         // Broadcast of HTLC-timeout tx on local commitment tx, trigger failure-update of non-dust HTLCs
7223
7224         let chanmon_cfgs = create_chanmon_cfgs(3);
7225         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
7226         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
7227         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
7228         let chan = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
7229
7230         let bs_dust_limit = nodes[1].node.channel_state.lock().unwrap().by_id.get(&chan.2).unwrap().our_dust_limit_satoshis;
7231
7232         let (_payment_preimage_1, dust_hash) = route_payment(&nodes[0], &[&nodes[1]], bs_dust_limit*1000);
7233         let (_payment_preimage_2, non_dust_hash) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
7234
7235         let as_commitment_tx = get_local_commitment_txn!(nodes[0], chan.2);
7236         let bs_commitment_tx = get_local_commitment_txn!(nodes[1], chan.2);
7237
7238         // We revoked bs_commitment_tx
7239         if revoked {
7240                 let (payment_preimage_3, _) = route_payment(&nodes[0], &[&nodes[1]], 1000000);
7241                 claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage_3, 1_000_000);
7242         }
7243
7244         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7245         let mut timeout_tx = Vec::new();
7246         if local {
7247                 // We fail dust-HTLC 1 by broadcast of local commitment tx
7248                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![as_commitment_tx[0].clone()]}, 1);
7249                 check_closed_broadcast!(nodes[0], false);
7250                 check_added_monitors!(nodes[0], 1);
7251                 assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
7252                 timeout_tx.push(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap()[0].clone());
7253                 let parent_hash  = connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 2, true, header.bitcoin_hash());
7254                 expect_payment_failed!(nodes[0], dust_hash, true);
7255                 assert_eq!(timeout_tx[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
7256                 // We fail non-dust-HTLC 2 by broadcast of local HTLC-timeout tx on local commitment tx
7257                 let header_2 = BlockHeader { version: 0x20000000, prev_blockhash: parent_hash, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7258                 assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
7259                 nodes[0].block_notifier.block_connected(&Block { header: header_2, txdata: vec![timeout_tx[0].clone()]}, 7);
7260                 let header_3 = BlockHeader { version: 0x20000000, prev_blockhash: header_2.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7261                 connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 8, true, header_3.bitcoin_hash());
7262                 expect_payment_failed!(nodes[0], non_dust_hash, true);
7263         } else {
7264                 // We fail dust-HTLC 1 by broadcast of remote commitment tx. If revoked, fail also non-dust HTLC
7265                 nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![bs_commitment_tx[0].clone()]}, 1);
7266                 check_closed_broadcast!(nodes[0], false);
7267                 check_added_monitors!(nodes[0], 1);
7268                 assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
7269                 timeout_tx.push(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap()[0].clone());
7270                 let parent_hash  = connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 2, true, header.bitcoin_hash());
7271                 let header_2 = BlockHeader { version: 0x20000000, prev_blockhash: parent_hash, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7272                 if !revoked {
7273                         expect_payment_failed!(nodes[0], dust_hash, true);
7274                         assert_eq!(timeout_tx[0].input[0].witness.last().unwrap().len(), ACCEPTED_HTLC_SCRIPT_WEIGHT);
7275                         // We fail non-dust-HTLC 2 by broadcast of local timeout tx on remote commitment tx
7276                         nodes[0].block_notifier.block_connected(&Block { header: header_2, txdata: vec![timeout_tx[0].clone()]}, 7);
7277                         assert_eq!(nodes[0].node.get_and_clear_pending_events().len(), 0);
7278                         let header_3 = BlockHeader { version: 0x20000000, prev_blockhash: header_2.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7279                         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 8, true, header_3.bitcoin_hash());
7280                         expect_payment_failed!(nodes[0], non_dust_hash, true);
7281                 } else {
7282                         // If revoked, both dust & non-dust HTLCs should have been failed after ANTI_REORG_DELAY confs of revoked
7283                         // commitment tx
7284                         let events = nodes[0].node.get_and_clear_pending_events();
7285                         assert_eq!(events.len(), 2);
7286                         let first;
7287                         match events[0] {
7288                                 Event::PaymentFailed { payment_hash, .. } => {
7289                                         if payment_hash == dust_hash { first = true; }
7290                                         else { first = false; }
7291                                 },
7292                                 _ => panic!("Unexpected event"),
7293                         }
7294                         match events[1] {
7295                                 Event::PaymentFailed { payment_hash, .. } => {
7296                                         if first { assert_eq!(payment_hash, non_dust_hash); }
7297                                         else { assert_eq!(payment_hash, dust_hash); }
7298                                 },
7299                                 _ => panic!("Unexpected event"),
7300                         }
7301                 }
7302         }
7303 }
7304
7305 #[test]
7306 fn test_sweep_outbound_htlc_failure_update() {
7307         do_test_sweep_outbound_htlc_failure_update(false, true);
7308         do_test_sweep_outbound_htlc_failure_update(false, false);
7309         do_test_sweep_outbound_htlc_failure_update(true, false);
7310 }
7311
7312 #[test]
7313 fn test_upfront_shutdown_script() {
7314         // BOLT 2 : Option upfront shutdown script, if peer commit its closing_script at channel opening
7315         // enforce it at shutdown message
7316
7317         let mut config = UserConfig::default();
7318         config.channel_options.announced_channel = true;
7319         config.peer_channel_config_limits.force_announced_channel_preference = false;
7320         config.channel_options.commit_upfront_shutdown_pubkey = false;
7321         let user_cfgs = [None, Some(config), None];
7322         let chanmon_cfgs = create_chanmon_cfgs(3);
7323         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
7324         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &user_cfgs);
7325         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
7326
7327         // We test that in case of peer committing upfront to a script, if it changes at closing, we refuse to sign
7328         let flags = InitFeatures::known();
7329         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1000000, 1000000, flags.clone(), flags.clone());
7330         nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
7331         let mut node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id());
7332         node_0_shutdown.scriptpubkey = Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script().to_p2sh();
7333         // Test we enforce upfront_scriptpbukey if by providing a diffrent one at closing that  we disconnect peer
7334         nodes[2].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
7335     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()));
7336         check_added_monitors!(nodes[2], 1);
7337
7338         // We test that in case of peer committing upfront to a script, if it doesn't change at closing, we sign
7339         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 2, 1000000, 1000000, flags.clone(), flags.clone());
7340         nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
7341         let node_0_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[2].node.get_our_node_id());
7342         // We test that in case of peer committing upfront to a script, if it oesn't change at closing, we sign
7343         nodes[2].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_0_shutdown);
7344         let events = nodes[2].node.get_and_clear_pending_msg_events();
7345         assert_eq!(events.len(), 1);
7346         match events[0] {
7347                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[0].node.get_our_node_id()) }
7348                 _ => panic!("Unexpected event"),
7349         }
7350
7351         // We test that if case of peer non-signaling we don't enforce committed script at channel opening
7352         let flags_no = InitFeatures::known().clear_upfront_shutdown_script();
7353         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, flags_no, flags.clone());
7354         nodes[0].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
7355         let mut node_1_shutdown = get_event_msg!(nodes[0], MessageSendEvent::SendShutdown, nodes[1].node.get_our_node_id());
7356         node_1_shutdown.scriptpubkey = Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script().to_p2sh();
7357         nodes[1].node.handle_shutdown(&nodes[0].node.get_our_node_id(), &node_1_shutdown);
7358         let events = nodes[1].node.get_and_clear_pending_msg_events();
7359         assert_eq!(events.len(), 1);
7360         match events[0] {
7361                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[0].node.get_our_node_id()) }
7362                 _ => panic!("Unexpected event"),
7363         }
7364
7365         // We test that if user opt-out, we provide a zero-length script at channel opening and we are able to close
7366         // channel smoothly, opt-out is from channel initiator here
7367         let chan = create_announced_chan_between_nodes_with_value(&nodes, 1, 0, 1000000, 1000000, flags.clone(), flags.clone());
7368         nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
7369         let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
7370         node_0_shutdown.scriptpubkey = Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script().to_p2sh();
7371         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_0_shutdown);
7372         let events = nodes[0].node.get_and_clear_pending_msg_events();
7373         assert_eq!(events.len(), 1);
7374         match events[0] {
7375                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
7376                 _ => panic!("Unexpected event"),
7377         }
7378
7379         //// We test that if user opt-out, we provide a zero-length script at channel opening and we are able to close
7380         //// channel smoothly
7381         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, flags.clone(), flags.clone());
7382         nodes[1].node.close_channel(&OutPoint { txid: chan.3.txid(), index: 0 }.to_channel_id()).unwrap();
7383         let mut node_0_shutdown = get_event_msg!(nodes[1], MessageSendEvent::SendShutdown, nodes[0].node.get_our_node_id());
7384         node_0_shutdown.scriptpubkey = Builder::new().push_opcode(opcodes::all::OP_RETURN).into_script().to_p2sh();
7385         nodes[0].node.handle_shutdown(&nodes[1].node.get_our_node_id(), &node_0_shutdown);
7386         let events = nodes[0].node.get_and_clear_pending_msg_events();
7387         assert_eq!(events.len(), 2);
7388         match events[0] {
7389                 MessageSendEvent::SendShutdown { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
7390                 _ => panic!("Unexpected event"),
7391         }
7392         match events[1] {
7393                 MessageSendEvent::SendClosingSigned { node_id, .. } => { assert_eq!(node_id, nodes[1].node.get_our_node_id()) }
7394                 _ => panic!("Unexpected event"),
7395         }
7396 }
7397
7398 #[test]
7399 fn test_user_configurable_csv_delay() {
7400         // We test our channel constructors yield errors when we pass them absurd csv delay
7401
7402         let mut low_our_to_self_config = UserConfig::default();
7403         low_our_to_self_config.own_channel_config.our_to_self_delay = 6;
7404         let mut high_their_to_self_config = UserConfig::default();
7405         high_their_to_self_config.peer_channel_config_limits.their_to_self_delay = 100;
7406         let user_cfgs = [Some(high_their_to_self_config.clone()), None];
7407         let chanmon_cfgs = create_chanmon_cfgs(2);
7408         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7409         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &user_cfgs);
7410         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7411
7412         // We test config.our_to_self > BREAKDOWN_TIMEOUT is enforced in Channel::new_outbound()
7413         let keys_manager: Arc<KeysInterface<ChanKeySigner = EnforcingChannelKeys>> = Arc::new(test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet));
7414         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) {
7415                 match error {
7416                         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())); },
7417                         _ => panic!("Unexpected event"),
7418                 }
7419         } else { assert!(false) }
7420
7421         // We test config.our_to_self > BREAKDOWN_TIMEOUT is enforced in Channel::new_from_req()
7422         nodes[1].node.create_channel(nodes[0].node.get_our_node_id(), 1000000, 1000000, 42, None).unwrap();
7423         let mut open_channel = get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, nodes[0].node.get_our_node_id());
7424         open_channel.to_self_delay = 200;
7425         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) {
7426                 match error {
7427                         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()));  },
7428                         _ => panic!("Unexpected event"),
7429                 }
7430         } else { assert!(false); }
7431
7432         // We test msg.to_self_delay <= config.their_to_self_delay is enforced in Chanel::accept_channel()
7433         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 1000000, 1000000, 42, None).unwrap();
7434         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()));
7435         let mut accept_channel = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
7436         accept_channel.to_self_delay = 200;
7437         nodes[0].node.handle_accept_channel(&nodes[1].node.get_our_node_id(), InitFeatures::known(), &accept_channel);
7438         if let MessageSendEvent::HandleError { ref action, .. } = nodes[0].node.get_and_clear_pending_msg_events()[0] {
7439                 match action {
7440                         &ErrorAction::SendErrorMessage { ref msg } => {
7441                                 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()));
7442                         },
7443                         _ => { assert!(false); }
7444                 }
7445         } else { assert!(false); }
7446
7447         // We test msg.to_self_delay <= config.their_to_self_delay is enforced in Channel::new_from_req()
7448         nodes[1].node.create_channel(nodes[0].node.get_our_node_id(), 1000000, 1000000, 42, None).unwrap();
7449         let mut open_channel = get_event_msg!(nodes[1], MessageSendEvent::SendOpenChannel, nodes[0].node.get_our_node_id());
7450         open_channel.to_self_delay = 200;
7451         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) {
7452                 match error {
7453                         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())); },
7454                         _ => panic!("Unexpected event"),
7455                 }
7456         } else { assert!(false); }
7457 }
7458
7459 #[test]
7460 fn test_data_loss_protect() {
7461         // We want to be sure that :
7462         // * we don't broadcast our Local Commitment Tx in case of fallen behind
7463         // * we close channel in case of detecting other being fallen behind
7464         // * we are able to claim our own outputs thanks to to_remote being static
7465         let keys_manager;
7466         let logger;
7467         let fee_estimator;
7468         let tx_broadcaster;
7469         let chain_monitor;
7470         let monitor;
7471         let node_state_0;
7472         let chanmon_cfgs = create_chanmon_cfgs(2);
7473         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7474         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7475         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7476
7477         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 1000000, InitFeatures::known(), InitFeatures::known());
7478
7479         // Cache node A state before any channel update
7480         let previous_node_state = nodes[0].node.encode();
7481         let mut previous_chan_monitor_state = test_utils::TestVecWriter(Vec::new());
7482         nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap().iter().next().unwrap().1.write_for_disk(&mut previous_chan_monitor_state).unwrap();
7483
7484         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
7485         send_payment(&nodes[0], &vec!(&nodes[1])[..], 8000000, 8_000_000);
7486
7487         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
7488         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
7489
7490         // Restore node A from previous state
7491         logger = test_utils::TestLogger::with_id(format!("node {}", 0));
7492         let mut chan_monitor = <(BlockHash, ChannelMonitor<EnforcingChannelKeys>)>::read(&mut ::std::io::Cursor::new(previous_chan_monitor_state.0)).unwrap().1;
7493         chain_monitor = ChainWatchInterfaceUtil::new(Network::Testnet);
7494         tx_broadcaster = test_utils::TestBroadcaster{txn_broadcasted: Mutex::new(Vec::new())};
7495         fee_estimator = test_utils::TestFeeEstimator { sat_per_kw: 253 };
7496         keys_manager = test_utils::TestKeysInterface::new(&nodes[0].node_seed, Network::Testnet);
7497         monitor = test_utils::TestChannelMonitor::new(&chain_monitor, &tx_broadcaster, &logger, &fee_estimator);
7498         node_state_0 = {
7499                 let mut channel_monitors = HashMap::new();
7500                 channel_monitors.insert(OutPoint { txid: chan.3.txid(), index: 0 }, &mut chan_monitor);
7501                 <(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 {
7502                         keys_manager: &keys_manager,
7503                         fee_estimator: &fee_estimator,
7504                         monitor: &monitor,
7505                         logger: &logger,
7506                         tx_broadcaster: &tx_broadcaster,
7507                         default_config: UserConfig::default(),
7508                         channel_monitors: &mut channel_monitors,
7509                 }).unwrap().1
7510         };
7511         nodes[0].node = &node_state_0;
7512         assert!(monitor.add_monitor(OutPoint { txid: chan.3.txid(), index: 0 }, chan_monitor).is_ok());
7513         nodes[0].chan_monitor = &monitor;
7514         nodes[0].chain_monitor = &chain_monitor;
7515
7516         nodes[0].block_notifier = BlockNotifier::new(&nodes[0].chain_monitor);
7517         nodes[0].block_notifier.register_listener(&nodes[0].chan_monitor.simple_monitor);
7518         nodes[0].block_notifier.register_listener(nodes[0].node);
7519
7520         check_added_monitors!(nodes[0], 1);
7521
7522         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
7523         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
7524
7525         let reestablish_0 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
7526
7527         // Check we don't broadcast any transactions following learning of per_commitment_point from B
7528         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_0[0]);
7529         check_added_monitors!(nodes[0], 1);
7530
7531         {
7532                 let node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
7533                 assert_eq!(node_txn.len(), 0);
7534         }
7535
7536         let mut reestablish_1 = Vec::with_capacity(1);
7537         for msg in nodes[0].node.get_and_clear_pending_msg_events() {
7538                 if let MessageSendEvent::SendChannelReestablish { ref node_id, ref msg } = msg {
7539                         assert_eq!(*node_id, nodes[1].node.get_our_node_id());
7540                         reestablish_1.push(msg.clone());
7541                 } else if let MessageSendEvent::BroadcastChannelUpdate { .. } = msg {
7542                 } else if let MessageSendEvent::HandleError { ref action, .. } = msg {
7543                         match action {
7544                                 &ErrorAction::SendErrorMessage { ref msg } => {
7545                                         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");
7546                                 },
7547                                 _ => panic!("Unexpected event!"),
7548                         }
7549                 } else {
7550                         panic!("Unexpected event")
7551                 }
7552         }
7553
7554         // Check we close channel detecting A is fallen-behind
7555         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
7556         assert_eq!(check_closed_broadcast!(nodes[1], true).unwrap().data, "Peer attempted to reestablish channel with a very old local commitment transaction");
7557         check_added_monitors!(nodes[1], 1);
7558
7559
7560         // Check A is able to claim to_remote output
7561         let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap().clone();
7562         assert_eq!(node_txn.len(), 1);
7563         check_spends!(node_txn[0], chan.3);
7564         assert_eq!(node_txn[0].output.len(), 2);
7565         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42};
7566         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![node_txn[0].clone()]}, 0);
7567         connect_blocks(&nodes[0].block_notifier, ANTI_REORG_DELAY - 1, 0, true, header.bitcoin_hash());
7568         let spend_txn = check_spendable_outputs!(nodes[0], 1, node_cfgs[0].keys_manager, 100000);
7569         assert_eq!(spend_txn.len(), 1);
7570         check_spends!(spend_txn[0], node_txn[0]);
7571 }
7572
7573 #[test]
7574 fn test_check_htlc_underpaying() {
7575         // Send payment through A -> B but A is maliciously
7576         // sending a probe payment (i.e less than expected value0
7577         // to B, B should refuse payment.
7578
7579         let chanmon_cfgs = create_chanmon_cfgs(2);
7580         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7581         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7582         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7583
7584         // Create some initial channels
7585         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
7586
7587         let (payment_preimage, payment_hash) = route_payment(&nodes[0], &[&nodes[1]], 10_000);
7588
7589         // Node 3 is expecting payment of 100_000 but receive 10_000,
7590         // fail htlc like we didn't know the preimage.
7591         nodes[1].node.claim_funds(payment_preimage, &None, 100_000);
7592         nodes[1].node.process_pending_htlc_forwards();
7593
7594         let events = nodes[1].node.get_and_clear_pending_msg_events();
7595         assert_eq!(events.len(), 1);
7596         let (update_fail_htlc, commitment_signed) = match events[0] {
7597                 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 } } => {
7598                         assert!(update_add_htlcs.is_empty());
7599                         assert!(update_fulfill_htlcs.is_empty());
7600                         assert_eq!(update_fail_htlcs.len(), 1);
7601                         assert!(update_fail_malformed_htlcs.is_empty());
7602                         assert!(update_fee.is_none());
7603                         (update_fail_htlcs[0].clone(), commitment_signed)
7604                 },
7605                 _ => panic!("Unexpected event"),
7606         };
7607         check_added_monitors!(nodes[1], 1);
7608
7609         nodes[0].node.handle_update_fail_htlc(&nodes[1].node.get_our_node_id(), &update_fail_htlc);
7610         commitment_signed_dance!(nodes[0], nodes[1], commitment_signed, false, true);
7611
7612         // 10_000 msat as u64, followed by a height of 99 as u32
7613         let mut expected_failure_data = byte_utils::be64_to_array(10_000).to_vec();
7614         expected_failure_data.extend_from_slice(&byte_utils::be32_to_array(99));
7615         expect_payment_failed!(nodes[0], payment_hash, true, 0x4000|15, &expected_failure_data[..]);
7616         nodes[1].node.get_and_clear_pending_events();
7617 }
7618
7619 #[test]
7620 fn test_announce_disable_channels() {
7621         // Create 2 channels between A and B. Disconnect B. Call timer_chan_freshness_every_min and check for generated
7622         // ChannelUpdate. Reconnect B, reestablish and check there is non-generated ChannelUpdate.
7623
7624         let chanmon_cfgs = create_chanmon_cfgs(2);
7625         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7626         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7627         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7628
7629         let short_id_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
7630         let short_id_2 = create_announced_chan_between_nodes(&nodes, 1, 0, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
7631         let short_id_3 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
7632
7633         // Disconnect peers
7634         nodes[0].node.peer_disconnected(&nodes[1].node.get_our_node_id(), false);
7635         nodes[1].node.peer_disconnected(&nodes[0].node.get_our_node_id(), false);
7636
7637         nodes[0].node.timer_chan_freshness_every_min(); // dirty -> stagged
7638         nodes[0].node.timer_chan_freshness_every_min(); // staged -> fresh
7639         let msg_events = nodes[0].node.get_and_clear_pending_msg_events();
7640         assert_eq!(msg_events.len(), 3);
7641         for e in msg_events {
7642                 match e {
7643                         MessageSendEvent::BroadcastChannelUpdate { ref msg } => {
7644                                 let short_id = msg.contents.short_channel_id;
7645                                 // Check generated channel_update match list in PendingChannelUpdate
7646                                 if short_id != short_id_1 && short_id != short_id_2 && short_id != short_id_3 {
7647                                         panic!("Generated ChannelUpdate for wrong chan!");
7648                                 }
7649                         },
7650                         _ => panic!("Unexpected event"),
7651                 }
7652         }
7653         // Reconnect peers
7654         nodes[0].node.peer_connected(&nodes[1].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
7655         let reestablish_1 = get_chan_reestablish_msgs!(nodes[0], nodes[1]);
7656         assert_eq!(reestablish_1.len(), 3);
7657         nodes[1].node.peer_connected(&nodes[0].node.get_our_node_id(), &msgs::Init { features: InitFeatures::empty() });
7658         let reestablish_2 = get_chan_reestablish_msgs!(nodes[1], nodes[0]);
7659         assert_eq!(reestablish_2.len(), 3);
7660
7661         // Reestablish chan_1
7662         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[0]);
7663         handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
7664         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[0]);
7665         handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
7666         // Reestablish chan_2
7667         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[1]);
7668         handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
7669         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[1]);
7670         handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
7671         // Reestablish chan_3
7672         nodes[0].node.handle_channel_reestablish(&nodes[1].node.get_our_node_id(), &reestablish_2[2]);
7673         handle_chan_reestablish_msgs!(nodes[0], nodes[1]);
7674         nodes[1].node.handle_channel_reestablish(&nodes[0].node.get_our_node_id(), &reestablish_1[2]);
7675         handle_chan_reestablish_msgs!(nodes[1], nodes[0]);
7676
7677         nodes[0].node.timer_chan_freshness_every_min();
7678         assert!(nodes[0].node.get_and_clear_pending_msg_events().is_empty());
7679 }
7680
7681 #[test]
7682 fn test_bump_penalty_txn_on_revoked_commitment() {
7683         // In case of penalty txn with too low feerates for getting into mempools, RBF-bump them to be sure
7684         // we're able to claim outputs on revoked commitment transaction before timelocks expiration
7685
7686         let chanmon_cfgs = create_chanmon_cfgs(2);
7687         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7688         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7689         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7690
7691         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known());
7692         let logger = test_utils::TestLogger::new();
7693
7694
7695         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
7696         let net_graph_msg_handler = &nodes[1].net_graph_msg_handler;
7697         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();
7698         send_along_route(&nodes[1], route, &vec!(&nodes[0])[..], 3000000);
7699
7700         let revoked_txn = get_local_commitment_txn!(nodes[0], chan.2);
7701         // Revoked commitment txn with 4 outputs : to_local, to_remote, 1 outgoing HTLC, 1 incoming HTLC
7702         assert_eq!(revoked_txn[0].output.len(), 4);
7703         assert_eq!(revoked_txn[0].input.len(), 1);
7704         assert_eq!(revoked_txn[0].input[0].previous_output.txid, chan.3.txid());
7705         let revoked_txid = revoked_txn[0].txid();
7706
7707         let mut penalty_sum = 0;
7708         for outp in revoked_txn[0].output.iter() {
7709                 if outp.script_pubkey.is_v0_p2wsh() {
7710                         penalty_sum += outp.value;
7711                 }
7712         }
7713
7714         // Connect blocks to change height_timer range to see if we use right soonest_timelock
7715         let header_114 = connect_blocks(&nodes[1].block_notifier, 114, 0, false, Default::default());
7716
7717         // Actually revoke tx by claiming a HTLC
7718         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
7719         let header = BlockHeader { version: 0x20000000, prev_blockhash: header_114, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7720         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_txn[0].clone()] }, 115);
7721         check_added_monitors!(nodes[1], 1);
7722
7723         // One or more justice tx should have been broadcast, check it
7724         let penalty_1;
7725         let feerate_1;
7726         {
7727                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
7728                 assert_eq!(node_txn.len(), 3); // justice tx (broadcasted from ChannelMonitor) + local commitment tx + local HTLC-timeout (broadcasted from ChannelManager)
7729                 assert_eq!(node_txn[0].input.len(), 3); // Penalty txn claims to_local, offered_htlc and received_htlc outputs
7730                 assert_eq!(node_txn[0].output.len(), 1);
7731                 check_spends!(node_txn[0], revoked_txn[0]);
7732                 let fee_1 = penalty_sum - node_txn[0].output[0].value;
7733                 feerate_1 = fee_1 * 1000 / node_txn[0].get_weight() as u64;
7734                 penalty_1 = node_txn[0].txid();
7735                 node_txn.clear();
7736         };
7737
7738         // After exhaustion of height timer, a new bumped justice tx should have been broadcast, check it
7739         let header = connect_blocks(&nodes[1].block_notifier, 3, 115,  true, header.bitcoin_hash());
7740         let mut penalty_2 = penalty_1;
7741         let mut feerate_2 = 0;
7742         {
7743                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
7744                 assert_eq!(node_txn.len(), 1);
7745                 if node_txn[0].input[0].previous_output.txid == revoked_txid {
7746                         assert_eq!(node_txn[0].input.len(), 3); // Penalty txn claims to_local, offered_htlc and received_htlc outputs
7747                         assert_eq!(node_txn[0].output.len(), 1);
7748                         check_spends!(node_txn[0], revoked_txn[0]);
7749                         penalty_2 = node_txn[0].txid();
7750                         // Verify new bumped tx is different from last claiming transaction, we don't want spurrious rebroadcast
7751                         assert_ne!(penalty_2, penalty_1);
7752                         let fee_2 = penalty_sum - node_txn[0].output[0].value;
7753                         feerate_2 = fee_2 * 1000 / node_txn[0].get_weight() as u64;
7754                         // Verify 25% bump heuristic
7755                         assert!(feerate_2 * 100 >= feerate_1 * 125);
7756                         node_txn.clear();
7757                 }
7758         }
7759         assert_ne!(feerate_2, 0);
7760
7761         // After exhaustion of height timer for a 2nd time, a new bumped justice tx should have been broadcast, check it
7762         connect_blocks(&nodes[1].block_notifier, 3, 118, true, header);
7763         let penalty_3;
7764         let mut feerate_3 = 0;
7765         {
7766                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
7767                 assert_eq!(node_txn.len(), 1);
7768                 if node_txn[0].input[0].previous_output.txid == revoked_txid {
7769                         assert_eq!(node_txn[0].input.len(), 3); // Penalty txn claims to_local, offered_htlc and received_htlc outputs
7770                         assert_eq!(node_txn[0].output.len(), 1);
7771                         check_spends!(node_txn[0], revoked_txn[0]);
7772                         penalty_3 = node_txn[0].txid();
7773                         // Verify new bumped tx is different from last claiming transaction, we don't want spurrious rebroadcast
7774                         assert_ne!(penalty_3, penalty_2);
7775                         let fee_3 = penalty_sum - node_txn[0].output[0].value;
7776                         feerate_3 = fee_3 * 1000 / node_txn[0].get_weight() as u64;
7777                         // Verify 25% bump heuristic
7778                         assert!(feerate_3 * 100 >= feerate_2 * 125);
7779                         node_txn.clear();
7780                 }
7781         }
7782         assert_ne!(feerate_3, 0);
7783
7784         nodes[1].node.get_and_clear_pending_events();
7785         nodes[1].node.get_and_clear_pending_msg_events();
7786 }
7787
7788 #[test]
7789 fn test_bump_penalty_txn_on_revoked_htlcs() {
7790         // In case of penalty txn with too low feerates for getting into mempools, RBF-bump them to sure
7791         // we're able to claim outputs on revoked HTLC transactions before timelocks expiration
7792
7793         let chanmon_cfgs = create_chanmon_cfgs(2);
7794         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7795         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7796         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7797
7798         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known());
7799         // Lock HTLC in both directions
7800         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3_000_000).0;
7801         route_payment(&nodes[1], &vec!(&nodes[0])[..], 3_000_000).0;
7802
7803         let revoked_local_txn = get_local_commitment_txn!(nodes[1], chan.2);
7804         assert_eq!(revoked_local_txn[0].input.len(), 1);
7805         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid());
7806
7807         // Revoke local commitment tx
7808         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 3_000_000);
7809
7810         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7811         // B will generate both revoked HTLC-timeout/HTLC-preimage txn from revoked commitment tx
7812         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![revoked_local_txn[0].clone()] }, 1);
7813         check_closed_broadcast!(nodes[1], false);
7814         check_added_monitors!(nodes[1], 1);
7815
7816         let revoked_htlc_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
7817         assert_eq!(revoked_htlc_txn.len(), 4);
7818         if revoked_htlc_txn[0].input[0].witness.last().unwrap().len() == ACCEPTED_HTLC_SCRIPT_WEIGHT {
7819                 assert_eq!(revoked_htlc_txn[0].input.len(), 1);
7820                 check_spends!(revoked_htlc_txn[0], revoked_local_txn[0]);
7821                 assert_eq!(revoked_htlc_txn[1].input.len(), 1);
7822                 assert_eq!(revoked_htlc_txn[1].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
7823                 check_spends!(revoked_htlc_txn[1], revoked_local_txn[0]);
7824         } else if revoked_htlc_txn[1].input[0].witness.last().unwrap().len() == ACCEPTED_HTLC_SCRIPT_WEIGHT {
7825                 assert_eq!(revoked_htlc_txn[1].input.len(), 1);
7826                 check_spends!(revoked_htlc_txn[1], revoked_local_txn[0]);
7827                 assert_eq!(revoked_htlc_txn[0].input.len(), 1);
7828                 assert_eq!(revoked_htlc_txn[0].input[0].witness.last().unwrap().len(), OFFERED_HTLC_SCRIPT_WEIGHT);
7829                 check_spends!(revoked_htlc_txn[0], revoked_local_txn[0]);
7830         }
7831
7832         // Broadcast set of revoked txn on A
7833         let header_128 = connect_blocks(&nodes[0].block_notifier, 128, 0, true, header.bitcoin_hash());
7834         expect_pending_htlcs_forwardable_ignore!(nodes[0]);
7835
7836         let header_129 = BlockHeader { version: 0x20000000, prev_blockhash: header_128, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7837         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);
7838         let first;
7839         let feerate_1;
7840         let penalty_txn;
7841         {
7842                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
7843                 assert_eq!(node_txn.len(), 5); // 3 penalty txn on revoked commitment tx + A commitment tx + 1 penalty tnx on revoked HTLC txn
7844                 // Verify claim tx are spending revoked HTLC txn
7845                 assert_eq!(node_txn[4].input.len(), 2);
7846                 assert_eq!(node_txn[4].output.len(), 1);
7847                 check_spends!(node_txn[4], revoked_htlc_txn[0], revoked_htlc_txn[1]);
7848                 first = node_txn[4].txid();
7849                 // Store both feerates for later comparison
7850                 let fee_1 = revoked_htlc_txn[0].output[0].value + revoked_htlc_txn[1].output[0].value - node_txn[4].output[0].value;
7851                 feerate_1 = fee_1 * 1000 / node_txn[4].get_weight() as u64;
7852                 penalty_txn = vec![node_txn[0].clone(), node_txn[1].clone(), node_txn[2].clone()];
7853                 node_txn.clear();
7854         }
7855
7856         // Connect three more block to see if bumped penalty are issued for HTLC txn
7857         let header_130 = BlockHeader { version: 0x20000000, prev_blockhash: header_129.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7858         nodes[0].block_notifier.block_connected(&Block { header: header_130, txdata: penalty_txn }, 130);
7859         {
7860                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
7861                 assert_eq!(node_txn.len(), 2); // 2 bumped penalty txn on revoked commitment tx
7862
7863                 check_spends!(node_txn[0], revoked_local_txn[0]);
7864                 check_spends!(node_txn[1], revoked_local_txn[0]);
7865
7866                 node_txn.clear();
7867         };
7868
7869         // Few more blocks to confirm penalty txn
7870         let header_135 = connect_blocks(&nodes[0].block_notifier, 5, 130, true, header_130.bitcoin_hash());
7871         assert!(nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap().is_empty());
7872         let header_144 = connect_blocks(&nodes[0].block_notifier, 9, 135, true, header_135);
7873         let node_txn = {
7874                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
7875                 assert_eq!(node_txn.len(), 1);
7876
7877                 assert_eq!(node_txn[0].input.len(), 2);
7878                 check_spends!(node_txn[0], revoked_htlc_txn[0], revoked_htlc_txn[1]);
7879                 // Verify bumped tx is different and 25% bump heuristic
7880                 assert_ne!(first, node_txn[0].txid());
7881                 let fee_2 = revoked_htlc_txn[0].output[0].value + revoked_htlc_txn[1].output[0].value - node_txn[0].output[0].value;
7882                 let feerate_2 = fee_2 * 1000 / node_txn[0].get_weight() as u64;
7883                 assert!(feerate_2 * 100 > feerate_1 * 125);
7884                 let txn = vec![node_txn[0].clone()];
7885                 node_txn.clear();
7886                 txn
7887         };
7888         // Broadcast claim txn and confirm blocks to avoid further bumps on this outputs
7889         let header_145 = BlockHeader { version: 0x20000000, prev_blockhash: header_144, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7890         nodes[0].block_notifier.block_connected(&Block { header: header_145, txdata: node_txn }, 145);
7891         connect_blocks(&nodes[0].block_notifier, 20, 145, true, header_145.bitcoin_hash());
7892         {
7893                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
7894                 // We verify than no new transaction has been broadcast because previously
7895                 // we were buggy on this exact behavior by not tracking for monitoring remote HTLC outputs (see #411)
7896                 // which means we wouldn't see a spend of them by a justice tx and bumped justice tx
7897                 // were generated forever instead of safe cleaning after confirmation and ANTI_REORG_SAFE_DELAY blocks.
7898                 // Enforce spending of revoked htlc output by claiming transaction remove request as expected and dry
7899                 // up bumped justice generation.
7900                 assert_eq!(node_txn.len(), 0);
7901                 node_txn.clear();
7902         }
7903         check_closed_broadcast!(nodes[0], false);
7904         check_added_monitors!(nodes[0], 1);
7905 }
7906
7907 #[test]
7908 fn test_bump_penalty_txn_on_remote_commitment() {
7909         // In case of claim txn with too low feerates for getting into mempools, RBF-bump them to be sure
7910         // we're able to claim outputs on remote commitment transaction before timelocks expiration
7911
7912         // Create 2 HTLCs
7913         // Provide preimage for one
7914         // Check aggregation
7915
7916         let chanmon_cfgs = create_chanmon_cfgs(2);
7917         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
7918         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
7919         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
7920
7921         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known());
7922         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 3000000).0;
7923         route_payment(&nodes[1], &vec!(&nodes[0])[..], 3000000).0;
7924
7925         // Remote commitment txn with 4 outputs : to_local, to_remote, 1 outgoing HTLC, 1 incoming HTLC
7926         let remote_txn = get_local_commitment_txn!(nodes[0], chan.2);
7927         assert_eq!(remote_txn[0].output.len(), 4);
7928         assert_eq!(remote_txn[0].input.len(), 1);
7929         assert_eq!(remote_txn[0].input[0].previous_output.txid, chan.3.txid());
7930
7931         // Claim a HTLC without revocation (provide B monitor with preimage)
7932         nodes[1].node.claim_funds(payment_preimage, &None, 3_000_000);
7933         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
7934         nodes[1].block_notifier.block_connected(&Block { header, txdata: vec![remote_txn[0].clone()] }, 1);
7935         check_added_monitors!(nodes[1], 2);
7936
7937         // One or more claim tx should have been broadcast, check it
7938         let timeout;
7939         let preimage;
7940         let feerate_timeout;
7941         let feerate_preimage;
7942         {
7943                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
7944                 assert_eq!(node_txn.len(), 5); // 2 * claim tx (broadcasted from ChannelMonitor) + local commitment tx + local HTLC-timeout + local HTLC-success (broadcasted from ChannelManager)
7945                 assert_eq!(node_txn[0].input.len(), 1);
7946                 assert_eq!(node_txn[1].input.len(), 1);
7947                 check_spends!(node_txn[0], remote_txn[0]);
7948                 check_spends!(node_txn[1], remote_txn[0]);
7949                 check_spends!(node_txn[2], chan.3);
7950                 check_spends!(node_txn[3], node_txn[2]);
7951                 check_spends!(node_txn[4], node_txn[2]);
7952                 if node_txn[0].input[0].witness.last().unwrap().len() == ACCEPTED_HTLC_SCRIPT_WEIGHT {
7953                         timeout = node_txn[0].txid();
7954                         let index = node_txn[0].input[0].previous_output.vout;
7955                         let fee = remote_txn[0].output[index as usize].value - node_txn[0].output[0].value;
7956                         feerate_timeout = fee * 1000 / node_txn[0].get_weight() as u64;
7957
7958                         preimage = node_txn[1].txid();
7959                         let index = node_txn[1].input[0].previous_output.vout;
7960                         let fee = remote_txn[0].output[index as usize].value - node_txn[1].output[0].value;
7961                         feerate_preimage = fee * 1000 / node_txn[1].get_weight() as u64;
7962                 } else {
7963                         timeout = node_txn[1].txid();
7964                         let index = node_txn[1].input[0].previous_output.vout;
7965                         let fee = remote_txn[0].output[index as usize].value - node_txn[1].output[0].value;
7966                         feerate_timeout = fee * 1000 / node_txn[1].get_weight() as u64;
7967
7968                         preimage = node_txn[0].txid();
7969                         let index = node_txn[0].input[0].previous_output.vout;
7970                         let fee = remote_txn[0].output[index as usize].value - node_txn[0].output[0].value;
7971                         feerate_preimage = fee * 1000 / node_txn[0].get_weight() as u64;
7972                 }
7973                 node_txn.clear();
7974         };
7975         assert_ne!(feerate_timeout, 0);
7976         assert_ne!(feerate_preimage, 0);
7977
7978         // After exhaustion of height timer, new bumped claim txn should have been broadcast, check it
7979         connect_blocks(&nodes[1].block_notifier, 15, 1,  true, header.bitcoin_hash());
7980         {
7981                 let mut node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
7982                 assert_eq!(node_txn.len(), 2);
7983                 assert_eq!(node_txn[0].input.len(), 1);
7984                 assert_eq!(node_txn[1].input.len(), 1);
7985                 check_spends!(node_txn[0], remote_txn[0]);
7986                 check_spends!(node_txn[1], remote_txn[0]);
7987                 if node_txn[0].input[0].witness.last().unwrap().len() == ACCEPTED_HTLC_SCRIPT_WEIGHT {
7988                         let index = node_txn[0].input[0].previous_output.vout;
7989                         let fee = remote_txn[0].output[index as usize].value - node_txn[0].output[0].value;
7990                         let new_feerate = fee * 1000 / node_txn[0].get_weight() as u64;
7991                         assert!(new_feerate * 100 > feerate_timeout * 125);
7992                         assert_ne!(timeout, node_txn[0].txid());
7993
7994                         let index = node_txn[1].input[0].previous_output.vout;
7995                         let fee = remote_txn[0].output[index as usize].value - node_txn[1].output[0].value;
7996                         let new_feerate = fee * 1000 / node_txn[1].get_weight() as u64;
7997                         assert!(new_feerate * 100 > feerate_preimage * 125);
7998                         assert_ne!(preimage, node_txn[1].txid());
7999                 } else {
8000                         let index = node_txn[1].input[0].previous_output.vout;
8001                         let fee = remote_txn[0].output[index as usize].value - node_txn[1].output[0].value;
8002                         let new_feerate = fee * 1000 / node_txn[1].get_weight() as u64;
8003                         assert!(new_feerate * 100 > feerate_timeout * 125);
8004                         assert_ne!(timeout, node_txn[1].txid());
8005
8006                         let index = node_txn[0].input[0].previous_output.vout;
8007                         let fee = remote_txn[0].output[index as usize].value - node_txn[0].output[0].value;
8008                         let new_feerate = fee * 1000 / node_txn[0].get_weight() as u64;
8009                         assert!(new_feerate * 100 > feerate_preimage * 125);
8010                         assert_ne!(preimage, node_txn[0].txid());
8011                 }
8012                 node_txn.clear();
8013         }
8014
8015         nodes[1].node.get_and_clear_pending_events();
8016         nodes[1].node.get_and_clear_pending_msg_events();
8017 }
8018
8019 #[test]
8020 fn test_set_outpoints_partial_claiming() {
8021         // - remote party claim tx, new bump tx
8022         // - disconnect remote claiming tx, new bump
8023         // - disconnect tx, see no tx anymore
8024         let chanmon_cfgs = create_chanmon_cfgs(2);
8025         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8026         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
8027         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8028
8029         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known());
8030         let payment_preimage_1 = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3_000_000).0;
8031         let payment_preimage_2 = route_payment(&nodes[1], &vec!(&nodes[0])[..], 3_000_000).0;
8032
8033         // Remote commitment txn with 4 outputs: to_local, to_remote, 2 outgoing HTLC
8034         let remote_txn = get_local_commitment_txn!(nodes[1], chan.2);
8035         assert_eq!(remote_txn.len(), 3);
8036         assert_eq!(remote_txn[0].output.len(), 4);
8037         assert_eq!(remote_txn[0].input.len(), 1);
8038         assert_eq!(remote_txn[0].input[0].previous_output.txid, chan.3.txid());
8039         check_spends!(remote_txn[1], remote_txn[0]);
8040         check_spends!(remote_txn[2], remote_txn[0]);
8041
8042         // Connect blocks on node A to advance height towards TEST_FINAL_CLTV
8043         let prev_header_100 = connect_blocks(&nodes[1].block_notifier, 100, 0, false, Default::default());
8044         // Provide node A with both preimage
8045         nodes[0].node.claim_funds(payment_preimage_1, &None, 3_000_000);
8046         nodes[0].node.claim_funds(payment_preimage_2, &None, 3_000_000);
8047         check_added_monitors!(nodes[0], 2);
8048         nodes[0].node.get_and_clear_pending_events();
8049         nodes[0].node.get_and_clear_pending_msg_events();
8050
8051         // Connect blocks on node A commitment transaction
8052         let header = BlockHeader { version: 0x20000000, prev_blockhash: prev_header_100, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8053         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![remote_txn[0].clone()] }, 101);
8054         check_closed_broadcast!(nodes[0], false);
8055         check_added_monitors!(nodes[0], 1);
8056         // Verify node A broadcast tx claiming both HTLCs
8057         {
8058                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
8059                 // ChannelMonitor: claim tx, ChannelManager: local commitment tx + HTLC-Success*2
8060                 assert_eq!(node_txn.len(), 4);
8061                 check_spends!(node_txn[0], remote_txn[0]);
8062                 check_spends!(node_txn[1], chan.3);
8063                 check_spends!(node_txn[2], node_txn[1]);
8064                 check_spends!(node_txn[3], node_txn[1]);
8065                 assert_eq!(node_txn[0].input.len(), 2);
8066                 node_txn.clear();
8067         }
8068
8069         // Connect blocks on node B
8070         connect_blocks(&nodes[1].block_notifier, 135, 0, false, Default::default());
8071         check_closed_broadcast!(nodes[1], false);
8072         check_added_monitors!(nodes[1], 1);
8073         // Verify node B broadcast 2 HTLC-timeout txn
8074         let partial_claim_tx = {
8075                 let node_txn = nodes[1].tx_broadcaster.txn_broadcasted.lock().unwrap();
8076                 assert_eq!(node_txn.len(), 3);
8077                 check_spends!(node_txn[1], node_txn[0]);
8078                 check_spends!(node_txn[2], node_txn[0]);
8079                 assert_eq!(node_txn[1].input.len(), 1);
8080                 assert_eq!(node_txn[2].input.len(), 1);
8081                 node_txn[1].clone()
8082         };
8083
8084         // Broadcast partial claim on node A, should regenerate a claiming tx with HTLC dropped
8085         let header = BlockHeader { version: 0x20000000, prev_blockhash: header.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8086         nodes[0].block_notifier.block_connected(&Block { header, txdata: vec![partial_claim_tx.clone()] }, 102);
8087         {
8088                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
8089                 assert_eq!(node_txn.len(), 1);
8090                 check_spends!(node_txn[0], remote_txn[0]);
8091                 assert_eq!(node_txn[0].input.len(), 1); //dropped HTLC
8092                 node_txn.clear();
8093         }
8094         nodes[0].node.get_and_clear_pending_msg_events();
8095
8096         // Disconnect last block on node A, should regenerate a claiming tx with HTLC dropped
8097         nodes[0].block_notifier.block_disconnected(&header, 102);
8098         {
8099                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
8100                 assert_eq!(node_txn.len(), 1);
8101                 check_spends!(node_txn[0], remote_txn[0]);
8102                 assert_eq!(node_txn[0].input.len(), 2); //resurrected HTLC
8103                 node_txn.clear();
8104         }
8105
8106         //// Disconnect one more block and then reconnect multiple no transaction should be generated
8107         nodes[0].block_notifier.block_disconnected(&header, 101);
8108         connect_blocks(&nodes[1].block_notifier, 15, 101, false, prev_header_100);
8109         {
8110                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
8111                 assert_eq!(node_txn.len(), 0);
8112                 node_txn.clear();
8113         }
8114 }
8115
8116 #[test]
8117 fn test_counterparty_raa_skip_no_crash() {
8118         // Previously, if our counterparty sent two RAAs in a row without us having provided a
8119         // commitment transaction, we would have happily carried on and provided them the next
8120         // commitment transaction based on one RAA forward. This would probably eventually have led to
8121         // channel closure, but it would not have resulted in funds loss. Still, our
8122         // EnforcingChannelKeys would have paniced as it doesn't like jumps into the future. Here, we
8123         // check simply that the channel is closed in response to such an RAA, but don't check whether
8124         // we decide to punish our counterparty for revoking their funds (as we don't currently
8125         // implement that).
8126         let chanmon_cfgs = create_chanmon_cfgs(2);
8127         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8128         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
8129         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8130         let channel_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).2;
8131
8132         let mut guard = nodes[0].node.channel_state.lock().unwrap();
8133         let local_keys = &guard.by_id.get_mut(&channel_id).unwrap().local_keys;
8134         const INITIAL_COMMITMENT_NUMBER: u64 = (1 << 48) - 1;
8135         let next_per_commitment_point = PublicKey::from_secret_key(&Secp256k1::new(),
8136                 &SecretKey::from_slice(&local_keys.release_commitment_secret(INITIAL_COMMITMENT_NUMBER - 2)).unwrap());
8137         let per_commitment_secret = local_keys.release_commitment_secret(INITIAL_COMMITMENT_NUMBER);
8138
8139         nodes[1].node.handle_revoke_and_ack(&nodes[0].node.get_our_node_id(),
8140                 &msgs::RevokeAndACK { channel_id, per_commitment_secret, next_per_commitment_point });
8141         assert_eq!(check_closed_broadcast!(nodes[1], true).unwrap().data, "Received an unexpected revoke_and_ack");
8142         check_added_monitors!(nodes[1], 1);
8143 }
8144
8145 #[test]
8146 fn test_bump_txn_sanitize_tracking_maps() {
8147         // Sanitizing pendning_claim_request and claimable_outpoints used to be buggy,
8148         // verify we clean then right after expiration of ANTI_REORG_DELAY.
8149
8150         let chanmon_cfgs = create_chanmon_cfgs(2);
8151         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8152         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
8153         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8154
8155         let chan = create_announced_chan_between_nodes_with_value(&nodes, 0, 1, 1000000, 59000000, InitFeatures::known(), InitFeatures::known());
8156         // Lock HTLC in both directions
8157         let payment_preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9_000_000).0;
8158         route_payment(&nodes[1], &vec!(&nodes[0])[..], 9_000_000).0;
8159
8160         let revoked_local_txn = get_local_commitment_txn!(nodes[1], chan.2);
8161         assert_eq!(revoked_local_txn[0].input.len(), 1);
8162         assert_eq!(revoked_local_txn[0].input[0].previous_output.txid, chan.3.txid());
8163
8164         // Revoke local commitment tx
8165         claim_payment(&nodes[0], &vec!(&nodes[1])[..], payment_preimage, 9_000_000);
8166
8167         // Broadcast set of revoked txn on A
8168         let header_128 = connect_blocks(&nodes[0].block_notifier, 128, 0,  false, Default::default());
8169         expect_pending_htlcs_forwardable_ignore!(nodes[0]);
8170
8171         let header_129 = BlockHeader { version: 0x20000000, prev_blockhash: header_128, merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8172         nodes[0].block_notifier.block_connected(&Block { header: header_129, txdata: vec![revoked_local_txn[0].clone()] }, 129);
8173         check_closed_broadcast!(nodes[0], false);
8174         check_added_monitors!(nodes[0], 1);
8175         let penalty_txn = {
8176                 let mut node_txn = nodes[0].tx_broadcaster.txn_broadcasted.lock().unwrap();
8177                 assert_eq!(node_txn.len(), 4); //ChannelMonitor: justice txn * 3, ChannelManager: local commitment tx
8178                 check_spends!(node_txn[0], revoked_local_txn[0]);
8179                 check_spends!(node_txn[1], revoked_local_txn[0]);
8180                 check_spends!(node_txn[2], revoked_local_txn[0]);
8181                 let penalty_txn = vec![node_txn[0].clone(), node_txn[1].clone(), node_txn[2].clone()];
8182                 node_txn.clear();
8183                 penalty_txn
8184         };
8185         let header_130 = BlockHeader { version: 0x20000000, prev_blockhash: header_129.bitcoin_hash(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8186         nodes[0].block_notifier.block_connected(&Block { header: header_130, txdata: penalty_txn }, 130);
8187         connect_blocks(&nodes[0].block_notifier, 5, 130,  false, header_130.bitcoin_hash());
8188         {
8189                 let monitors = nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap();
8190                 if let Some(monitor) = monitors.get(&OutPoint { txid: chan.3.txid(), index: 0 }) {
8191                         assert!(monitor.onchain_tx_handler.pending_claim_requests.is_empty());
8192                         assert!(monitor.onchain_tx_handler.claimable_outpoints.is_empty());
8193                 }
8194         }
8195 }
8196
8197 #[test]
8198 fn test_override_channel_config() {
8199         let chanmon_cfgs = create_chanmon_cfgs(2);
8200         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8201         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
8202         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8203
8204         // Node0 initiates a channel to node1 using the override config.
8205         let mut override_config = UserConfig::default();
8206         override_config.own_channel_config.our_to_self_delay = 200;
8207
8208         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 16_000_000, 12_000_000, 42, Some(override_config)).unwrap();
8209
8210         // Assert the channel created by node0 is using the override config.
8211         let res = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
8212         assert_eq!(res.channel_flags, 0);
8213         assert_eq!(res.to_self_delay, 200);
8214 }
8215
8216 #[test]
8217 fn test_override_0msat_htlc_minimum() {
8218         let mut zero_config = UserConfig::default();
8219         zero_config.own_channel_config.our_htlc_minimum_msat = 0;
8220         let chanmon_cfgs = create_chanmon_cfgs(2);
8221         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8222         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, Some(zero_config.clone())]);
8223         let nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8224
8225         nodes[0].node.create_channel(nodes[1].node.get_our_node_id(), 16_000_000, 12_000_000, 42, Some(zero_config)).unwrap();
8226         let res = get_event_msg!(nodes[0], MessageSendEvent::SendOpenChannel, nodes[1].node.get_our_node_id());
8227         assert_eq!(res.htlc_minimum_msat, 1);
8228
8229         nodes[1].node.handle_open_channel(&nodes[0].node.get_our_node_id(), InitFeatures::known(), &res);
8230         let res = get_event_msg!(nodes[1], MessageSendEvent::SendAcceptChannel, nodes[0].node.get_our_node_id());
8231         assert_eq!(res.htlc_minimum_msat, 1);
8232 }
8233
8234 #[test]
8235 fn test_simple_payment_secret() {
8236         // Simple test of sending a payment with a payment_secret present. This does not use any AMP
8237         // features, however.
8238         let chanmon_cfgs = create_chanmon_cfgs(3);
8239         let node_cfgs = create_node_cfgs(3, &chanmon_cfgs);
8240         let node_chanmgrs = create_node_chanmgrs(3, &node_cfgs, &[None, None, None]);
8241         let nodes = create_network(3, &node_cfgs, &node_chanmgrs);
8242
8243         create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
8244         create_announced_chan_between_nodes(&nodes, 1, 2, InitFeatures::known(), InitFeatures::known());
8245         let logger = test_utils::TestLogger::new();
8246
8247         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(&nodes[0]);
8248         let payment_secret = PaymentSecret([0xdb; 32]);
8249         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
8250         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();
8251         send_along_route_with_secret(&nodes[0], route, &[&[&nodes[1], &nodes[2]]], 100000, payment_hash, Some(payment_secret.clone()));
8252         // Claiming with all the correct values but the wrong secret should result in nothing...
8253         assert_eq!(nodes[2].node.claim_funds(payment_preimage, &None, 100_000), false);
8254         assert_eq!(nodes[2].node.claim_funds(payment_preimage, &Some(PaymentSecret([42; 32])), 100_000), false);
8255         // ...but with the right secret we should be able to claim all the way back
8256         claim_payment_along_route_with_secret(&nodes[0], &[&[&nodes[1], &nodes[2]]], false, payment_preimage, Some(payment_secret.clone()), 100_000);
8257 }
8258
8259 #[test]
8260 fn test_simple_mpp() {
8261         // Simple test of sending a multi-path payment.
8262         let chanmon_cfgs = create_chanmon_cfgs(4);
8263         let node_cfgs = create_node_cfgs(4, &chanmon_cfgs);
8264         let node_chanmgrs = create_node_chanmgrs(4, &node_cfgs, &[None, None, None, None]);
8265         let nodes = create_network(4, &node_cfgs, &node_chanmgrs);
8266
8267         let chan_1_id = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
8268         let chan_2_id = create_announced_chan_between_nodes(&nodes, 0, 2, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
8269         let chan_3_id = create_announced_chan_between_nodes(&nodes, 1, 3, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
8270         let chan_4_id = create_announced_chan_between_nodes(&nodes, 2, 3, InitFeatures::known(), InitFeatures::known()).0.contents.short_channel_id;
8271         let logger = test_utils::TestLogger::new();
8272
8273         let (payment_preimage, payment_hash) = get_payment_preimage_hash!(&nodes[0]);
8274         let payment_secret = PaymentSecret([0xdb; 32]);
8275         let net_graph_msg_handler = &nodes[0].net_graph_msg_handler;
8276         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();
8277         let path = route.paths[0].clone();
8278         route.paths.push(path);
8279         route.paths[0][0].pubkey = nodes[1].node.get_our_node_id();
8280         route.paths[0][0].short_channel_id = chan_1_id;
8281         route.paths[0][1].short_channel_id = chan_3_id;
8282         route.paths[1][0].pubkey = nodes[2].node.get_our_node_id();
8283         route.paths[1][0].short_channel_id = chan_2_id;
8284         route.paths[1][1].short_channel_id = chan_4_id;
8285         send_along_route_with_secret(&nodes[0], route, &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]], 200_000, payment_hash, Some(payment_secret.clone()));
8286         // Claiming with all the correct values but the wrong secret should result in nothing...
8287         assert_eq!(nodes[3].node.claim_funds(payment_preimage, &None, 200_000), false);
8288         assert_eq!(nodes[3].node.claim_funds(payment_preimage, &Some(PaymentSecret([42; 32])), 200_000), false);
8289         // ...but with the right secret we should be able to claim all the way back
8290         claim_payment_along_route_with_secret(&nodes[0], &[&[&nodes[1], &nodes[3]], &[&nodes[2], &nodes[3]]], false, payment_preimage, Some(payment_secret), 200_000);
8291 }
8292
8293 #[test]
8294 fn test_update_err_monitor_lockdown() {
8295         // Our monitor will lock update of local commitment transaction if a broadcastion condition
8296         // has been fulfilled (either force-close from Channel or block height requiring a HTLC-
8297         // timeout). Trying to update monitor after lockdown should return a ChannelMonitorUpdateErr.
8298         //
8299         // This scenario may happen in a watchtower setup, where watchtower process a block height
8300         // triggering a timeout while a slow-block-processing ChannelManager receives a local signed
8301         // commitment at same time.
8302
8303         let chanmon_cfgs = create_chanmon_cfgs(2);
8304         let node_cfgs = create_node_cfgs(2, &chanmon_cfgs);
8305         let node_chanmgrs = create_node_chanmgrs(2, &node_cfgs, &[None, None]);
8306         let mut nodes = create_network(2, &node_cfgs, &node_chanmgrs);
8307
8308         // Create some initial channel
8309         let chan_1 = create_announced_chan_between_nodes(&nodes, 0, 1, InitFeatures::known(), InitFeatures::known());
8310         let outpoint = OutPoint { txid: chan_1.3.txid(), index: 0 };
8311
8312         // Rebalance the network to generate htlc in the two directions
8313         send_payment(&nodes[0], &vec!(&nodes[1])[..], 10_000_000, 10_000_000);
8314
8315         // Route a HTLC from node 0 to node 1 (but don't settle)
8316         let preimage = route_payment(&nodes[0], &vec!(&nodes[1])[..], 9_000_000).0;
8317
8318         // Copy SimpleManyChannelMonitor to simulate a watchtower and update block height of node 0 until its ChannelMonitor timeout HTLC onchain
8319         let logger = test_utils::TestLogger::with_id(format!("node {}", 0));
8320         let chain_monitor = chaininterface::ChainWatchInterfaceUtil::new(Network::Testnet);
8321         let watchtower = {
8322                 let monitors = nodes[0].chan_monitor.simple_monitor.monitors.lock().unwrap();
8323                 let monitor = monitors.get(&outpoint).unwrap();
8324                 let mut w = test_utils::TestVecWriter(Vec::new());
8325                 monitor.write_for_disk(&mut w).unwrap();
8326                 let new_monitor = <(BlockHash, channelmonitor::ChannelMonitor<EnforcingChannelKeys>)>::read(
8327                                 &mut ::std::io::Cursor::new(&w.0)).unwrap().1;
8328                 assert!(new_monitor == *monitor);
8329                 let watchtower = test_utils::TestChannelMonitor::new(&chain_monitor, &chanmon_cfgs[0].tx_broadcaster, &logger, &chanmon_cfgs[0].fee_estimator);
8330                 assert!(watchtower.add_monitor(outpoint, new_monitor).is_ok());
8331                 watchtower
8332         };
8333         let header = BlockHeader { version: 0x20000000, prev_blockhash: Default::default(), merkle_root: Default::default(), time: 42, bits: 42, nonce: 42 };
8334         watchtower.simple_monitor.block_connected(&header, 200, &vec![], &vec![]);
8335
8336         // Try to update ChannelMonitor
8337         assert!(nodes[1].node.claim_funds(preimage, &None, 9_000_000));
8338         check_added_monitors!(nodes[1], 1);
8339         let updates = get_htlc_update_msgs!(nodes[1], nodes[0].node.get_our_node_id());
8340         assert_eq!(updates.update_fulfill_htlcs.len(), 1);
8341         nodes[0].node.handle_update_fulfill_htlc(&nodes[1].node.get_our_node_id(), &updates.update_fulfill_htlcs[0]);
8342         if let Some(ref mut channel) = nodes[0].node.channel_state.lock().unwrap().by_id.get_mut(&chan_1.2) {
8343                 if let Ok((_, _, _, update)) = channel.commitment_signed(&updates.commitment_signed, &node_cfgs[0].fee_estimator, &node_cfgs[0].logger) {
8344                         if let Err(_) =  watchtower.simple_monitor.update_monitor(outpoint, update.clone()) {} else { assert!(false); }
8345                         if let Ok(_) = nodes[0].chan_monitor.update_monitor(outpoint, update) {} else { assert!(false); }
8346                 } else { assert!(false); }
8347         } else { assert!(false); };
8348         // Our local monitor is in-sync and hasn't processed yet timeout
8349         check_added_monitors!(nodes[0], 1);
8350         let events = nodes[0].node.get_and_clear_pending_events();
8351         assert_eq!(events.len(), 1);
8352 }